public Delegate GenerateEncoder(Type type, Func <Type, Delegate> recurse) { return(new Func <UInt16, EncodeBuffer>(value => { return new EncodeBuffer(UnsignedVlq.Encode(value)); })); }
public override EncodeBuffer Encode(Object value) { var v = value as String; if (v == null) { if (IsNullable) { return(Precomputed.Zero); } else { throw new UnexpectedNullValueException(); } } var length = (UInt64)v.Length; if (IsNullable) { length++; } // Encode value var output = new EncodeBuffer(2); output.Append(new ArraySegment <Byte>(Encoding.UTF8.GetBytes(v))); // Prepend length output.SetFirst(UnsignedVlq.Encode(length)); // Offset by one, since 0 is NULL return(output); }
public Delegate GenerateEncoder(Type type, Func <Type, Delegate> recurse) { // Get serializer for sub items var valueEncoder = recurse(type.GetElementType()); return(new Func <Array, EncodeBuffer>(value => { // Handle nulls if (null == value) { return Null; } // Serialize elements var output = new EncodeBuffer(); foreach (var subValue in value) { output.Append((EncodeBuffer)valueEncoder.DynamicInvokeTransparent(subValue)); } // Encode length output.SetFirst(UnsignedVlq.Encode((UInt64)value.Length + 1)); // Number of elements, not number of bytes return output; })); }
public Delegate GenerateEncoder(Type type, Func <Type, Delegate> recurse) { // Get serializer for sub items var keyEncoder = recurse(type.GenericTypeArguments[0]); var valueEncoder = recurse(type.GenericTypeArguments[1]); return(new Func <IDictionary, EncodeBuffer>(value => { // Handle nulls if (null == value) { return Null; } // Serialize elements var output = new EncodeBuffer(); var e = value.GetEnumerator(); UInt64 count = 0; while (e.MoveNext()) { output.Append((EncodeBuffer)keyEncoder.DynamicInvokeTransparent(e.Key)); output.Append((EncodeBuffer)valueEncoder.DynamicInvokeTransparent(e.Value)); count++; } // Encode length output.SetFirst(UnsignedVlq.Encode(count + 1)); return output; })); }
public Delegate GenerateEncoder(Type type, Func <Type, Delegate> recurse) { // Get serializer for sub items var valueEncoder = recurse(type.GenericTypeArguments[0]); return(new Func <IList, EncodeBuffer>(value => { // Handle nulls if (null == value) { return Null; } // Serialize elements var output = new EncodeBuffer(); foreach (var element in value) { output.Append((EncodeBuffer)valueEncoder.DynamicInvokeTransparent(element)); } // Encode length output.SetFirst(UnsignedVlq.Encode((UInt64)value.Count + 1)); return output; })); }
public void UnsignedEncodeNullableNull() { var coder = new HeliumIntegerUnsigned(0, true, 1, 0); coder.Prepare(typeof(UInt32?)); var encoded = coder.Encode((UInt32?)null); Assert.Equal(UnsignedVlq.Encode(UnsignedVlq.MinValue).ToHexString(), encoded.ToHexString()); }
public void UnsignedEncodeMax() { var coder = new HeliumIntegerUnsigned(0, false, 1, 0); coder.Prepare(typeof(UInt64)); var encoded = coder.Encode(UnsignedVlq.MaxValue); Assert.Equal(UnsignedVlq.Encode(UnsignedVlq.MaxValue).ToHexString(), encoded.ToHexString()); }
public void UnsignedDecodeNullableNull() { var coder = new HeliumIntegerUnsigned(0, true, 1, 0); coder.Prepare(typeof(UInt32?)); var decoded = coder.Decode(new DecodeBuffer(UnsignedVlq.Encode(0).ToArray())); Assert.Equal((UInt32?)null, decoded); }
public void UnsignedDecodeMax() { var coder = new HeliumIntegerUnsigned(0, false, 1, 0); coder.Prepare(typeof(UInt64)); var decoded = coder.Decode(new DecodeBuffer(UnsignedVlq.Encode(UnsignedVlq.MaxValue).ToArray())); Assert.Equal(UnsignedVlq.MaxValue, decoded); }
public void UnsignedDecodeMin() { var coder = new HeliumIntegerUnsigned(0, false, 1, 0); coder.Prepare(typeof(UInt32)); var decoded = coder.Decode(new DecodeBuffer(UnsignedVlq.Encode(0).ToArray())); Assert.Equal((UInt32)0, decoded); }
public override EncodeBuffer Encode(Object value) { if (value == null && IsNullable) { return(Precomputed.Zero); } var v = Convert.ToUInt64(value); v -= Minimum; v /= Increment; if (IsNullable) { v++; } return(new EncodeBuffer(UnsignedVlq.Encode(v))); }
public override EncodeBuffer Encode(Object value) { #if DEBUG if (null == Records) { throw new InvalidOperationException("Coder has not yet been prepared."); } #endif // Handle nulls if (null == value) { if (!IsNullable) { throw new UnexpectedNullValueException(); } return(Precomputed.Zero); } var output = new EncodeBuffer(); for (Byte i = 0; i < Records.Length; i++) { var record = Records[i]; // Extract value var v = record.Field.GetValue(value); // Add to output output.Append(record.Coder.Encode(v)); } // Increment length if nullable, to allow space for null representation var length = (UInt64)output.TotalLength; if (IsNullable) { length++; } // Encode length output.SetFirst(UnsignedVlq.Encode(length)); return(output); }
public Delegate GenerateEncoder(Type type, Func <Type, Delegate> recurse) { return(new Func <String, EncodeBuffer>(value => { // Handle nulls if (null == value) { return Null; } // Encode value var output = new EncodeBuffer(2); output.Append(new ArraySegment <Byte>(Encoding.UTF8.GetBytes(value))); // Prepend length output.SetFirst(UnsignedVlq.Encode((UInt64)output.TotalLength + 1)); // Offset by one, since 0 is NULL return output; })); }
public void UInt32SerializeMax() { Assert.Equal(UnsignedVlq.Encode(UInt32.MaxValue), LightWeight.Serialize(UInt32.MaxValue)); }
public void BooleanSerializeTrue() { Assert.Equal(UnsignedVlq.Encode(1), LightWeight.Serialize(true)); }
public void BooleanDeserializeFalse() { Assert.False(LightWeight.Deserialize <Boolean>(UnsignedVlq.Encode(0).ToArray())); }
public void BooleanDeserializeTrue() { Assert.True(LightWeight.Deserialize <Boolean>(UnsignedVlq.Encode(1).ToArray())); }
public void BooleanSerializeFalse() { Assert.Equal(UnsignedVlq.Encode(0), LightWeight.Serialize(false)); }
public void UInt16SerializeEnum() { Assert.Equal(UnsignedVlq.Encode((UInt16)TestEnum.B).ToArray().ToHexString(), LightWeight.Serialize(TestEnum.B).ToHexString()); }
public void UInt64DeserializeMin() { Assert.Equal(UnsignedVlq.MinValue, LightWeight.Deserialize <UInt64>(UnsignedVlq.Encode(UnsignedVlq.MinValue).ToArray())); }
public void StringSerializeNull() { Assert.Equal(UnsignedVlq.Encode(0), LightWeight.Serialize <String>(null)); }
public void UInt32DeserializeEnum() { Assert.Equal(TestEnum.B, LightWeight.Deserialize <TestEnum>(UnsignedVlq.Encode((UInt32)TestEnum.B).ToArray())); }
public void UInt32SerializeEnum() { Assert.Equal(UnsignedVlq.Encode((UInt32)TestEnum.B), LightWeight.Serialize(TestEnum.B)); }
public void UInt32DeserializeMax() { Assert.Equal(UInt32.MaxValue, LightWeight.Deserialize <UInt32>(UnsignedVlq.Encode(UInt32.MaxValue).ToArray())); }
public void StringDeserializeNull() { Assert.Null(LightWeight.Deserialize <String>(UnsignedVlq.Encode(0).ToArray())); }
public Delegate GenerateEncoder(Type type, Func <Type, Delegate> recurse) { var records = new Record[Byte.MaxValue]; // Find all properties decorated with LightWeightProperty attribute var fieldCount = -1; foreach (var property in type.GetRuntimeFields()) { // Get property attribute which tells us the properties' index var attribute = (LightWeightPropertyAttribute)property.GetCustomAttribute(typeof(LightWeightPropertyAttribute), false); if (null == attribute) { // No attribute found, skip continue; } // Check for duplicate index if (null != records[attribute.Index]) { throw new DuplicateIndexException($"The index {attribute.Index} is already used and cannot be reused."); } // Note the max index used if (attribute.Index > fieldCount) { fieldCount = attribute.Index; } // Find/create encoder var encoder = recurse(property.FieldType); // Find floor, if any var transformations = property.GetCustomAttributes <TransformationAttribute>(true).ToArray(); // Store property in lookup records[attribute.Index] = new Record() { Field = property, Coder = encoder, Transformations = transformations }; } // If no properties, shortcut the whole thing and return a blank if (fieldCount == -1) { return(new Func <Object, EncodeBuffer>(value => { // Handle nulls if (null == value) { return Null; } return One; })); } // Check that no indexes have been missed for (var i = 0; i < fieldCount; i++) { if (null == records[i]) { throw new MissingIndexException($"Indexes must not be skipped, however missing index {i}."); // TODO: Make so indexes can be skipped for easier versioning } } return(new Func <Object, EncodeBuffer>(value => { // Handle nulls if (null == value) { return Null; } var output = new EncodeBuffer(); for (Byte i = 0; i <= fieldCount; i++) { var record = records[i]; // Get the serializer for the sub-item var subType = recurse(record.Field.FieldType); // Get it's method info var subMethodInfo = subType.GetMethodInfo(); // Extract value var v = record.Field.GetValue(value); // Apply transformations foreach (var transformation in record.Transformations) { v = transformation.ApplyEffect(v); } // Add to output output.Append((EncodeBuffer)record.Coder.DynamicInvokeTransparent(v)); } // Encode length output.SetFirst(UnsignedVlq.Encode((UInt64)output.TotalLength + 1)); // Number of bytes return output; })); }
public void StringDeserializeEmpty() { Assert.Equal(String.Empty, LightWeight.Deserialize <String>(UnsignedVlq.Encode(1).ToArray())); }
public void UInt64SerializeMin() { Assert.Equal(UnsignedVlq.Encode(UnsignedVlq.MinValue), LightWeight.Serialize(UnsignedVlq.MinValue)); }
public void StringSerializeEmpty() { Assert.Equal(UnsignedVlq.Encode(1), LightWeight.Serialize(String.Empty)); }