예제 #1
0
        private CsdlPropertyValue OnPropertyValueElement(XmlElementInfo element, XmlElementValueCollection childValues)
        {
            string             property   = Required(CsdlConstants.Attribute_Property);
            CsdlExpressionBase expression = this.ParseAnnotationExpression(element, childValues);

            return(new CsdlPropertyValue(property, expression, element.Location));
        }
예제 #2
0
        private IEdmExpression ComputeValue()
        {
            IEdmTypeReference  termType           = Term is UnresolvedVocabularyTerm ? null : Term.Type;
            CsdlExpressionBase adjustedExpression = AdjustStringConstantUsingTermType((this.Annotation).Expression, termType);

            return(CsdlSemanticsModel.WrapExpression(adjustedExpression, TargetBindingContext, this.Schema));
        }
예제 #3
0
 public CsdlAnnotation(string term, string qualifier, CsdlExpressionBase expression, CsdlLocation location)
     : base(location)
 {
     this.expression = expression;
     this.qualifier  = qualifier;
     this.term       = term;
 }
예제 #4
0
        /// <summary>
        /// Parse the IsOf expression using <see cref="JsonElement"/>.
        /// </summary>
        /// <param name="element">The input JSON element.</param>
        /// <param name="context">The parser context.</param>
        /// <param name="isOfExp">The built IsOf expression.</param>
        /// <returns>true/false</returns>
        private static bool BuildIsOfExpression(JsonElement element, JsonParserContext context, out CsdlIsTypeExpression isOfExp)
        {
            Debug.Assert(context != null);
            isOfExp = null;

            // Is-of expressions are represented as an object with a member $IsOf whose value is an annotation expression,
            JsonElement propertyValue;

            if (element.ValueKind != JsonValueKind.Object || !element.TryGetProperty("$IsOf", out propertyValue))
            {
                return(false);
            }

            // whose value is  an annotation expression,
            CsdlExpressionBase expression = propertyValue.ProcessProperty("$IsOf", context, ParseExpression);

            // a member $Type whose value is a string containing an qualified type name, and optionally a member $Collection with a value of true.

            // If the specified type is a primitive type or a collection of primitive types,
            // the facet members $MaxLength, $Unicode, $Precision, $Scale, and $SRID MAY be specified if applicable to the specified primitive type.
            // If the facet members are not specified, their values are considered unspecified.
            CsdlTypeReference typeReference = CsdlJsonParseHelper.ParseCsdlTypeReference(element, context);

            isOfExp = new CsdlIsTypeExpression(typeReference, expression, context.Location());
            return(true);
        }
예제 #5
0
 public CsdlAnnotation(string term, string qualifier, CsdlExpressionBase expression, CsdlLocation location)
     : base(location)
 {
     this.expression = expression;
     this.qualifier = qualifier;
     this.term = term;
 }
예제 #6
0
 public CsdlIfExpression(CsdlExpressionBase test, CsdlExpressionBase ifTrue, CsdlExpressionBase ifFalse, CsdlLocation location)
     : base(location)
 {
     this.test = test;
     this.ifTrue = ifTrue;
     this.ifFalse = ifFalse;
 }
예제 #7
0
        public void ParseIfExpressionWorksAsExpected()
        {
            string json = @" {
  ""$If"": [
    {
       ""$Path"": ""IsFemale""
    },
    ""Female"",
    ""Male""
  ]
}";

            CsdlExpressionBase expressionBase = ParseExpression(json);

            Assert.NotNull(expressionBase);
            CsdlIfExpression ifExp = Assert.IsType <CsdlIfExpression>(expressionBase);

            Assert.NotNull(ifExp.Test);
            CsdlPathExpression pathExp = Assert.IsType <CsdlPathExpression>(ifExp.Test);

            Assert.Equal("IsFemale", pathExp.Path);

            Assert.NotNull(ifExp.IfTrue);
            CsdlConstantExpression trueExp = Assert.IsType <CsdlConstantExpression>(ifExp.IfTrue);

            Assert.Equal(EdmValueKind.String, trueExp.ValueKind);
            Assert.Equal("Female", trueExp.Value);

            Assert.NotNull(ifExp.IfFalse);
            CsdlConstantExpression falseExp = Assert.IsType <CsdlConstantExpression>(ifExp.IfFalse);

            Assert.Equal(EdmValueKind.String, falseExp.ValueKind);
            Assert.Equal("Male", falseExp.Value);
        }
