public override void WriteValueNotNull(HessianWriter writer, HessianContext context, object value) { var type = value.GetType(); var typeCode = Type.GetTypeCode(type); switch (typeCode) { case TypeCode.Byte: WriteInt(writer, context, (byte)value); break; case TypeCode.SByte: WriteInt(writer, context, (sbyte)value); break; case TypeCode.Int16: WriteInt(writer, context, (short)value); break; case TypeCode.UInt16: WriteInt(writer, context, (ushort)value); break; case TypeCode.Int32: WriteInt(writer, context, (int)value); break; case TypeCode.UInt32: WriteUInt(writer, context, (uint)value); break; default: throw Exceptions.UnExpectedTypeException(type); } }
public override object ReadValue(HessianReader reader, HessianContext context, Type objectType, byte initialOctet) { using (var stream = new MemoryStream()) { while (initialOctet == Constants.BC_BINARY_CHUNK) { int len = reader.ReadInt16(); FillBuffer(reader, stream, len); initialOctet = reader.ReadByte(); } if (initialOctet == Constants.BC_BINARY) { int len = reader.ReadInt16(); FillBuffer(reader, stream, len); } else if (Constants.BC_BINARY_DIRECT <= initialOctet && initialOctet <= Constants.BC_BINARY_DIRECT + Constants.BINARY_DIRECT_MAX) { FillBuffer(reader, stream, initialOctet - Constants.BC_BINARY_DIRECT); } else { throw Exceptions.UnExpectedInitialOctet(this, initialOctet); } return(stream.ToArray()); } }
public override object ReadValue(HessianReader reader, HessianContext context, Type objectType, byte initialOctet) { if (0x80 <= initialOctet && initialOctet <= 0xbf) { return(initialOctet - 0x90); } else if (0xc0 <= initialOctet && initialOctet <= 0xcf) { var b0 = reader.ReadByte(); return(((initialOctet - 0xc8) << 8) + b0); } else if (0xd0 <= initialOctet && initialOctet <= 0xd7) { var s = reader.ReadUInt16(); return(((initialOctet - 0xd4) << 16) + s); } else if (Constants.BC_INT == initialOctet) { return(reader.ReadInt32()); } else { throw Exceptions.UnExpectedInitialOctet(this, initialOctet); } }
public override object ReadValue(HessianReader reader, HessianContext context, Type objectType, byte initialOctet) { var builder = new StringBuilder(); int len = 0; while (Constants.BC_STRING_CHUNK == initialOctet) { len = reader.ReadUInt16(); builder.Append(reader.ReadString(len)); initialOctet = reader.ReadByte(); } if (0x00 <= initialOctet && initialOctet <= 0x1f) { len = initialOctet; } else if (0x30 <= initialOctet && initialOctet <= 0x34) { var b0 = reader.ReadByte(); len = ((initialOctet - 0x30) << 8) + b0; } else if (Constants.BC_STRING == initialOctet) { len = reader.ReadUInt16(); } else { throw Exceptions.UnExpectedInitialOctet(this, initialOctet); } builder.Append(reader.ReadString(len)); return(builder.ToString()); }
public override void WriteValueNotNull(HessianWriter writer, HessianContext context, object value) { var type = value.GetType(); var converter = GetConverter(type); converter.WriteValueNotNull(writer, context, value); }
public override object ReadValue(HessianReader reader, HessianContext context, Type objectType, byte initialOctet) { if (initialOctet == Constants.BC_DOUBLE_ZERO) { return(0d); } else if (initialOctet == Constants.BC_DOUBLE_ONE) { return(1d); } else if (initialOctet == Constants.BC_DOUBLE_BYTE) { return((double)reader.ReadSByte()); } else if (initialOctet == Constants.BC_DOUBLE_SHORT) { return((double)reader.ReadInt16()); } else if (initialOctet == Constants.BC_DOUBLE_MILL) { return(reader.ReadInt32() / 1000.0d); } else if (initialOctet == Constants.BC_DOUBLE) { return(reader.ReadDouble()); } else { throw Exceptions.UnExpectedInitialOctet(this, initialOctet); } }
public override void WriteValueNotExisted(HessianWriter writer, HessianContext context, object value) { Type type = value.GetType(); if (!IsMap(type)) { throw Exceptions.UnExpectedTypeException(type); } writer.Write(Constants.BC_MAP_UNTYPED); var kvType = typeof(KeyValuePair <,>).MakeGenericType(type.GenericTypeArguments); var keyProperty = kvType.GetProperty("Key"); var valueProperty = kvType.GetProperty("Value"); var keyConverter = AutoConverter.GetConverter(type.GenericTypeArguments[0]); var valueConverter = AutoConverter.GetConverter(type.GenericTypeArguments[1]); foreach (var entry in (IEnumerable)value) { keyConverter.WriteValue(writer, context, keyProperty.GetValue(entry)); valueConverter.WriteValue(writer, context, valueProperty.GetValue(entry)); } writer.Write(Constants.BC_END); }
public override object ReadValue(HessianReader reader, HessianContext context, Type objectType, byte initialOctet) { if (0xd8 <= initialOctet && initialOctet <= 0xef) { return((long)(initialOctet - 0xe0)); } else if (0xf0 <= initialOctet && initialOctet <= 0xff) { var b0 = reader.ReadByte(); return((long)(((initialOctet - 0xf8) << 8) + b0)); } else if (0x38 <= initialOctet && initialOctet <= 0x3f) { var s = reader.ReadUInt16(); return((long)(((initialOctet - 0x3c) << 16) + s)); } else if (Constants.BC_LONG_INT == initialOctet) { return((long)reader.ReadInt32()); } else if (Constants.BC_LONG == initialOctet) { return(reader.ReadInt64()); } else { throw Exceptions.UnExpectedInitialOctet(this, initialOctet); } }
public override void WriteValueNotNull(HessianWriter writer, HessianContext context, object value) { var type = value.GetType(); string s = null; if (type == typeof(string)) { s = (string)value; } else if (type == typeof(char)) { s = value.ToString(); } else { throw Exceptions.UnExpectedTypeException(type); } int length = s.Length; int index = 0; while (index + Constants.BINARY_CHUNK_SIZE < length) { writer.Write(Constants.BC_STRING_CHUNK); writer.Write((short)Constants.STRING_CHUNK_SIZE); writer.Write(s.Substring(index, Constants.STRING_CHUNK_SIZE)); index += Constants.BINARY_CHUNK_SIZE; } int leftSize = length - index; if (leftSize == 0) { if (index == 0) { writer.Write(Constants.BC_STRING_DIRECT); } } else { if (leftSize <= Constants.STRING_DIRECT_MAX) { writer.Write((byte)(Constants.BC_STRING_DIRECT + leftSize)); } else if (leftSize <= Constants.STRING_SHORT_MAX) { writer.Write((byte)(Constants.BC_STRING_SHORT + (leftSize >> 8))); writer.Write((byte)leftSize); } else { writer.Write(Constants.BC_STRING); writer.Write((short)leftSize); } writer.Write(s.Substring(index, leftSize)); } }
public override void WriteValueNotNull(HessianWriter writer, HessianContext context, object value) { var type = value.GetType(); double v = 0; if (type == typeof(double)) { v = (double)value; } else if (type == typeof(float)) { v = Convert.ToDouble(value); } else { throw Exceptions.UnExpectedTypeException(type); } int intValue = (int)v; if (intValue == v) { if (intValue == 0) { writer.Write(Constants.BC_DOUBLE_ZERO); return; } else if (intValue == 1) { writer.Write(Constants.BC_DOUBLE_ONE); return; } else if (-0x80 <= intValue && intValue < 0x80) { writer.Write(Constants.BC_DOUBLE_BYTE); writer.Write((byte)intValue); return; } else if (-0x8000 <= intValue && intValue < 0x8000) { writer.Write(Constants.BC_DOUBLE_SHORT); writer.Write((short)intValue); return; } } int mills = (int)(v * 1000); if (0.001 * mills == v) { writer.Write(Constants.BC_DOUBLE_MILL); writer.Write(mills); return; } writer.Write(Constants.BC_DOUBLE); writer.Write(v); }
public override void WriteValueNotNull(HessianWriter writer, HessianContext context, object value) { if (!(value is Type)) { throw Exceptions.UnExpectedTypeException(value.GetType()); } WriteType(writer, context, (Type)value); }
public virtual void WriteValue(HessianWriter writer, HessianContext context, object value) { if (value == null) { writer.Write(Constants.BC_NULL); return; } WriteValueNotNull(writer, context, value); }
public override void WriteValueNotExisted(HessianWriter writer, HessianContext context, object value) { Type type = value.GetType(); if (!type.IsArray) { throw Exceptions.UnExpectedTypeException(type); } var elementType = type.GetElementType(); if (elementType == typeof(byte) || elementType == typeof(sbyte)) { GetConverter <BinaryConverter>().WriteValueNotNull(writer, context, value); return; } var array = (Array)value; HessianConverter itemConverter = null; if (elementType == typeof(object)) { //untyped array if (array.Length <= Constants.LIST_DIRECT_MAX) { writer.Write((byte)(Constants.BC_LIST_DIRECT_UNTYPED + array.Length)); } else { writer.Write(Constants.BC_LIST_FIXED_UNTYPED); IntConverter.WriteInt(writer, context, array.Length); } itemConverter = AutoConverter; } else { if (array.Length <= Constants.LIST_DIRECT_MAX) { writer.Write((byte)(Constants.BC_LIST_DIRECT + array.Length)); TypeConverter.WriteType(writer, context, type); } else { writer.Write(Constants.BC_LIST_FIXED); TypeConverter.WriteType(writer, context, type); IntConverter.WriteInt(writer, context, array.Length); } itemConverter = AutoConverter.GetConverter(elementType); } foreach (var item in array) { itemConverter.WriteValue(writer, context, item); } }
public virtual object ReadValue(HessianReader reader, HessianContext context, Type objectType) { var initialOctet = reader.ReadByte(); if (initialOctet == Constants.BC_NULL) { return(null); } return(ReadValue(reader, context, objectType, initialOctet)); }
public override object ReadValue(HessianReader reader, HessianContext context, Type objectType, byte initialOctet) { if (Constants.BC_REF == initialOctet) { var index = (int)IntConverter.ReadValue(reader, context, typeof(int)); return(context.ValueRefs.GetItem(index)); } else { return(ReadValueNotExisted(reader, context, objectType, initialOctet)); } }
public override void WriteValueNotNull(HessianWriter writer, HessianContext context, object value) { (var index, var isNew) = context.ValueRefs.AddItem(value); if (isNew) { WriteValueNotExisted(writer, context, value); } else { writer.Write(Constants.BC_REF); IntConverter.WriteInt(writer, context, index); } }
public override void WriteValue(HessianWriter writer, HessianContext context, object value) { if (value == null) { throw new ArgumentNullException(nameof(value)); } if (!(value is ClassDefinition)) { throw new InvalidOperationException("value is not an class definition"); } WriteClassDefinition(writer, context, value as ClassDefinition, out int definitionIndex); }
public override object ReadValue(HessianReader reader, HessianContext context, Type objectType, byte initialOctet) { if (initialOctet == Constants.BC_TRUE) { return(true); } else if (initialOctet == Constants.BC_FALSE) { return(false); } else { throw Exceptions.UnExpectedInitialOctet(this, initialOctet); } }
public override object ReadValueNotExisted(HessianReader reader, HessianContext context, Type objectType, byte initialOctet) { int len = 0; Type elementType = null; if (0x70 <= initialOctet && initialOctet <= 0x77) { elementType = ((Type)TypeConverter.ReadValue(reader, context, null)).GetElementType(); len = initialOctet - 0x70; } else if (0x78 <= initialOctet && initialOctet <= 0x7f) { elementType = typeof(object); len = initialOctet - 0x78; } else if (Constants.BC_LIST_FIXED_UNTYPED == initialOctet) { elementType = typeof(object); len = (int)IntConverter.ReadValue(reader, context, typeof(int)); } else if (Constants.BC_LIST_FIXED == initialOctet) { elementType = ((Type)TypeConverter.ReadValue(reader, context, null)).GetElementType(); len = (int)IntConverter.ReadValue(reader, context, typeof(int)); } var array = Array.CreateInstance(elementType, len); context.ValueRefs.AddItem(array); HessianConverter itemConverter = null; if (elementType == typeof(object)) { itemConverter = AutoConverter; } else { itemConverter = AutoConverter.GetConverter(elementType); } for (int i = 0; i < len; i++) { var item = itemConverter.ReadValue(reader, context, elementType); array.SetValue(item, i); } return(array); }
public override object ReadValueNotExisted(HessianReader reader, HessianContext context, Type objectType, byte initialOctet) { if (ClassDefinitionConverter.CanRead(initialOctet)) { ClassDefinitionConverter.ReadValue(reader, context, typeof(ClassDefinition), initialOctet); initialOctet = reader.ReadByte(); } int definitionIndex = 0; if (0x60 <= initialOctet && initialOctet <= 0x6f) { definitionIndex = initialOctet - Constants.BC_OBJECT_DIRECT; } else if (Constants.BC_OBJECT == initialOctet) { definitionIndex = (int)IntConverter.ReadValue(reader, context, typeof(int)); } var definition = context.ClassRefs.GetItem(definitionIndex); object value = null; if (definition.Type.IsEnum) { definition.VisitFields(field => { var fieldValue = AutoConverter.ReadValue(reader, context, field.Type); if (field.Name == "name") { value = Enum.Parse(definition.Type, (string)fieldValue); context.ValueRefs.AddItem(value); } }); } else { value = Activator.CreateInstance(definition.Type); context.ValueRefs.AddItem(value); definition.VisitFields(field => { var fieldValue = AutoConverter.ReadValue(reader, context, field.Type); field.Setter(value, fieldValue); }); } return(value); }
public void TypeRef() { Serializer.AutoReset = false; Serializer.Serialize(Stream, typeof(string)); Serializer.Serialize(Stream, typeof(string)); Stream.Seek(0, System.IO.SeekOrigin.Begin); var reader = new HessianReader(Stream); var context = new HessianContext(); var type1 = (Type)HessianConverter.TypeConverter.ReadValue(reader, context, null); Assert.Equal(typeof(string), type1); var type2 = (Type)HessianConverter.TypeConverter.ReadValue(reader, context, null); Assert.Same(type1, type2); }
public override object ReadValue(HessianReader reader, HessianContext context, Type objectType, byte initialOctet) { if (initialOctet == Constants.BC_DATE) { var timeStamp = reader.ReadInt64(); return(BeginDate.AddTicks(timeStamp * 10000)); } else if (initialOctet == Constants.BC_DATE_MINUTE) { var minutes = reader.ReadInt32(); return(BeginDate.AddMinutes(minutes)); } else { throw Exceptions.UnExpectedInitialOctet(this, initialOctet); } }
public override object ReadValue(HessianReader reader, HessianContext context, Type objectType, byte initialOctet) { if (Constants.BC_REF == initialOctet) { var index = (int)IntConverter.ReadValue(reader, context, typeof(int)); return(context.ValueRefs.GetItem(index)); } foreach (var converter in ConverterCache.Values) { if (converter != this && !(converter is ClassDefinitionConverter) && converter.CanRead(initialOctet)) { return(converter.ReadValue(reader, context, objectType, initialOctet)); } } throw Exceptions.UnExpectedInitialOctet(this, initialOctet); }
public void WriteType(HessianWriter writer, HessianContext context, Type type) { if (type == null) { throw new ArgumentNullException(nameof(type)); } (int index, bool isNewItem) = context.TypeRefs.AddItem(type); if (isNewItem) { StringConverter.WriteValueNotNull(writer, context, GetTypeName(type)); } else { IntConverter.WriteInt(writer, context, index); } }
public void ReadClassDefinition() { Serializer.AutoReset = false; var writer = new HessianWriter(Stream); var context = new HessianContext(); HessianConverter.ClassDefinitionConverter.WriteClassDefinition(writer, context, ClassDefinition.ForType(typeof(Car)), out int index); Stream.Seek(0, System.IO.SeekOrigin.Begin); var reader = new HessianReader(Stream); context = new HessianContext(); var definition = (ClassDefinition)HessianConverter.ClassDefinitionConverter.ReadValue(reader, context, typeof(ClassDefinition)); Assert.Equal(typeof(Car), definition.Type); Assert.Equal(2, definition.FieldNames.Count); Assert.Equal(nameof(Car.color), definition.FieldNames[0]); Assert.Equal(nameof(Car.model), definition.FieldNames[1]); }
public override void WriteValueNotNull(HessianWriter writer, HessianContext context, object value) { var type = value.GetType(); var typeCode = Type.GetTypeCode(type); switch (typeCode) { case TypeCode.Int64: WriteLong(writer, (long)value); break; case TypeCode.UInt64: WriteULong(writer, (ulong)value); break; default: throw Exceptions.UnExpectedTypeException(type); } }
public override object ReadValue(HessianReader reader, HessianContext context, Type objectType, byte initialOctet) { if (StringConverter.CanRead(initialOctet)) { var typeName = (string)StringConverter.ReadValue(reader, context, typeof(string), initialOctet); var type = GetType(typeName); context.TypeRefs.AddItem(type); return(type); } else if (IntConverter.CanRead(initialOctet)) { var typeIndex = (int)IntConverter.ReadValue(reader, context, typeof(int), initialOctet); return(context.TypeRefs.GetItem(typeIndex)); } else { throw Exceptions.UnExpectedInitialOctet(this, initialOctet); } }
public override void WriteValueNotNull(HessianWriter writer, HessianContext context, object value) { var type = value.GetType(); if (type != typeof(bool)) { throw Exceptions.UnExpectedTypeException(type); } bool b = (bool)value; if (b) { writer.Write(Constants.BC_TRUE); } else { writer.Write(Constants.BC_FALSE); } }
public void WriteClassDefinition(HessianWriter writer, HessianContext context, ClassDefinition definition, out int definitionIndex) { if (definition == null) { throw new ArgumentNullException(nameof(definition)); } (var index, var isNewItem) = context.ClassRefs.AddItem(definition); if (isNewItem) { writer.Write(Constants.BC_OBJECT_DEF); TypeConverter.WriteType(writer, context, definition.Type); IntConverter.WriteInt(writer, context, definition.FieldNames.Count); foreach (var fieldName in definition.FieldNames) { StringConverter.WriteValueNotNull(writer, context, fieldName); } } definitionIndex = index; }
public override void WriteValueNotExisted(HessianWriter writer, HessianContext context, object value) { var definition = ClassDefinition.ForType(value.GetType()); ClassDefinitionConverter.WriteClassDefinition(writer, context, definition, out int definitionIndex); if (definitionIndex <= Constants.OBJECT_DIRECT_MAX) { writer.Write((byte)(Constants.BC_OBJECT_DIRECT + definitionIndex)); } else { writer.Write(Constants.BC_OBJECT); writer.Write(definitionIndex); } definition.VisitFields(field => { var fieldValue = field.Getter(value); AutoConverter.WriteValue(writer, context, fieldValue); }); }