private IJsonWrapper ReadValue(WrapperFactory factory,
JsonReader reader)
{
reader.Read();
if (reader.Token == JsonToken.ArrayEnd ||
reader.Token == JsonToken.Null)
{
return(null);
}
IJsonWrapper instance = factory();
if (reader.Token == JsonToken.String)
{
instance.SetString((string)reader.Value);
return(instance);
}
if (reader.Token == JsonToken.Double)
{
instance.SetDouble((double)reader.Value);
return(instance);
}
if (reader.Token == JsonToken.Int)
{
instance.SetInt((int)reader.Value);
return(instance);
}
if (reader.Token == JsonToken.Long)
{
instance.SetLong((long)reader.Value);
return(instance);
}
if (reader.Token == JsonToken.Boolean)
{
instance.SetBoolean((bool)reader.Value);
return(instance);
}
if (reader.Token == JsonToken.ArrayStart)
{
instance.SetJsonType(JsonType.Array);
while (true)
{
IJsonWrapper item = ReadValue(factory, reader);
if (reader.Token == JsonToken.ArrayEnd)
{
break;
}
((IList)instance).Add(item);
}
}
else if (reader.Token == JsonToken.ObjectStart)
{
instance.SetJsonType(JsonType.Object);
while (true)
{
reader.Read();
if (reader.Token == JsonToken.ObjectEnd)
{
break;
}
string property = (string)reader.Value;
((IDictionary)instance) [property] = ReadValue(
factory, reader);
}
}
return(instance);
}
private static void WriteJson(IJsonWrapper obj, JsonWriter writer)
{
if (obj.IsString) {
writer.Write (obj.GetString ());
return;
}
if (obj.IsBoolean) {
writer.Write (obj.GetBoolean ());
return;
}
if (obj.IsDouble) {
writer.Write (obj.GetDouble ());
return;
}
if (obj.IsInt) {
writer.Write (obj.GetInt ());
return;
}
if (obj.IsLong) {
writer.Write (obj.GetLong ());
return;
}
if (obj.IsArray) {
writer.WriteArrayStart ();
foreach (object elem in (IList) obj)
WriteJson ((JsonData) elem, writer);
writer.WriteArrayEnd ();
return;
}
if (obj.IsObject) {
writer.WriteObjectStart ();
foreach (DictionaryEntry entry in ((IDictionary) obj)) {
writer.WritePropertyName ((string) entry.Key);
WriteJson ((JsonData) entry.Value, writer);
}
writer.WriteObjectEnd ();
return;
}
}
private static object ReadValue(Type inst_type, JsonReader reader)
{
reader.Read();
if (reader.Token == JsonToken.ArrayEnd)
{
return(null);
}
Type underlying_type = Nullable.GetUnderlyingType(inst_type);
Type value_type = underlying_type ?? inst_type;
if (reader.Token == JsonToken.Null)
{
if (inst_type.IsClass || underlying_type != null)
{
return(null);
}
throw new JsonException(String.Format(
"Can't assign null to an instance of type {0}",
inst_type));
}
if (reader.Token == JsonToken.Double ||
reader.Token == JsonToken.Int ||
reader.Token == JsonToken.Long ||
reader.Token == JsonToken.String ||
reader.Token == JsonToken.Boolean)
{
Type json_type = reader.Value.GetType();
if (value_type.IsAssignableFrom(json_type))
{
return(reader.Value);
}
// If there's a custom importer that fits, use it
if (custom_importers_table.ContainsKey(json_type) &&
custom_importers_table[json_type].ContainsKey(
value_type))
{
ImporterFunc importer =
custom_importers_table[json_type][value_type];
return(importer(reader.Value));
}
// Maybe there's a base importer that works
if (base_importers_table.ContainsKey(json_type) &&
base_importers_table[json_type].ContainsKey(
value_type))
{
ImporterFunc importer =
base_importers_table[json_type][value_type];
return(importer(reader.Value));
}
// Maybe it's an enum
if (value_type.IsEnum)
{
return(Enum.ToObject(value_type, reader.Value));
}
// Try using an implicit conversion operator
MethodInfo conv_op = GetConvOp(value_type, json_type);
if (conv_op != null)
{
return(conv_op.Invoke(null,
new object[] { reader.Value }));
}
// No luck
throw new JsonException(String.Format(
"Can't assign value '{0}' (type {1}) to type {2}",
reader.Value, json_type, inst_type));
}
object instance = null;
if (reader.Token == JsonToken.ArrayStart)
{
AddArrayMetadata(inst_type);
ArrayMetadata t_data = array_metadata[inst_type];
if (!t_data.IsArray && !t_data.IsList)
{
throw new JsonException(String.Format(
"Type {0} can't act as an array",
inst_type));
}
IList list;
Type elem_type;
if (!t_data.IsArray)
{
list = (IList)Activator.CreateInstance(inst_type);
elem_type = t_data.ElementType;
}
else
{
list = new ArrayList();
elem_type = inst_type.GetElementType();
}
while (true)
{
object item = ReadValue(elem_type, reader);
if (item == null && reader.Token == JsonToken.ArrayEnd)
{
break;
}
list.Add(item);
}
if (t_data.IsArray)
{
int n = list.Count;
instance = Array.CreateInstance(elem_type, n);
for (int i = 0; i < n; i++)
{
((Array)instance).SetValue(list[i], i);
}
}
else
{
instance = list;
}
}
else if (reader.Token == JsonToken.ObjectStart)
{
if (custom_object_convert.ContainsKey(value_type))
{
WrapperFactory factory = delegate { return(new JsonData()); };
IJsonWrapper wrapper = factory();
wrapper.SetJsonType(JsonType.Object);
while (true)
{
reader.Read();
if (reader.Token == JsonToken.ObjectEnd)
{
break;
}
string property = (string)reader.Value;
((IDictionary)wrapper)[property] = ReadValue(
factory, reader);
}
ConvertFunc convert = custom_object_convert[value_type];
return(convert(wrapper));
}
else
{
AddObjectMetadata(value_type);
ObjectMetadata t_data = object_metadata[value_type];
instance = Activator.CreateInstance(value_type);
while (true)
{
reader.Read();
if (reader.Token == JsonToken.ObjectEnd)
{
break;
}
string property = (string)reader.Value;
if (t_data.Properties.ContainsKey(property))
{
PropertyMetadata prop_data =
t_data.Properties[property];
if (prop_data.IsField)
{
((FieldInfo)prop_data.Info).SetValue(
instance, ReadValue(prop_data.Type, reader));
}
else
{
PropertyInfo p_info =
(PropertyInfo)prop_data.Info;
if (p_info.CanWrite)
{
p_info.SetValue(
instance,
ReadValue(prop_data.Type, reader),
null);
}
else
{
ReadValue(prop_data.Type, reader);
}
}
}
else
{
if (!t_data.IsDictionary)
{
if (!reader.SkipNonMembers)
{
throw new JsonException(String.Format(
"The type {0} doesn't have the " +
"property '{1}'",
inst_type, property));
}
else
{
ReadSkip(reader);
continue;
}
}
((IDictionary)instance).Add(
property, ReadValue(
t_data.ElementType, reader));
}
}
}
}
return(instance);
}
private static void WriteJson(IJsonWrapper obj, JsonWriter writer)
{
if (obj == null)
{
writer.Write(null);
return;
}
if (obj.IsString)
{
writer.Write(obj.GetString());
return;
}
if (obj.IsBoolean)
{
writer.Write(obj.GetBoolean());
return;
}
if (obj.IsDouble)
{
writer.Write(obj.GetDouble());
return;
}
if (obj.IsInt)
{
writer.Write(obj.GetInt());
return;
}
if (obj.IsLong)
{
writer.Write(obj.GetLong());
return;
}
if (obj.IsArray)
{
writer.WriteArrayStart();
foreach (object elem in (IList)obj)
{
WriteJson((JsonData)elem, writer);
}
writer.WriteArrayEnd();
return;
}
if (obj.IsObject)
{
writer.WriteObjectStart();
foreach (DictionaryEntry entry in ((IDictionary)obj))
{
writer.WritePropertyName((string)entry.Key);
WriteJson((JsonData)entry.Value, writer);
}
writer.WriteObjectEnd();
return;
}
}
private static void WriteJson(IJsonWrapper wrapper, JsonWriter writer)
{
if (wrapper == null && !JsonWriter.SkipNullMember)
{
writer.Write(null);
return;
}
if (wrapper.IsString)
{
writer.Write(wrapper.GetString());
return;
}
if (wrapper.IsBoolean)
{
writer.Write(wrapper.GetBoolean());
return;
}
if (wrapper.IsDouble)
{
writer.Write(wrapper.GetDouble());
return;
}
if (wrapper.IsInt)
{
writer.Write(wrapper.GetInt());
return;
}
if (wrapper.IsLong)
{
writer.Write(wrapper.GetLong());
return;
}
if (wrapper.IsArray)
{
writer.WriteArrayStart();
foreach (object elem in (IList)wrapper)
{
WriteJson((JsonData)elem, writer);
}
writer.WriteArrayEnd();
return;
}
if (wrapper.IsObject)
{
if (JsonWriter.SkipNullMember && ((IDictionary)wrapper).Count <= 0)
{
return;
}
writer.WriteObjectStart();
foreach (DictionaryEntry entry in ((IDictionary)wrapper))
{
if (JsonWriter.SkipNullMember)
{
var type = ((JsonData)entry.Value).GetJsonType();
if (type == JsonType.None)
{
continue;
}
if (type == JsonType.Array && ((IList)entry.Value).Count <= 0)
{
continue;
}
}
writer.WritePropertyName((string)entry.Key);
WriteJson((JsonData)entry.Value, writer);
}
writer.WriteObjectEnd();
return;
}
if (wrapper.GetJsonType() == JsonType.None)
{
writer.WriteObjectStart();
writer.WriteObjectEnd();
return;
}
}
private static IJsonWrapper ReadValue(WrapperFactory factory, JsonReader reader)
{
reader.Read();
if (reader.Token == JsonToken.ArrayEnd || reader.Token == JsonToken.Null)
{
return(null);
}
IJsonWrapper jsonWrapper = factory();
if (reader.Token == JsonToken.String)
{
jsonWrapper.SetString((string)reader.Value);
return(jsonWrapper);
}
if (reader.Token == JsonToken.Double)
{
jsonWrapper.SetDouble((double)reader.Value);
return(jsonWrapper);
}
if (reader.Token == JsonToken.Int)
{
jsonWrapper.SetInt((int)reader.Value);
return(jsonWrapper);
}
if (reader.Token == JsonToken.Long)
{
jsonWrapper.SetLong((long)reader.Value);
return(jsonWrapper);
}
if (reader.Token == JsonToken.Boolean)
{
jsonWrapper.SetBoolean((bool)reader.Value);
return(jsonWrapper);
}
if (reader.Token == JsonToken.ArrayStart)
{
jsonWrapper.SetJsonType(JsonType.Array);
while (true)
{
IJsonWrapper jsonWrapper2 = ReadValue(factory, reader);
if (jsonWrapper2 == null && reader.Token == JsonToken.ArrayEnd)
{
break;
}
jsonWrapper.Add(jsonWrapper2);
}
}
else if (reader.Token == JsonToken.ObjectStart)
{
jsonWrapper.SetJsonType(JsonType.Object);
while (true)
{
reader.Read();
if (reader.Token == JsonToken.ObjectEnd)
{
break;
}
string key = (string)reader.Value;
jsonWrapper[key] = ReadValue(factory, reader);
}
}
return(jsonWrapper);
}
private static IJsonWrapper ReadValue(WrapperFactory factory,
JsonReader reader)
{
reader.Read();
if (reader.Token == JsonToken.ArrayEnd ||
reader.Token == JsonToken.Null)
{
return(null);
}
IJsonWrapper instance = factory();
if (reader.Token == JsonToken.String)
{
instance.SetString((string)reader.Value);
return(instance);
}
if (reader.Token == JsonToken.Double)
{
instance.SetDouble((double)reader.Value);
return(instance);
}
if (reader.Token == JsonToken.Int)
{
instance.SetInt((int)reader.Value);
return(instance);
}
if (reader.Token == JsonToken.Long)
{
instance.SetLong((long)reader.Value);
return(instance);
}
if (reader.Token == JsonToken.Boolean)
{
instance.SetBoolean((bool)reader.Value);
return(instance);
}
if (reader.Token == JsonToken.ArrayStart)
{
instance.SetJsonType(JsonType.Array);
while (true)
{
IJsonWrapper item = ReadValue(factory, reader);
// nij - added check to see if the item is not null. This is to handle arrays within arrays.
// In those cases when the outer array read the inner array an item was returned back the current
// reader.Token is at the ArrayEnd for the inner array.
if (item == null && reader.Token == JsonToken.ArrayEnd)
{
break;
}
((IList)instance).Add(item);
}
}
else if (reader.Token == JsonToken.ObjectStart)
{
instance.SetJsonType(JsonType.Object);
while (true)
{
reader.Read();
if (reader.Token == JsonToken.ObjectEnd)
{
break;
}
string property = (string)reader.Value;
((IDictionary)instance)[property] = ReadValue(
factory, reader);
}
}
return(instance);
}
private static void WriteJson(IJsonWrapper obj, JsonWriter writer)
{
if (obj.IsString)
{
writer.Write(obj.GetString());
return;
}
if (obj.IsBoolean)
{
writer.Write(obj.GetBoolean());
return;
}
if (obj.IsDouble)
{
writer.Write(obj.GetDouble());
return;
}
if (obj.IsInt)
{
writer.Write(obj.GetInt());
return;
}
if (obj.IsLong)
{
writer.Write(obj.GetLong());
return;
}
if (obj.IsArray)
{
writer.WriteArrayStart();
IEnumerator enumerator = obj.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
object obj2 = enumerator.Current;
JsonData.WriteJson((JsonData)obj2, writer);
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator as IDisposable)) != null)
{
disposable.Dispose();
}
}
writer.WriteArrayEnd();
return;
}
if (obj.IsObject)
{
writer.WriteObjectStart();
IDictionaryEnumerator enumerator2 = obj.GetEnumerator();
try
{
while (enumerator2.MoveNext())
{
object obj3 = enumerator2.Current;
DictionaryEntry dictionaryEntry = (DictionaryEntry)obj3;
writer.WritePropertyName((string)dictionaryEntry.Key);
JsonData.WriteJson((JsonData)dictionaryEntry.Value, writer);
}
}
finally
{
IDisposable disposable2;
if ((disposable2 = (enumerator2 as IDisposable)) != null)
{
disposable2.Dispose();
}
}
writer.WriteObjectEnd();
return;
}
}
public void WriteJsonWrapper(IJsonWrapper wrapper, bool privateWriter)
{
if (privateWriter) {
this.TextWriter.Write(wrapper.ToJson());
}
else {
// ((IJsonWrapper)obj).ToJson(writer);
wrapper.ToJson(this);
}
context.ExpectingValue = false;
}
