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();
}
}
}
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>
/// 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);
}
