private static object Read(
SerializeNode node,
string name,
MemberInfo member
)
{
SerializeItemInfo itemInfo = member;
ExceptionInfo exceptionInfo = member;
var type = itemInfo.Type;
var typeInfo = type.GetTypeInfo();
logger.InternalDebug("Item \"{0}\" has type \"{1}\"", name, typeInfo.FullName);
var result = CreateObject(type);
if (node.ContainsItem(name) &&
(typeInfo.IsSerializePredefSingle() || typeInfo.IsSerializeObjectSingleType()))
{
logger.InternalDebug("Parsing item \"{0}\"", name);
result = ReadItem(node.GetItem(name), type, exceptionInfo);
}
else if (node.ContainsNode(name) && (typeInfo.IsSerializeCustom() || typeInfo.IsSerializeObjectSingleType()))
{
logger.InternalDebug("Creating node \"{0}\"", name);
result = ReadNode(node.GetNode(name), type, exceptionInfo);
}
else // no matching item or node found
{
var att = itemInfo.Attr;
if (att.SkipNull)
{
result = null;
logger.InternalDebug("Item \"{0}\" not found in node. Assign null.", name);
}
else if (att.SkipEmptyString && typeInfo.IsSubclassOf(typeof(string)))
{
result = "";
logger.InternalDebug("Item \"{0}\" not found in node. Assign empty string.", name);
}
else if (!att.UseDefault)
{
throw new ParsingFailureException(exceptionInfo, ParsingFailureException.Reason_1);
}
else
{
logger.InternalDebug("Item \"{0}\" not found in node. Do nothing.", name);
}
}
return(result);
}
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);
}
