public ClientEdmCollectionValueTests() { this._intType = EdmCoreModel.Instance.GetInt32(false); this._value1 = new EdmIntegerConstant(1); this._value2 = new EdmIntegerConstant(2); this._collection = new ClientEdmCollectionValue(this._intType, new IEdmValue[] { this._value1, this._value2 }); }
public void TestIntegerConstant() { var constant = new EdmIntegerConstant(0); Assert.AreEqual(EdmValueKind.Integer, constant.ValueKind, "Invalid value kind."); this.ValidateEdmValueKindRoundTrip(EdmValueKind.Integer, EdmCoreModel.Instance.GetByte(true), constant); this.ValidateEdmValueKindRoundTrip(EdmValueKind.Integer, EdmCoreModel.Instance.GetSByte(true), constant); this.ValidateEdmValueKindRoundTrip(EdmValueKind.Integer, EdmCoreModel.Instance.GetInt16(true), constant); this.ValidateEdmValueKindRoundTrip(EdmValueKind.Integer, EdmCoreModel.Instance.GetInt32(true), constant); this.ValidateEdmValueKindRoundTrip(EdmValueKind.Integer, EdmCoreModel.Instance.GetInt64(true), constant); }
public void BuildEdmExpression_Works_ForTypeDefinitionValue() { // Arrange EdmTypeDefinition definition = new EdmTypeDefinition("NS", "MyTypeDefinition", EdmPrimitiveTypeKind.Int32); // Act IEdmExpression exp = IEdmTermExtensions.BuildEdmExpression(definition, "42"); // Assert Assert.NotNull(exp); EdmIntegerConstant constant = Assert.IsType <EdmIntegerConstant>(exp); Assert.Equal(42, constant.Value); }
public void BuildEdmExpression_Works_ForLongValue() { // Arrange IEdmType edmType = EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int64); // Act IEdmExpression exp = IEdmTermExtensions.BuildEdmExpression(edmType, long.MaxValue.ToString()); // Assert Assert.NotNull(exp); EdmIntegerConstant constant = Assert.IsType <EdmIntegerConstant>(exp); Assert.Equal(long.MaxValue, constant.Value); }
public void BuildEdmExpression_Works_ForIntValue() { // Arrange IEdmType edmType = EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int32); // Act IEdmExpression exp = IEdmTermExtensions.BuildEdmExpression(edmType, "3"); // Assert Assert.NotNull(exp); EdmIntegerConstant constant = Assert.IsType <EdmIntegerConstant>(exp); Assert.Equal(3, constant.Value); }
public void EdmIntegerConstant() { var e = new EdmIntegerConstant(2); Assert.AreEqual(EdmExpressionKind.IntegerConstant, e.ExpressionKind, "e.ExpressionKind"); Assert.IsNull(e.Type, "e.Type"); Assert.AreEqual(2, e.Value, "e.Value"); e = new EdmIntegerConstant(EdmCoreModel.Instance.GetInt32(true), 3); Assert.AreEqual(true, e.Type.IsNullable, "e.Type.IsNullable"); Assert.AreEqual(3, e.Value, "e.Value"); e = new EdmIntegerConstant(null, 2); Assert.IsNull(e.Type, "e.Type"); Assert.IsFalse(e.IsBad(), "Expression not bad."); Assert.AreEqual(0, e.Errors().Count(), "Expression has no errors"); }
private static void GetEnumValuesAndNames(IEdmEnumType enumType, ref ulong[] values, ref string[] names, bool getValues, bool getNames) { Dictionary <string, ulong> dict = new Dictionary <string, ulong>(); foreach (var member in enumType.Members) { EdmIntegerConstant intValue = member.Value as EdmIntegerConstant; if (intValue != null) { dict.Add(member.Name, (ulong)intValue.Value); } } Dictionary <string, ulong> sortedDict = dict.OrderBy(d => d.Value).ToDictionary(d => d.Key, d => d.Value); values = sortedDict.Select(d => d.Value).ToArray(); names = sortedDict.Select(d => d.Key).ToArray(); }
public static void SetScaleMeasuresAnnotation(this EdmModel model, IEdmProperty property, byte scale) { if (model == null) { throw new ArgumentNullException("model"); } if (property == null) { throw new ArgumentNullException("property"); } var target = property; var term = ScaleTerm; var expression = new EdmIntegerConstant(scale); var annotation = new EdmAnnotation(target, term, expression); annotation.SetSerializationLocation(model, property.ToSerializationLocation()); model.AddVocabularyAnnotation(annotation); }
public IEdmExpression ConvertToStockExpression(IEdmExpression edmExpression, EdmModel stockModel) { IEdmExpression result = null; switch (edmExpression.ExpressionKind) { case EdmExpressionKind.Null: result = EdmNullExpression.Instance; break; case EdmExpressionKind.StringConstant: var tempString = (IEdmStringConstantExpression)edmExpression; result = new EdmStringConstant(tempString.Type != null ? this.ConvertToStockTypeReference(tempString.Type, stockModel).AsString() : null, tempString.Value); break; case EdmExpressionKind.IntegerConstant: var tempInteger = (IEdmIntegerConstantExpression)edmExpression; result = new EdmIntegerConstant(tempInteger.Type != null ? this.ConvertToStockTypeReference(tempInteger.Type, stockModel).AsPrimitive() : null, tempInteger.Value); break; case EdmExpressionKind.Record: var tempRecord = (IEdmRecordExpression)edmExpression; result = new EdmRecordExpression( tempRecord.DeclaredType == null ? null : this.ConvertToStockTypeReference(tempRecord.DeclaredType, stockModel).AsStructured(), tempRecord.Properties.Select(edmProperty => (IEdmPropertyConstructor) new EdmPropertyConstructor(edmProperty.Name, this.ConvertToStockExpression(edmProperty.Value, stockModel)))); break; case EdmExpressionKind.Collection: var tempCollection = (IEdmCollectionExpression)edmExpression; result = new EdmCollectionExpression(tempCollection.Elements.Select(element => this.ConvertToStockExpression(element, stockModel))); break; default: throw new NotImplementedException(); } return(result); }
private IEdmValue Eval(IEdmExpression expression, IEdmStructuredValue context) { switch (expression.ExpressionKind) { case EdmExpressionKind.IntegerConstant: return((IEdmIntegerConstantExpression)expression); case EdmExpressionKind.StringConstant: return((IEdmStringConstantExpression)expression); case EdmExpressionKind.BinaryConstant: return((IEdmBinaryConstantExpression)expression); case EdmExpressionKind.BooleanConstant: return((IEdmBooleanConstantExpression)expression); case EdmExpressionKind.DateTimeOffsetConstant: return((IEdmDateTimeOffsetConstantExpression)expression); case EdmExpressionKind.DecimalConstant: return((IEdmDecimalConstantExpression)expression); case EdmExpressionKind.FloatingConstant: return((IEdmFloatingConstantExpression)expression); case EdmExpressionKind.GuidConstant: return((IEdmGuidConstantExpression)expression); case EdmExpressionKind.DurationConstant: return((IEdmDurationConstantExpression)expression); case EdmExpressionKind.DateConstant: return((IEdmDateConstantExpression)expression); case EdmExpressionKind.TimeOfDayConstant: return((IEdmTimeOfDayConstantExpression)expression); case EdmExpressionKind.Null: return((IEdmNullExpression)expression); case EdmExpressionKind.Path: { if (context == null) { throw new InvalidOperationException(Edm.Strings.Edm_Evaluator_NoContextPath); } IEdmPathExpression pathExpression = (IEdmPathExpression)expression; IEdmValue result = context; #if ORCAS // [EdmLib] Need to handle paths that bind to things other than properties. foreach (string hop in pathExpression.Path) { result = FindProperty(hop, result); if (result == null) { throw new InvalidOperationException(Edm.Strings.Edm_Evaluator_UnboundPath(hop)); } } #else // Only Support Annotation in EntityType or ComplexType or Property or NavigationProperty. // Empty Path is not supported. foreach (string hop in pathExpression.Path) { if (hop.Contains("@")) { var currentPathSegementInfos = hop.Split('@'); var propertyName = currentPathSegementInfos[0]; var termInfo = currentPathSegementInfos[1]; IEdmExpression termCastExpression = null; if (!string.IsNullOrWhiteSpace(termInfo)) { var termInfos = termInfo.Split('#'); if (termInfos.Length <= 2) { string termName = termInfos[0]; string qualifier = termInfos.Length == 2 ? termInfos[1] : null; if (string.IsNullOrWhiteSpace(propertyName) && this.getAnnotationExpressionForType != null) { termCastExpression = this.getAnnotationExpressionForType(edmModel, context.Type.Definition, termName, qualifier); } else if (!string.IsNullOrWhiteSpace(propertyName) && this.getAnnotationExpressionForProperty != null) { termCastExpression = this.getAnnotationExpressionForProperty(edmModel, context.Type.Definition, propertyName, termName, qualifier); } } } if (termCastExpression == null) { result = null; break; } result = this.Eval(termCastExpression, context); } else if (hop == "$count") { var edmCollectionValue = result as IEdmCollectionValue; if (edmCollectionValue != null) { result = new EdmIntegerConstant(edmCollectionValue.Elements.Count()); } else { result = null; break; } } else if (hop.Contains(".")) { if (edmModel == null) { throw new InvalidOperationException(Edm.Strings.Edm_Evaluator_TypeCastNeedsEdmModel); } IEdmType typeSegmentClientType = this.resolveTypeFromName(hop, this.edmModel); if (typeSegmentClientType == null) { result = null; break; } IEdmTypeReference operandType = result.Type; EdmValueKind operandKind = result.ValueKind; if (operandKind == EdmValueKind.Collection) { List <IEdmDelayedValue> elementValues = new List <IEdmDelayedValue>(); var collection = result as IEdmCollectionValue; foreach (IEdmDelayedValue element in collection.Elements) { if (element.Value.Type.Definition.IsOrInheritsFrom(typeSegmentClientType)) { elementValues.Add(element); } } result = new EdmCollectionValue( new EdmCollectionTypeReference(new EdmCollectionType(typeSegmentClientType.GetTypeReference(false))), elementValues); } else if (operandKind != EdmValueKind.Structured || (operandKind == EdmValueKind.Structured && !operandType.Definition.IsOrInheritsFrom(typeSegmentClientType))) { result = null; break; } } else { result = FindProperty(hop, result); if (result == null) { throw new InvalidOperationException(Edm.Strings.Edm_Evaluator_UnboundPath(hop)); } } } #endif return(result); } case EdmExpressionKind.PropertyPath: case EdmExpressionKind.NavigationPropertyPath: { EdmUtil.CheckArgumentNull(context, "context"); IEdmPathExpression pathExpression = (IEdmPathExpression)expression; IEdmValue result = context; // [EdmLib] Need to handle paths that bind to things other than properties. foreach (string hop in pathExpression.Path) { result = FindProperty(hop, result); if (result == null) { throw new InvalidOperationException(Edm.Strings.Edm_Evaluator_UnboundPath(hop)); } } return(result); } case EdmExpressionKind.OperationApplication: { IEdmApplyExpression apply = (IEdmApplyExpression)expression; IEdmExpression targetReference = apply.AppliedOperation; IEdmOperationReferenceExpression targetOperationReference = targetReference as IEdmOperationReferenceExpression; if (targetOperationReference != null) { IList <IEdmExpression> argumentExpressions = apply.Arguments.ToList(); IEdmValue[] arguments = new IEdmValue[argumentExpressions.Count()]; { int argumentIndex = 0; foreach (IEdmExpression argument in argumentExpressions) { arguments[argumentIndex++] = this.Eval(argument, context); } } IEdmOperation target = targetOperationReference.ReferencedOperation; //// Static validation will have checked that the number and types of arguments are correct, //// so those checks are not performed dynamically. Func <IEdmValue[], IEdmValue> operationEvaluator; if (this.builtInFunctions.TryGetValue(target, out operationEvaluator)) { return(operationEvaluator(arguments)); } if (this.lastChanceOperationApplier != null) { return(this.lastChanceOperationApplier(target.FullName(), arguments)); } } throw new InvalidOperationException(Edm.Strings.Edm_Evaluator_UnboundFunction(targetOperationReference != null ? targetOperationReference.ReferencedOperation.ToTraceString() : string.Empty)); } case EdmExpressionKind.If: { IEdmIfExpression ifExpression = (IEdmIfExpression)expression; if (((IEdmBooleanValue)this.Eval(ifExpression.TestExpression, context)).Value) { return(this.Eval(ifExpression.TrueExpression, context)); } return(this.Eval(ifExpression.FalseExpression, context)); } case EdmExpressionKind.IsType: { IEdmIsTypeExpression isType = (IEdmIsTypeExpression)expression; IEdmValue operand = this.Eval(isType.Operand, context); IEdmTypeReference targetType = isType.Type; return(new EdmBooleanConstant(MatchesType(targetType, operand))); } case EdmExpressionKind.Cast: { IEdmCastExpression castType = (IEdmCastExpression)expression; IEdmValue operand = this.Eval(castType.Operand, context); IEdmTypeReference targetType = castType.Type; return(Cast(targetType, operand)); } case EdmExpressionKind.Record: { IEdmRecordExpression record = (IEdmRecordExpression)expression; DelayedExpressionContext recordContext = new DelayedExpressionContext(this, context); List <IEdmPropertyValue> propertyValues = new List <IEdmPropertyValue>(); //// Static validation will have checked that the set of supplied properties are appropriate //// for the supplied type and have no duplicates, so those checks are not performed dynamically. foreach (IEdmPropertyConstructor propertyConstructor in record.Properties) { propertyValues.Add(new DelayedRecordProperty(recordContext, propertyConstructor)); } EdmStructuredValue result = new EdmStructuredValue(record.DeclaredType != null ? record.DeclaredType.AsStructured() : null, propertyValues); return(result); } case EdmExpressionKind.Collection: { IEdmCollectionExpression collection = (IEdmCollectionExpression)expression; DelayedExpressionContext collectionContext = new DelayedExpressionContext(this, context); List <IEdmDelayedValue> elementValues = new List <IEdmDelayedValue>(); //// Static validation will have checked that the result types of the element expressions are //// appropriate and so these checks are not performed dynamically. foreach (IEdmExpression element in collection.Elements) { elementValues.Add(this.MapLabeledExpressionToDelayedValue(element, collectionContext, context)); } EdmCollectionValue result = new EdmCollectionValue(collection.DeclaredType != null ? collection.DeclaredType.AsCollection() : null, elementValues); return(result); } case EdmExpressionKind.LabeledExpressionReference: { return(this.MapLabeledExpressionToDelayedValue(((IEdmLabeledExpressionReferenceExpression)expression).ReferencedLabeledExpression, null, context).Value); } case EdmExpressionKind.Labeled: return(this.MapLabeledExpressionToDelayedValue(expression, new DelayedExpressionContext(this, context), context).Value); case EdmExpressionKind.EnumMember: IEdmEnumMemberExpression enumMemberExpression = (IEdmEnumMemberExpression)expression; var enumMembers = enumMemberExpression.EnumMembers.ToList(); IEdmEnumType enumType = enumMembers.First().DeclaringType; IEdmEnumTypeReference enumTypeReference = new EdmEnumTypeReference(enumType, false); if (enumMembers.Count() == 1) { return(new EdmEnumValue(enumTypeReference, enumMemberExpression.EnumMembers.Single())); } else { if (!enumType.IsFlags || !EdmEnumValueParser.IsEnumIntergeType(enumType)) { throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Type {0} cannot be assigned with multi-values.", enumType.FullName())); } long result = 0; foreach (var enumMember in enumMembers) { long value = (enumMember.Value as EdmIntegerConstant).Value; result |= value; } return(new EdmEnumValue(enumTypeReference, new EdmIntegerConstant(result))); } case EdmExpressionKind.EnumMemberReference: IEdmEnumMemberReferenceExpression enumMemberReferenceExpression = (IEdmEnumMemberReferenceExpression)expression; var referencedEnumMember = enumMemberReferenceExpression.ReferencedEnumMember; IEdmEnumTypeReference referencedEnumTypeReference = new EdmEnumTypeReference(referencedEnumMember.DeclaringType, false); return(new EdmEnumValue(referencedEnumTypeReference, enumMemberReferenceExpression.ReferencedEnumMember)); case EdmExpressionKind.ParameterReference: case EdmExpressionKind.OperationReference: case EdmExpressionKind.PropertyReference: case EdmExpressionKind.ValueTermReference: case EdmExpressionKind.EntitySetReference: throw new InvalidOperationException(Edm.Strings.Edm_Evaluator_UnrecognizedExpressionKind(((int)expression.ExpressionKind).ToString(System.Globalization.CultureInfo.InvariantCulture))); default: throw new InvalidOperationException(Edm.Strings.Edm_Evaluator_UnrecognizedExpressionKind(((int)expression.ExpressionKind).ToString(System.Globalization.CultureInfo.InvariantCulture))); } }