예제 #8
0
        public void ParseCastExpressionWorksAsExpected()
        {
            string json = @" {
  ""$Cast"": {
    ""$Path"": ""Average""
  },
  ""$Type"": ""Edm.Decimal"",
  ""$Precision"": 42
}";

            CsdlExpressionBase expressionBase = ParseExpression(json);

            Assert.NotNull(expressionBase);
            CsdlCastExpression castExp = Assert.IsType <CsdlCastExpression>(expressionBase);

            Assert.NotNull(castExp.Operand);
            CsdlPathExpression pathExp = Assert.IsType <CsdlPathExpression>(castExp.Operand);

            Assert.Equal("Average", pathExp.Path);

            Assert.NotNull(castExp.Type);
            CsdlDecimalTypeReference decimalType = Assert.IsType <CsdlDecimalTypeReference>(castExp.Type);

            Assert.NotNull(decimalType.Precision);
            Assert.Equal(42, decimalType.Precision.Value);
            Assert.Null(decimalType.Scale);
        }
예제 #9
0
        /// <summary>
        /// Parse the If expression using <see cref="JsonElement"/>.
        /// </summary>
        /// <param name="element">The input JSON element.</param>
        /// <param name="context">The parser context.</param>
        /// <param name="ifExp">The built if expression.</param>
        /// <returns>true/false</returns>
        private static bool TryParseIfExpression(JsonElement element, JsonParserContext context, out CsdlIfExpression ifExp)
        {
            Debug.Assert(context != null);
            ifExp = null;

            // Conditional expressions are represented as an object with a member $If whose value is an array of two or three annotation expressions.
            JsonElement propertyValue;

            if (element.ValueKind != JsonValueKind.Object ||
                !element.TryGetProperty("$If", out propertyValue) ||
                propertyValue.ValueKind != JsonValueKind.Array)
            {
                return(false);
            }

            // first child is the test
            CsdlExpressionBase testExpression = propertyValue.ProcessItem(0, context, ParseExpression);

            // the second child is ture clause
            CsdlExpressionBase trueExpression = propertyValue.ProcessItem(1, context, ParseExpression);

            // the third child is false clause
            CsdlExpressionBase falseExpression = null;

            if (propertyValue.GetArrayLength() >= 3)
            {
                // if and only if the if-then-else expression is an item of a collection expression,
                // the third child expression MAY be omitted, reducing it to an if-then expression.
                falseExpression = propertyValue.ProcessItem(2, context, ParseExpression);
            }

            ifExp = new CsdlIfExpression(testExpression, trueExpression, falseExpression, context.Location());
            return(true);
        }
예제 #10
0
 public CsdlIfExpression(CsdlExpressionBase test, CsdlExpressionBase ifTrue, CsdlExpressionBase ifFalse, CsdlLocation location)
     : base(location)
 {
     this.test    = test;
     this.ifTrue  = ifTrue;
     this.ifFalse = ifFalse;
 }
 public CsdlSemanticsLabeledExpression(string name, CsdlExpressionBase element, IEdmEntityType bindingContext, CsdlSemanticsSchema schema)
     : base(element)
 {
     this.name           = name;
     this.sourceElement  = element;
     this.bindingContext = bindingContext;
     this.schema         = schema;
 }
예제 #12
0
        private CsdlAnnotation OnAnnotationElement(XmlElementInfo element, XmlElementValueCollection childValues)
        {
            string             term       = RequiredQualifiedName(CsdlConstants.Attribute_Term);
            string             qualifier  = Optional(CsdlConstants.Attribute_Qualifier);
            CsdlExpressionBase expression = this.ParseAnnotationExpression(element, childValues);

            return(new CsdlAnnotation(term, qualifier, expression, element.Location));
        }
