public override object JsonToObject(EasyJsonData data, Type t)
{
if (data.IsNullValue)
{
return(null);
}
if (data.Type != EasyJsonDataType.JsonObject)
{
throw new EasyJsonException("Invalid JSON data type " + data.Type.ToString() + ", JSON OBJECT expected");
}
IDictionary inst = Activator.CreateInstance(t) as IDictionary;
JsonItemMetadata metadata = _getItemMetadata(t);
JsonToObjectFunc keyFunc = _stringDataToKey;
if (metadata.IndexType != typeof(string))
{
keyFunc = _jsonDataToKey;
}
foreach (string name in data.Names)
{
object key = keyFunc(name, metadata.IndexType);
object value = base.JsonToObject(data[name], metadata.ElementType);
inst.Add(key, value);
}
return(inst);
}
static EasyJsonData __load(string json, ref int start)
{
JsonUtil.SkipIgnoredChar(json, ref start, false);
if (start == json.Length)
{
return(null);
}
EasyJsonDataType type = EasyJsonDataType.Unknown;
switch (json[start])
{
case JsonUtil.OBJECT_START:
type = EasyJsonDataType.JsonObject;
break;
case JsonUtil.ARRAY_START:
type = EasyJsonDataType.JsonArray;
break;
case JsonUtil.STRING_QUOTE:
type = EasyJsonDataType.JsonString;
break;
}
EasyJsonData jsonData = new EasyJsonData(type);
jsonData._load(json, ref start);
return(jsonData);
}
public virtual object JsonToObject(EasyJsonData data, Type t)
{
if (data == null)
{
return(null);
}
return(_readObject(data, t));
}
public override object JsonToObject(EasyJsonData data, Type t)
{
if (data.IsNullValue)
{
return(null);
}
return(data.Data);
}
public override object JsonToObject(EasyJsonData data, Type t)
{
try
{
return(Enum.Parse(t, data.Data));
}
catch (Exception e)
{
throw new EasyJsonException("Fail to parse " + data.Data + " to " + t.ToString(), e);
}
}
void _loadObject(string json, ref int start)
{
do
{
++start;
string name = JsonUtil.GetString(json, ref start);
if (name == null)
{
if (json[start] != JsonUtil.OBJECT_END)
{
throw new EasyJsonException("Bad JSON format");
}
break;
}
else
{
JsonUtil.SkipIgnoredChar(json, ref start, false);
if (start == json.Length)
{
throw new EasyJsonException("Bad JSON format");
}
if (json[start] != JsonUtil.KV_SEPARATOR)
{
throw new EasyJsonException("Bad JSON format");
}
++start;
EasyJsonData data = EasyJsonData.__load(json, ref start);
_object.Add(name, data);
JsonUtil.SkipIgnoredChar(json, ref start, false);
if (start < json.Length)
{
if (json[start] == JsonUtil.DATA_SEPARATOR)
{
continue;
}
if (json[start] == JsonUtil.OBJECT_END)
{
break;
}
}
throw new EasyJsonException("Bad JSON format");
}
}while (true);
++start;
}
public EasyJsonData this[string name]
{
get
{
if (_object == null)
{
throw new EasyJsonException("Can't get JSON data using STRING name");
}
EasyJsonData data = null;
_object.TryGetValue(name, out data);
return(data);
}
}
void _readArray(Array inst, EasyJsonData data, int[] startIdx, int dim, Type t)
{
for (int i = 0; i < inst.GetLength(dim); ++i)
{
startIdx[dim] = i;
if (dim == inst.Rank - 1)
{
inst.SetValue(base.JsonToObject(data[i], t), startIdx);
}
else
{
_readArray(inst, data[i], startIdx, dim + 1, t);
}
}
startIdx[dim] = 0;
}
public override object JsonToObject(EasyJsonData data, Type t)
{
string value = data.Data.ToLower();
if (value == "true")
{
return(true);
}
else if (value == "false")
{
return(false);
}
else
{
throw new EasyJsonException("Can't parse " + data.Data + " to bool value");
}
}
public override object JsonToObject(EasyJsonData data, Type t)
{
if (data.IsNullValue)
{
return(null);
}
Type ut = Nullable.GetUnderlyingType(t);
EasyJsonController controller = GetController(ut);
if (controller == null)
{
throw new EasyJsonException("Doesn't support JSON parser for Nullable " + ut.ToString());
}
return(controller.JsonToObject(data, ut));
}
public static EasyJsonData Load(string json)
{
if (json == null)
{
return(null);
}
int start = 0;
EasyJsonData jsonData = __load(json, ref start);
JsonUtil.SkipIgnoredChar(json, ref start, false);
if (start < json.Length)
{
throw new EasyJsonException("Bad JSON format");
}
return(jsonData);
}
public override object JsonToObject(EasyJsonData data, Type t)
{
if (data.IsNullValue)
{
return(null);
}
Type inst = null;
foreach (Assembly ass in AppDomain.CurrentDomain.GetAssemblies())
{
if ((inst = ass.GetType(data.Data)) != null)
{
return(inst);
}
}
throw new EasyJsonException("Can't find type definition " + data.Data);
}
void _loadArray(string json, ref int start)
{
bool allIsNull = true;
do
{
++start;
EasyJsonData data = EasyJsonData.__load(json, ref start);
_array.Add(data);
if (!data.IsNullValue)
{
allIsNull = false;
}
JsonUtil.SkipIgnoredChar(json, ref start, false);
if (start < json.Length)
{
if (json[start] == JsonUtil.DATA_SEPARATOR)
{
continue;
}
if (json[start] == JsonUtil.ARRAY_END)
{
break;
}
}
throw new EasyJsonException("Bad JSON format");
}while (true);
if (allIsNull)
{
_array.Clear();
}
++start;
}
public override object JsonToObject(EasyJsonData data, Type t)
{
if (data.IsNullValue)
{
return(null);
}
if (data.Type != EasyJsonDataType.JsonArray)
{
throw new EasyJsonException("Invalid JSON data type " + data.Type.ToString() + ", JSON ARRAY expected");
}
JsonItemMetadata metadata = _getItemMetadata(t);
IList inst = Activator.CreateInstance(t) as IList;
for (int i = 0; i < data.Count; ++i)
{
object element = base.JsonToObject(data[i], metadata.ElementType);
inst.Add(element);
}
return(inst);
}
public override object JsonToObject(EasyJsonData data, Type t)
{
if (data.IsNullValue)
{
return(null);
}
int rank = t.GetArrayRank();
int[] lengths = new int[rank];
EasyJsonData tmpData = data;
for (int i = 0; i < rank; ++i)
{
if (tmpData.Type != EasyJsonDataType.JsonArray)
{
throw new EasyJsonException("Invalid JSON data type " + tmpData.Type.ToString() + ", JSON ARRAY expected");
}
if (0 == (lengths[i] = tmpData.Count))
{
break;
}
tmpData = tmpData[0];
}
Type et = t.GetElementType();
Array inst = Array.CreateInstance(et, lengths);
int[] idx = new int[rank];
_readArray(inst, data, idx, 0, et);
return(inst);
}
object _readObject(EasyJsonData data, Type t)
{
if (data.IsNullValue)
{
return(null);
}
try
{
// If user register a specific type controller but still invoke base JsonToObject, there
// will make a loop: base -> GetController(t) -> child -> base
if (_checkedData != data)
{
_checkedData = data;
if (data.Type == EasyJsonDataType.JsonObject)
{
EasyJsonData typeData = data[DYNAMIC_TYPE_NAME];
if (typeData != null)
{
JsonSystemTypeController typeController = GetController(typeof(Type)) as JsonSystemTypeController;
if (typeController == null)
{
throw new EasyJsonException("Can't find System.Type controller to process dynamic type");
}
t = typeController.JsonToObject(typeData, typeof(Type)) as Type;
}
}
EasyJsonController controller = GetController(t);
if (controller != null)
{
return(controller.JsonToObject(data, t));
}
}
if (data.Type != EasyJsonDataType.JsonObject)
{
throw new EasyJsonException("Can't load JSON data for " + t.ToString());
}
object inst = Activator.CreateInstance(t);
JsonClassMetadata metadata = _getMetadata(t);
foreach (KeyValuePair <string, FieldInfo> kv in metadata.Fields)
{
EasyJsonData fieldData = data[kv.Key];
if (fieldData != null)
{
FieldInfo field = kv.Value;
field.SetValue(inst, _readObject(fieldData, field.FieldType));
}
}
foreach (KeyValuePair <string, PropertyInfo> kv in metadata.Properties)
{
EasyJsonData propertyData = data[kv.Key];
if (propertyData != null)
{
PropertyInfo property = kv.Value;
property.SetValue(inst, _readObject(propertyData, property.PropertyType), null);
}
}
return(inst);
}
finally
{
_checkedData = null;
}
}
internal object JsonToObject(string json, Type t)
{
EasyJsonData data = EasyJsonData.Load(json);
return(JsonToObject(data, t));
}
public override object JsonToObject(EasyJsonData data, Type t)
{
return(UInt16.Parse(data.Data));
}
public static T ToObject <T>(EasyJsonData jsonData)
{
EasyJsonController controller = GetMainController();
return((T)(controller.JsonToObject(jsonData, typeof(T))));
}
object _jsonDataToKey(string json, Type t)
{
EasyJsonData data = EasyJsonData.Load(json);
return(base.JsonToObject(data, t));
}
public override object JsonToObject(EasyJsonData data, Type t)
{
return(DateTime.Parse(data.Data).ToUniversalTime());
}
public static object ToObject(EasyJsonData jsonData, Type t)
{
EasyJsonController controller = GetMainController();
return(controller.JsonToObject(jsonData, t));
}
public override object JsonToObject(EasyJsonData data, Type t)
{
return(data);
}