public Object Deserialize(Stream serializationStream,
HeaderHandler handler)
{
// Validate the parameters.
if(serializationStream == null)
{
throw new ArgumentNullException("serializationStream");
}
// Wrap the stream in a binary reader.
using(BinaryReader reader =
new BinaryReader(serializationStream))
{
DeserializationContext context = new DeserializationContext(this, reader);
return BinaryValueReader.Deserialize(context);
}
}
public override bool Read(DeserializationContext context, out Object outVal)
{
uint id = context.Reader.ReadUInt32();
uint count = context.Reader.ReadUInt32();
return Read(context, id, count, typeof(Object), out outVal);
}
public override bool Read(DeserializationContext context, out Object outVal)
{
uint id = context.Reader.ReadUInt32();
String str = context.Reader.ReadString();
context.Manager.RegisterObject(str, id);
outVal = str;
return true;
}
public override bool Read(DeserializationContext context, out Object outVal)
{
context.Manager.DoFixups();
outVal = null;
return false;
}
public abstract bool Read(DeserializationContext context, out Object outVal);
public static bool ReadValue(DeserializationContext context, out Object outVal)
{
BinaryElementType element = (BinaryElementType) context.Reader.ReadByte();
BinaryValueReader reader = GetReader(element);
return reader.Read(context, out outVal);
}
public static void ReadPrimitiveTypeArray(DeserializationContext context, BinaryPrimitiveTypeCode typeCode, Array array)
{
int count = array.GetLength(0);
switch(typeCode)
{
case BinaryPrimitiveTypeCode.Boolean:
bool[] boolArray = (bool[]) array;
for(int i = 0; i < count; i++) {
boolArray[i] = context.Reader.ReadBoolean();
}
break;
case BinaryPrimitiveTypeCode.Byte:
byte[] byteArray = (byte[]) array;
for(int i = 0; i < count; i++) {
byteArray[i] = context.Reader.ReadByte();
}
break;
case BinaryPrimitiveTypeCode.Char:
char[] charArray = (char[]) array;
for(int i = 0; i < count; i++) {
charArray[i] = context.Reader.ReadChar();
}
break;
case BinaryPrimitiveTypeCode.Decimal:
decimal[] decimalArray = (decimal[]) array;
for(int i = 0; i < count; i++) {
decimalArray[i] = Decimal.Parse(context.Reader.ReadString());
}
break;
case BinaryPrimitiveTypeCode.Double:
double[] doubleArray = (double[]) array;
for(int i = 0; i < count; i++) {
doubleArray[i] = context.Reader.ReadDouble();
}
break;
case BinaryPrimitiveTypeCode.Int16:
short[] shortArray = (short[]) array;
for(int i = 0; i < count; i++) {
shortArray[i] = context.Reader.ReadInt16();
}
break;
case BinaryPrimitiveTypeCode.Int32:
int[] intArray = (int[]) array;
for(int i = 0; i < count; i++) {
intArray[i] = context.Reader.ReadInt32();
}
break;
case BinaryPrimitiveTypeCode.Int64:
long[] longArray = (long[]) array;
for(int i = 0; i < count; i++) {
longArray[i] = context.Reader.ReadInt64();
}
break;
case BinaryPrimitiveTypeCode.SByte:
sbyte[] sbyteArray = (sbyte[]) array;
for(int i = 0; i < count; i++) {
sbyteArray[i] = context.Reader.ReadSByte();
}
break;
case BinaryPrimitiveTypeCode.Single:
float[] singleArray = (float[]) array;
for(int i = 0; i < count; i++) {
singleArray[i] = context.Reader.ReadChar();
}
break;
case BinaryPrimitiveTypeCode.TimeSpan:
TimeSpan[] tsArray = (TimeSpan[]) array;
for(int i = 0; i < count; i++) {
tsArray[i] = new TimeSpan(context.Reader.ReadInt64());
}
break;
case BinaryPrimitiveTypeCode.DateTime:
DateTime[] dtArray = (DateTime[]) array;
for(int i = 0; i < count; i++) {
dtArray[i] = new DateTime(context.Reader.ReadInt64());
}
break;
case BinaryPrimitiveTypeCode.UInt16:
ushort[] ushortArray = (ushort[]) array;
for(int i = 0; i < count; i++) {
ushortArray[i] = context.Reader.ReadUInt16();
}
break;
case BinaryPrimitiveTypeCode.UInt32:
uint[] uintArray = (uint[]) array;
for(int i = 0; i < count; i++) {
uintArray[i] = context.Reader.ReadUInt32();
}
break;
case BinaryPrimitiveTypeCode.UInt64:
ulong[] ulongArray = (ulong[]) array;
for(int i = 0; i < count; i++) {
ulongArray[i] = context.Reader.ReadUInt64();
}
break;
case BinaryPrimitiveTypeCode.String:
string[] stringArray = (string[]) array;
for(int i = 0; i < count; i++) {
stringArray[i] = context.Reader.ReadString();
}
break;
default:
throw new SerializationException("unknown primitive type code:"+typeCode);
}
}
public TypeInfo(DeserializationContext context, String name, String[] fieldNames,
BinaryTypeTag[] tt, TypeSpecification[] ts, Assembly assembly)
{
mConverter = context.Formatter.converter;
mFieldNames = fieldNames;
mTypeTag = tt;
mTypeSpec = ts;
// lookup our type in the right assembly
if(assembly == null)
{
mObjectType = Type.GetType(name, true);
}
else
{
mObjectType = assembly.GetType(name, true);
}
if(typeof(ISerializable).IsAssignableFrom(mObjectType))
{
mIsIserializable = true;
}
else
{
mIsIserializable = false;
// lookup all members once
mMembers = new MemberInfo[NumMembers];
for(int i = 0; i < NumMembers; i++)
{
// ms and mono have their values for boxed primitive types called 'm_value', we need a fix for that
if(mObjectType.IsPrimitive && (mFieldNames[i] == "m_value"))
{
mFieldNames[i] = "value_";
}
else if (mObjectType == typeof(DateTime) &&
(mFieldNames[i] == "ticks"))
{
// this is for DateTime
mFieldNames[i] = "value_";
}
else if (mObjectType == typeof(TimeSpan) &&
(mFieldNames[i] == "_ticks"))
{
// this is for TimeSpan
mFieldNames[i] = "value_";
}
else if (mObjectType == typeof(Decimal))
{
switch(mFieldNames[i])
{
case "hi":
{
mFieldNames[i] = "high";
}
break;
case "lo":
{
mFieldNames[i] = "low";
}
break;
case "mid":
{
mFieldNames[i] = "middle";
}
break;
}
}
Type memberType;
String memberName;
int classSeparator = mFieldNames[i].IndexOf('+');
if(classSeparator != -1)
{
/*
* TODO: check if there are constraints in which assembly
* the Type may be looked up! for now just look it up
* generally
*/
String baseName = mFieldNames[i].Substring(0, classSeparator);
memberName = mFieldNames[i].Substring(classSeparator+1, mFieldNames[i].Length-classSeparator-1);
memberType = mObjectType;
// MS does NOT store the FullQualifiedTypename if there
// is no collision but only the Typename :-(
while(!memberType.FullName.EndsWith(baseName))
{
// check if we reached System.Object
if(memberType == memberType.BaseType || memberType == null)
{
// TODO : I18n
throw new SerializationException("Can't find member "+mFieldNames[i]);
}
memberType = memberType.BaseType;
}
}
else
{
memberType = mObjectType;
memberName = mFieldNames[i];
}
// get member from object
MemberInfo[] members = memberType.GetMember(memberName,
MemberTypes.Field |
MemberTypes.Property,
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.NonPublic);
if((members == null) || (members.Length < 1))
{
// TODO: I18n
throw new SerializationException("Can't find member "+mFieldNames[i]);
}
else
{
mMembers[i] = members[0];
}
}
}
}
public override bool Read(DeserializationContext context, out Object outVal)
{
outVal = null;
return(true);
}
public abstract bool Read(DeserializationContext context, out Object outVal);
public static TypeSpecification ReadTypeSpec(DeserializationContext context, BinaryTypeTag typeTag)
{
switch (typeTag)
{
case BinaryTypeTag.PrimitiveType:
case BinaryTypeTag.ArrayOfPrimitiveType:
BinaryPrimitiveTypeCode typeCode = (BinaryPrimitiveTypeCode)context.Reader.ReadByte();
switch (typeCode)
{
case BinaryPrimitiveTypeCode.Boolean:
return(sBooleanSpec);
case BinaryPrimitiveTypeCode.Byte:
return(sByteSpec);
case BinaryPrimitiveTypeCode.Char:
return(sCharSpec);
case BinaryPrimitiveTypeCode.Decimal:
return(sDecimalSpec);
case BinaryPrimitiveTypeCode.Double:
return(sDoubleSpec);
case BinaryPrimitiveTypeCode.Int16:
return(sInt16Spec);
case BinaryPrimitiveTypeCode.Int32:
return(sInt32Spec);
case BinaryPrimitiveTypeCode.Int64:
return(sInt64Spec);
case BinaryPrimitiveTypeCode.SByte:
return(sSByteSpec);
case BinaryPrimitiveTypeCode.Single:
return(sSingleSpec);
case BinaryPrimitiveTypeCode.TimeSpan:
return(sTimeSpanSpec);
case BinaryPrimitiveTypeCode.DateTime:
return(sDateTimeSpec);
case BinaryPrimitiveTypeCode.UInt16:
return(sUInt16Spec);
case BinaryPrimitiveTypeCode.UInt32:
return(sUInt32Spec);
case BinaryPrimitiveTypeCode.UInt64:
return(sUInt64Spec);
case BinaryPrimitiveTypeCode.String:
return(sStringArraySpec);
default:
throw new SerializationException("unknown primitive type code:" + typeCode);
}
throw new SerializationException("unknown primitive type code:" + typeCode);
case BinaryTypeTag.RuntimeType:
return(new TypeSpecification(context.Reader.ReadString()));
case BinaryTypeTag.GenericType:
String typeName = context.Reader.ReadString();
uint assId = context.Reader.ReadUInt32();
return(new TypeSpecification(typeName, assId));
case BinaryTypeTag.String:
return(sStringSpecObject);
case BinaryTypeTag.ObjectType:
return(sObjectSpec);
case BinaryTypeTag.ArrayOfString:
return(sStringArraySpec);
case BinaryTypeTag.ArrayOfObject:
return(sObjectArraySpec);
default:
return(null);
}
}
internal static Array ReadPrimitiveTypeArray(DeserializationContext context, BinaryPrimitiveTypeCode typeCode, int count)
{
switch (typeCode)
{
case BinaryPrimitiveTypeCode.Boolean:
bool[] boolArray = new bool[count];
for (int i = 0; i < count; i++)
{
boolArray[i] = context.Reader.ReadBoolean();
}
return(boolArray);
case BinaryPrimitiveTypeCode.Byte:
byte[] byteArray = context.Reader.ReadBytes(count);
return(byteArray);
case BinaryPrimitiveTypeCode.Char:
char[] charArray = context.Reader.ReadChars(count);
return(charArray);
case BinaryPrimitiveTypeCode.Decimal:
decimal[] decimalArray = new decimal[count];
for (int i = 0; i < count; i++)
{
decimalArray[i] = Decimal.Parse(context.Reader.ReadString());
}
return(decimalArray);
case BinaryPrimitiveTypeCode.Double:
double[] doubleArray = new double[count];
for (int i = 0; i < count; i++)
{
doubleArray[i] = context.Reader.ReadDouble();
}
return(doubleArray);
case BinaryPrimitiveTypeCode.Int16:
short[] shortArray = new short[count];
for (int i = 0; i < count; i++)
{
shortArray[i] = context.Reader.ReadInt16();
}
return(shortArray);
case BinaryPrimitiveTypeCode.Int32:
int[] intArray = new int[count];
for (int i = 0; i < count; i++)
{
intArray[i] = context.Reader.ReadInt32();
}
return(intArray);
case BinaryPrimitiveTypeCode.Int64:
long[] longArray = new long[count];
for (int i = 0; i < count; i++)
{
longArray[i] = context.Reader.ReadInt64();
}
return(longArray);
case BinaryPrimitiveTypeCode.SByte:
sbyte[] sbyteArray = new sbyte[count];
for (int i = 0; i < count; i++)
{
sbyteArray[i] = context.Reader.ReadSByte();
}
return(sbyteArray);
case BinaryPrimitiveTypeCode.Single:
float[] singleArray = new float[count];
for (int i = 0; i < count; i++)
{
singleArray[i] = context.Reader.ReadChar();
}
return(singleArray);
case BinaryPrimitiveTypeCode.TimeSpan:
TimeSpan[] tsArray = new TimeSpan[count];
for (int i = 0; i < count; i++)
{
tsArray[i] = new TimeSpan(context.Reader.ReadInt64());
}
return(tsArray);
case BinaryPrimitiveTypeCode.DateTime:
DateTime[] dtArray = new DateTime[count];
for (int i = 0; i < count; i++)
{
dtArray[i] = new DateTime(context.Reader.ReadInt64());
}
return(dtArray);
case BinaryPrimitiveTypeCode.UInt16:
ushort[] ushortArray = new ushort[count];
for (int i = 0; i < count; i++)
{
ushortArray[i] = context.Reader.ReadUInt16();
}
return(ushortArray);
case BinaryPrimitiveTypeCode.UInt32:
uint[] uintArray = new uint[count];
for (int i = 0; i < count; i++)
{
uintArray[i] = context.Reader.ReadUInt32();
}
return(uintArray);
case BinaryPrimitiveTypeCode.UInt64:
ulong[] ulongArray = new ulong[count];
for (int i = 0; i < count; i++)
{
ulongArray[i] = context.Reader.ReadUInt64();
}
return(ulongArray);
case BinaryPrimitiveTypeCode.String:
string[] stringArray = new string[count];
for (int i = 0; i < count; i++)
{
stringArray[i] = context.Reader.ReadString();
}
return(stringArray);
default:
throw new SerializationException("unknown primitive type code:" + typeCode);
}
}
public TypeInfo(DeserializationContext context, String name, String[] fieldNames,
BinaryTypeTag[] tt, TypeSpecification[] ts, Assembly assembly)
{
mConverter = context.Formatter.converter;
mFieldNames = fieldNames;
mTypeTag = tt;
mTypeSpec = ts;
// lookup our type in the right assembly
if (assembly == null)
{
mObjectType = Type.GetType(name, true);
}
else
{
mObjectType = assembly.GetType(name, true);
}
if (typeof(ISerializable).IsAssignableFrom(mObjectType))
{
mIsIserializable = true;
}
else
{
mIsIserializable = false;
// lookup all members once
mMembers = new MemberInfo[NumMembers];
for (int i = 0; i < NumMembers; i++)
{
// ms and mono have their values for boxed primitive types called 'm_value', we need a fix for that
if (mObjectType.IsPrimitive && (mFieldNames[i] == "m_value"))
{
mFieldNames[i] = "value_";
}
else if (mObjectType == typeof(DateTime) &&
(mFieldNames[i] == "ticks"))
{
// this is for DateTime
mFieldNames[i] = "value_";
}
else if (mObjectType == typeof(TimeSpan) &&
(mFieldNames[i] == "_ticks"))
{
// this is for TimeSpan
mFieldNames[i] = "value_";
}
else if (mObjectType == typeof(Decimal))
{
switch (mFieldNames[i])
{
case "hi":
{
mFieldNames[i] = "high";
}
break;
case "lo":
{
mFieldNames[i] = "low";
}
break;
case "mid":
{
mFieldNames[i] = "middle";
}
break;
}
}
Type memberType;
String memberName;
int classSeparator = mFieldNames[i].IndexOf('+');
if (classSeparator != -1)
{
/*
* TODO: check if there are constraints in which assembly
* the Type may be looked up! for now just look it up
* generally
*/
String baseName = mFieldNames[i].Substring(0, classSeparator);
memberName = mFieldNames[i].Substring(classSeparator + 1, mFieldNames[i].Length - classSeparator - 1);
memberType = mObjectType;
// MS does NOT store the FullQualifiedTypename if there
// is no collision but only the Typename :-(
while (!memberType.FullName.EndsWith(baseName))
{
// check if we reached System.Object
if (memberType == memberType.BaseType || memberType == null)
{
// TODO : I18n
throw new SerializationException("Can't find member " + mFieldNames[i]);
}
memberType = memberType.BaseType;
}
}
else
{
memberType = mObjectType;
memberName = mFieldNames[i];
}
// get member from object
MemberInfo[] members = memberType.GetMember(memberName,
MemberTypes.Field |
MemberTypes.Property,
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.NonPublic);
if ((members == null) || (members.Length < 1))
{
// TODO: I18n
throw new SerializationException("Can't find member " + mFieldNames[i]);
}
else
{
mMembers[i] = members[0];
}
}
}
}
public override bool Read(DeserializationContext context, out Object outVal)
{
return(Read(context, out outVal, false));
}
public override bool Read(DeserializationContext context, out Object outVal)
{
uint id = context.Reader.ReadUInt32();
uint arrayType = context.Reader.ReadByte();
uint dimensions = context.Reader.ReadUInt32();
uint[] dimSizes = new uint[dimensions];
for(int i = 0; i < dimensions; i++)
{
dimSizes[i] = context.Reader.ReadUInt32();
}
// TODO: up to now we only support single dimension arrays
if(dimensions > 1 || ((BinaryArrayType) arrayType != BinaryArrayType.Single))
{
throw new SerializationException("array dimmensions > 1 || jagged arrays NYI!");
}
BinaryTypeTag typeTag = (BinaryTypeTag) context.Reader.ReadByte();
TypeSpecification typeSpec = ReadTypeSpec(context, typeTag);
if(typeTag == BinaryTypeTag.PrimitiveType)
{
return Read(context, id, dimSizes[0], typeSpec.GetPrimitiveType(), out outVal);
}
else
{
return Read(context, id, dimSizes[0], typeSpec.GetObjectType(context), out outVal);
}
}
public bool Read(DeserializationContext context, out Object outVal, uint id, TypeInfo typeInfo)
{
bool ret = true;
// create instance
Object obj = null;
SerializationInfo info = null;
if (typeInfo.IsISerializable)
{
info = typeInfo.GetSerializationInfo();
// create instance
obj = FormatterServices.GetUninitializedObject(typeInfo.ObjectType);
// read and set values
for (uint i = 0; i < typeInfo.NumMembers; i++)
{
// first get inlined data
Object memberValue;
if (typeInfo.GetTypeTag(i) == BinaryTypeTag.PrimitiveType)
{
memberValue = ReadPrimitiveType(context, typeInfo.GetTypeSpecification(i).GetPrimitiveType());
}
else
{
ret &= ReadValue(context, out memberValue);
}
// set value
String field = typeInfo.GetFieldName(i);
if (memberValue is DelayedReferenceHolder)
{
// this is a reference
DelayedReferenceHolder holder = (DelayedReferenceHolder)memberValue;
context.Manager.RecordDelayedFixup(id, field, holder.ReferenceId);
}
else
{
// this is a real value
info.AddValue(field, memberValue, typeInfo.GetTypeSpecification(i).GetObjectType(context));
}
}
context.Manager.RegisterObject(obj, id, info);
}
else
{
// create instance
obj = FormatterServices.GetUninitializedObject(typeInfo.ObjectType);
// read and set values
for (uint i = 0; i < typeInfo.NumMembers; i++)
{
// first get inlined data
Object memberValue;
if (typeInfo.GetTypeTag(i) == BinaryTypeTag.PrimitiveType)
{
memberValue = ReadPrimitiveType(context, typeInfo.GetTypeSpecification(i).GetPrimitiveType());
}
else
{
ret &= ReadValue(context, out memberValue);
}
// set value
MemberInfo field = typeInfo.GetMember(i);
if (memberValue is DelayedReferenceHolder)
{
// this is a reference
DelayedReferenceHolder holder = (DelayedReferenceHolder)memberValue;
context.Manager.RecordFixup(id, field, holder.ReferenceId);
}
else
{
// this is a real value
if (field is FieldInfo)
{
FieldInfo fi = (FieldInfo)field;
fi.SetValue(obj, memberValue);
}
// TODO: i'm not sure if I have to cover that case, too!
// I just noticed that Mono does this
// else if(field is PropertyInfo)
// {
// PropertyInfo pi = (PropertyInfo) field;
// pi.SetValue();
else
{
throw new SerializationException("unknown memeber type:" + field.GetType());
}
}
}
context.Manager.RegisterObject(obj, id);
}
outVal = obj;
return(ret);
}
public override bool Read(DeserializationContext context, out Object outVal)
{
context.Manager.DoFixups();
outVal = null;
return(false);
}
public static Object ReadPrimitiveType(DeserializationContext context, BinaryPrimitiveTypeCode typeCode)
{
switch(typeCode)
{
case BinaryPrimitiveTypeCode.Boolean:
return context.Reader.ReadBoolean();
case BinaryPrimitiveTypeCode.Byte:
return context.Reader.ReadByte();
case BinaryPrimitiveTypeCode.Char:
return context.Reader.ReadChar();
case BinaryPrimitiveTypeCode.Decimal:
return Decimal.Parse(context.Reader.ReadString());
case BinaryPrimitiveTypeCode.Double:
return context.Reader.ReadDouble();
case BinaryPrimitiveTypeCode.Int16:
return context.Reader.ReadInt16();
case BinaryPrimitiveTypeCode.Int32:
return context.Reader.ReadInt32();
case BinaryPrimitiveTypeCode.Int64:
return context.Reader.ReadInt64();
case BinaryPrimitiveTypeCode.SByte:
return context.Reader.ReadSByte();
case BinaryPrimitiveTypeCode.Single:
return context.Reader.ReadSingle();
case BinaryPrimitiveTypeCode.TimeSpan:
return new TimeSpan(context.Reader.ReadInt64());
case BinaryPrimitiveTypeCode.DateTime:
return new DateTime(context.Reader.ReadInt64());
case BinaryPrimitiveTypeCode.UInt16:
return context.Reader.ReadUInt16();
case BinaryPrimitiveTypeCode.UInt32:
return context.Reader.ReadUInt32();
case BinaryPrimitiveTypeCode.UInt64:
return context.Reader.ReadUInt64();
case BinaryPrimitiveTypeCode.String:
return context.Reader.ReadString();
default:
throw new SerializationException("unknown primitive type code:"+typeCode);
}
}
public bool Read(DeserializationContext context, out Object outVal, uint id, TypeInfo typeInfo)
{
bool ret = true;
// create instance
Object obj = null;
SerializationInfo info = null;
if(typeInfo.IsISerializable)
{
info = typeInfo.GetSerializationInfo();
// create instance
obj = FormatterServices.GetUninitializedObject(typeInfo.ObjectType);
// read and set values
for(uint i = 0; i < typeInfo.NumMembers; i++)
{
// first get inlined data
Object memberValue;
if(typeInfo.GetTypeTag(i) == BinaryTypeTag.PrimitiveType)
{
memberValue = ReadPrimitiveType(context, typeInfo.GetTypeSpecification(i).GetPrimitiveType());
}
else
{
ret &= ReadValue(context, out memberValue);
}
// set value
String field = typeInfo.GetFieldName(i);
if(memberValue is DelayedReferenceHolder)
{
// this is a reference
DelayedReferenceHolder holder = (DelayedReferenceHolder) memberValue;
context.Manager.RecordDelayedFixup(id, field, holder.ReferenceId);
}
else
{
// this is a real value
info.AddValue(field, memberValue, typeInfo.GetTypeSpecification(i).GetObjectType(context));
}
}
context.Manager.RegisterObject(obj, id, info);
}
else
{
// create instance
obj = FormatterServices.GetUninitializedObject(typeInfo.ObjectType);
// read and set values
for(uint i = 0; i < typeInfo.NumMembers; i++)
{
// first get inlined data
Object memberValue;
if(typeInfo.GetTypeTag(i) == BinaryTypeTag.PrimitiveType)
{
memberValue = ReadPrimitiveType(context, typeInfo.GetTypeSpecification(i).GetPrimitiveType());
}
else
{
ret &= ReadValue(context, out memberValue);
}
// set value
MemberInfo field = typeInfo.GetMember(i);
if(memberValue is DelayedReferenceHolder)
{
// this is a reference
DelayedReferenceHolder holder = (DelayedReferenceHolder) memberValue;
context.Manager.RecordFixup(id, field, holder.ReferenceId);
}
else
{
// this is a real value
if(field is FieldInfo)
{
FieldInfo fi = (FieldInfo) field;
fi.SetValue(obj, memberValue);
}
// TODO: i'm not sure if I have to cover that case, too!
// I just noticed that Mono does this
// else if(field is PropertyInfo)
// {
// PropertyInfo pi = (PropertyInfo) field;
// pi.SetValue();
else
{
throw new SerializationException("unknown memeber type:"+field.GetType());
}
}
}
context.Manager.RegisterObject(obj, id);
}
outVal = obj;
return ret;
}
public static Object Deserialize(DeserializationContext context)
{
bool keepGoing = true;
Object tree = null;
// TODO: find better solution for finding the root of the object tree
do
{
Object other;
keepGoing = ReadValue(context, out other);
if(tree == null && other != null)
{
tree = other;
}
} while(keepGoing);
return tree;
}
public bool Read(DeserializationContext context, out Object outVal, bool external)
{
uint id = context.Reader.ReadUInt32();
String name = context.Reader.ReadString();
uint fieldCount = context.Reader.ReadUInt32();
// collect the names of the fields
String[] fieldNames = new String[fieldCount];
for(int i = 0; i < fieldCount; i++)
{
fieldNames[i] = context.Reader.ReadString();
}
// collect the type-tags of the fields
BinaryTypeTag[] typeTags = new BinaryTypeTag[fieldCount];
for(int i = 0; i < fieldCount; i++)
{
typeTags[i] = (BinaryTypeTag) context.Reader.ReadByte();
}
// collect the type-specifications of the fields if necessary
TypeSpecification[] typeSpecs = new TypeSpecification[fieldCount];
for(int i = 0; i < fieldCount; i++)
{
typeSpecs[i] = ReadTypeSpec(context, typeTags[i]);
}
// read assembly-id if this is no runtime object
Assembly assembly = null;
if(external)
{
assembly = context.GetAssembly(context.Reader.ReadUInt32());
}
// store type-information for later usage
TypeInfo typeInfo = new TypeInfo(context, name, fieldNames, typeTags, typeSpecs, assembly);
context.SetTypeInfo(id, typeInfo);
// let our parent read the inlined values
return Read(context, out outVal, id, typeInfo);
}
public static TypeSpecification ReadTypeSpec(DeserializationContext context, BinaryTypeTag typeTag)
{
switch(typeTag)
{
case BinaryTypeTag.PrimitiveType:
case BinaryTypeTag.ArrayOfPrimitiveType:
BinaryPrimitiveTypeCode typeCode = (BinaryPrimitiveTypeCode) context.Reader.ReadByte();
switch(typeCode)
{
case BinaryPrimitiveTypeCode.Boolean:
return sBooleanSpec;
case BinaryPrimitiveTypeCode.Byte:
return sByteSpec;
case BinaryPrimitiveTypeCode.Char:
return sCharSpec;
case BinaryPrimitiveTypeCode.Decimal:
return sDecimalSpec;
case BinaryPrimitiveTypeCode.Double:
return sDoubleSpec;
case BinaryPrimitiveTypeCode.Int16:
return sInt16Spec;
case BinaryPrimitiveTypeCode.Int32:
return sInt32Spec;
case BinaryPrimitiveTypeCode.Int64:
return sInt64Spec;
case BinaryPrimitiveTypeCode.SByte:
return sSByteSpec;
case BinaryPrimitiveTypeCode.Single:
return sSingleSpec;
case BinaryPrimitiveTypeCode.TimeSpan:
return sTimeSpanSpec;
case BinaryPrimitiveTypeCode.DateTime:
return sDateTimeSpec;
case BinaryPrimitiveTypeCode.UInt16:
return sUInt16Spec;
case BinaryPrimitiveTypeCode.UInt32:
return sUInt32Spec;
case BinaryPrimitiveTypeCode.UInt64:
return sUInt64Spec;
case BinaryPrimitiveTypeCode.String:
return sStringArraySpec;
default:
throw new SerializationException("unknown primitive type code:"+typeCode);
}
throw new SerializationException("unknown primitive type code:"+typeCode);
case BinaryTypeTag.RuntimeType:
return new TypeSpecification(context.Reader.ReadString());
case BinaryTypeTag.GenericType:
String typeName = context.Reader.ReadString();
uint assId = context.Reader.ReadUInt32();
return new TypeSpecification(typeName, assId);
case BinaryTypeTag.String:
return sStringSpecObject;
case BinaryTypeTag.ObjectType:
return sObjectSpec;
case BinaryTypeTag.ArrayOfString:
return sStringArraySpec;
case BinaryTypeTag.ArrayOfObject:
return sObjectArraySpec;
default:
return null;
}
}
public override bool Read(DeserializationContext context, out Object outVal)
{
return Read(context, out outVal, false);
}
public override bool Read(DeserializationContext context, out Object outVal)
{
outVal = null;
return true;
}
public override bool Read(DeserializationContext context, out Object outVal)
{
uint id = context.Reader.ReadUInt32();
uint refId = context.Reader.ReadUInt32();
// get type-information from context
TypeInfo typeInfo = context.GetTypeInfo(refId);
return Read(context, out outVal, id, typeInfo);
}
public override bool Read(DeserializationContext context, out Object outVal)
{
uint id = context.Reader.ReadUInt32();
// check if there is a serialization header
int hasHeader = context.Reader.ReadInt32();
if(hasHeader == 2)
{
context.IsHeaderPresent = true;
}
else if(hasHeader == -1)
{
context.IsHeaderPresent = false;
}
else
{
throw new SerializationException("unknown header specification:"+hasHeader);
}
// read major/minor version
context.MajorVersion = context.Reader.ReadUInt32();
context.MinorVersion = context.Reader.ReadUInt32();
outVal = null;
return true;
}
public override bool Read(DeserializationContext context, out Object outVal)
{
uint refId = context.Reader.ReadUInt32();
// this 'special' object indicates that we haven't read a real object, but will read it later on
outVal = new DelayedReferenceHolder(refId);
return true;
}
public bool Read(DeserializationContext context, uint id, uint count, Object type, out Object outVal)
{
bool ret = true;
Type convertedType;
Array array;
if(type is BinaryPrimitiveTypeCode)
{
// this is a primitive array
convertedType = GetPrimitiveType((BinaryPrimitiveTypeCode) type);
array = Array.CreateInstance(convertedType, (int) count);
ReadPrimitiveTypeArray(context, (BinaryPrimitiveTypeCode) type, array);
}
else if(type is Type)
{
// this is an object array
convertedType = (Type) type;
array = Array.CreateInstance(convertedType, (int) count);
for(int i = 0; i < count; i++)
{
Object val;
ret &= ReadValue(context, out val);
if(val is DelayedReferenceHolder)
{
// record this index for fixup
DelayedReferenceHolder holder = (DelayedReferenceHolder) val;
context.Manager.RecordArrayElementFixup(id, i, holder.ReferenceId);
}
else if(val is ArrayNullValueHolder)
{
ArrayNullValueHolder holder = (ArrayNullValueHolder) val;
for(int j = 0; j < holder.NumNullValues; j++)
{
array.SetValue(null, i);
i++;
}
}
else
{
// set this value
array.SetValue(val, i);
}
}
}
else
{
throw new SerializationException("illegal call with:"+type);
}
context.Manager.RegisterObject(array, id);
outVal = array;
return ret;
}
public override bool Read(DeserializationContext context, out Object outVal)
{
uint numNulls = context.Reader.ReadUInt32();
// this 'special' object indicates that we haven't read a real object,
// but should insert a number of NULL values.
outVal = new ArrayNullValueHolder(numNulls);
return true;
}
public override bool Read(DeserializationContext context, out Object outVal)
{
uint id = context.Reader.ReadUInt32();
uint count = context.Reader.ReadUInt32();
BinaryPrimitiveTypeCode typeCode = (BinaryPrimitiveTypeCode) context.Reader.ReadByte();
return Read(context, id, count, typeCode, out outVal);
}
public override bool Read(DeserializationContext context, out Object outVal)
{
TypeSpecification typeSpec = ReadTypeSpec(context, BinaryTypeTag.PrimitiveType);
outVal = ReadPrimitiveType(context, typeSpec.GetPrimitiveType());
return true;
}
public override bool Read(DeserializationContext context, out Object outVal)
{
uint id = context.Reader.ReadUInt32();
String name = context.Reader.ReadString();
// load specified assembly
Assembly assembly = Assembly.Load(name);
context.SetAssembly(id, assembly);
/*
* registering an assembly leads to instanciating at fixup which will not work
* context.mObjManager.RegisterObject(assembly, id);
*
* returning the assembly would break the (much to simple!) alg. in Deserialize()
* which chooses the first object
* outVal = assembly;
*/
outVal = null;
return true;
}
public Type GetObjectType(DeserializationContext context)
{
if(mTag == BinaryTypeTag.PrimitiveType)
{
return BinaryValueReader.GetPrimitiveType(mPrimitiveType);
}
else if(mTag == BinaryTypeTag.RuntimeType)
{
return Type.GetType(mClassName, true);
}
else
{
Assembly assembly = context.GetAssembly(mAssembly);
return assembly.GetType(mClassName, true);
}
}