예제 #13
0
        public void ParseRecordExpressionWorksAsExpected()
        {
            string json = @" {
  ""@type"": ""org.example.person.Manager"",
  ""@Core.Description"": ""Annotation on record"",
  ""GivenName"": {
    ""$Path"": ""FirstName""
  },
  ""*****@*****.**"": ""Annotation on record member"",
  ""Surname"": {
    ""$Path"": ""LastName""
  },
  ""DirectSupervisor"": {
    ""$Path"": ""Manager""
  },
  ""CostCenter"": ""CostCenter Value""
}";

            CsdlExpressionBase expressionBase = ParseExpression(json, out JsonParserContext context);

            Assert.NotEmpty(context.Errors);
            Assert.Equal(2, context.Errors.Count);
            Assert.Equal("A member at JSON path '[email protected]' is not supported.", context.Errors.First().ErrorMessage);
            Assert.Equal("A member at JSON path '[email protected]' is not supported.", context.Errors.Last().ErrorMessage);

            Assert.NotNull(expressionBase);
            CsdlRecordExpression recordExp = Assert.IsType <CsdlRecordExpression>(expressionBase);

            Assert.NotNull(recordExp.Type);
            CsdlNamedTypeReference namedType = Assert.IsType <CsdlNamedTypeReference>(recordExp.Type);

            Assert.Equal("org.example.person.Manager", namedType.FullName);

            Assert.NotNull(recordExp.PropertyValues);
            Assert.Equal(4, recordExp.PropertyValues.Count());

            // GivenName
            CsdlPropertyValue propertyValue = recordExp.PropertyValues.FirstOrDefault(c => c.Property == "GivenName");

            Assert.NotNull(propertyValue);
            Assert.IsType <CsdlPathExpression>(propertyValue.Expression);

            // Surname
            propertyValue = recordExp.PropertyValues.FirstOrDefault(c => c.Property == "Surname");
            Assert.NotNull(propertyValue);
            Assert.IsType <CsdlPathExpression>(propertyValue.Expression);

            // DirectSupervisor
            propertyValue = recordExp.PropertyValues.FirstOrDefault(c => c.Property == "DirectSupervisor");
            Assert.NotNull(propertyValue);
            Assert.IsType <CsdlPathExpression>(propertyValue.Expression);

            // DirectSupervisor
            propertyValue = recordExp.PropertyValues.FirstOrDefault(c => c.Property == "CostCenter");
            Assert.NotNull(propertyValue);
            Assert.IsType <CsdlConstantExpression>(propertyValue.Expression);
        }
예제 #14
0
        [InlineData("1.7976931348623157E+308", EdmValueKind.Floating, "1.7976931348623157E+308")] // double.MaxValue
        public void ParseConstantExpressionWorksAsExpected(string json, EdmValueKind kind, string expected)
        {
            CsdlExpressionBase expressionBase = ParseExpression(json);

            Assert.NotNull(expressionBase);
            CsdlConstantExpression constExp = Assert.IsType <CsdlConstantExpression>(expressionBase);

            Assert.Equal(kind, constExp.ValueKind);
            Assert.Equal(expected, constExp.Value);
        }
예제 #15
0
        private static CsdlExpressionBase AdjustStringConstantUsingTermType(CsdlExpressionBase expression, IEdmTypeReference termType)
        {
            if (expression == null || termType == null)
            {
                return(expression);
            }

            switch (expression.ExpressionKind)
            {
            case EdmExpressionKind.Collection:
                if (termType.IsCollection())
                {
                    IEdmTypeReference          elementType   = termType.AsCollection().ElementType();
                    IList <CsdlExpressionBase> newElements   = new List <CsdlExpressionBase>();
                    CsdlCollectionExpression   collectionExp = (CsdlCollectionExpression)expression;

                    foreach (CsdlExpressionBase exp in collectionExp.ElementValues)
                    {
                        if (exp != null && exp.ExpressionKind == EdmExpressionKind.StringConstant)
                        {
                            newElements.Add(AdjustStringConstantUsingTermType(exp, elementType));
                        }
                        else
                        {
                            newElements.Add(exp);
                        }
                    }

                    return(new CsdlCollectionExpression(collectionExp.Type, newElements, collectionExp.Location as CsdlLocation));
                }

                break;

            case EdmExpressionKind.StringConstant:
                CsdlConstantExpression constantExp = (CsdlConstantExpression)expression;
                switch (termType.TypeKind())
                {
                case EdmTypeKind.Primitive:
                    IEdmPrimitiveTypeReference primitiveTypeReference = (IEdmPrimitiveTypeReference)termType;
                    return(BuildPrimitiveExpression(primitiveTypeReference, constantExp));

                case EdmTypeKind.Path:
                    IEdmPathType pathType = (IEdmPathType)termType.Definition;
                    return(BuildPathExpression(pathType, constantExp));

                case EdmTypeKind.Enum:
                    IEdmEnumType enumType = (IEdmEnumType)termType.Definition;
                    return(BuildEnumExpression(enumType, constantExp));
                }

                break;
            }

            return(expression);
        }
