/// <summary> /// Builds a URI with the given type name appended as a new segment on the base URI. /// </summary> /// <param name="baseUri">The URI to append to.</param> /// <param name="typeName">The fully qualified type name to append.</param> /// <returns>The URI with the type segment appended.</returns> internal override Uri AppendTypeSegment(Uri baseUri, string typeName) { ValidateBaseUri(baseUri); ExceptionUtils.CheckArgumentStringNotNullOrEmpty(typeName, "typeName"); return(AppendSegment(baseUri, typeName, true /*escapeSegment*/)); }
/// <summary> /// Builds the navigation link for the navigation property. /// </summary> /// <param name="baseUri">The URI to append to.</param> /// <param name="navigationPropertyName">The name of the navigation property to get the navigation link URI for.</param> /// <returns>The navigation link URI for the navigation property.</returns> internal override Uri BuildNavigationLinkUri(Uri baseUri, string navigationPropertyName) { ValidateBaseUri(baseUri); ExceptionUtils.CheckArgumentStringNotNullOrEmpty(navigationPropertyName, "navigationPropertyName"); return(AppendSegment(baseUri, navigationPropertyName, true /*escapeSegment*/)); }
/// <summary> /// Add a custom uri function to extend uri functions. /// In case the function name already exists as a custom function, the signature will be added as an another overload. /// </summary> /// <param name="functionName">The new custom function name</param> /// <param name="functionSignature">The new custom function signature</param> /// <exception cref="ArgumentNullException">Arguments are null, or function signature return type is null</exception> /// <exception cref="ODataException">Throws if built-in function name already exists.</exception> /// <exception cref="ODataException">Throws if built-in function signature overload already exists.</exception> /// <exception cref="ODataException">Throws if custom function signature overload already exists</exception> public static void AddCustomUriFunction(string functionName, FunctionSignatureWithReturnType functionSignature) { // Parameters validation ExceptionUtils.CheckArgumentStringNotNullOrEmpty(functionName, "customFunctionName"); ExceptionUtils.CheckArgumentNotNull(functionSignature, "newCustomFunctionSignature"); ValidateFunctionWithReturnType(functionSignature); // Thread saftey - before using the custom functions dictionary lock (Locker) { // Check if the function does already exists in the Built-In functions // If 'addAsOverloadToBuiltInFunction' parameter is false - throw expection // Else, add as a custom function FunctionSignatureWithReturnType[] existingBuiltInFunctionOverload; if (BuiltInUriFunctions.TryGetBuiltInFunction(functionName, out existingBuiltInFunctionOverload)) { // Function name exists, check if full signature exists among the overloads. if (existingBuiltInFunctionOverload.Any(builtInFunction => AreFunctionsSignatureEqual(functionSignature, builtInFunction))) { throw new ODataException(Strings.CustomUriFunctions_AddCustomUriFunction_BuiltInExistsFullSignature(functionName)); } } AddCustomFunction(functionName, functionSignature); } }
/// <summary> /// Builds the URI for an entity set. /// </summary> /// <param name="baseUri">The URI to append to.</param> /// <param name="entitySetName">The entity set name.</param> /// <returns>The entity set URI.</returns> internal override Uri BuildEntitySetUri(Uri baseUri, string entitySetName) { ValidateBaseUri(baseUri); ExceptionUtils.CheckArgumentStringNotNullOrEmpty(entitySetName, "entitySetName"); return(AppendSegment(baseUri, entitySetName, true /*escapeSegment*/)); }
/// <summary> /// Gets the association link URI for the specified navigation property. /// </summary> /// <param name="navigationPropertyName">The name of the navigation property to get the association link URI for.</param> /// <param name="associationLinkUrl">The value of the link URI as seen on the wire or provided explicitly by the user or previously returned by the metadata builder, which may be null.</param> /// <param name="hasAssociationLinkUrl">true if the value of the <paramref name="associationLinkUrl"/> was seen on the wire or provided explicitly by the user or previously returned by /// the metadata builder, false otherwise. This flag allows the metadata builder to determine whether a null association link url is an uninitialized value or a value that was set explicitly.</param> /// <returns> /// The association link URI for the navigation property. /// null if its not possible to determine the association link for the specified navigation property. /// </returns> internal override Uri GetAssociationLinkUri(string navigationPropertyName, Uri associationLinkUrl, bool hasAssociationLinkUrl) { DebugUtils.CheckNoExternalCallers(); ExceptionUtils.CheckArgumentStringNotNullOrEmpty(navigationPropertyName, "navigationPropertyName"); return(hasAssociationLinkUrl ? associationLinkUrl : this.uriBuilder.BuildAssociationLinkUri(this.GetEditLink(), navigationPropertyName)); }
/// <summary> /// Create a EndPathToken given the Identifier and the NextToken (if any) /// </summary> /// <param name="identifier">The Identifier of the property to access.</param> /// <param name="nextToken">The NextToken token to access the property on. </param> public EndPathToken(string identifier, QueryToken nextToken) { ExceptionUtils.CheckArgumentStringNotNullOrEmpty(identifier, "identifier"); this.identifier = identifier; this.nextToken = nextToken; }
/// <summary> /// Create a PropertyAccessQueryToken given the name and the parent (if any) /// </summary> /// <param name="name">The name of the property to access.</param> /// <param name="parent">The parent token to access the property on. Pass no if this property has no parent.</param> public PropertyAccessQueryToken(string name, QueryToken parent) { ExceptionUtils.CheckArgumentStringNotNullOrEmpty(name, "name"); this.name = name; this.parent = parent; }
/// <summary> /// Constructs a new instance of Astoria type using the specified clr type. /// </summary> /// <param name="instanceType">CLR type that represents the flow format inside the Astoria runtime.</param> /// <param name="resourceTypeKind">Kind of the resource type.</param> /// <param name="baseType">Base type of the resource type.</param> /// <param name="namespaceName">Namespace name of the given resource type.</param> /// <param name="name">Name of the given resource type.</param> /// <param name="isAbstract">Whether the resource type is an abstract type or not.</param> public ResourceType( Type instanceType, ResourceTypeKind resourceTypeKind, ResourceType baseType, string namespaceName, string name, bool isAbstract) : this(instanceType, baseType, namespaceName, name, isAbstract) { ExceptionUtils.CheckArgumentNotNull(instanceType, "instanceType"); ExceptionUtils.CheckArgumentStringNotNullOrEmpty(name, "name"); CheckResourceTypeKind(resourceTypeKind, "resourceTypeKind"); if (resourceTypeKind == ResourceTypeKind.Primitive || resourceTypeKind == ResourceTypeKind.MultiValue) { throw new ArgumentException(Strings.ResourceType_InvalidValueForResourceTypeKind, "resourceTypeKind"); } if (baseType != null && baseType.ResourceTypeKind != resourceTypeKind) { throw new ArgumentException( Strings.ResourceType_InvalidResourceTypeKindInheritance(resourceTypeKind.ToString(), baseType.ResourceTypeKind.ToString()), "resourceTypeKind"); } if (instanceType.IsValueType) { throw new ArgumentException(Strings.ResourceType_TypeCannotBeValueType, "instanceType"); } this.resourceTypeKind = resourceTypeKind; }
/// <summary> /// Initializes a new <see cref="ServiceOperation"/> instance. /// </summary> /// <param name="name">name of the service operation.</param> /// <param name="resultKind">Kind of result expected from this operation.</param> /// <param name="resultType">Type of element of the method result.</param> /// <param name="resultSet">EntitySet of the result expected from this operation.</param> /// <param name="method">Protocol (for example HTTP) method the service operation responds to.</param> /// <param name="parameters">In-order parameters for this operation.</param> public ServiceOperation( string name, ServiceOperationResultKind resultKind, ResourceType resultType, ResourceSet resultSet, string method, IEnumerable <ServiceOperationParameter> parameters) { ExceptionUtils.CheckArgumentStringNotNullOrEmpty(name, "name"); CheckServiceOperationResultKind(resultKind, "resultKind"); ExceptionUtils.CheckArgumentStringNotNullOrEmpty(method, "method"); if ((resultKind == ServiceOperationResultKind.Void && resultType != null) || (resultKind != ServiceOperationResultKind.Void && resultType == null)) { throw new ArgumentException(Strings.ServiceOperation_ResultTypeAndKindMustMatch("resultKind", "resultType", ServiceOperationResultKind.Void)); } if ((resultType == null || resultType.ResourceTypeKind != ResourceTypeKind.EntityType) && resultSet != null) { throw new ArgumentException(Strings.ServiceOperation_ResultSetMustBeNull("resultSet", "resultType")); } if (resultType != null && resultType.ResourceTypeKind == ResourceTypeKind.EntityType && (resultSet == null || !resultSet.ResourceType.IsAssignableFrom(resultType))) { throw new ArgumentException(Strings.ServiceOperation_ResultTypeAndResultSetMustMatch("resultType", "resultSet")); } if (resultType != null && resultType.ResourceTypeKind == ResourceTypeKind.MultiValue) { throw new ArgumentException(Strings.ServiceOperation_InvalidResultType(resultType.FullName)); } if (method != HttpConstants.HttpMethodGet && method != HttpConstants.HttpMethodPost) { throw new ArgumentException(Strings.ServiceOperation_NotSupportedProtocolMethod(method, name)); } this.name = name; this.resultKind = resultKind; this.resultType = resultType; this.resourceSet = resultSet; this.method = method; if (parameters == null) { this.parameters = ServiceOperation.emptyParameterCollection; } else { this.parameters = new ReadOnlyCollection <ServiceOperationParameter>(new List <ServiceOperationParameter>(parameters)); HashSet <string> paramNames = new HashSet <string>(StringComparer.Ordinal); foreach (ServiceOperationParameter p in this.parameters) { if (!paramNames.Add(p.Name)) { throw new ArgumentException(Strings.ServiceOperation_DuplicateParameterName(p.Name), "parameters"); } } } }
/// <summary> /// Resolves a name to an <see cref="IEdmEntitySet"/> instance. /// </summary> /// <param name="model">The model to resolve the name against.</param> /// <param name="entitySetName">The name of the entity set to look up.</param> /// <returns>An <see cref="IEdmEntitySet"/> instance with the specified <paramref name="entitySetName"/> or null if no such entity set exists.</returns> public static IEdmEntitySet TryResolveEntitySet(this IEdmModel model, string entitySetName) { ExceptionUtils.CheckArgumentNotNull(model, "model"); ExceptionUtils.CheckArgumentStringNotNullOrEmpty(entitySetName, "entitySetName"); IEnumerable <IEdmEntityContainer> entityContainers = model.EntityContainers(); if (entityContainers == null) { return(null); } IEdmEntitySet entitySet = null; foreach (IEdmEntityContainer container in entityContainers) { entitySet = container.FindEntitySet(entitySetName); if (entitySet != null) { break; } } return(entitySet); }
/// <summary> /// Resolves a name to an <see cref="IEdmFunctionImport"/> instance. /// </summary> /// <param name="model">The model to resolve the name against.</param> /// <param name="operationName">The name of the service operation to look up.</param> /// <returns>An <see cref="IEdmFunctionImport"/> instance with the specified <paramref name="operationName"/> or null if no such service operation exists.</returns> public static IEdmFunctionImport TryResolveServiceOperation(this IEdmModel model, string operationName) { ExceptionUtils.CheckArgumentNotNull(model, "model"); ExceptionUtils.CheckArgumentStringNotNullOrEmpty(operationName, "operationName"); IEdmFunctionImport functionImport = null; foreach (IEdmFunctionImport import in model.ResolveFunctionImports(operationName)) { if (model.IsServiceOperation(import)) { if (functionImport == null) { functionImport = import; } else { throw new ODataException( ODataErrorStrings.ODataQueryUtils_FoundMultipleServiceOperations(operationName)); } } } return(functionImport); }
/// <summary> /// Get the operation title for the specified <paramref name="operationName"/>. /// </summary> /// <param name="operationName">The fully qualified name of the operation for which to get the target URI.</param> /// <returns> /// The title for the operation. /// null if it is not possible to determine the title for the specified operation. /// </returns> internal override string GetOperationTitle(string operationName) { ExceptionUtils.CheckArgumentStringNotNullOrEmpty(operationName, "operationName"); // TODO: What is the convention for operation title? return(operationName); }
/// <summary> /// Create a ConstantNode /// </summary> /// <param name="constantValue">This node's primitive value.</param> /// <param name="literalText">The literal text for this node's value, formatted according to the OData URI literal formatting rules.</param> /// <param name="typeReference">The typeReference of this node's value.</param> /// <exception cref="System.ArgumentNullException">Throws if the input literalText is null.</exception> public ConstantNode(object constantValue, string literalText, IEdmTypeReference typeReference) : this(constantValue) { ExceptionUtils.CheckArgumentStringNotNullOrEmpty(literalText, "literalText"); this.LiteralText = literalText; this.typeReference = typeReference; }
/// <summary> /// Create a new FunctionCallQueryToken given name and arguments. /// </summary> /// <param name="name">The name of the function to call.</param> /// <param name="arguments">The arguments for the function.</param> public FunctionCallQueryToken(string name, IEnumerable <QueryToken> arguments) { ExceptionUtils.CheckArgumentStringNotNullOrEmpty(name, "name"); this.name = name; this.arguments = new ReadOnlyEnumerable <QueryToken>(arguments ?? QueryToken.EmptyTokens); }
/// <summary> /// Constructs a <see cref="SingleValueOpenPropertyAccessNode"/>. /// </summary> /// <param name="source">The value containing this property.</param> /// <param name="openPropertyName">The name of the open property to be bound outside the EDM model.</param> /// <exception cref="System.ArgumentNullException">Throws if the input source or openPropertyName is null.</exception> public SingleValueOpenPropertyAccessNode(SingleValueNode source, string openPropertyName) { ExceptionUtils.CheckArgumentNotNull(source, "source"); ExceptionUtils.CheckArgumentStringNotNullOrEmpty(openPropertyName, "openPropertyName"); this.name = openPropertyName; this.source = source; }
/// <summary> /// Create an ComputeExpressionToken. /// </summary> /// <param name="expression">The computation token.</param> /// <param name="alias">The alias for the computation.</param> public ComputeExpressionToken(QueryToken expression, string alias) { ExceptionUtils.CheckArgumentNotNull(expression, "expression"); ExceptionUtils.CheckArgumentStringNotNullOrEmpty(alias, "alias"); this.expression = expression; this.alias = alias; }
/// <summary> /// Create a new FunctionCallToken using the given function name and parameter tokens. /// </summary> /// <param name="name">The name of the function to call.</param> /// <param name="arguments">The arguments for the function.</param> /// <param name="source">The syntactically bound parent of this function</param> public FunctionCallToken(string name, IEnumerable <FunctionParameterToken> arguments, QueryToken source) { ExceptionUtils.CheckArgumentStringNotNullOrEmpty(name, "name"); this.name = name; this.arguments = new ReadOnlyEnumerableForUriParser <FunctionParameterToken>(arguments ?? FunctionParameterToken.EmptyParameterList); this.source = source; }
/// <summary> /// Builds the URI for an entity set. /// </summary> /// <param name="baseUri">The URI to append to.</param> /// <param name="entitySetName">The entity set name.</param> /// <returns>The entity set URI.</returns> internal virtual Uri BuildEntitySetUri(Uri baseUri, string entitySetName) { #if ODATA_CLIENT Util.CheckArgumentNullAndEmpty(entitySetName, "entitySetName"); #else ExceptionUtils.CheckArgumentStringNotNullOrEmpty(entitySetName, "entitySetName"); #endif return(null); }
/// <summary> /// Create a TypeSegmentQueryToken given the name and the parent (if any) /// </summary> /// <param name="space">The namespace of the type segment.</param> /// <param name="name">The name of the type segment.</param> /// <param name="parent">The parent segment.</param> public CastToken(string space, string name, QueryToken parent) { ExceptionUtils.CheckArgumentStringNotNullOrEmpty(name, "name"); ExceptionUtils.CheckArgumentStringNotNullOrEmpty(space, "ns"); this.space = space; this.name = name; this.parent = parent; }
/// <summary> /// Builds the operation target URI for the specified <paramref name="operationName"/>. /// </summary> /// <param name="baseUri">The URI to append to.</param> /// <param name="operationName">The fully qualified name of the operation for which to get the target URI.</param> /// <param name="bindingParameterTypeName">The binding parameter type name to include in the target, or null/empty if there is none.</param> /// <param name="parameterNames">The parameter names to include in the target, or null/empty if there is none.</param> /// <returns>The target URI for the operation.</returns> internal virtual Uri BuildOperationTargetUri(Uri baseUri, string operationName, string bindingParameterTypeName, string parameterNames) { #if ODATA_CLIENT Util.CheckArgumentNullAndEmpty(operationName, "operationName"); #else ExceptionUtils.CheckArgumentStringNotNullOrEmpty(operationName, "operationName"); #endif return(null); }
/// <summary> /// Builds a URI with the given type name appended as a new segment on the base URI. /// </summary> /// <param name="baseUri">The URI to append to.</param> /// <param name="typeName">The fully qualified type name to append.</param> /// <returns>The URI with the type segment appended.</returns> internal virtual Uri AppendTypeSegment(Uri baseUri, string typeName) { #if ODATA_CLIENT Util.CheckArgumentNullAndEmpty(typeName, "typeName"); #else ExceptionUtils.CheckArgumentStringNotNullOrEmpty(typeName, "typeName"); #endif return(null); }
/// <summary> /// Get the operation target URI for the specified <paramref name="operationName"/>. /// </summary> /// <param name="operationName">The fully qualified name of the operation for which to get the target URI.</param> /// <param name="bindingParameterTypeName">The binding parameter type name to include in the target, or null/empty if there is none.</param> /// <returns> /// The target URI for the operation. /// null if it is not possible to determine the target URI for the specified operation. /// </returns> internal virtual Uri GetOperationTargetUri(string operationName, string bindingParameterTypeName) { #if ASTORIA_CLIENT Util.CheckArgumentNullAndEmpty(operationName, "operationName"); #else ExceptionUtils.CheckArgumentStringNotNullOrEmpty(operationName, "operationName"); #endif return(null); }
/// <summary> /// Builds the association link for the navigation property. /// </summary> /// <param name="baseUri">The URI to append to.</param> /// <param name="navigationPropertyName">The name of the navigation property to get the association link URI for.</param> /// <returns>The association link URI for the navigation property.</returns> internal virtual Uri BuildAssociationLinkUri(Uri baseUri, string navigationPropertyName) { #if ODATA_CLIENT Util.CheckArgumentNullAndEmpty(navigationPropertyName, "navigationPropertyName"); #else ExceptionUtils.CheckArgumentStringNotNullOrEmpty(navigationPropertyName, "navigationPropertyName"); #endif return(null); }
/// <summary> /// Removes all the function overloads from the custom uri functions. /// </summary> /// <param name="functionName">The custom function name</param> /// <returns>'False' if custom function signature doesn't exist. 'True' if function has been removed successfully</returns> /// <exception cref="ArgumentNullException">Arguments are null, or function signature return type is null</exception> public static bool RemoveCustomUriFunction(string functionName) { ExceptionUtils.CheckArgumentStringNotNullOrEmpty(functionName, "customFunctionName"); lock (Locker) { return(CustomFunctions.Remove(functionName)); } }
/// <summary> /// Gets the <see cref="EntityPropertyMappingAttribute"/> for the specified <paramref name="propertyName"/> /// from the <paramref name="epmParentSourcePathSegment"/>. /// </summary> /// <param name="epmParentSourcePathSegment">The EPM source path segment for the parent of the property being written.</param> /// <param name="propertyName">The name of the property to get the <see cref="EntityPropertyMappingAttribute"/> for.</param> /// <returns>The <see cref="EntityPropertyMappingAttribute"/> for the specified <paramref name="propertyName"/> or null if none exists.</returns> internal static EntityPropertyMappingAttribute GetEntityPropertyMapping(EpmSourcePathSegment epmParentSourcePathSegment, string propertyName) { DebugUtils.CheckNoExternalCallers(); ExceptionUtils.CheckArgumentStringNotNullOrEmpty(propertyName, "propertyName"); EpmSourcePathSegment epmSourcePathSegment = GetPropertySourcePathSegment(epmParentSourcePathSegment, propertyName); return(GetEntityPropertyMapping(epmSourcePathSegment)); }
/// <summary> /// Gets the association link URI for the specified navigation property. /// </summary> /// <param name="navigationPropertyName">The name of the navigation property to get the association link URI for.</param> /// <param name="associationLinkUrl">The value of the link URI as seen on the wire or provided explicitly by the user or previously returned by the metadata builder, which may be null.</param> /// <param name="hasAssociationLinkUrl">true if the value of the <paramref name="associationLinkUrl"/> was seen on the wire or provided explicitly by the user or previously returned by /// the metadata builder, false otherwise. This flag allows the metadata builder to determine whether a null association link url is an uninitialized value or a value that was set explicitly.</param> /// <returns> /// The association link URI for the navigation property. /// null if its not possible to determine the association link for the specified navigation property. /// </returns> internal virtual Uri GetAssociationLinkUri(string navigationPropertyName, Uri associationLinkUrl, bool hasAssociationLinkUrl) { #if ODATA_CLIENT Util.CheckArgumentNullAndEmpty(navigationPropertyName, "navigationPropertyName"); #else ExceptionUtils.CheckArgumentStringNotNullOrEmpty(navigationPropertyName, "navigationPropertyName"); #endif return(null); }
/// <summary> /// Get the operation title for the specified <paramref name="operationName"/>. /// </summary> /// <param name="operationName">The fully qualified name of the operation for which to get the target URI.</param> /// <returns> /// The title for the operation. /// null if it is not possible to determine the title for the specified operation. /// </returns> internal virtual string GetOperationTitle(string operationName) { #if ODATA_CLIENT Util.CheckArgumentNullAndEmpty(operationName, "operationName"); #else ExceptionUtils.CheckArgumentStringNotNullOrEmpty(operationName, "operationName"); #endif return(null); }
/// <summary> /// Binds a an end path token into a PropertyAccessToken, OpenPropertyToken, or FunctionCallToken. /// </summary> /// <param name="endPathToken">The property access token to bind.</param> /// <returns>A Query node representing this endpath token, bound to metadata.</returns> internal QueryNode BindEndPath(EndPathToken endPathToken) { ExceptionUtils.CheckArgumentNotNull(endPathToken, "EndPathToken"); ExceptionUtils.CheckArgumentStringNotNullOrEmpty(endPathToken.Identifier, "EndPathToken.Identifier"); // Set the parent (get the parent type, so you can check whether the Identifier inside EndPathToken really is legit offshoot of the parent type) QueryNode parent = this.DetermineParentNode(endPathToken); QueryNode boundFunction; SingleValueNode singleValueParent = parent as SingleValueNode; if (singleValueParent == null) { if (functionCallBinder.TryBindEndPathAsFunctionCall(endPathToken, parent, state, out boundFunction)) { return(boundFunction); } // Collection with any or all expression is already supported and handled separately. // Add support of collection with $count segment. CollectionNode colNode = parent as CollectionNode; if (colNode != null && endPathToken.Identifier.Equals(UriQueryConstants.CountSegment)) { // create a collection count node for collection node property. return(new CountNode(colNode)); } throw new ODataException(ODataErrorStrings.MetadataBinder_PropertyAccessSourceNotSingleValue(endPathToken.Identifier)); } // Now that we have the parent type, can find its corresponding EDM type IEdmStructuredTypeReference structuredParentType = singleValueParent.TypeReference == null ? null : singleValueParent.TypeReference.AsStructuredOrNull(); IEdmProperty property = structuredParentType == null ? null : this.Resolver.ResolveProperty(structuredParentType.StructuredDefinition(), endPathToken.Identifier); if (property != null) { return(GeneratePropertyAccessQueryNode(singleValueParent as SingleResourceNode, property, state)); } if (endPathToken.Identifier == ExpressionConstants.QueryOptionCount) { return(new CountVirtualPropertyNode()); } if (functionCallBinder.TryBindEndPathAsFunctionCall(endPathToken, singleValueParent, state, out boundFunction)) { return(boundFunction); } return(GeneratePropertyAccessQueryForOpenType(endPathToken, singleValueParent)); }
/// <summary> /// Builds the association link for the navigation property. /// </summary> /// <param name="baseUri">The URI to append to.</param> /// <param name="navigationPropertyName">The name of the navigation property to get the association link URI for.</param> /// <returns>The association link URI for the navigation property.</returns> internal override Uri BuildAssociationLinkUri(Uri baseUri, string navigationPropertyName) { ValidateBaseUri(baseUri); ExceptionUtils.CheckArgumentStringNotNullOrEmpty(navigationPropertyName, "navigationPropertyName"); Uri baseUriWithLinksSegment = AppendSegment(baseUri, navigationPropertyName, true /*escapeSegment*/); // We don't want the $ref segment to be escaped, so append that first without escaping, then append the property name with escaping return(AppendSegment(baseUriWithLinksSegment, ODataConstants.EntityReferenceSegmentName, false /*escapeSegment*/)); }
/// <summary> /// Create a new FunctionCallToken using the given function name and argument values. /// </summary> /// <param name="name">The name of the function to call.</param> /// <param name="argumentValues">The argument values for the function.</param> public FunctionCallToken(string name, IEnumerable <QueryToken> argumentValues) { ExceptionUtils.CheckArgumentStringNotNullOrEmpty(name, "name"); this.name = name; this.arguments = argumentValues == null ? new ReadOnlyEnumerableForUriParser <FunctionParameterToken>(FunctionParameterToken.EmptyParameterList) : new ReadOnlyEnumerableForUriParser <FunctionParameterToken>(argumentValues.Select(v => new FunctionParameterToken(null, v))); this.source = null; }