private static void WriteNode(
SerializeNode node,
object value,
ExceptionInfo exceptionInfo
)
{
var typeInfo = value.GetObjTypeInfo();
if (typeInfo.IsSerializePredefSingle())
{
throw new WritingFailureException(exceptionInfo, WritingFailureException.Reason_1);
}
if (value.IsSerializeObjectStruct())
{
foreach (var kvp in typeInfo.GetFieldsAndPropertiesWithAttributeDict <SerializeItemAttribute>())
{
var member = kvp.Key;
var att = kvp.Value[0];
if (att == null || att.SkipItem(member.GetValue(value)))
{
continue;
}
Write(node, att.SerializeName ?? member.Name, member.GetValue(value), member);
}
}
else if (value.IsSerializeObjectCustom())
{
_save.Do(value, node);
}
else if (value.IsSerializeObjectSingle())
{
var member = typeInfo.GetSerializeObjectSingleMember();
if (member == null)
{
throw new WritingFailureException(exceptionInfo, WritingFailureException.Reason_0);
}
WriteNode(node, member.GetValue(value), member);
}
else if (typeInfo.IsGenericType)
{
if (typeInfo.IsList() || typeInfo.IsDict())
{
var enumerator =
(IEnumerator)typeInfo.GetMethod("GetEnumerator").Invoke(value, null);
while (enumerator.MoveNext())
{
var item = enumerator.Current;
Write(node, "item", item, exceptionInfo);
}
}
else if (typeInfo.IsKeyValuePair())
{
var key = value.GetObjTypeInfo().GetMethod("get_Key").Invoke(value, null);
Write(node, "key", key, exceptionInfo);
var val = value.GetObjTypeInfo().GetMethod("get_Value").Invoke(value, null);
Write(node, "value", val, exceptionInfo);
}
}
}
private static void LoadDefault(this object obj)
{
if (!obj.GetObjTypeInfo().IsSerializeObjectLoadDefaultType())
{
return;
}
logger.InternalDebug("Loading default value for object of type {0}", obj.GetType().FullName);
_default.Do(obj);
}
private static object ReadNode(
SerializeNode node,
Type type,
ExceptionInfo exceptionInfo
)
{
var result = CreateObject(type);
var typeInfo = type.GetTypeInfo();
if (result.IsSerializeObjectStruct())
{
foreach (var kvp in typeInfo.GetFieldsAndPropertiesWithAttributeDict <SerializeItemAttribute>())
{
var member = kvp.Key;
var att = kvp.Value[0];
if (att == null || att.Ignore)
{
continue;
}
ReadFieldOrProperty(result, member, node, att.SerializeName ?? member.Name);
}
}
else if (result.IsSerializeObjectCustom())
{
_load.Do(result, node);
}
else if (result.IsSerializeObjectSingle())
{
var member = typeInfo.GetSerializeObjectSingleMember();
if (member == null)
{
throw new ParsingFailureException(exceptionInfo, ParsingFailureException.Reason_0);
}
var val = member.GetValue(result);
if (val == null)
{
val = CreateObject(member.GetValueType());
}
result = ReadNode(node, type, member);
member.SetValue(result, val);
}
else if (typeInfo.IsGenericType)
{
Type[] paramTypes;
if (typeInfo.IsList(out paramTypes))
{
result = CreateObject(type);
var itemType = paramTypes[0];
if (node.ContainsItem("item"))
{
foreach (var value in node.GetItems("item"))
{
var item = ReadItem(value, itemType, exceptionInfo);
object[] par = { item };
typeInfo.GetMethod("Add").Invoke(result, par);
}
}
else if (node.ContainsNode("item"))
{
foreach (var itemNode in node.GetNodes("item"))
{
var item = ReadNode(itemNode, paramTypes[0], exceptionInfo);
object[] par = { item };
typeInfo.GetMethod("Add").Invoke(result, par);
}
}
}
else if (typeInfo.IsDict(out paramTypes))
{
result = CreateObject(type);
var keyType = paramTypes[0];
var valueType = paramTypes[1];
foreach (var itemNode in node.GetNodes("item"))
{
var kvpType = typeof(KeyValuePair <,>).MakeGenericType(keyType, valueType).GetTypeInfo();
var key = Read(itemNode, "key", kvpType.GetProperty("Key"));
var val = Read(itemNode, "value", kvpType.GetProperty("Value"));
object[] par = { key, val };
typeInfo.GetMethod("Add").Invoke(result, par);
}
}
else
{
throw new TypeNotSupportedException(true, type);
}
}
else
{
throw new TypeNotSupportedException(true, result.GetType());
}
return(result);
}