예제 #16
0
        public void ParseValuePathExpressionWorksAsExpected()
        {
            string json = @" { ""$Path"": ""@vCard.Address#work/FullName""  }";

            CsdlExpressionBase expressionBase = ParseExpression(json);

            Assert.NotNull(expressionBase);
            CsdlPathExpression pathExp = Assert.IsType <CsdlPathExpression>(expressionBase);

            Assert.Equal("@vCard.Address#work/FullName", pathExp.Path);
        }
예제 #17
0
        public void ParseLabeledElementReferenceExpressionWorksAsExpected()
        {
            string json = @" { ""$LabeledElementReference"": ""self.CustomerFirstName"" }";

            CsdlExpressionBase expressionBase = ParseExpression(json);

            Assert.NotNull(expressionBase);
            CsdlLabeledExpressionReferenceExpression labeledRefExp = Assert.IsType <CsdlLabeledExpressionReferenceExpression>(expressionBase);

            Assert.Equal("self.CustomerFirstName", labeledRefExp.Label);
        }
예제 #18
0
        /// <summary>
        /// Parse the record expression expression using <see cref="JsonElement"/>.
        /// </summary>
        /// <param name="element">The input JSON element.</param>
        /// <param name="context">The parser context.</param>
        /// <returns>the built record expression.</returns>
        private static CsdlRecordExpression ParseRecordExpression(JsonElement element, JsonParserContext context)
        {
            Debug.Assert(context != null);

            // A record expression MAY specify the structured type of its result, which MUST be an entity type or complex type in scope.
            // If not explicitly specified, the type is derived from the expression’s context

            // The type of a record expression is represented as the @type control information
            // for example: "@type": "https://example.org/vocabs/person#org.example.person.Manager",
            // So far, ODL doesn't support the type "@type" with relative path, only supports like "#Model.VipCustomer", or without #
            // for 4.0, this name MUST be prefixed with the hash symbol (#);
            // or non-OData 4.0 payloads, built-in primitive type values SHOULD be represented without the hash symbol,
            // but consumers of 4.01 or greater payloads MUST support values with or without the hash symbol.

            CsdlTypeReference typeReference = null;

            if (element.TryGetProperty("@type", out JsonElement typeValue))
            {
                // Try to build the type. The type should be "Complex type" or "Entity Type".
                string typeName = typeValue.ProcessProperty("@type", context, (e, c) => e.ParseAsString(c));
                int    index    = typeName.IndexOf('#');
                if (index >= 0)
                {
                    typeName = typeName.Substring(index + 1); // remove the "#"
                }

                typeReference = new CsdlNamedTypeReference(typeName, true, context.Location());
            }

            IList <CsdlPropertyValue> propertyValues = new List <CsdlPropertyValue>();

            element.ParseAsObject(context, (propertyName, propertyValue) =>
            {
                // skips the @type, because it's processed above.
                if (propertyName == "@type")
                {
                    return;
                }

                // It MAY contain annotations for itself and its members. Annotations for record members are prefixed with the member name.
                // So far, it's not supported. So report non-fatal error for all the annotations on record.
                if (propertyName.IndexOf('@') != -1)
                {
                    context.ReportError(EdmErrorCode.UnsupportedElement, Strings.CsdlJsonParser_UnsupportedJsonMember(context.Path));
                    return;
                }

                CsdlExpressionBase propertyValueExpression = ParseExpression(propertyValue, context);
                propertyValues.Add(new CsdlPropertyValue(propertyName, propertyValueExpression, context.Location()));
            });

            return(new CsdlRecordExpression(typeReference, propertyValues, context.Location()));
        }
