private static object GetObject(DataNode root, Type baseType, Dictionary <Guid, Type> derivedTypes, object parent)
{
object ret = null;
if (typeof(DataNode).IsAssignableFrom(baseType))
{
ret = root.CloneNode();
}
else if (baseType == typeof(byte[]))
{
ret = root.ToArray();
}
else if (baseType == typeof(char[]))
{
ret = root.ToDataString().ToCharArray();
}
else if (baseType == typeof(string))
{
ret = root.ToDataString();
}
else if (typeof(IPrimitiveValue).IsAssignableFrom(baseType))
{
IPrimitiveValue prim = (IPrimitiveValue)Activator.CreateInstance(baseType);
DataValue value = root as DataValue;
if (value == null)
{
throw new ArgumentException(Properties.Resources.ObjectConverter_GetObjectPrimitive);
}
prim.Value = value.Value;
ret = prim;
}
else if (baseType == typeof(DateTime))
{
DateTimeDataValue value = root as DateTimeDataValue;
if (value == null)
{
throw new ArgumentException(Properties.Resources.ObjectConverter_GetObjectDateTime);
}
ret = value.Value;
}
else if (baseType == typeof(BigInteger))
{
BigIntegerDataValue value = root as BigIntegerDataValue;
if (value != null)
{
ret = value.Value;
}
else
{
ret = new BigInteger(root.ToArray());
}
}
else if (baseType.IsPrimitive)
{
DataValue value = root as DataValue;
if (value == null)
{
throw new ArgumentException(Properties.Resources.ObjectConverter_GetObjectPrimitive);
}
ret = Convert.ChangeType(value.Value, baseType);
}
else if (baseType.IsArray)
{
DataKey key = root as DataKey;
if (key == null)
{
throw new ArgumentException(Properties.Resources.ObjectConverter_GetObjectArray);
}
ret = GetArray(key, baseType.GetElementType(), derivedTypes, parent);
}
else if (baseType.IsEnum)
{
DataValue value = root as DataValue;
if (value != null)
{
Type valueType = value.Value.GetType();
if (valueType == typeof(string))
{
ret = Enum.Parse(baseType, value.Value.ToString());
}
else if (valueType == typeof(PortableEnum))
{
ret = Enum.ToObject(baseType, Convert.ChangeType(value.Value.Value, baseType.GetEnumUnderlyingType()));
}
else if (valueType.IsPrimitive)
{
ret = Enum.ToObject(baseType, Convert.ChangeType(value.Value, baseType.GetEnumUnderlyingType()));
}
else
{
throw new ArgumentException(Properties.Resources.ObjectConverter_GetObjectEnum);
}
}
}
else if (baseType == typeof(IPAddress))
{
ret = new IPAddress(root.ToArray());
}
else
{
try
{
Type createType = GetTypeFromNode(baseType, root, derivedTypes);
if (createType.IsAbstract)
{
throw new ArgumentException(String.Format(Properties.Resources.ObjectConverter_GetObjectAbstract, createType));
}
ret = Activator.CreateInstance(createType);
}
catch (MissingMethodException ex)
{
throw new ArgumentException(String.Format(Properties.Resources.ObjectConverter_GetObjectCouldntCreate, baseType), ex);
}
INodeInitializer converter = ret as INodeInitializer;
if (converter != null)
{
converter.FromNode(root);
}
else
{
DataKey key = root as DataKey;
if (key == null)
{
throw new ArgumentException(Properties.Resources.ObjectConverter_GetObjectComplex);
}
PopulateObject(key, ret, derivedTypes);
}
}
SetParent(ret, parent);
return(ret);
}
private static DataNode GetNode(string name, object o, Dictionary <Type, Guid> derivedTypes, bool readOnly)
{
DataNode ret = null;
if (o != null)
{
Type t = o.GetType();
if (o is DataNode)
{
ret = ((DataNode)o).CloneNode();
}
else if (t.IsEnum)
{
ret = new EnumDataValue(name, (Enum)o);
}
else if (t.IsPrimitive)
{
ret = GetPrimitiveType(name, t, o);
}
else if (o is IPrimitiveValue)
{
object v = ((IPrimitiveValue)o).Value;
ret = GetPrimitiveType(name, v.GetType(), v);
}
else if (t == typeof(DateTime))
{
// Use a unix datetime, doesn't _really_ matter
ret = new UnixDateTimeDataValue(name, false, (DateTime)o);
}
else if (t == typeof(string))
{
ret = new StringDataValue(name, (string)o);
}
else if (t == typeof(BigInteger))
{
ret = new BigIntegerDataValue(name, (BigInteger)o);
}
else if (t.IsArray)
{
if (t.GetElementType() == typeof(byte))
{
byte[] newArr = (byte[])((byte[])o).Clone();
ret = new ByteArrayDataValue(name, (byte[])o);
}
else if (t.GetElementType() == typeof(char))
{
ret = new StringDataValue(name, new string((char[])o));
}
else
{
DataKey key = new DataKey(name);
GetArrayType(key, t, o, derivedTypes, readOnly);
ret = key;
}
}
else if (t == typeof(IPAddress))
{
ret = new IPAddressDataValue(name, (IPAddress)o);
}
else
{
INodeConverter converter = o as INodeConverter;
if (converter != null)
{
ret = converter.ToNode(name);
}
else
{
DataKey key = new DataKey(name);
GetComplexType(key, t, o, derivedTypes);
ret = key;
}
}
if (ret != null)
{
ret.Readonly = readOnly;
}
}
return(ret);
}
