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 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 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 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);
});
}
public override object ReadValueNotExisted(HessianReader reader, HessianContext context, Type objectType, byte initialOctet)
{
if (Constants.BC_MAP_UNTYPED == initialOctet)
{
var dict = new Dictionary <object, object>();
context.ValueRefs.AddItem(dict);
initialOctet = reader.ReadByte();
while (Constants.BC_END != initialOctet)
{
var key = AutoConverter.ReadValue(reader, context, typeof(object), initialOctet);
var value = AutoConverter.ReadValue(reader, context, typeof(object));
dict.Add(key, value);
initialOctet = reader.ReadByte();
}
return(dict);
}
else
{
throw Exceptions.UnExpectedInitialOctet(this, initialOctet);
}
}
public override object ReadValueNotExisted(HessianReader reader, HessianContext context, Type objectType, byte initialOctet)
{
Type listType = null;
Type elementType = null;
HessianConverter itemConverter = null;
if (Constants.BC_LIST_VARIABLE_UNTYPED == initialOctet)
{
listType = typeof(List <object>);
elementType = typeof(object);
itemConverter = AutoConverter;
}
else if (Constants.BC_LIST_VARIABLE == initialOctet)
{
listType = (Type)TypeConverter.ReadValue(reader, context, null);
elementType = listType.GenericTypeArguments[0];
itemConverter = AutoConverter.GetConverter(elementType);
}
else
{
throw Exceptions.UnExpectedInitialOctet(this, initialOctet);
}
var addMethod = listType.GetMethod("Add");
var list = Activator.CreateInstance(listType);
context.ValueRefs.AddItem(list);
initialOctet = reader.ReadByte();
var parameters = new object[1];
while (Constants.BC_END != initialOctet)
{
parameters[0] = itemConverter.ReadValue(reader, context, elementType, initialOctet);
addMethod.Invoke(list, parameters);
initialOctet = reader.ReadByte();
}
return(list);
}
public override void WriteValueNotExisted(HessianWriter writer, HessianContext context, object value)
{
Type type = value.GetType();
Type itemType = null;
if (type == typeof(ArrayList))
{
itemType = typeof(object);
}
else if (IsGenericList(type))
{
itemType = type.GenericTypeArguments[0];
}
else
{
throw Exceptions.UnExpectedTypeException(type);
}
HessianConverter itemConverter = null;
if (itemType == typeof(object))
{
writer.Write(Constants.BC_LIST_VARIABLE_UNTYPED);
itemConverter = AutoConverter;
}
else
{
writer.Write(Constants.BC_LIST_VARIABLE);
TypeConverter.WriteType(writer, context, type);
itemConverter = AutoConverter.GetConverter(itemType);
}
foreach (var item in (IEnumerable)value)
{
itemConverter.WriteValue(writer, context, item);
}
writer.Write(Constants.BC_END);
}