예제 #19
0
        public void ParseLabeledElementExpressionWorksAsExpected()
        {
            string json = @" { ""$LabeledElement"": {
     ""$Path"": ""FirstName""
  },
   ""$Name"": ""CustomerFirstName""
}";

            CsdlExpressionBase expressionBase = ParseExpression(json);

            Assert.NotNull(expressionBase);
            CsdlLabeledExpression labeledExp = Assert.IsType <CsdlLabeledExpression>(expressionBase);

            Assert.Equal("CustomerFirstName", labeledExp.Label);
            Assert.NotNull(labeledExp.Element);
            Assert.IsType <CsdlPathExpression>(labeledExp.Element);
        }
예제 #20
0
        public void ParseCollectionExpressionWorksAsExpected()
        {
            string json = @" [
  ""Product"",
  ""Supplier"",
  ""Customer""
]";

            CsdlExpressionBase expressionBase = ParseExpression(json);

            Assert.NotNull(expressionBase);
            CsdlCollectionExpression collectionExp = Assert.IsType <CsdlCollectionExpression>(expressionBase);

            Assert.Equal(3, collectionExp.ElementValues.Count());

            Assert.Equal(new[] { "Product", "Supplier", "Customer" },
                         collectionExp.ElementValues.Select(e => ((CsdlConstantExpression)e).Value));
        }
예제 #21
0
        /// <summary>
        /// Parse the Labeled Element expression using <see cref="JsonElement"/>.
        /// </summary>
        /// <param name="element">The input JSON element.</param>
        /// <param name="context">The parser context.</param>
        /// <param name="labeledExp">The built labeled element expression.</param>
        /// <returns>true/false</returns>
        private static bool TryParseLabeledElementExpression(JsonElement element, JsonParserContext context, out CsdlLabeledExpression labeledExp)
        {
            Debug.Assert(context != null);
            labeledExp = null;

            // Labeled element expressions are represented as an object with a member $LabeledElement whose value is an annotation expression
            JsonElement propertyValue;

            if (element.ValueKind != JsonValueKind.Object || !element.TryGetProperty("$LabeledElement", out propertyValue))
            {
                return(false);
            }

            CsdlExpressionBase expression = propertyValue.ProcessProperty("$LabeledElement", context, ParseExpression);

            // a member $Name whose value is a string containing the labeled element’s name.
            string label = element.ProcessRequiredProperty("$Name", context, (v, p) => v.ParseAsString(p));

            labeledExp = new CsdlLabeledExpression(label, expression, context.Location());
            return(true);
        }
예제 #22
0
        /// <summary>
        /// Parse the Cast expression using <see cref="JsonElement"/>.
        /// </summary>
        /// <param name="element">The input JSON element.</param>
        /// <param name="context">The parser context.</param>
        /// <param name="castExp">The built cast expression.</param>
        /// <returns>true/false.</returns>
        private static bool TryParseCastExpression(JsonElement element, JsonParserContext context, out CsdlCastExpression castExp)
        {
            Debug.Assert(context != null);

            castExp = null;
            // Cast expressions are represented as an object with a member $Cast
            JsonElement propertyValue;

            if (element.ValueKind != JsonValueKind.Object || !element.TryGetProperty("$Cast", out propertyValue))
            {
                return(false);
            }

            // with a member $Cast whose value is an annotation expression
            CsdlExpressionBase expression = propertyValue.ProcessProperty("$Cast", context, ParseExpression);

            // a member $Type whose value is a string containing the qualified type name, and optionally a member $Collection with a value of true.
            CsdlTypeReference typeReference = CsdlJsonParseHelper.ParseCsdlTypeReference(element, context);

            castExp = new CsdlCastExpression(typeReference, expression, context.Location());
            return(true);
        }
예제 #23
0
        /// <summary>
        /// Try to parse the input json value <see cref="JsonElement"/> to <see cref="CsdlAnnotation"/>.
        /// </summary>
        /// <param name="annotionName">The input annotation name, annotation name should start with '@'.</param>
        /// <param name="element">The JSON value to parse.</param>
        /// <param name="context">The parser context.</param>
        /// <param name="csdlAnnotation">The built CSDL annotation.</param>
        /// <returns>true/false.</returns>
        public static bool TryParseCsdlAnnotation(string annotionName, JsonElement element, JsonParserContext context, out CsdlAnnotation csdlAnnotation)
        {
            EdmUtil.CheckArgumentNull(context, nameof(context));

            csdlAnnotation = null;

            // An annotation is represented as a member whose name consists of an at (@) character,
            // followed by the qualified name of a term, optionally followed by a hash (#) and a qualifier.
            if (!ParseAnnotationName(annotionName, out string termName, out string qualifier))
            {
                return(false);
            }

            context.EnterScope(annotionName);

            CsdlExpressionBase expression = ParseExpression(element, context);

            context.LeaveScope(annotionName);

            csdlAnnotation = new CsdlAnnotation(termName, qualifier, expression, context.Location());
            return(true);
        }
