/// <summary>
/// Try to bind a <see cref="DottedIdentifierToken"/> as a function call. Used for container qualified functions without parameters.
/// </summary>
/// <param name="dottedIdentifierToken">the dotted identifier token to bind</param>
/// <param name="parent">the semantically bound parent node for this dotted identifier</param>
/// <param name="boundFunction">a single value function call node representing the function call, if we found one.</param>
/// <returns>true if we found a function for this token, false otherwise.</returns>
internal bool TryBindDottedIdentifierAsFunctionCall(DottedIdentifierToken dottedIdentifierToken, SingleValueNode parent, out QueryNode boundFunction)
{
return(this.TryBindIdentifier(dottedIdentifierToken.Identifier, null, parent, state, out boundFunction));
}
/// <summary>
/// Binds a DottedIdentifierToken and it's parent node (if needed).
/// </summary>
/// <param name="dottedIdentifierToken">Token to bind to metadata.</param>
/// <returns>A bound node representing the cast.</returns>
internal QueryNode BindDottedIdentifier(DottedIdentifierToken dottedIdentifierToken)
{
ExceptionUtils.CheckArgumentNotNull(dottedIdentifierToken, "castToken");
ExceptionUtils.CheckArgumentNotNull(state, "state");
QueryNode parent = null;
IEdmType parentType = null;
if (state.ImplicitRangeVariable != null)
{
if (dottedIdentifierToken.NextToken == null)
{
parent = NodeFactory.CreateRangeVariableReferenceNode(state.ImplicitRangeVariable);
parentType = state.ImplicitRangeVariable.TypeReference.Definition;
}
else
{
parent = this.bindMethod(dottedIdentifierToken.NextToken);
parentType = parent.GetEdmType();
}
}
SingleResourceNode parentAsSingleResource = parent as SingleResourceNode;
IEdmSchemaType childType = UriEdmHelpers.FindTypeFromModel(state.Model, dottedIdentifierToken.Identifier, this.Resolver);
IEdmStructuredType childStructuredType = childType as IEdmStructuredType;
if (childStructuredType == null)
{
SingleValueNode singleValueNode = parent as SingleValueNode;
FunctionCallBinder functionCallBinder = new FunctionCallBinder(bindMethod, state);
QueryNode functionCallNode;
if (functionCallBinder.TryBindDottedIdentifierAsFunctionCall(dottedIdentifierToken, singleValueNode, out functionCallNode))
{
return(functionCallNode);
}
else if ((!string.IsNullOrEmpty(dottedIdentifierToken.Identifier)) &&
(dottedIdentifierToken.Identifier[dottedIdentifierToken.Identifier.Length - 1] == '\''))
{
// check if it is enum or not
QueryNode enumNode;
if (EnumBinder.TryBindDottedIdentifierAsEnum(dottedIdentifierToken, parentAsSingleResource, state, this.Resolver, out enumNode))
{
return(enumNode);
}
else
{
throw new ODataException(ODataErrorStrings.Binder_IsNotValidEnumConstant(dottedIdentifierToken.Identifier));
}
}
else
{
IEdmTypeReference edmTypeReference = UriEdmHelpers.FindTypeFromModel(state.Model, dottedIdentifierToken.Identifier, this.Resolver).ToTypeReference();
if (edmTypeReference is IEdmPrimitiveTypeReference || edmTypeReference is IEdmEnumTypeReference)
{
IEdmPrimitiveType childPrimitiveType = childType as IEdmPrimitiveType;
if (childPrimitiveType != null && dottedIdentifierToken.NextToken != null)
{
return(new SingleValueCastNode(singleValueNode, childPrimitiveType));
}
else
{
return(new ConstantNode(dottedIdentifierToken.Identifier, dottedIdentifierToken.Identifier));
}
}
else
{
throw new ODataException(ODataErrorStrings.CastBinder_ChildTypeIsNotEntity(dottedIdentifierToken.Identifier));
}
}
}
// Check whether childType is a derived type of the type of its parent node
UriEdmHelpers.CheckRelatedTo(parentType, childType);
this.state.ParsedSegments.Add(new TypeSegment(childType, parentType, null));
CollectionResourceNode parentAsCollection = parent as CollectionResourceNode;
if (parentAsCollection != null)
{
return(new CollectionResourceCastNode(parentAsCollection, childStructuredType));
}
return(new SingleResourceCastNode(parentAsSingleResource, childStructuredType));
}
/// <summary>Attempts to parse key values from the specified text.</summary>
/// <param name='text'>Text to parse (not null).</param>
/// <param name='instance'>After invocation, the parsed key instance.</param>
/// <param name="enableUriTemplateParsing">Whether Uri template parsing is enabled.</param>
/// <returns>
/// true if the key instance was parsed; false if there was a
/// syntactic error.
/// </returns>
/// <remarks>
/// The returned instance contains only string values. To get typed values, a call to
/// TryConvertValues is necessary.
/// </remarks>
private static bool TryParseFromUri(string text, out SegmentArgumentParser instance, bool enableUriTemplateParsing)
{
Debug.Assert(text != null, "text != null");
Dictionary <string, string> namedValues = null;
List <string> positionalValues = null;
// parse keys just like function parameters
ExpressionLexer lexer = new ExpressionLexer(string.Concat("(", text, ")"), true, false);
UriQueryExpressionParser exprParser = new UriQueryExpressionParser(ODataUriParserSettings.DefaultFilterLimit /* default limit for parsing key value */, lexer);
var tmp = (new FunctionCallParser(lexer, exprParser)).ParseArgumentListOrEntityKeyList();
if (lexer.CurrentToken.Kind != ExpressionTokenKind.End)
{
instance = null;
return(false);
}
if (tmp.Length == 0)
{
instance = Empty;
return(true);
}
foreach (FunctionParameterToken t in tmp)
{
string valueText = null;
LiteralToken literalToken = t.ValueToken as LiteralToken;
if (literalToken != null)
{
valueText = literalToken.OriginalText;
// disallow "{...}" if enableUriTemplateParsing is false (which could have been seen as valid function parameter, e.g. array notation)
if (!enableUriTemplateParsing && UriTemplateParser.IsValidTemplateLiteral(valueText))
{
instance = null;
return(false);
}
}
else
{
DottedIdentifierToken dottedIdentifierToken = t.ValueToken as DottedIdentifierToken; // for enum
if (dottedIdentifierToken != null)
{
valueText = dottedIdentifierToken.Identifier;
}
}
if (valueText != null)
{
if (t.ParameterName == null)
{
if (namedValues != null)
{
instance = null; // We cannot mix named and non-named values.
return(false);
}
CreateIfNull(ref positionalValues);
positionalValues.Add(valueText);
}
else
{
if (positionalValues != null)
{
instance = null; // We cannot mix named and non-named values.
return(false);
}
CreateIfNull(ref namedValues);
namedValues.Add(t.ParameterName, valueText);
}
}
else
{
instance = null;
return(false);
}
}
instance = new SegmentArgumentParser(namedValues, positionalValues, false, enableUriTemplateParsing);
return(true);
}
/// <summary>
/// Try to bind a dotted identifier as enum node
/// </summary>
/// <param name="dottedIdentifierToken">a dotted identifier token</param>
/// <param name="parent">the parent node</param>
/// <param name="state">the current state of the binding algorithm</param>
/// <param name="resolver">ODataUriResolver</param>
/// <param name="boundEnum">the output bound enum node</param>
/// <returns>true if we bound an enum node, false otherwise.</returns>
internal static bool TryBindDottedIdentifierAsEnum(DottedIdentifierToken dottedIdentifierToken, SingleValueNode parent, BindingState state, ODataUriResolver resolver, out QueryNode boundEnum)
{
return(TryBindIdentifier(dottedIdentifierToken.Identifier, null, state.Model, resolver, out boundEnum));
}
/// <summary>
/// Binds a type startPath token.
/// </summary>
/// <param name="dottedIdentifierToken">The type startPath token to bind.</param>
/// <returns>The bound type startPath token.</returns>
protected virtual QueryNode BindCast(DottedIdentifierToken dottedIdentifierToken)
{
DottedIdentifierBinder dottedIdentifierBinder = new DottedIdentifierBinder(this.Bind, this.BindingState);
return(dottedIdentifierBinder.BindDottedIdentifier(dottedIdentifierToken));
}
/// <summary>
/// Visits a DottedIdentifierToken
/// </summary>
/// <param name="tokenIn">The DottedIdentifierToken to visit</param>
/// <returns>Either a SingleResourceCastNode, or CollectionResourceCastNode bound to this DottedIdentifierToken</returns>
public virtual T Visit(DottedIdentifierToken tokenIn)
{
throw new NotImplementedException();
}
