private object DeserializeValueArray(string name, Type t, object o, DeserializationFlags flags)
{
bool ignoreCase = flags.HasFlag(DeserializationFlags.IgnoreCase);
object prim = GetPrimitive(t, name, ignoreCase);
if (prim == null)
{
return(null);
}
PropertyInfo elemCountProp = prim.GetType().GetProperty(nameof(Primitive <byte> .ElementCount));
PropertyInfo valueProp = prim.GetType().GetProperty(nameof(Primitive <byte> .Value));
MethodInfo indexerMeth = prim.GetType().GetMethod("get_Item"); // 'this[int i]' property
int elemCount = (int)elemCountProp.GetValue(prim, null);
Array arr = Array.CreateInstance(t, elemCount);
for (int i = 0; i < elemCount; i++)
{
object elem = indexerMeth.Invoke(prim, new object[] { i });
object val = valueProp.GetValue(elem);
arr.SetValue(val, i);
}
return(arr);
}
private object DeserializePrimitive(string name, Type t, object o, DeserializationFlags flags)
{
bool ignoreCase = flags.HasFlag(DeserializationFlags.IgnoreCase);
object prim = GetPrimitive(t, name, ignoreCase);
return(prim);
}
private object DeserializeToFields(Type t, object o, DeserializationFlags flags, BindingFlags bindFlags)
{
// TODO: there /has/ to be some way to generalize this process
// for both fields and properties...
FieldInfo[] allFields;
Type fieldType;
bool isArray;
Type elemType;
bool isGeneric;
Type genType;
object val;
if (!flags.HasFlag(DeserializationFlags.Fields))
{
return(o);
}
allFields = t.GetFields(bindFlags);
foreach (FieldInfo f in allFields)
{
fieldType = f.FieldType;
isArray = fieldType.IsArray;
elemType = fieldType.GetElementType();
isGeneric = fieldType.IsGenericType;
if (isGeneric && fieldType.GetGenericTypeDefinition() == typeof(Primitive <>))
{
genType = fieldType.GetGenericArguments()[0];
val = DeserializePrimitive(f.Name, genType, o, flags);
}
else if (isArray)
{
if (PrimitiveTypeUtils.IsPrimitiveType(elemType))
{
val = DeserializeValueArray(f.Name, elemType, o, flags);
}
else
{
val = DeserializeStructureArray(f.Name, elemType, o, flags);
}
}
else if (PrimitiveTypeUtils.IsPrimitiveType(fieldType))
{
val = DeserializeValue(f.Name, fieldType, o, flags);
}
else
{
val = DeserializeStructure(f.Name, fieldType, o, flags);
}
if (val != null)
{
f.SetValue(o, val);
}
}
return(o);
}
private object DeserializeStructure(string name, Type t, object o, DeserializationFlags flags)
{
bool ignoreCase = flags.HasFlag(DeserializationFlags.IgnoreCase);
Structure s = GetStructure(name, ignoreCase);
if (s == null)
{
return(null);
}
return(s.Deserialize(t, flags));
}
private object Deserialize(Type t, DeserializationFlags flags)
{
object o;
BindingFlags bindFlags;
o = Activator.CreateInstance(t);
bindFlags = BindingFlags.Instance;
if (flags.HasFlag(DeserializationFlags.NonPublic))
{
bindFlags |= BindingFlags.NonPublic;
}
if (flags.HasFlag(DeserializationFlags.Public))
{
bindFlags |= BindingFlags.Public;
}
o = DeserializeToProperties(t, o, flags, bindFlags);
o = DeserializeToFields(t, o, flags, bindFlags);
return(o);
}
private object DeserializeValue(string name, Type t, object o, DeserializationFlags flags)
{
bool ignoreCase = flags.HasFlag(DeserializationFlags.IgnoreCase);
object prim = GetPrimitive(t, name, ignoreCase);
if (prim == null)
{
return(null);
}
PropertyInfo valueProp = prim.GetType().GetProperty(nameof(Primitive <byte> .Value));
return(valueProp.GetValue(prim, null));
}
private object DeserializeStructureArray(string name, Type t, object o, DeserializationFlags flags)
{
bool ignoreCase = flags.HasFlag(DeserializationFlags.IgnoreCase);
Structure s = GetStructure(name, ignoreCase);
if (s == null)
{
return(null);
}
Array arr = Array.CreateInstance(t, s.ElementCount);
for (int i = 0; i < s.ElementCount; i++)
{
object elem = s[i].Deserialize(t, flags);
arr.SetValue(elem, i);
}
return(arr);
}
private object DeserializeToProperties(Type t, object o, DeserializationFlags flags, BindingFlags bindFlags)
{
PropertyInfo[] allProperties;
Type propType;
bool isArray;
Type elemType;
bool isGeneric;
Type genType;
object val;
if (!flags.HasFlag(DeserializationFlags.Properties))
{
return(o);
}
allProperties = t.GetProperties(bindFlags);
foreach (PropertyInfo p in allProperties)
{
propType = p.PropertyType;
isArray = propType.IsArray;
elemType = propType.GetElementType();
isGeneric = propType.IsGenericType;
if (p.GetSetMethod() == null)
{
continue;
}
if (isGeneric && propType.GetGenericTypeDefinition() == typeof(Primitive <>))
{
genType = propType.GetGenericArguments()[0];
val = DeserializePrimitive(p.Name, genType, o, flags);
}
else if (isArray)
{
if (PrimitiveTypeUtils.IsPrimitiveType(elemType))
{
val = DeserializeValueArray(p.Name, elemType, o, flags);
}
else
{
val = DeserializeStructureArray(p.Name, elemType, o, flags);
}
}
else if (PrimitiveTypeUtils.IsPrimitiveType(propType))
{
val = DeserializeValue(p.Name, propType, o, flags);
}
else
{
val = DeserializeStructure(p.Name, propType, o, flags);
}
if (val != null)
{
p.SetValue(o, val);
}
}
return(o);
}