예제 #24
0
        public void ParseIsOfExpressionWorksAsExpected()
        {
            string json = @" { ""$IsOf"": {
     ""$Path"": ""FirstName""
  },
   ""$Type"": ""self.PreferredCustomer"",
   ""$Collection"": true
}";

            CsdlExpressionBase expressionBase = ParseExpression(json);

            Assert.NotNull(expressionBase);
            CsdlIsTypeExpression isTypeExp = Assert.IsType <CsdlIsTypeExpression>(expressionBase);

            Assert.NotNull(isTypeExp.Type);
            CsdlExpressionTypeReference expTypeReference = Assert.IsType <CsdlExpressionTypeReference>(isTypeExp.Type);
            CsdlCollectionType          collectionType   = Assert.IsType <CsdlCollectionType>(expTypeReference.TypeExpression);
            CsdlNamedTypeReference      namedType        = Assert.IsType <CsdlNamedTypeReference>(collectionType.ElementType);

            Assert.Equal("self.PreferredCustomer", namedType.FullName);

            Assert.NotNull(isTypeExp.Operand);
            Assert.IsType <CsdlPathExpression>(isTypeExp.Operand);
        }
예제 #25
0
 protected CsdlSemanticsExpression(CsdlSemanticsSchema schema, CsdlExpressionBase element)
     : base(element)
 {
     this.schema = schema;
 }
예제 #26
0
 public CsdlPropertyValue(string property, CsdlExpressionBase expression, CsdlLocation location)
     : base(location)
 {
     this.property   = property;
     this.expression = expression;
 }
예제 #27
0
 public CsdlLabeledExpression(string label, CsdlExpressionBase element, CsdlLocation location)
     : base(location)
 {
     this.label = label;
     this.element = element;
 }
예제 #28
0
 public CsdlIsTypeExpression(CsdlTypeReference type, CsdlExpressionBase operand, CsdlLocation location)
     : base(location)
 {
     this.type = type;
     this.operand = operand;
 }
예제 #29
0
 public CsdlPropertyReferenceExpression(string property, CsdlExpressionBase baseExpression, CsdlLocation location)
     : base(location)
 {
     this.property       = property;
     this.baseExpression = baseExpression;
 }
