public override ISymbolValue this[DVariable variable] { get { ISymbolValue v; if (Locals.TryGetValue(variable, out v)) return v; // Assign a default value to the variable var t = TypeResolution.TypeDeclarationResolver.HandleNodeMatch(variable, base.ResolutionContext) as MemberSymbol; if (t != null) { if (t.Base is PrimitiveType) v= new PrimitiveValue(0M, t.Base as PrimitiveType); else v = new NullValue(t.Base as DSymbol); } else v = new NullValue(); Locals[variable] = v; return v; } set { if (variable == null) throw new CtfeException("variable must not be null"); Locals[variable] = value; } }
/// <summary> /// Tries to convert the value if it is spatial. Preserves any OData-specific fields. /// </summary> /// <param name="jsonObject">The json object that might be spatial.</param> /// <param name="value">The converted spatial value.</param> /// <returns>Whether the object was spatial and could be converted</returns> public bool TryConvertIfSpatial(JsonObject jsonObject, out PrimitiveValue value) { ExceptionUtilities.CheckArgumentNotNull(jsonObject, "jsonObject"); string edmTypeName; SpatialTypeKind? expectedType = null; if (TryExtractMetadataTypeName(jsonObject, out edmTypeName)) { ExceptionUtilities.CheckObjectNotNull(this.PrimitiveDataTypeConverter, "Cannot infer clr type from edm type without converter"); var clrType = this.PrimitiveDataTypeConverter.ToClrType(edmTypeName); if (clrType == null) { // must not be primitive, let alone spatial value = null; return false; } SpatialUtilities.TryInferSpatialTypeKind(clrType, out expectedType); } var dictionary = this.DictionaryConverter.Convert(jsonObject); object spatialInstance; if (this.GeoJsonFormatter.TryParse(dictionary, expectedType, out spatialInstance)) { value = new PrimitiveValue(edmTypeName, spatialInstance); return true; } value = null; return false; }
/// <summary> /// Visits the payload element /// </summary> /// <param name="payloadElement">The payload element to visit</param> public override void Visit(PrimitiveValue payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); if (payloadElement.FullTypeName == "Edm.String") { payloadElement.FullTypeName = null; } }
/// <summary> /// Visits the payload element /// </summary> /// <param name="payloadElement">The payload element to visit</param> public override void Visit(PrimitiveValue payloadElement) { if (!payloadElement.IsNull) { EntityModelTypeAnnotation typeAnnotation = payloadElement.GetAnnotation<EntityModelTypeAnnotation>(); if (payloadElement.FullTypeName == null && typeAnnotation != null) { payloadElement.FullTypeName = ((IEdmPrimitiveTypeReference)typeAnnotation.EdmModelType).FullName(); } } base.Visit(payloadElement); }
public Encoding() { _primitiveType = null; _presence = Presence.Required; _byteOrder = ByteOrder.LittleEndian; _minValue = null; _maxValue = null; _nullValue = null; _constValue = null; _characterEncoding = null; _epoch = null; _timeUnit = null; _semanticType = null; }
/// <summary> /// Tries to convert the value if it is spatial. Adds OData-specific fields to GeoJSON microformat. /// </summary> /// <param name="value">The value that might be spatial.</param> /// <param name="jsonObject">The converted json object.</param> /// <returns>Whether the value was spatial and could be converted</returns> public bool TryConvertIfSpatial(PrimitiveValue value, out JsonObject jsonObject) { ExceptionUtilities.CheckArgumentNotNull(value, "value"); ExceptionUtilities.CheckAllRequiredDependencies(this); IDictionary<string, object> dictionary; if (this.GeoJsonFormatter.TryConvert(value.ClrValue, out dictionary)) { jsonObject = this.DictionaryConverter.Convert(dictionary); return true; } jsonObject = null; return false; }
protected RealmValue ToRealmValue(PrimitiveValue primitive, RealmObjectBase.Metadata metadata, Realm realm) { if (primitive.Type != RealmValueType.Object) { return(new RealmValue(primitive)); } var objectHandle = primitive.AsObject(Root); if (metadata == null) { throw new NotImplementedException("Mixed objects are not supported yet."); } return(new RealmValue(realm.MakeObject(metadata, objectHandle))); }
public Encoding(PrimitiveType primitiveType, Presence presence, ByteOrder byteOrder, PrimitiveValue minValue, PrimitiveValue maxValue, PrimitiveValue nullValue, PrimitiveValue constValue, string characterEncoding, string epoch, string timeUnit, string semanticType) { Verify.NotNull(presence, "presence"); Verify.NotNull(byteOrder, "byteOrder"); _primitiveType = primitiveType; _presence = presence; _byteOrder = byteOrder; _minValue = minValue; _maxValue = maxValue; _nullValue = nullValue; _constValue = constValue; _characterEncoding = characterEncoding; _epoch = epoch; _timeUnit = timeUnit; _semanticType = semanticType; }
/// <summary cref="IBackendCodeGenerator.GenerateCode(PrimitiveValue)"/> public void GenerateCode(PrimitiveValue value) { // Check whether we are loading an FP16 value. In this case, we have to // move the resulting constant into a register since the PTX compiler // expects a converted FP16 value in the scope of a register. var description = ResolveRegisterDescription(value.Type); var register = new ConstantRegister(description, value); if (value.BasicValueType == BasicValueType.Float16) { Bind(value, EnsureHardwareRegister(register)); } else { Bind(value, register); } }
/// <summary cref="IValueVisitor.Visit(PrimitiveValue)"/> public void Visit(PrimitiveValue value) { if (value.Uses.TryGetSingleUse(out Use use) && use.Resolve() is Alloca) { return; } var variable = Allocate(value); using (var statement = BeginStatement(variable)) { switch (value.BasicValueType) { case BasicValueType.Int1: statement.AppendConstant(value.Int1Value ? 1 : 0); break; case BasicValueType.Int8: statement.AppendConstant(value.UInt8Value); break; case BasicValueType.Int16: statement.AppendConstant(value.UInt16Value); break; case BasicValueType.Int32: statement.AppendConstant(value.UInt32Value); break; case BasicValueType.Int64: statement.AppendConstant(value.UInt64Value); break; case BasicValueType.Float32: statement.AppendConstant(value.Float32Value); break; case BasicValueType.Float64: statement.AppendConstant(value.Float64Value); break; default: throw new InvalidCodeGenerationException(); } } }
/// <summary> /// Convert clr values to JSON primitive representations for primitiveValue payloadElement so that when this can be /// compared against the one generated by the JSON DeSerializer /// </summary> /// <param name="payloadElement">payloadElement to convert primitive values from</param> public override void Visit(PrimitiveValue payloadElement) { // convert byte array to string rep for JSON according to OData rules byte[] bytes = payloadElement.ClrValue as byte[]; if (bytes != null) { payloadElement.ClrValue = Convert.ToBase64String(bytes); return; } // convert int to long since the DeSerializer we use converts JSON numbers to longs int? num = payloadElement.ClrValue as int?; if (num != null) { payloadElement.ClrValue = Convert.ToInt64(num); return; } // int64 and decimals are represented as JSON strings , so do the same for help with later comparison if (payloadElement.ClrValue is Int64 || payloadElement.ClrValue is decimal) { payloadElement.ClrValue = payloadElement.ClrValue.ToString(); return; } // convert TimeSpans to JSON data representation TimeSpan? timespan = payloadElement.ClrValue as TimeSpan?; if (timespan != null) { payloadElement.ClrValue = XmlConvert.ToString(timespan.Value); } // Convert DateTimeOffsets to JSON Data representation DateTimeOffset? dto = payloadElement.ClrValue as DateTimeOffset?; if (dto != null) { payloadElement.ClrValue = XmlConvert.ToString(dto.Value); } // Convert DateTimes to JSON Data representation DateTime? date = payloadElement.ClrValue as DateTime?; if (date != null) { payloadElement.ClrValue = XmlConvert.ToString(date.Value, XmlDateTimeSerializationMode.RoundtripKind); } }
public async Task EnableApiKeyAsync(AppHandle app, ObjectId id) { var tcs = new TaskCompletionSource <object>(); var tcsHandle = GCHandle.Alloc(tcs); try { var primitiveId = PrimitiveValue.ObjectId(id); NativeMethods.enable_api_key(this, app, primitiveId, GCHandle.ToIntPtr(tcsHandle), out var ex); ex.ThrowIfNecessary(); await tcs.Task; } finally { tcsHandle.Free(); } }
public override void Visit(PrimitiveValue payloadElement) { if (payloadElement.ClrValue is DateTime) { // In V1 and V2, DateTimes surface with Utc Kind, regardless of original source Kind. var dateTimePayload = (DateTime)payloadElement.ClrValue; if (dateTimePayload.Kind == DateTimeKind.Local) { dateTimePayload = dateTimePayload.ToUniversalTime(); } // In V1 and V2, a certain amount of precision is lost when deserializing the old JSON format, // so strip out the last four digits on the Ticks property. long newTicks = Convert.ToInt64(Math.Truncate((decimal)dateTimePayload.Ticks / 10000) * 10000); payloadElement.ClrValue = new DateTime(newTicks, DateTimeKind.Utc); } base.Visit(payloadElement); }
private static ODataPayloadElement ConvertToBinaryPayloadElement(ODataPayloadElement stringPayload) { Debug.Assert(stringPayload != null && stringPayload.ElementType == ODataPayloadElementType.PrimitiveValue, "Expected non-null, primitive value as payload"); PrimitiveValue primitiveValue = (PrimitiveValue)stringPayload; Debug.Assert(primitiveValue.ClrValue.GetType() == typeof(string), "Only expect string primitive values."); string stringValue = (string)primitiveValue.ClrValue; // very simple conversion assuming all chars are in the range of byte byte[] bytes = new byte[stringValue.Length]; for (int i = 0; i < stringValue.Length; ++i) { bytes[i] = (byte)stringValue[i]; } return(PayloadBuilder.PrimitiveValue(bytes)); }
/// <summary> /// Validator for spatial values. /// </summary> /// <param name="payloadElement">The payload element to validate.</param> /// <param name="testConfigLimits">The test configuration limits to modify.</param> public static void SpatialValueValidator(ODataPayloadElement payloadElement, TestConfigurationLimits testConfigLimits) { PrimitiveValue primitiveValue = payloadElement as PrimitiveValue; ExceptionUtilities.Assert(primitiveValue != null, "This validator only works on primitive values."); if (primitiveValue.ClrValue is ISpatial) { // Spatial values require V3. testConfigLimits.RaiseMinPayloadVersion(ODataVersion.V4); } else if (primitiveValue.ClrValue == null) { EntityModelTypeAnnotation typeAnnotation = primitiveValue.GetAnnotation <EntityModelTypeAnnotation>(); if (typeAnnotation != null && typeAnnotation.EdmModelType.Definition.IsSpatial()) { testConfigLimits.RaiseMinPayloadVersion(ODataVersion.V4); } } }
private static bool IsSpatialValue(PrimitiveValue primitiveValue) { // if the metadata is provided and is known to be spatial, expect an error var dataTypeAnnotation = primitiveValue.Annotations.OfType <DataTypeAnnotation>().SingleOrDefault(); if (dataTypeAnnotation != null && dataTypeAnnotation.DataType is SpatialDataType) { return(true); } // if the object is non-null and a spatial value, expect an error SpatialTypeKind?kind; if (primitiveValue.ClrValue.IfValid(false, o => SpatialUtilities.TryInferSpatialTypeKind(o.GetType(), out kind))) { return(true); } return(false); }
/// <summary> /// Visits a collection start. /// </summary> /// <param name="collection">The collection start to visit.</param> protected override ODataPayloadElement VisitCollectionStart(ODataCollectionStart collection) { ExceptionUtilities.CheckArgumentNotNull(collection, "collection"); // NOTE the Taupo OM does not currently support heterogenous collections; we determine the // type of the collection by looking at the first non-null item ODataCollectionItemsObjectModelAnnotation itemsAnnotation = collection.GetAnnotation <ODataCollectionItemsObjectModelAnnotation>(); ExceptionUtilities.Assert(itemsAnnotation != null, "itemsAnnotation != null"); PrimitiveCollection primitiveCollection = PayloadBuilder.PrimitiveCollection(collection.Name); foreach (object item in itemsAnnotation) { PrimitiveValue primitiveValue = (PrimitiveValue)this.Visit(item); primitiveCollection.Add(primitiveValue); } return(primitiveCollection); }
/// <summary> Gets a string representation of the value </summary> /// <param name="maxLength"> /// The maximum length of the result string. /// </param> public string AsString(int maxLength = int.MaxValue) { if (this.IsNull) { return("null"); } if (this.Type.IsPrimitiveType() || this.Type.IsKnownType(KnownTypeCode.String)) { string text = PrimitiveValue.ToString(); if (text != null && text.Length > maxLength) { text = text.Substring(0, Math.Max(0, maxLength - 3)) + "..."; } return(text); } else { return("{" + this.Type.FullName + "}"); } }
public override ResultsHandle GetFilteredResults(string query, RealmValue[] arguments) { var primitiveValues = new PrimitiveValue[arguments.Length]; var handles = new RealmValue.HandlesToCleanup?[arguments.Length]; for (var i = 0; i < arguments.Length; i++) { (primitiveValues[i], handles[i]) = arguments[i].ToNative(); } var ptr = NativeMethods.get_filtered_results(this, query, (IntPtr)query.Length, primitiveValues, (IntPtr)primitiveValues.Length, out var ex); foreach (var handle in handles) { handle?.Dispose(); } ex.ThrowIfNecessary(); return(new ResultsHandle(this, ptr)); }
public override ISymbolValue this[DVariable variable] { get { ISymbolValue v; if (Locals.TryGetValue(variable, out v)) { return(v); } // Assign a default value to the variable var t = TypeResolution.TypeDeclarationResolver.HandleNodeMatch(variable, base.ResolutionContext) as MemberSymbol; if (t != null) { if (t.Base is PrimitiveType) { v = new PrimitiveValue(0M, t.Base as PrimitiveType); } else { v = new NullValue(t.Base); } } else { v = new NullValue(); } Locals[variable] = v; return(v); } set { if (variable == null) { throw new CtfeException("variable must not be null"); } Locals[variable] = value; } }
/// <summary> /// Tries to convert the value if it is spatial. Adds OData-specific fields to GeoJSON microformat. /// </summary> /// <param name="value">The value that might be spatial.</param> /// <param name="jsonObject">The converted json object.</param> /// <returns>Whether the value was spatial and could be converted</returns> public bool TryConvertIfSpatial(PrimitiveValue value, out JsonObject jsonObject) { ExceptionUtilities.CheckArgumentNotNull(value, "value"); ExceptionUtilities.CheckAllRequiredDependencies(this); IDictionary<string, object> dictionary; if (this.GeoJsonFormatter.TryConvert(value.ClrValue, out dictionary)) { jsonObject = this.DictionaryConverter.Convert(dictionary); if (value.FullTypeName != null) { jsonObject.Insert(0, new JsonProperty(ODataConstants.JsonMetadataPropertyName, new JsonObject() { new JsonProperty(ODataConstants.TypeAttributeName, new JsonPrimitiveValue(value.FullTypeName)) })); } return true; } jsonObject = null; return false; }
public override int GetHashCode() { int hash = 1; if (PrimitiveValue != 0) { hash ^= PrimitiveValue.GetHashCode(); } hash ^= primitiveArray_.GetHashCode(); if (messageValue_ != null) { hash ^= MessageValue.GetHashCode(); } hash ^= messageArray_.GetHashCode(); if (EnumValue != global::UnitTest.Issues.TestProtos.DeprecatedEnum.DEPRECATED_ZERO) { hash ^= EnumValue.GetHashCode(); } hash ^= enumArray_.GetHashCode(); return(hash); }
public static Name BuildName(object value) { if (value == null) { return(NIL_SYMBOL); } var str = value as string; if (str != null) { if (string.IsNullOrEmpty(str)) { throw new ArgumentException("Invalid symbol \"\""); } str = str.Trim(); return(ParseName(str)); } return(new PrimitiveSymbol(PrimitiveValue.Cast(value))); }
public void Utilities_CanConvertStringToPrimitiveValue() { // Int. Assert.That(PrimitiveValue.FromString("123").type, Is.EqualTo(TypeCode.Int32)); Assert.That(PrimitiveValue.FromString("123").ToInt32(), Is.EqualTo(123)); Assert.That(PrimitiveValue.FromString("-123456").type, Is.EqualTo(TypeCode.Int32)); Assert.That(PrimitiveValue.FromString("-123456").ToInt32(), Is.EqualTo(-123456)); Assert.That(PrimitiveValue.FromString("0x1234ABC").type, Is.EqualTo(TypeCode.Int32)); Assert.That(PrimitiveValue.FromString("0x1234ABC").ToInt32(), Is.EqualTo(0x1234ABC)); // Double. Assert.That(PrimitiveValue.FromString("0.0").type, Is.EqualTo(TypeCode.Double)); Assert.That(PrimitiveValue.FromString("0.0").ToDouble(), Is.EqualTo(0).Within(0.00001)); Assert.That(PrimitiveValue.FromString("1.23").type, Is.EqualTo(TypeCode.Double)); Assert.That(PrimitiveValue.FromString("1.23").ToDouble(), Is.EqualTo(1.23).Within(0.00001)); Assert.That(PrimitiveValue.FromString("-1.23456").type, Is.EqualTo(TypeCode.Double)); Assert.That(PrimitiveValue.FromString("-1.23456").ToDouble(), Is.EqualTo(-1.23456).Within(0.00001)); Assert.That(PrimitiveValue.FromString("1e10").type, Is.EqualTo(TypeCode.Double)); Assert.That(PrimitiveValue.FromString("1e10").ToDouble(), Is.EqualTo(1e10).Within(0.00001)); Assert.That(PrimitiveValue.FromString("-2E-10").type, Is.EqualTo(TypeCode.Double)); Assert.That(PrimitiveValue.FromString("-2E-10").ToDouble(), Is.EqualTo(-2e-10f).Within(0.00001)); Assert.That(PrimitiveValue.FromString("Infinity").type, Is.EqualTo(TypeCode.Double)); Assert.That(PrimitiveValue.FromString("Infinity").ToDouble(), Is.EqualTo(double.PositiveInfinity)); Assert.That(PrimitiveValue.FromString("-Infinity").type, Is.EqualTo(TypeCode.Double)); Assert.That(PrimitiveValue.FromString("-Infinity").ToDouble(), Is.EqualTo(double.NegativeInfinity)); // Bool. Assert.That(PrimitiveValue.FromString("true").type, Is.EqualTo(TypeCode.Boolean)); Assert.That(PrimitiveValue.FromString("true").ToBoolean(), Is.True); Assert.That(PrimitiveValue.FromString("false").type, Is.EqualTo(TypeCode.Boolean)); Assert.That(PrimitiveValue.FromString("false").ToBoolean(), Is.False); Assert.That(PrimitiveValue.FromString("True").type, Is.EqualTo(TypeCode.Boolean)); Assert.That(PrimitiveValue.FromString("True").ToBoolean(), Is.True); Assert.That(PrimitiveValue.FromString("False").type, Is.EqualTo(TypeCode.Boolean)); Assert.That(PrimitiveValue.FromString("False").ToBoolean(), Is.False); Assert.That(PrimitiveValue.FromString("TRUE").type, Is.EqualTo(TypeCode.Boolean)); Assert.That(PrimitiveValue.FromString("TRUE").ToBoolean(), Is.True); Assert.That(PrimitiveValue.FromString("FALSE").type, Is.EqualTo(TypeCode.Boolean)); Assert.That(PrimitiveValue.FromString("FALSE").ToBoolean(), Is.False); }
public async Task <UserApiKey?> FetchApiKeyAsync(AppHandle app, ObjectId id) { var tcs = new TaskCompletionSource <UserApiKey[]>(); var tcsHandle = GCHandle.Alloc(tcs); try { var primitiveId = PrimitiveValue.ObjectId(id); NativeMethods.fetch_api_key(this, app, primitiveId, GCHandle.ToIntPtr(tcsHandle), out var ex); ex.ThrowIfNecessary(); var result = await tcs.Task; Debug.Assert(result == null || result.Length <= 1, "The result of the fetch operation should be either null, or an array of 0 or 1 elements."); return(result == null || result.Length == 0 ? (UserApiKey?)null : result.Single()); } finally { tcsHandle.Free(); } }
public unsafe void Write(IntPtr statePtr, PrimitiveValue value) { var valuePtr = new IntPtr(statePtr.ToInt64() + (int)byteOffset); if (format == kTypeBit) { if (sizeInBits != 1) { throw new NotImplementedException("Cannot yet convert multi-bit fields to floats"); } MemoryHelpers.WriteSingleBit(valuePtr, bitOffset, value.ToBool()); } else if (format == kTypeFloat) { *(float *)valuePtr = value.ToFloat(); } else { throw new NotImplementedException(); } }
/// <summary cref="IBackendCodeGenerator.GenerateCode(PrimitiveValue)"/> public void GenerateCode(PrimitiveValue value) { var variable = Allocate(value); using var statement = BeginStatement(variable); switch (value.BasicValueType) { case BasicValueType.Int1: statement.AppendConstant(value.Int1Value ? 1 : 0); break; case BasicValueType.Int8: statement.AppendConstant(value.UInt8Value); break; case BasicValueType.Int16: statement.AppendConstant(value.UInt16Value); break; case BasicValueType.Int32: statement.AppendConstant(value.UInt32Value); break; case BasicValueType.Int64: statement.AppendConstant(value.UInt64Value); break; case BasicValueType.Float32: statement.AppendConstant(value.Float32Value); break; case BasicValueType.Float64: statement.AppendConstant(value.Float64Value); break; default: throw new InvalidCodeGenerationException(); } }
private Task <InvocationDescriptor> CreateInvocationDescriptorInt(Stream stream, Func <string, Type[]> getParams) { var inputStream = new CodedInputStream(stream, leaveOpen: true); var invocationHeader = new RpcInvocationHeader(); inputStream.ReadMessage(invocationHeader); var argumentTypes = getParams(invocationHeader.Name); var invocationDescriptor = new InvocationDescriptor(); invocationDescriptor.Method = invocationHeader.Name; invocationDescriptor.Id = invocationHeader.Id.ToString(); invocationDescriptor.Arguments = new object[argumentTypes.Length]; var primitiveParser = PrimitiveValue.Parser; for (var i = 0; i < argumentTypes.Length; i++) { if (typeof(int) == argumentTypes[i]) { var value = new PrimitiveValue(); inputStream.ReadMessage(value); invocationDescriptor.Arguments[i] = value.Int32Value; } else if (typeof(string) == argumentTypes[i]) { var value = new PrimitiveValue(); inputStream.ReadMessage(value); invocationDescriptor.Arguments[i] = value.StringValue; } else { var serializer = _serviceProvider.GetRequiredService <ProtobufSerializer>(); invocationDescriptor.Arguments[i] = serializer.GetValue(inputStream, argumentTypes[i]); } } return(Task.FromResult(invocationDescriptor)); }
internal static RealmValue Create <T>(T value, RealmValueType type) { if (value is null) { return(new RealmValue(PrimitiveValue.Null())); } return(type switch { RealmValueType.String => String(Operator.Convert <T, string>(value)), RealmValueType.Data => Data(Operator.Convert <T, byte[]>(value)), RealmValueType.Bool => Bool(Operator.Convert <T, bool>(value)), RealmValueType.Int => Int(Operator.Convert <T, long>(value)), RealmValueType.Float => Float(Operator.Convert <T, float>(value)), RealmValueType.Double => Double(Operator.Convert <T, double>(value)), RealmValueType.Date => Date(Operator.Convert <T, DateTimeOffset>(value)), RealmValueType.Decimal128 => Decimal(Operator.Convert <T, Decimal128>(value)), RealmValueType.ObjectId => ObjectId(Operator.Convert <T, ObjectId>(value)), RealmValueType.Guid => Guid(Operator.Convert <T, Guid>(value)), RealmValueType.Object => Object(Operator.Convert <T, RealmObjectBase>(value)), _ => throw new NotSupportedException($"RealmValueType {type} is not supported."), });
public void Utilities_CanConvertObjectToPrimitiveValue() { Assert.That(PrimitiveValue.FromObject(true).type, Is.EqualTo(TypeCode.Boolean)); Assert.That(PrimitiveValue.FromObject(true).ToBoolean(), Is.True); Assert.That(PrimitiveValue.FromObject('c').type, Is.EqualTo(TypeCode.Char)); Assert.That(PrimitiveValue.FromObject('c').ToByte(), Is.EqualTo('c')); Assert.That(PrimitiveValue.FromObject((byte)123).type, Is.EqualTo(TypeCode.Byte)); Assert.That(PrimitiveValue.FromObject(123).ToByte(), Is.EqualTo(123)); Assert.That(PrimitiveValue.FromObject((sbyte)-123).type, Is.EqualTo(TypeCode.SByte)); Assert.That(PrimitiveValue.FromObject(-123).ToSByte(), Is.EqualTo(-123)); Assert.That(PrimitiveValue.FromObject((short)-1234).type, Is.EqualTo(TypeCode.Int16)); Assert.That(PrimitiveValue.FromObject(-1234).ToInt16(), Is.EqualTo(-1234)); Assert.That(PrimitiveValue.FromObject((ushort)1234).type, Is.EqualTo(TypeCode.UInt16)); Assert.That(PrimitiveValue.FromObject(1234).ToUInt16(), Is.EqualTo(1234)); Assert.That(PrimitiveValue.FromObject(-1234).type, Is.EqualTo(TypeCode.Int32)); Assert.That(PrimitiveValue.FromObject(-1234).ToInt32(), Is.EqualTo(-1234)); Assert.That(PrimitiveValue.FromObject((uint)1234).type, Is.EqualTo(TypeCode.UInt32)); Assert.That(PrimitiveValue.FromObject(1234).ToUInt32(), Is.EqualTo(1234)); Assert.That(PrimitiveValue.FromObject((long)-1234).type, Is.EqualTo(TypeCode.Int64)); Assert.That(PrimitiveValue.FromObject(-1234).ToInt64(), Is.EqualTo(-1234)); Assert.That(PrimitiveValue.FromObject((ulong)1234).type, Is.EqualTo(TypeCode.UInt64)); Assert.That(PrimitiveValue.FromObject(1234).ToUInt64(), Is.EqualTo(1234)); Assert.That(PrimitiveValue.FromObject(1.2345f).type, Is.EqualTo(TypeCode.Single)); Assert.That(PrimitiveValue.FromObject(1.2345f).ToSingle(), Is.EqualTo(1.2345).Within(0.00001)); Assert.That(PrimitiveValue.FromObject(1.2345).type, Is.EqualTo(TypeCode.Double)); Assert.That(PrimitiveValue.FromObject(1.2345).ToSingle(), Is.EqualTo(1.2345).Within(0.00001)); }
Value CreatePointerLikeValue(DmdType defaultType, long value, out DmdType type) { var vm = engine.MonoVirtualMachine; if (defaultType.IsPointer || defaultType.IsFunctionPointer) { type = defaultType; if (vm.Version.AtLeast(2, 46)) { return(new PointerValue(vm, GetType(type), value)); } return(new PrimitiveValue(vm, ElementType.Ptr, value)); } else { if (defaultType == defaultType.AppDomain.System_IntPtr || defaultType == defaultType.AppDomain.System_UIntPtr) { type = defaultType; } else { type = defaultType.AppDomain.System_IntPtr; } var monoType = GetType(type); Value monoValue; if (vm.Version.AtLeast(2, 46)) { monoValue = new PointerValue(vm, GetType(type.AppDomain.System_Void.MakePointerType()), value); } else { monoValue = new PrimitiveValue(vm, ElementType.Ptr, value); } return(vm.CreateStructMirror(monoType, new[] { monoValue })); } }
private static string ReadEncodingAsString(DirectBuffer buffer, int index, Token typeToken, int actingVersion) { PrimitiveValue constOrNotPresentValue = ConstOrNotPresentValue(typeToken, actingVersion); if (null != constOrNotPresentValue) { return(constOrNotPresentValue.ToString()); } var sb = new StringBuilder(); Encoding encoding = typeToken.Encoding; int elementSize = encoding.PrimitiveType.Size; for (int i = 0, size = typeToken.ArrayLength; i < size; i++) { MapEncodingToString(sb, buffer, index + (i * elementSize), encoding); sb.Append(", "); } sb.Length = sb.Length - 2; return(sb.ToString()); }
////REVIEW: check whether parameters have *actually* changed? /// <summary> /// Refresh <see cref="m_Parameters"/> from the current parameter values in <paramref name="target"/>. /// </summary> /// <param name="target">An instance of the current type we are editing parameters on.</param> private void ReadParameterValuesFrom(object target) { if (m_Parameters == null) { return; } for (var i = 0; i < m_Parameters.Length; ++i) { var parameter = m_Parameters[i]; object value = null; try { value = parameter.field.GetValue(target); } catch { // Ignore exceptions from getters. } m_Parameters[i].value.value = PrimitiveValue.FromObject(value).ConvertTo(parameter.value.type); } }
internal RealmValue(PrimitiveValue primitive, ObjectHandle handle = default, IntPtr propertyIndex = default) : this() { Type = primitive.Type; _objectHandle = handle; _propertyIndex = propertyIndex; switch (Type) { case RealmValueType.Data: _dataValue = primitive.AsBinary(); break; case RealmValueType.String: _stringValue = primitive.AsString(); break; case RealmValueType.Object: throw new NotSupportedException("Use RealmValue(RealmObject) instead."); default: _primitiveValue = primitive; break; } }
/// <summary> /// Converts the primitive value into the correct CLR type based on the metadata /// </summary> /// <param name="payloadElement">The payload element to potentially replace</param> /// <returns>The original element or a copy to replace it with</returns> public override ODataPayloadElement Visit(PrimitiveValue payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); if (payloadElement.ClrValue == null) { return(payloadElement); } var dataTypeAnnotation = payloadElement.Annotations.OfType <DataTypeAnnotation>().SingleOrDefault(); if (dataTypeAnnotation == null) { return(payloadElement); } var primitiveType = dataTypeAnnotation.DataType as PrimitiveDataType; // Handles the case where the there is an empty string value and its a different datatype if (primitiveType == null) { return(payloadElement); } var clrType = primitiveType.GetFacet <PrimitiveClrTypeFacet>(); if (clrType.Value.IsAssignableFrom(payloadElement.ClrValue.GetType())) { return(payloadElement); } var converted = this.ConvertPrimitiveValue(payloadElement.ClrValue, clrType.Value); var replacement = new PrimitiveValue(payloadElement.FullTypeName, converted); return(payloadElement.ReplaceWith(replacement)); }
/// <summary> /// Builds a complex instance from the given payloadElements to represent a parameters payload. /// </summary> /// <param name="payloadElements">Each ODataPayloadElement represents the value for each parameter.</param> /// <param name="model">EdmModel instance.</param> /// <param name="functionImportName">Name of the function import to add to the model.</param> /// <returns></returns> private static ComplexInstance PayloadElementsToParameterPayload(ODataPayloadElement[] payloadElements, EdmModel model, string functionImportName) { EdmOperationImport operationImport = (EdmOperationImport)model.EntityContainer.FindOperationImports(functionImportName).FirstOrDefault(); EdmOperation operation = (EdmOperation)operationImport.Operation; var parameterPayload = new ComplexInstance(null, false); for (int idx = 0; idx < payloadElements.Length; idx++) { ODataPayloadElement p = payloadElements[idx]; string parameterName = "p" + idx; PropertyInstance parameter; IEdmTypeReference entityModelType = p.GetAnnotation<EntityModelTypeAnnotation>().EdmModelType; switch (p.ElementType) { case ODataPayloadElementType.PrimitiveValue: object clrValue = ((PrimitiveValue)p).ClrValue; PrimitiveValue primitiveValue = new PrimitiveValue(clrValue == null ? null : clrValue.GetType().FullName, clrValue); primitiveValue.CopyAnnotation<PrimitiveValue, EntityModelTypeAnnotation>(p); parameter = new PrimitiveProperty(parameterName, primitiveValue); operation.AddParameter(parameterName, MetadataUtils.GetPrimitiveTypeReference(primitiveValue.ClrValue.GetType())); break; case ODataPayloadElementType.ComplexInstance: parameter = new ComplexProperty(parameterName, (ComplexInstance)p); operation.AddParameter(parameterName, entityModelType); break; case ODataPayloadElementType.PrimitiveMultiValue: PrimitiveMultiValue primitiveMultiValue = (PrimitiveMultiValue)p; if (primitiveMultiValue.Annotations.OfType<JsonCollectionResultWrapperAnnotation>().SingleOrDefault() == null) { primitiveMultiValue.Annotations.Add(new JsonCollectionResultWrapperAnnotation(false)); } parameter = new PrimitiveMultiValueProperty(parameterName, primitiveMultiValue); operation.AddParameter(parameterName, entityModelType); break; case ODataPayloadElementType.ComplexMultiValue: ComplexMultiValue complexMultiValue = (ComplexMultiValue)p; if (complexMultiValue.Annotations.OfType<JsonCollectionResultWrapperAnnotation>().SingleOrDefault() == null) { complexMultiValue.Annotations.Add(new JsonCollectionResultWrapperAnnotation(false)); } parameter = new ComplexMultiValueProperty(parameterName, complexMultiValue); operation.AddParameter(parameterName, entityModelType); break; case ODataPayloadElementType.EntityInstance: parameter = new NavigationPropertyInstance(parameterName, (EntityInstance)p); operation.AddParameter(parameterName, entityModelType); break; case ODataPayloadElementType.EntitySetInstance: parameter = new NavigationPropertyInstance(parameterName, (EntitySetInstance)p); operation.AddParameter(parameterName, entityModelType); break; default: throw new NotSupportedException("PayloadElementsToParameterPayload() is called on unsupported ODataPayloadElement type: " + p.ElementType); } parameterPayload.Add(parameter); } parameterPayload.ExpectedFunctionImport(operationImport); return parameterPayload; }
/// <summary> /// Visits a payload element whose root is a PrimitiveValue. /// </summary> /// <param name="payloadElement">The root node of payload element being visited.</param> public void Visit(PrimitiveValue payloadElement) { if (payloadElement.IsNull) { this.writer.WriteNull(); } else { JsonObject jsonObject; if (this.parent.SpatialConverter.TryConvertIfSpatial(payloadElement, out jsonObject)) { this.writer.WriteJsonValue(jsonObject, o => this.parent.PrimitiveConverter.SerializePrimitive(o)); } else { var stringValue = this.parent.PrimitiveConverter.SerializePrimitive(payloadElement.ClrValue); payloadElement.Annotations.Add(new RawTextPayloadElementRepresentationAnnotation() { Text = stringValue }); this.writer.WriteRaw(stringValue); } } this.isRootElement = false; }
/// <summary> /// Converts the primitive value into the correct CLR type based on the metadata /// </summary> /// <param name="payloadElement">The payload element to potentially replace</param> /// <returns>The original element or a copy to replace it with</returns> public override ODataPayloadElement Visit(PrimitiveValue payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); if (payloadElement.ClrValue == null) { return payloadElement; } var dataTypeAnnotation = payloadElement.Annotations.OfType<DataTypeAnnotation>().SingleOrDefault(); if (dataTypeAnnotation == null) { return payloadElement; } var primitiveType = dataTypeAnnotation.DataType as PrimitiveDataType; // Handles the case where the there is an empty string value and its a different datatype if (primitiveType == null) { return payloadElement; } var clrType = primitiveType.GetFacet<PrimitiveClrTypeFacet>(); if (clrType.Value.IsAssignableFrom(payloadElement.ClrValue.GetType())) { return payloadElement; } var converted = this.ConvertPrimitiveValue(payloadElement.ClrValue, clrType.Value); var replacement = new PrimitiveValue(payloadElement.FullTypeName, converted); return payloadElement.ReplaceWith(replacement); }
/// <summary> /// Visits a primitive value and clears its type name if it is 'Edm.String' /// </summary> /// <param name="payloadElement">The primitive value</param> public override void Visit(PrimitiveValue payloadElement) { base.Visit(payloadElement); if (payloadElement.FullTypeName == "Edm.String") { payloadElement.FullTypeName = null; } }
/// <summary> /// Visits the payload element /// </summary> /// <param name="payloadElement">The payload element to visit</param> public override void Visit(PrimitiveValue payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); var annotation = payloadElement.Annotations.Where(a => a is DataTypeAnnotation).SingleOrDefault(); payloadElement.Annotations.Remove(annotation); }
public override void Visit(PrimitiveValue payloadElement) { if (payloadElement.ClrValue is DateTime) { // In V1 and V2, DateTimes surface with Utc Kind, regardless of original source Kind. var dateTimePayload = (DateTime)payloadElement.ClrValue; if (dateTimePayload.Kind == DateTimeKind.Local) { dateTimePayload = dateTimePayload.ToUniversalTime(); } // In V1 and V2, a certain amount of precision is lost when deserializing the old JSON format, // so strip out the last four digits on the Ticks property. long newTicks = Convert.ToInt64(Math.Truncate((decimal) dateTimePayload.Ticks/10000)*10000); payloadElement.ClrValue = new DateTime(newTicks, DateTimeKind.Utc); } base.Visit(payloadElement); }
/// <summary> /// Visits a payload element whose root is a PrimitiveValue. /// </summary> /// <param name="payloadElement">The root node of payload element being visited.</param> public void Visit(PrimitiveValue payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); var current = this.expectedValueStack.Peek(); var value = current as QueryScalarValue; if (value == null) { // handle named stream value var streamValue = current as AstoriaQueryStreamValue; ExceptionUtilities.CheckObjectNotNull(streamValue, "Value was not a primitive value or a stream. Value was: '{0}'", current.ToString()); // TODO: verify the binary content of the stream is correct } else { this.VerifyTypeName(value, payloadElement.FullTypeName, "Type name did not match expectation for primitive value"); if (value.IsNull) { this.parent.Assert.IsTrue(payloadElement.IsNull, "Primitive value unexpectedly non-null"); } else { this.parent.Assert.IsFalse(payloadElement.IsNull, "Primitive value unexpectedly null"); if (value.Value is DateTime && ((DateTime)value.Value).Kind == DateTimeKind.Local && this.parent.ExpectedPayloadOptions.HasFlag(ODataPayloadOptions.UseOldDateTimeFormat)) { // The old DateTime format cannot represent Local DateTimes, so convert the expected value to Utc value = new QueryScalarValue(value.Type, TimeZoneInfo.ConvertTime((DateTime)value.Value, TimeZoneInfo.Utc), value.EvaluationError, this.parent.QueryEvaluationStrategy); } ExceptionUtilities.CheckObjectNotNull(this.parent.PrimitiveValueComparer, "Cannot compare primitive values without primitive comparer"); this.parent.PrimitiveValueComparer.Compare(value, payloadElement.ClrValue, this.parent.Assert); } } }
public Builder MinValue(PrimitiveValue minValue) { _minVal = minValue; return this; }
public Builder NullValue(PrimitiveValue nullValue) { _nullVal = nullValue; return this; }
public Builder MaxValue(PrimitiveValue maxValue) { _maxVal = maxValue; return this; }
public override ODataPayloadElement Visit(PrimitiveValue payloadElement) { var rawText = payloadElement.Annotations.OfType<RawTextPayloadElementRepresentationAnnotation>().Select(r => r.Text).SingleOrDefault(); var dataType = payloadElement.Annotations.OfType<DataTypeAnnotation>().Select(d => d.DataType).OfType<PrimitiveDataType>().SingleOrDefault(); if (rawText != null && dataType != null) { using (var reader = new StringReader(rawText)) { var tokenizer = new JsonTokenizer(reader); var parsed = tokenizer.Value; if (tokenizer.TokenType == JsonTokenType.String) { var clrType = dataType.GetFacetValue<PrimitiveClrTypeFacet, Type>(null); if (this.converter.TryConvertFromString((string)parsed, clrType, out parsed)) { return payloadElement.ReplaceWith(new PrimitiveValue(payloadElement.FullTypeName, parsed)); } } } } return base.Visit(payloadElement); }
private void CompareRequest(ExpectedClientRequest expected, IHttpRequest actual) { this.parent.Assert.AreEqual(expected.Verb, actual.Verb, "Request verb did not match"); // The headers are quite different when using XmlHttp if (!this.contextData.UsesXmlHttpStack()) { this.CompareHeaders(expected.Headers, actual.Headers); } if (expected.Body == null) { int actualLength = 0; var actualBody = actual.GetRequestBody(); if (actualBody != null) { actualLength = actualBody.Length; } this.parent.Assert.AreEqual(0, actualLength, "Request should not have had a body"); } else { ODataPayloadElement actualPayload; if (expected.Body.ElementType == ODataPayloadElementType.EntityInstance) { actualPayload = actual.DeserializeAndCast<EntityInstance>(this.parent.FormatSelector); } else if (expected.Body.ElementType == ODataPayloadElementType.DeferredLink) { actualPayload = actual.DeserializeAndCast<DeferredLink>(this.parent.FormatSelector); } else { ExceptionUtilities.Assert(expected.Body.ElementType == ODataPayloadElementType.PrimitiveValue, "Expected payload element was neither an entity, a link, nor a stream"); actualPayload = new PrimitiveValue(null, actual.GetRequestBody()); } try { this.parent.PayloadComparer.Compare(expected.Body, actualPayload); } catch (TestFailedException e) { this.parent.Log.WriteLine(LogLevel.Error, "Expected client request payload did not match actual."); var strategy = this.parent.FormatSelector.GetStrategy(actual.GetHeaderValueIfExists(HttpHeaders.ContentType), null); var expectedBinary = strategy.GetSerializer().SerializeToBinary(expected.Body); this.parent.Log.WriteLine(LogLevel.Verbose, "Expected request:"); var expectedToLog = new HttpRequestData() { Verb = expected.Verb, Uri = expected.Uri, Body = expectedBinary }; expectedToLog.Headers.AddRange(expected.Headers); expectedToLog.WriteToLog(this.parent.Log, LogLevel.Verbose); this.parent.Log.WriteLine(LogLevel.Verbose, "Actual request:"); actual.WriteToLog(this.parent.Log, LogLevel.Verbose); // wrap to preserve call stack throw new AssertionFailedException("Expected client request payload did not match actual.", e); } } }
/// <summary> /// Visits the payload element and annotates it with metadata /// </summary> /// <param name="payloadElement">The payload element to visit</param> public override void Visit(PrimitiveValue payloadElement) { ExceptionUtilities.CheckArgumentNotNull(payloadElement, "payloadElement"); // It will not always be a Primitive DataType, it may be an empty value of some collection type from a serviceoperation or action var dataType = this.MetadataStack.Peek() as DataType; ExceptionUtilities.CheckObjectNotNull(dataType, "Expected primitive data type, got '{0}'", this.MetadataStack.Peek()); payloadElement.AddAnnotationIfNotExist(new DataTypeAnnotation() { DataType = dataType }); }
internal PrimitiveType(string name, int size, double minValue, double maxValue, double nullValue, SbePrimitiveType sbePrimitiveType) { _name = name; _size = size; _sbePrimitiveType = sbePrimitiveType; _minValue = new PrimitiveValue(minValue, size); _maxValue = new PrimitiveValue(maxValue, size); _nullValue = new PrimitiveValue(nullValue, size); }
/// <summary> /// Finds a different(not guaranteed) primitive value of the same type as the value passed /// </summary> /// <param name="currentValue">primitive value for which to provide a different value</param> /// <param name="usedValues">Optional used values to exclude when returning a new value</param> /// <returns>A new primitive value with different value(not guaranteed) but the same type</returns> public static PrimitiveValue GetDifferentPrimitiveValue(PrimitiveValue currentValue, IEnumerable<PrimitiveValue> usedValues = null) { if (currentValue == null) { return null; } if (currentValue.ClrValue == null) { return currentValue.DeepCopy(); } Type expectedClrType = currentValue.ClrValue.GetType(); var valuesOfExpectedType = TestValues.CreatePrimitiveValuesWithMetadata(true).Where(v => v.ClrValue != null && v.ClrValue.GetType() == expectedClrType && v.ClrValue != currentValue.ClrValue); // Make sure that our list of primitives has atleast one value with the expected type ExceptionUtilities.Assert(valuesOfExpectedType.Count() > 0, "CreatePrimitiveValuesWithMetadata does not have a primitve value with the clr type: " + expectedClrType.ToString() + " that is different from " + currentValue.ClrValue.ToString()); // Find unused values var unUsedValues = valuesOfExpectedType; if (usedValues != null) { unUsedValues = unUsedValues.Where(v => !usedValues.Any(usedVal => usedVal.ClrValue == currentValue.ClrValue)); } var newPrimitiveValue = unUsedValues.Count() > 0 ? unUsedValues.First() : valuesOfExpectedType.First(); // Make a deep copy of the original and replace only the clr value so that we won't touch annotations etc. var newValueToBeReturned = currentValue.DeepCopy(); newValueToBeReturned.ClrValue = newPrimitiveValue.ClrValue; return newValueToBeReturned; }
public static extern void get_value(ListHandle listHandle, IntPtr link_ndx, out PrimitiveValue value, out NativeException ex);
/// <summary> /// Remove fulltype names on PrimitiveValue /// </summary> /// <param name="payloadElement">payloadElement to remove the type names from</param> public override void Visit(PrimitiveValue payloadElement) { payloadElement.FullTypeName = null; }
/// <summary> /// Not supported; we collected primitive values already. /// <param name="payloadElement">A primitive value payload.</param> public override void Visit(PrimitiveValue payloadElement) { throw new NotSupportedException(); }
public Builder ConstValue(PrimitiveValue constValue) { _constVal = constValue; return this; }
public static int Put(DirectBuffer buffer, PrimitiveValue value, PrimitiveType type) { if (value == null) { return 0; } switch (type.Type) { case SbePrimitiveType.Char: if (value.Size == 1) { buffer.CharPut(0, (byte)value.LongValue()); return 1; } else { var byteArrayValue = value.ByteArrayValue(); buffer.SetBytes(0, byteArrayValue, 0, byteArrayValue.Length); return byteArrayValue.Length; } case SbePrimitiveType.Int8: buffer.Int8Put(0, (sbyte)value.LongValue()); return 1; case SbePrimitiveType.Int16: buffer.Int16PutLittleEndian(0, (short)value.LongValue()); return 2; case SbePrimitiveType.Int32: buffer.Int32PutLittleEndian(0, (int)value.LongValue()); return 4; case SbePrimitiveType.Int64: buffer.Int64PutLittleEndian(0, value.LongValue()); return 8; case SbePrimitiveType.UInt8: buffer.Uint8Put(0, (byte)value.LongValue()); return 1; case SbePrimitiveType.UInt16: buffer.Uint16PutLittleEndian(0, (ushort)value.LongValue()); return 2; case SbePrimitiveType.UInt32: buffer.Uint32PutLittleEndian(0, (uint) value.LongValue()); return 4; case SbePrimitiveType.UInt64: buffer.Uint64PutLittleEndian(0, value.ULongValue()); return 8; case SbePrimitiveType.Float: buffer.FloatPutLittleEndian(0, (float) value.DoubleValue()); return 4; case SbePrimitiveType.Double: buffer.DoublePutLittleEndian(0, value.DoubleValue()); return 8; default: return 0; } }
public static extern void insert_value(ListHandle listHandle, IntPtr targetIndex, PrimitiveValue value, out NativeException ex);
/// <summary> /// Not supported; we collected primitive values already. /// <param name="payloadElement">A primitive value payload.</param> public override void Visit(PrimitiveValue payloadElement) { ExceptionUtilities.Assert(this.items.Count == 0, "This should not get called unless primitive is top level"); this.items.Push(payloadElement.ClrValue); }
public static extern IntPtr find_value(ListHandle listHandle, PrimitiveValue value, out NativeException ex);
/// <summary> /// Visits the payload element /// </summary> /// <param name="payloadElement">The payload element to visit</param> public override void Visit(PrimitiveValue payloadElement) { var value = payloadElement.ClrValue; this.AddValue(value); }