예제 #30
0
        internal static IEdmExpression WrapExpression(CsdlExpressionBase expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema)
        {
            if (expression != null)
            {
                switch (expression.ExpressionKind)
                {
                case EdmExpressionKind.Cast:
                    return(new CsdlSemanticsCastExpression((CsdlCastExpression)expression, bindingContext, schema));

                case EdmExpressionKind.BinaryConstant:
                    return(new CsdlSemanticsBinaryConstantExpression((CsdlConstantExpression)expression, schema));

                case EdmExpressionKind.BooleanConstant:
                    return(new CsdlSemanticsBooleanConstantExpression((CsdlConstantExpression)expression, schema));

                case EdmExpressionKind.Collection:
                    return(new CsdlSemanticsCollectionExpression((CsdlCollectionExpression)expression, bindingContext, schema));

                case EdmExpressionKind.DateTimeOffsetConstant:
                    return(new CsdlSemanticsDateTimeOffsetConstantExpression((CsdlConstantExpression)expression, schema));

                case EdmExpressionKind.DecimalConstant:
                    return(new CsdlSemanticsDecimalConstantExpression((CsdlConstantExpression)expression, schema));

                case EdmExpressionKind.EnumMember:
                    return(new CsdlSemanticsEnumMemberExpression((CsdlEnumMemberExpression)expression, bindingContext, schema));

                case EdmExpressionKind.FloatingConstant:
                    return(new CsdlSemanticsFloatingConstantExpression((CsdlConstantExpression)expression, schema));

                case EdmExpressionKind.Null:
                    return(new CsdlSemanticsNullExpression((CsdlConstantExpression)expression, schema));

                case EdmExpressionKind.FunctionApplication:
                    return(new CsdlSemanticsApplyExpression((CsdlApplyExpression)expression, bindingContext, schema));

                case EdmExpressionKind.GuidConstant:
                    return(new CsdlSemanticsGuidConstantExpression((CsdlConstantExpression)expression, schema));

                case EdmExpressionKind.If:
                    return(new CsdlSemanticsIfExpression((CsdlIfExpression)expression, bindingContext, schema));

                case EdmExpressionKind.IntegerConstant:
                    return(new CsdlSemanticsIntConstantExpression((CsdlConstantExpression)expression, schema));

                case EdmExpressionKind.IsType:
                    return(new CsdlSemanticsIsTypeExpression((CsdlIsTypeExpression)expression, bindingContext, schema));

                case EdmExpressionKind.LabeledExpressionReference:
                    return(new CsdlSemanticsLabeledExpressionReferenceExpression((CsdlLabeledExpressionReferenceExpression)expression, bindingContext, schema));

                case EdmExpressionKind.Labeled:
                    return(schema.WrapLabeledElement((CsdlLabeledExpression)expression, bindingContext));

                case EdmExpressionKind.Path:
                    return(new CsdlSemanticsPathExpression((CsdlPathExpression)expression, bindingContext, schema));

                case EdmExpressionKind.PropertyPath:
                    return(new CsdlSemanticsPropertyPathExpression((CsdlPropertyPathExpression)expression, bindingContext, schema));

                case EdmExpressionKind.NavigationPropertyPath:
                    return(new CsdlSemanticsNavigationPropertyPathExpression((CsdlNavigationPropertyPathExpression)expression, bindingContext, schema));

                case EdmExpressionKind.Record:
                    return(new CsdlSemanticsRecordExpression((CsdlRecordExpression)expression, bindingContext, schema));

                case EdmExpressionKind.StringConstant:
                    return(new CsdlSemanticsStringConstantExpression((CsdlConstantExpression)expression, schema));

                case EdmExpressionKind.DurationConstant:
                    return(new CsdlSemanticsDurationConstantExpression((CsdlConstantExpression)expression, schema));

                case EdmExpressionKind.DateConstant:
                    return(new CsdlSemanticsDateConstantExpression((CsdlConstantExpression)expression, schema));

                case EdmExpressionKind.TimeOfDayConstant:
                    return(new CsdlSemanticsTimeOfDayConstantExpression((CsdlConstantExpression)expression, schema));

                case EdmExpressionKind.AnnotationPath:
                    return(new CsdlSemanticsAnnotationPathExpression((CsdlAnnotationPathExpression)expression, bindingContext, schema));
                }
            }

            return(null);
        }
예제 #31
0
 public CsdlPropertyValue(string property, CsdlExpressionBase expression, CsdlLocation location)
     : base(location)
 {
     this.property = property;
     this.expression = expression;
 }
예제 #32
0
        private static void AddLabeledExpressions(CsdlExpressionBase expression, Dictionary <string, object> result)
        {
            if (expression == null)
            {
                return;
            }

            switch (expression.ExpressionKind)
            {
            case Expressions.EdmExpressionKind.Labeled:
            {
                CsdlLabeledExpression labeledElement = (CsdlLabeledExpression)expression;
                string label = labeledElement.Label;
                object duplicateLabeledElement;
                if (result.TryGetValue(label, out duplicateLabeledElement))
                {
                    // If the label has multiple definitions, store the duplicates as a list of labeled elements.
                    List <CsdlLabeledExpression> duplicates = duplicateLabeledElement as List <CsdlLabeledExpression>;
                    if (duplicates == null)
                    {
                        duplicates = new List <CsdlLabeledExpression>();
                        duplicates.Add((CsdlLabeledExpression)duplicateLabeledElement);
                        result[label] = duplicates;
                    }

                    duplicates.Add(labeledElement);
                }
                else
                {
                    result[label] = labeledElement;
                }

                AddLabeledExpressions(labeledElement.Element, result);
                break;
            }

            case Expressions.EdmExpressionKind.Collection:
                foreach (CsdlExpressionBase element in ((CsdlCollectionExpression)expression).ElementValues)
                {
                    AddLabeledExpressions(element, result);
                }

                break;

            case Expressions.EdmExpressionKind.OperationApplication:
                foreach (CsdlExpressionBase argument in ((CsdlApplyExpression)expression).Arguments)
                {
                    AddLabeledExpressions(argument, result);
                }

                break;

            case Expressions.EdmExpressionKind.Record:
                foreach (CsdlPropertyValue property in ((CsdlRecordExpression)expression).PropertyValues)
                {
                    AddLabeledExpressions(property.Expression, result);
                }

                break;

            case Expressions.EdmExpressionKind.If:
            {
                CsdlIfExpression ifExpression = (CsdlIfExpression)expression;
                AddLabeledExpressions(ifExpression.Test, result);
                AddLabeledExpressions(ifExpression.IfTrue, result);
                AddLabeledExpressions(ifExpression.IfFalse, result);

                break;
            }

            case Expressions.EdmExpressionKind.IsType:
                AddLabeledExpressions(((CsdlIsTypeExpression)expression).Operand, result);
                break;

            case Expressions.EdmExpressionKind.Cast:
                AddLabeledExpressions(((CsdlCastExpression)expression).Operand, result);
                break;

            default:
                break;
            }
        }
예제 #33
0
        private static void AddLabeledExpressions(CsdlExpressionBase expression, Dictionary <string, object> result)
        {
            if (expression != null)
            {
                switch (expression.ExpressionKind)
                {
                case EdmExpressionKind.Record:
                    foreach (CsdlPropertyValue value2 in ((CsdlRecordExpression)expression).PropertyValues)
                    {
                        AddLabeledExpressions(value2.Expression, result);
                    }
                    return;

                case EdmExpressionKind.Collection:
                    foreach (CsdlExpressionBase base2 in ((CsdlCollectionExpression)expression).ElementValues)
                    {
                        AddLabeledExpressions(base2, result);
                    }
                    return;

                case EdmExpressionKind.If:
                {
                    CsdlIfExpression expression3 = (CsdlIfExpression)expression;
                    AddLabeledExpressions(expression3.Test, result);
                    AddLabeledExpressions(expression3.IfTrue, result);
                    AddLabeledExpressions(expression3.IfFalse, result);
                    return;
                }

                case EdmExpressionKind.AssertType:
                    AddLabeledExpressions(((CsdlAssertTypeExpression)expression).Operand, result);
                    return;

                case EdmExpressionKind.IsType:
                    AddLabeledExpressions(((CsdlIsTypeExpression)expression).Operand, result);
                    return;

                case EdmExpressionKind.FunctionApplication:
                    foreach (CsdlExpressionBase base3 in ((CsdlApplyExpression)expression).Arguments)
                    {
                        AddLabeledExpressions(base3, result);
                    }
                    return;

                case EdmExpressionKind.LabeledExpressionReference:
                    return;

                case EdmExpressionKind.Labeled:
                {
                    object obj2;
                    CsdlLabeledExpression item = (CsdlLabeledExpression)expression;
                    string label = item.Label;
                    if (!result.TryGetValue(label, out obj2))
                    {
                        result[label] = item;
                    }
                    else
                    {
                        List <CsdlLabeledExpression> list = obj2 as List <CsdlLabeledExpression>;
                        if (list == null)
                        {
                            list = new List <CsdlLabeledExpression> {
                                (CsdlLabeledExpression)obj2
                            };
                            result[label] = list;
                        }
                        list.Add(item);
                    }
                    AddLabeledExpressions(item.Element, result);
                    return;
                }
                }
            }
        }
 public CsdlPropertyReferenceExpression(string property, CsdlExpressionBase baseExpression, CsdlLocation location)
     : base(location)
 {
     this.property = property;
     this.baseExpression = baseExpression;
 }
예제 #35
0
 public CsdlLabeledExpression(string label, CsdlExpressionBase element, CsdlLocation location)
     : base(location)
 {
     this.label   = label;
     this.element = element;
 }
예제 #36
0
 public CsdlIsTypeExpression(CsdlTypeReference type, CsdlExpressionBase operand, CsdlLocation location)
     : base(location)
 {
     this.type    = type;
     this.operand = operand;
 }
예제 #37
0
 public CsdlValueAnnotation(string term, string qualifier, CsdlExpressionBase expression, CsdlLocation location)
     : base(term, qualifier, location)
 {
     this.expression = expression;
 }