From 002fe17a16f0a9fa5bb71654dd95c72c35f253b8 Mon Sep 17 00:00:00 2001
From: hch <305670599@qq.com>
Date: 星期一, 07 十二月 2020 23:10:46 +0800
Subject: [PATCH] 0312 更新ExecuteAlways 升级litjson
---
Assets/Plugins/LitJson/Lexer.cs | 8
Assets/PostProcessing/Runtime/PostProcessingBehaviour.cs | 2
Assets/Plugins/LitJson/JsonException.cs | 7
Assets/Plugins/LitJson/Netstandard15Polyfill.cs | 24 +
Assets/Plugins/LitJson/Netstandard15Polyfill.cs.meta | 11
Assets/Plugins/LitJson/JsonWriter.cs | 23
Assets/Plugins/LitJson/JsonData.cs | 81 +++
Assets/Plugins/QHierarchy/Editor/QObjectList.cs | 2
Assets/Plugins/LitJson/JsonMapper.cs | 679 ++++++++++++++++++++-----------------
Assets/Plugins/LitJson/JsonReader.cs | 207 +++++-----
10 files changed, 607 insertions(+), 437 deletions(-)
diff --git a/Assets/Plugins/LitJson/JsonData.cs b/Assets/Plugins/LitJson/JsonData.cs
index 975308d..e89e4b1 100644
--- a/Assets/Plugins/LitJson/JsonData.cs
+++ b/Assets/Plugins/LitJson/JsonData.cs
@@ -73,6 +73,16 @@
public ICollection<string> Keys {
get { EnsureDictionary (); return inst_object.Keys; }
}
+
+ /// <summary>
+ /// Determines whether the json contains an element that has the specified key.
+ /// </summary>
+ /// <param name="key">The key to locate in the json.</param>
+ /// <returns>true if the json contains an element that has the specified key; otherwise, false.</returns>
+ public Boolean ContainsKey(String key) {
+ EnsureDictionary();
+ return this.inst_object.Keys.Contains(key);
+ }
#endregion
@@ -425,22 +435,27 @@
return data.inst_double;
}
- public static explicit operator Int32 (JsonData data)
+ public static explicit operator Int32(JsonData data)
{
- if (data.type != JsonType.Int)
- throw new InvalidCastException (
+ if (data.type != JsonType.Int && data.type != JsonType.Long)
+ {
+ throw new InvalidCastException(
"Instance of JsonData doesn't hold an int");
+ }
- return data.inst_int;
+ // cast may truncate data... but that's up to the user to consider
+ return data.type == JsonType.Int ? data.inst_int : (int)data.inst_long;
}
- public static explicit operator Int64 (JsonData data)
+ public static explicit operator Int64(JsonData data)
{
- if (data.type != JsonType.Long)
- throw new InvalidCastException (
- "Instance of JsonData doesn't hold an int");
+ if (data.type != JsonType.Long && data.type != JsonType.Int)
+ {
+ throw new InvalidCastException(
+ "Instance of JsonData doesn't hold a long");
+ }
- return data.inst_long;
+ return data.type == JsonType.Long ? data.inst_long : data.inst_int;
}
public static explicit operator String (JsonData data)
@@ -804,6 +819,25 @@
return EnsureList ().Add (data);
}
+ public bool Remove(object obj)
+ {
+ json = null;
+ if(IsObject)
+ {
+ JsonData value = null;
+ if (inst_object.TryGetValue((string)obj, out value))
+ return inst_object.Remove((string)obj) && object_list.Remove(new KeyValuePair<string, JsonData>((string)obj, value));
+ else
+ throw new KeyNotFoundException("The specified key was not found in the JsonData object.");
+ }
+ if(IsArray)
+ {
+ return inst_array.Remove(ToJsonData(obj));
+ }
+ throw new InvalidOperationException (
+ "Instance of JsonData is not an object or a list.");
+ }
+
public void Clear ()
{
if (IsObject) {
@@ -823,7 +857,14 @@
return false;
if (x.type != this.type)
- return false;
+ {
+ // further check to see if this is a long to int comparison
+ if ((x.type != JsonType.Int && x.type != JsonType.Long)
+ || (this.type != JsonType.Int && this.type != JsonType.Long))
+ {
+ return false;
+ }
+ }
switch (this.type) {
case JsonType.None:
@@ -839,10 +880,26 @@
return this.inst_string.Equals (x.inst_string);
case JsonType.Int:
- return this.inst_int.Equals (x.inst_int);
+ {
+ if (x.IsLong)
+ {
+ if (x.inst_long < Int32.MinValue || x.inst_long > Int32.MaxValue)
+ return false;
+ return this.inst_int.Equals((int)x.inst_long);
+ }
+ return this.inst_int.Equals(x.inst_int);
+ }
case JsonType.Long:
- return this.inst_long.Equals (x.inst_long);
+ {
+ if (x.IsInt)
+ {
+ if (this.inst_long < Int32.MinValue || this.inst_long > Int32.MaxValue)
+ return false;
+ return x.inst_int.Equals((int)this.inst_long);
+ }
+ return this.inst_long.Equals(x.inst_long);
+ }
case JsonType.Double:
return this.inst_double.Equals (x.inst_double);
diff --git a/Assets/Plugins/LitJson/JsonException.cs b/Assets/Plugins/LitJson/JsonException.cs
index 8ad6f0a..4efd890 100644
--- a/Assets/Plugins/LitJson/JsonException.cs
+++ b/Assets/Plugins/LitJson/JsonException.cs
@@ -14,7 +14,12 @@
namespace LitJson
{
- public class JsonException : ApplicationException
+ public class JsonException :
+#if NETSTANDARD1_5
+ Exception
+#else
+ ApplicationException
+#endif
{
public JsonException () : base ()
{
diff --git a/Assets/Plugins/LitJson/JsonMapper.cs b/Assets/Plugins/LitJson/JsonMapper.cs
index 07624a3..9a7df3e 100644
--- a/Assets/Plugins/LitJson/JsonMapper.cs
+++ b/Assets/Plugins/LitJson/JsonMapper.cs
@@ -17,15 +17,18 @@
using System.Reflection;
-namespace LitJson {
- internal struct PropertyMetadata {
+namespace LitJson
+{
+ internal struct PropertyMetadata
+ {
public MemberInfo Info;
- public bool IsField;
- public Type Type;
+ public bool IsField;
+ public Type Type;
}
- internal struct ArrayMetadata {
+ internal struct ArrayMetadata
+ {
private Type element_type;
private bool is_array;
private bool is_list;
@@ -34,7 +37,7 @@
public Type ElementType {
get {
if (element_type == null)
- return typeof(JsonData);
+ return typeof (JsonData);
return element_type;
}
@@ -54,7 +57,8 @@
}
- internal struct ObjectMetadata {
+ internal struct ObjectMetadata
+ {
private Type element_type;
private bool is_dictionary;
@@ -64,7 +68,7 @@
public Type ElementType {
get {
if (element_type == null)
- return typeof(JsonData);
+ return typeof (JsonData);
return element_type;
}
@@ -84,215 +88,214 @@
}
- internal delegate void ExporterFunc (object obj, JsonWriter writer);
- public delegate void ExporterFunc<T> (T obj, JsonWriter writer);
+ internal delegate void ExporterFunc (object obj, JsonWriter writer);
+ public delegate void ExporterFunc<T> (T obj, JsonWriter writer);
- internal delegate object ImporterFunc (object input);
- public delegate TValue ImporterFunc<TJson, TValue> (TJson input);
+ internal delegate object ImporterFunc (object input);
+ public delegate TValue ImporterFunc<TJson, TValue> (TJson input);
public delegate IJsonWrapper WrapperFactory ();
- public class JsonMapper {
+ public class JsonMapper
+ {
#region Fields
- private static int max_nesting_depth;
+ private static readonly int max_nesting_depth;
- private static IFormatProvider datetime_format;
+ private static readonly IFormatProvider datetime_format;
- private static IDictionary<Type, ExporterFunc> base_exporters_table;
- private static IDictionary<Type, ExporterFunc> custom_exporters_table;
+ private static readonly IDictionary<Type, ExporterFunc> base_exporters_table;
+ private static readonly IDictionary<Type, ExporterFunc> custom_exporters_table;
- private static IDictionary<Type,
+ private static readonly IDictionary<Type,
IDictionary<Type, ImporterFunc>> base_importers_table;
- private static IDictionary<Type,
+ private static readonly IDictionary<Type,
IDictionary<Type, ImporterFunc>> custom_importers_table;
- private static IDictionary<Type, ArrayMetadata> array_metadata;
- private static readonly object array_metadata_lock = new Object();
+ private static readonly IDictionary<Type, ArrayMetadata> array_metadata;
+ private static readonly object array_metadata_lock = new Object ();
- private static IDictionary<Type,
+ private static readonly IDictionary<Type,
IDictionary<Type, MethodInfo>> conv_ops;
- private static readonly object conv_ops_lock = new Object();
+ private static readonly object conv_ops_lock = new Object ();
- private static IDictionary<Type, ObjectMetadata> object_metadata;
- private static readonly object object_metadata_lock = new Object();
+ private static readonly IDictionary<Type, ObjectMetadata> object_metadata;
+ private static readonly object object_metadata_lock = new Object ();
- private static IDictionary<Type,
+ private static readonly IDictionary<Type,
IList<PropertyMetadata>> type_properties;
- private static readonly object type_properties_lock = new Object();
+ private static readonly object type_properties_lock = new Object ();
- private static JsonWriter static_writer;
- private static readonly object static_writer_lock = new Object();
+ private static readonly JsonWriter static_writer;
+ private static readonly object static_writer_lock = new Object ();
#endregion
#region Constructors
- static JsonMapper () {
+ static JsonMapper ()
+ {
max_nesting_depth = 100;
- array_metadata = new Dictionary<Type, ArrayMetadata>();
- conv_ops = new Dictionary<Type, IDictionary<Type, MethodInfo>>();
- object_metadata = new Dictionary<Type, ObjectMetadata>();
+ array_metadata = new Dictionary<Type, ArrayMetadata> ();
+ conv_ops = new Dictionary<Type, IDictionary<Type, MethodInfo>> ();
+ object_metadata = new Dictionary<Type, ObjectMetadata> ();
type_properties = new Dictionary<Type,
- IList<PropertyMetadata>>();
+ IList<PropertyMetadata>> ();
- static_writer = new JsonWriter();
+ static_writer = new JsonWriter ();
datetime_format = DateTimeFormatInfo.InvariantInfo;
- base_exporters_table = new Dictionary<Type, ExporterFunc>();
- custom_exporters_table = new Dictionary<Type, ExporterFunc>();
+ base_exporters_table = new Dictionary<Type, ExporterFunc> ();
+ custom_exporters_table = new Dictionary<Type, ExporterFunc> ();
base_importers_table = new Dictionary<Type,
- IDictionary<Type, ImporterFunc>>();
+ IDictionary<Type, ImporterFunc>> ();
custom_importers_table = new Dictionary<Type,
- IDictionary<Type, ImporterFunc>>();
+ IDictionary<Type, ImporterFunc>> ();
- RegisterBaseExporters();
- RegisterBaseImporters();
+ RegisterBaseExporters ();
+ RegisterBaseImporters ();
}
#endregion
#region Private Methods
- private static void AddArrayMetadata (Type type) {
- if (array_metadata.ContainsKey(type))
+ private static void AddArrayMetadata (Type type)
+ {
+ if (array_metadata.ContainsKey (type))
return;
- ArrayMetadata data = new ArrayMetadata();
+ ArrayMetadata data = new ArrayMetadata ();
data.IsArray = type.IsArray;
- if (type.GetInterface("System.Collections.IList") != null)
+ if (type.GetInterface ("System.Collections.IList") != null)
data.IsList = true;
- foreach (PropertyInfo p_info in type.GetProperties()) {
+ foreach (PropertyInfo p_info in type.GetProperties ()) {
if (p_info.Name != "Item")
continue;
- ParameterInfo[] parameters = p_info.GetIndexParameters();
+ ParameterInfo[] parameters = p_info.GetIndexParameters ();
if (parameters.Length != 1)
continue;
- if (parameters[0].ParameterType == typeof(int))
+ if (parameters[0].ParameterType == typeof (int))
data.ElementType = p_info.PropertyType;
}
lock (array_metadata_lock) {
try {
- array_metadata.Add(type, data);
- }
- catch (ArgumentException) {
+ array_metadata.Add (type, data);
+ } catch (ArgumentException) {
return;
}
}
}
- private static void AddObjectMetadata (Type type) {
- if (object_metadata.ContainsKey(type))
+ private static void AddObjectMetadata (Type type)
+ {
+ if (object_metadata.ContainsKey (type))
return;
- ObjectMetadata data = new ObjectMetadata();
+ ObjectMetadata data = new ObjectMetadata ();
- if (type.GetInterface("System.Collections.IDictionary") != null)
+ if (type.GetInterface ("System.Collections.IDictionary") != null)
data.IsDictionary = true;
- data.Properties = new Dictionary<string, PropertyMetadata>();
+ data.Properties = new Dictionary<string, PropertyMetadata> ();
- foreach (PropertyInfo p_info in type.GetProperties()) {
+ foreach (PropertyInfo p_info in type.GetProperties ()) {
if (p_info.Name == "Item") {
- ParameterInfo[] parameters = p_info.GetIndexParameters();
+ ParameterInfo[] parameters = p_info.GetIndexParameters ();
if (parameters.Length != 1)
continue;
- if (parameters[0].ParameterType == typeof(string))
+ if (parameters[0].ParameterType == typeof (string))
data.ElementType = p_info.PropertyType;
continue;
}
- PropertyMetadata p_data = new PropertyMetadata();
+ PropertyMetadata p_data = new PropertyMetadata ();
p_data.Info = p_info;
p_data.Type = p_info.PropertyType;
- data.Properties.Add(p_info.Name, p_data);
+ data.Properties.Add (p_info.Name, p_data);
}
- foreach (FieldInfo f_info in type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public)) {
- if (f_info.IsNotSerialized)
- continue;
- PropertyMetadata p_data = new PropertyMetadata();
+ foreach (FieldInfo f_info in type.GetFields ()) {
+ PropertyMetadata p_data = new PropertyMetadata ();
p_data.Info = f_info;
p_data.IsField = true;
p_data.Type = f_info.FieldType;
- data.Properties.Add(f_info.Name, p_data);
+ data.Properties.Add (f_info.Name, p_data);
}
lock (object_metadata_lock) {
try {
- object_metadata.Add(type, data);
- }
- catch (ArgumentException) {
+ object_metadata.Add (type, data);
+ } catch (ArgumentException) {
return;
}
}
}
- private static void AddTypeProperties (Type type) {
- if (type_properties.ContainsKey(type))
+ private static void AddTypeProperties (Type type)
+ {
+ if (type_properties.ContainsKey (type))
return;
- IList<PropertyMetadata> props = new List<PropertyMetadata>();
+ IList<PropertyMetadata> props = new List<PropertyMetadata> ();
- foreach (PropertyInfo p_info in type.GetProperties()) {
+ foreach (PropertyInfo p_info in type.GetProperties ()) {
if (p_info.Name == "Item")
continue;
- PropertyMetadata p_data = new PropertyMetadata();
+
+ PropertyMetadata p_data = new PropertyMetadata ();
p_data.Info = p_info;
p_data.IsField = false;
- props.Add(p_data);
+ props.Add (p_data);
}
- foreach (FieldInfo f_info in type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public)) {
- if (f_info.IsNotSerialized)
- continue;
- PropertyMetadata p_data = new PropertyMetadata();
+ foreach (FieldInfo f_info in type.GetFields ()) {
+ PropertyMetadata p_data = new PropertyMetadata ();
p_data.Info = f_info;
p_data.IsField = true;
- props.Add(p_data);
+ props.Add (p_data);
}
lock (type_properties_lock) {
try {
- type_properties.Add(type, props);
- }
- catch (ArgumentException) {
+ type_properties.Add (type, props);
+ } catch (ArgumentException) {
return;
}
}
}
- private static MethodInfo GetConvOp (Type t1, Type t2) {
+ private static MethodInfo GetConvOp (Type t1, Type t2)
+ {
lock (conv_ops_lock) {
- if (!conv_ops.ContainsKey(t1))
- conv_ops.Add(t1, new Dictionary<Type, MethodInfo>());
+ if (! conv_ops.ContainsKey (t1))
+ conv_ops.Add (t1, new Dictionary<Type, MethodInfo> ());
}
- if (conv_ops[t1].ContainsKey(t2))
+ if (conv_ops[t1].ContainsKey (t2))
return conv_ops[t1][t2];
- MethodInfo op = t1.GetMethod(
+ MethodInfo op = t1.GetMethod (
"op_Implicit", new Type[] { t2 });
lock (conv_ops_lock) {
try {
- conv_ops[t1].Add(t2, op);
- }
- catch (ArgumentException) {
+ conv_ops[t1].Add (t2, op);
+ } catch (ArgumentException) {
return conv_ops[t1][t2];
}
}
@@ -300,8 +303,9 @@
return op;
}
- private static object ReadValue (Type inst_type, JsonReader reader) {
- reader.Read();
+ private static object ReadValue (Type inst_type, JsonReader reader)
+ {
+ reader.Read ();
if (reader.Token == JsonToken.ArrayEnd)
return null;
@@ -310,11 +314,17 @@
Type value_type = underlying_type ?? inst_type;
if (reader.Token == JsonToken.Null) {
+ #if NETSTANDARD1_5
+ if (inst_type.IsClass() || underlying_type != null) {
+ return null;
+ }
+ #else
if (inst_type.IsClass || underlying_type != null) {
return null;
}
+ #endif
- throw new JsonException(String.Format(
+ throw new JsonException (String.Format (
"Can't assign null to an instance of type {0}",
inst_type));
}
@@ -325,46 +335,50 @@
reader.Token == JsonToken.String ||
reader.Token == JsonToken.Boolean) {
- Type json_type = reader.Value.GetType();
+ Type json_type = reader.Value.GetType ();
- if (value_type.IsAssignableFrom(json_type))
+ 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(
+ 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);
+ 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(
+ 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);
+ return importer (reader.Value);
}
// Maybe it's an enum
+ #if NETSTANDARD1_5
+ if (value_type.IsEnum())
+ return Enum.ToObject (value_type, reader.Value);
+ #else
if (value_type.IsEnum)
- return Enum.ToObject(value_type, reader.Value);
-
+ return Enum.ToObject (value_type, reader.Value);
+ #endif
// Try using an implicit conversion operator
- MethodInfo conv_op = GetConvOp(value_type, json_type);
+ MethodInfo conv_op = GetConvOp (value_type, json_type);
if (conv_op != null)
- return conv_op.Invoke(null,
+ return conv_op.Invoke (null,
new object[] { reader.Value });
// No luck
- throw new JsonException(String.Format(
+ throw new JsonException (String.Format (
"Can't assign value '{0}' (type {1}) to type {2}",
reader.Value, json_type, inst_type));
}
@@ -373,99 +387,95 @@
if (reader.Token == JsonToken.ArrayStart) {
- AddArrayMetadata(inst_type);
+ AddArrayMetadata (inst_type);
ArrayMetadata t_data = array_metadata[inst_type];
- if (!t_data.IsArray && !t_data.IsList)
- throw new JsonException(String.Format(
+ 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);
+ if (! t_data.IsArray) {
+ list = (IList) Activator.CreateInstance (inst_type);
elem_type = t_data.ElementType;
+ } else {
+ list = new ArrayList ();
+ elem_type = inst_type.GetElementType ();
}
- else {
- list = new ArrayList();
- elem_type = inst_type.GetElementType();
- }
+
+ list.Clear();
while (true) {
- object item = ReadValue(elem_type, reader);
+ object item = ReadValue (elem_type, reader);
if (item == null && reader.Token == JsonToken.ArrayEnd)
break;
- list.Add(item);
+ list.Add (item);
}
if (t_data.IsArray) {
int n = list.Count;
- instance = Array.CreateInstance(elem_type, n);
+ instance = Array.CreateInstance (elem_type, n);
for (int i = 0; i < n; i++)
- ((Array)instance).SetValue(list[i], i);
- }
- else
+ ((Array) instance).SetValue (list[i], i);
+ } else
instance = list;
- }
- else if (reader.Token == JsonToken.ObjectStart) {
- AddObjectMetadata(value_type);
+ } else if (reader.Token == JsonToken.ObjectStart) {
+ AddObjectMetadata (value_type);
ObjectMetadata t_data = object_metadata[value_type];
- instance = Activator.CreateInstance(value_type);
+ instance = Activator.CreateInstance (value_type);
while (true) {
- reader.Read();
+ reader.Read ();
if (reader.Token == JsonToken.ObjectEnd)
break;
- string property = (string)reader.Value;
+ string property = (string) reader.Value;
- if (t_data.Properties.ContainsKey(property)) {
+ 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 {
+ ((FieldInfo) prop_data.Info).SetValue (
+ instance, ReadValue (prop_data.Type, reader));
+ } else {
PropertyInfo p_info =
- (PropertyInfo)prop_data.Info;
+ (PropertyInfo) prop_data.Info;
if (p_info.CanWrite)
- p_info.SetValue(
+ p_info.SetValue (
instance,
- ReadValue(prop_data.Type, reader),
+ ReadValue (prop_data.Type, reader),
null);
else
- ReadValue(prop_data.Type, reader);
+ ReadValue (prop_data.Type, reader);
}
- }
- else {
- if (!t_data.IsDictionary) {
+ } else {
+ if (! t_data.IsDictionary) {
- if (!reader.SkipNonMembers) {
- throw new JsonException(String.Format(
+ if (! reader.SkipNonMembers) {
+ throw new JsonException (String.Format (
"The type {0} doesn't have the " +
"property '{1}'",
inst_type, property));
- }
- else {
- ReadSkip(reader);
+ } else {
+ ReadSkip (reader);
continue;
}
}
- ((IDictionary)instance).Add(
- property, ReadValue(
- t_data.ElementType, reader));
+ ((IDictionary) instance).Add (
+ property, ReadValue (
+ t_data.ElementType, reader));
}
}
@@ -476,63 +486,64 @@
}
private static IJsonWrapper ReadValue (WrapperFactory factory,
- JsonReader reader) {
- reader.Read();
+ JsonReader reader)
+ {
+ reader.Read ();
if (reader.Token == JsonToken.ArrayEnd ||
reader.Token == JsonToken.Null)
return null;
- IJsonWrapper instance = factory();
+ IJsonWrapper instance = factory ();
if (reader.Token == JsonToken.String) {
- instance.SetString((string)reader.Value);
+ instance.SetString ((string) reader.Value);
return instance;
}
if (reader.Token == JsonToken.Double) {
- instance.SetDouble((double)reader.Value);
+ instance.SetDouble ((double) reader.Value);
return instance;
}
if (reader.Token == JsonToken.Int) {
- instance.SetInt((int)reader.Value);
+ instance.SetInt ((int) reader.Value);
return instance;
}
if (reader.Token == JsonToken.Long) {
- instance.SetLong((long)reader.Value);
+ instance.SetLong ((long) reader.Value);
return instance;
}
if (reader.Token == JsonToken.Boolean) {
- instance.SetBoolean((bool)reader.Value);
+ instance.SetBoolean ((bool) reader.Value);
return instance;
}
if (reader.Token == JsonToken.ArrayStart) {
- instance.SetJsonType(JsonType.Array);
+ instance.SetJsonType (JsonType.Array);
while (true) {
- IJsonWrapper item = ReadValue(factory, reader);
+ IJsonWrapper item = ReadValue (factory, reader);
if (item == null && reader.Token == JsonToken.ArrayEnd)
break;
- ((IList)instance).Add(item);
+ ((IList) instance).Add (item);
}
}
else if (reader.Token == JsonToken.ObjectStart) {
- instance.SetJsonType(JsonType.Object);
+ instance.SetJsonType (JsonType.Object);
while (true) {
- reader.Read();
+ reader.Read ();
if (reader.Token == JsonToken.ObjectEnd)
break;
- string property = (string)reader.Value;
+ string property = (string) reader.Value;
- ((IDictionary)instance)[property] = ReadValue(
+ ((IDictionary) instance)[property] = ReadValue (
factory, reader);
}
@@ -541,369 +552,415 @@
return instance;
}
- private static void ReadSkip (JsonReader reader) {
- ToWrapper(
- delegate { return new JsonMockWrapper(); }, reader);
+ private static void ReadSkip (JsonReader reader)
+ {
+ ToWrapper (
+ delegate { return new JsonMockWrapper (); }, reader);
}
- private static void RegisterBaseExporters () {
- base_exporters_table[typeof(byte)] =
+ private static void RegisterBaseExporters ()
+ {
+ base_exporters_table[typeof (byte)] =
delegate (object obj, JsonWriter writer) {
- writer.Write(Convert.ToInt32((byte)obj));
+ writer.Write (Convert.ToInt32 ((byte) obj));
};
- base_exporters_table[typeof(char)] =
+ base_exporters_table[typeof (char)] =
delegate (object obj, JsonWriter writer) {
- writer.Write(Convert.ToString((char)obj));
+ writer.Write (Convert.ToString ((char) obj));
};
- base_exporters_table[typeof(DateTime)] =
+ base_exporters_table[typeof (DateTime)] =
delegate (object obj, JsonWriter writer) {
- writer.Write(Convert.ToString((DateTime)obj,
+ writer.Write (Convert.ToString ((DateTime) obj,
datetime_format));
};
- base_exporters_table[typeof(decimal)] =
+ base_exporters_table[typeof (decimal)] =
delegate (object obj, JsonWriter writer) {
- writer.Write((decimal)obj);
+ writer.Write ((decimal) obj);
};
- base_exporters_table[typeof(sbyte)] =
+ base_exporters_table[typeof (sbyte)] =
delegate (object obj, JsonWriter writer) {
- writer.Write(Convert.ToInt32((sbyte)obj));
+ writer.Write (Convert.ToInt32 ((sbyte) obj));
};
- base_exporters_table[typeof(short)] =
+ base_exporters_table[typeof (short)] =
delegate (object obj, JsonWriter writer) {
- writer.Write(Convert.ToInt32((short)obj));
+ writer.Write (Convert.ToInt32 ((short) obj));
};
- base_exporters_table[typeof(ushort)] =
+ base_exporters_table[typeof (ushort)] =
delegate (object obj, JsonWriter writer) {
- writer.Write(Convert.ToInt32((ushort)obj));
+ writer.Write (Convert.ToInt32 ((ushort) obj));
};
- base_exporters_table[typeof(uint)] =
+ base_exporters_table[typeof (uint)] =
delegate (object obj, JsonWriter writer) {
- writer.Write(Convert.ToUInt64((uint)obj));
+ writer.Write (Convert.ToUInt64 ((uint) obj));
};
- base_exporters_table[typeof(ulong)] =
+ base_exporters_table[typeof (ulong)] =
delegate (object obj, JsonWriter writer) {
- writer.Write((ulong)obj);
+ writer.Write ((ulong) obj);
+ };
+
+ base_exporters_table[typeof(DateTimeOffset)] =
+ delegate (object obj, JsonWriter writer) {
+ writer.Write(((DateTimeOffset)obj).ToString("yyyy-MM-ddTHH:mm:ss.fffffffzzz", datetime_format));
};
}
- private static void RegisterBaseImporters () {
+ private static void RegisterBaseImporters ()
+ {
ImporterFunc importer;
importer = delegate (object input) {
- return Convert.ToByte((int)input);
+ return Convert.ToByte ((int) input);
+ };
+ RegisterImporter (base_importers_table, typeof (int),
+ typeof (byte), importer);
+
+ importer = delegate (object input) {
+ return Convert.ToUInt64 ((int) input);
+ };
+ RegisterImporter (base_importers_table, typeof (int),
+ typeof (ulong), importer);
+
+ importer = delegate (object input) {
+ return Convert.ToInt64((int)input);
};
RegisterImporter(base_importers_table, typeof(int),
- typeof(byte), importer);
+ typeof(long), importer);
importer = delegate (object input) {
- return Convert.ToUInt64((int)input);
+ return Convert.ToSByte ((int) input);
};
- RegisterImporter(base_importers_table, typeof(int),
- typeof(ulong), importer);
+ RegisterImporter (base_importers_table, typeof (int),
+ typeof (sbyte), importer);
importer = delegate (object input) {
- return Convert.ToSByte((int)input);
+ return Convert.ToInt16 ((int) input);
};
- RegisterImporter(base_importers_table, typeof(int),
- typeof(sbyte), importer);
+ RegisterImporter (base_importers_table, typeof (int),
+ typeof (short), importer);
importer = delegate (object input) {
- return Convert.ToInt16((int)input);
+ return Convert.ToUInt16 ((int) input);
};
- RegisterImporter(base_importers_table, typeof(int),
- typeof(short), importer);
+ RegisterImporter (base_importers_table, typeof (int),
+ typeof (ushort), importer);
importer = delegate (object input) {
- return Convert.ToUInt16((int)input);
+ return Convert.ToUInt32 ((int) input);
};
- RegisterImporter(base_importers_table, typeof(int),
- typeof(ushort), importer);
+ RegisterImporter (base_importers_table, typeof (int),
+ typeof (uint), importer);
importer = delegate (object input) {
- return Convert.ToUInt32((int)input);
+ return Convert.ToSingle ((int) input);
};
- RegisterImporter(base_importers_table, typeof(int),
- typeof(uint), importer);
+ RegisterImporter (base_importers_table, typeof (int),
+ typeof (float), importer);
importer = delegate (object input) {
- return Convert.ToSingle((int)input);
+ return Convert.ToDouble ((int) input);
};
- RegisterImporter(base_importers_table, typeof(int),
- typeof(float), importer);
+ RegisterImporter (base_importers_table, typeof (int),
+ typeof (double), importer);
importer = delegate (object input) {
- return Convert.ToDouble((int)input);
+ return Convert.ToDecimal ((double) input);
};
- RegisterImporter(base_importers_table, typeof(int),
- typeof(double), importer);
+ RegisterImporter (base_importers_table, typeof (double),
+ typeof (decimal), importer);
+
importer = delegate (object input) {
- return Convert.ToDecimal((double)input);
+ return Convert.ToUInt32 ((long) input);
};
- RegisterImporter(base_importers_table, typeof(double),
- typeof(decimal), importer);
-
+ RegisterImporter (base_importers_table, typeof (long),
+ typeof (uint), importer);
importer = delegate (object input) {
- return Convert.ToUInt32((long)input);
+ return Convert.ToChar ((string) input);
};
- RegisterImporter(base_importers_table, typeof(long),
- typeof(uint), importer);
+ RegisterImporter (base_importers_table, typeof (string),
+ typeof (char), importer);
importer = delegate (object input) {
- return Convert.ToChar((string)input);
+ return Convert.ToDateTime ((string) input, datetime_format);
+ };
+ RegisterImporter (base_importers_table, typeof (string),
+ typeof (DateTime), importer);
+
+ importer = delegate (object input) {
+ return DateTimeOffset.Parse((string)input, datetime_format);
};
RegisterImporter(base_importers_table, typeof(string),
- typeof(char), importer);
-
- importer = delegate (object input) {
- return Convert.ToDateTime((string)input, datetime_format);
- };
- RegisterImporter(base_importers_table, typeof(string),
- typeof(DateTime), importer);
+ typeof(DateTimeOffset), importer);
}
private static void RegisterImporter (
IDictionary<Type, IDictionary<Type, ImporterFunc>> table,
- Type json_type, Type value_type, ImporterFunc importer) {
- if (!table.ContainsKey(json_type))
- table.Add(json_type, new Dictionary<Type, ImporterFunc>());
+ Type json_type, Type value_type, ImporterFunc importer)
+ {
+ if (! table.ContainsKey (json_type))
+ table.Add (json_type, new Dictionary<Type, ImporterFunc> ());
table[json_type][value_type] = importer;
}
private static void WriteValue (object obj, JsonWriter writer,
bool writer_is_private,
- int depth) {
+ int depth)
+ {
if (depth > max_nesting_depth)
- throw new JsonException(String.Format(
- "Max allowed object depth reached while " +
+ throw new JsonException (
+ String.Format ("Max allowed object depth reached while " +
"trying to export from type {0}",
- obj.GetType()));
+ obj.GetType ()));
if (obj == null) {
- writer.Write(null);
+ writer.Write (null);
return;
}
if (obj is IJsonWrapper) {
if (writer_is_private)
- writer.TextWriter.Write(((IJsonWrapper)obj).ToJson());
+ writer.TextWriter.Write (((IJsonWrapper) obj).ToJson ());
else
- ((IJsonWrapper)obj).ToJson(writer);
+ ((IJsonWrapper) obj).ToJson (writer);
return;
}
if (obj is String) {
- writer.Write((string)obj);
+ writer.Write ((string) obj);
return;
}
if (obj is Double) {
- writer.Write((double)obj);
+ writer.Write ((double) obj);
return;
}
if (obj is Int32) {
- writer.Write((int)obj);
+ writer.Write ((int) obj);
return;
}
if (obj is Boolean) {
- writer.Write((bool)obj);
+ writer.Write ((bool) obj);
return;
}
if (obj is Int64) {
- writer.Write((long)obj);
+ writer.Write ((long) obj);
return;
}
if (obj is Array) {
- writer.WriteArrayStart();
+ writer.WriteArrayStart ();
- foreach (object elem in (Array)obj)
- WriteValue(elem, writer, writer_is_private, depth + 1);
+ foreach (object elem in (Array) obj)
+ WriteValue (elem, writer, writer_is_private, depth + 1);
- writer.WriteArrayEnd();
+ writer.WriteArrayEnd ();
return;
}
if (obj is IList) {
- writer.WriteArrayStart();
- foreach (object elem in (IList)obj)
- WriteValue(elem, writer, writer_is_private, depth + 1);
- writer.WriteArrayEnd();
+ writer.WriteArrayStart ();
+ foreach (object elem in (IList) obj)
+ WriteValue (elem, writer, writer_is_private, depth + 1);
+ writer.WriteArrayEnd ();
return;
}
- if (obj is IDictionary) {
- writer.WriteObjectStart();
- foreach (DictionaryEntry entry in (IDictionary)obj) {
- writer.WritePropertyName((string)entry.Key);
- WriteValue(entry.Value, writer, writer_is_private,
+ if (obj is IDictionary dictionary) {
+ writer.WriteObjectStart ();
+ foreach (DictionaryEntry entry in dictionary) {
+ var propertyName = entry.Key is string key ?
+ key
+ : Convert.ToString(entry.Key, CultureInfo.InvariantCulture);
+ writer.WritePropertyName (propertyName);
+ WriteValue (entry.Value, writer, writer_is_private,
depth + 1);
}
- writer.WriteObjectEnd();
+ writer.WriteObjectEnd ();
return;
}
- Type obj_type = obj.GetType();
+ Type obj_type = obj.GetType ();
// See if there's a custom exporter for the object
- if (custom_exporters_table.ContainsKey(obj_type)) {
+ if (custom_exporters_table.ContainsKey (obj_type)) {
ExporterFunc exporter = custom_exporters_table[obj_type];
- exporter(obj, writer);
+ exporter (obj, writer);
return;
}
// If not, maybe there's a base exporter
- if (base_exporters_table.ContainsKey(obj_type)) {
+ if (base_exporters_table.ContainsKey (obj_type)) {
ExporterFunc exporter = base_exporters_table[obj_type];
- exporter(obj, writer);
+ exporter (obj, writer);
return;
}
// Last option, let's see if it's an enum
if (obj is Enum) {
- Type e_type = Enum.GetUnderlyingType(obj_type);
+ Type e_type = Enum.GetUnderlyingType (obj_type);
- if (e_type == typeof(long)
- || e_type == typeof(uint)
- || e_type == typeof(ulong))
- writer.Write((ulong)obj);
+ if (e_type == typeof (long)
+ || e_type == typeof (uint)
+ || e_type == typeof (ulong))
+ writer.Write ((ulong) obj);
else
- writer.Write((int)obj);
+ writer.Write ((int) obj);
return;
}
// Okay, so it looks like the input should be exported as an
// object
- AddTypeProperties(obj_type);
+ AddTypeProperties (obj_type);
IList<PropertyMetadata> props = type_properties[obj_type];
- writer.WriteObjectStart();
+ writer.WriteObjectStart ();
foreach (PropertyMetadata p_data in props) {
if (p_data.IsField) {
- writer.WritePropertyName(p_data.Info.Name);
- WriteValue(((FieldInfo)p_data.Info).GetValue(obj),
+ writer.WritePropertyName (p_data.Info.Name);
+ WriteValue (((FieldInfo) p_data.Info).GetValue (obj),
writer, writer_is_private, depth + 1);
}
else {
- PropertyInfo p_info = (PropertyInfo)p_data.Info;
+ PropertyInfo p_info = (PropertyInfo) p_data.Info;
if (p_info.CanRead) {
- writer.WritePropertyName(p_data.Info.Name);
- WriteValue(p_info.GetValue(obj, null),
+ writer.WritePropertyName (p_data.Info.Name);
+ WriteValue (p_info.GetValue (obj, null),
writer, writer_is_private, depth + 1);
}
}
}
- writer.WriteObjectEnd();
+ writer.WriteObjectEnd ();
}
#endregion
- public static string ToJson (object obj) {
+ public static string ToJson (object obj)
+ {
lock (static_writer_lock) {
- static_writer.Reset();
+ static_writer.Reset ();
- WriteValue(obj, static_writer, true, 0);
+ WriteValue (obj, static_writer, true, 0);
- return static_writer.ToString();
+ return static_writer.ToString ();
}
}
- public static void ToJson (object obj, JsonWriter writer) {
- WriteValue(obj, writer, false, 0);
+ public static void ToJson (object obj, JsonWriter writer)
+ {
+ WriteValue (obj, writer, false, 0);
}
- public static JsonData ToObject (JsonReader reader) {
- return (JsonData)ToWrapper(
- delegate { return new JsonData(); }, reader);
+ public static JsonData ToObject (JsonReader reader)
+ {
+ return (JsonData) ToWrapper (
+ delegate { return new JsonData (); }, reader);
}
- public static JsonData ToObject (TextReader reader) {
- JsonReader json_reader = new JsonReader(reader);
+ public static JsonData ToObject (TextReader reader)
+ {
+ JsonReader json_reader = new JsonReader (reader);
- return (JsonData)ToWrapper(
- delegate { return new JsonData(); }, json_reader);
+ return (JsonData) ToWrapper (
+ delegate { return new JsonData (); }, json_reader);
}
- public static JsonData ToObject (string json) {
- return (JsonData)ToWrapper(
- delegate { return new JsonData(); }, json);
+ public static JsonData ToObject (string json)
+ {
+ return (JsonData) ToWrapper (
+ delegate { return new JsonData (); }, json);
}
- public static T ToObject<T> (JsonReader reader) {
- return (T)ReadValue(typeof(T), reader);
+ public static T ToObject<T> (JsonReader reader)
+ {
+ return (T) ReadValue (typeof (T), reader);
}
- public static T ToObject<T> (TextReader reader) {
- JsonReader json_reader = new JsonReader(reader);
+ public static T ToObject<T> (TextReader reader)
+ {
+ JsonReader json_reader = new JsonReader (reader);
- return (T)ReadValue(typeof(T), json_reader);
+ return (T) ReadValue (typeof (T), json_reader);
}
- public static T ToObject<T> (string json) {
+ public static T ToObject<T> (string json)
+ {
+ JsonReader reader = new JsonReader (json);
+
+ return (T) ReadValue (typeof (T), reader);
+ }
+
+ public static object ToObject(string json, Type ConvertType )
+ {
JsonReader reader = new JsonReader(json);
- return (T)ReadValue(typeof(T), reader);
+ return ReadValue(ConvertType, reader);
}
public static IJsonWrapper ToWrapper (WrapperFactory factory,
- JsonReader reader) {
- return ReadValue(factory, reader);
+ JsonReader reader)
+ {
+ return ReadValue (factory, reader);
}
public static IJsonWrapper ToWrapper (WrapperFactory factory,
- string json) {
- JsonReader reader = new JsonReader(json);
+ string json)
+ {
+ JsonReader reader = new JsonReader (json);
- return ReadValue(factory, reader);
+ return ReadValue (factory, reader);
}
- public static void RegisterExporter<T> (ExporterFunc<T> exporter) {
+ public static void RegisterExporter<T> (ExporterFunc<T> exporter)
+ {
ExporterFunc exporter_wrapper =
delegate (object obj, JsonWriter writer) {
- exporter((T)obj, writer);
+ exporter ((T) obj, writer);
};
- custom_exporters_table[typeof(T)] = exporter_wrapper;
+ custom_exporters_table[typeof (T)] = exporter_wrapper;
}
public static void RegisterImporter<TJson, TValue> (
- ImporterFunc<TJson, TValue> importer) {
+ ImporterFunc<TJson, TValue> importer)
+ {
ImporterFunc importer_wrapper =
delegate (object input) {
- return importer((TJson)input);
+ return importer ((TJson) input);
};
- RegisterImporter(custom_importers_table, typeof(TJson),
- typeof(TValue), importer_wrapper);
+ RegisterImporter (custom_importers_table, typeof (TJson),
+ typeof (TValue), importer_wrapper);
}
- public static void UnregisterExporters () {
- custom_exporters_table.Clear();
+ public static void UnregisterExporters ()
+ {
+ custom_exporters_table.Clear ();
}
- public static void UnregisterImporters () {
- custom_importers_table.Clear();
+ public static void UnregisterImporters ()
+ {
+ custom_importers_table.Clear ();
}
}
}
diff --git a/Assets/Plugins/LitJson/JsonReader.cs b/Assets/Plugins/LitJson/JsonReader.cs
index d0cd061..e47eabc 100644
--- a/Assets/Plugins/LitJson/JsonReader.cs
+++ b/Assets/Plugins/LitJson/JsonReader.cs
@@ -11,6 +11,7 @@
using System;
using System.Collections.Generic;
+using System.Globalization;
using System.IO;
using System.Text;
@@ -42,7 +43,7 @@
public class JsonReader
{
#region Fields
- private static IDictionary<int, IDictionary<int, int[]>> parse_table;
+ private static readonly IDictionary<int, IDictionary<int, int[]>> parse_table;
private Stack<int> automaton_stack;
private int current_input;
@@ -98,7 +99,7 @@
#region Constructors
static JsonReader ()
{
- PopulateParseTable ();
+ parse_table = PopulateParseTable ();
}
public JsonReader (string json_text) :
@@ -138,120 +139,122 @@
#region Static Methods
- private static void PopulateParseTable ()
+ private static IDictionary<int, IDictionary<int, int[]>> PopulateParseTable ()
{
// See section A.2. of the manual for details
- parse_table = new Dictionary<int, IDictionary<int, int[]>> ();
+ IDictionary<int, IDictionary<int, int[]>> parse_table = new Dictionary<int, IDictionary<int, int[]>> ();
- TableAddRow (ParserToken.Array);
- TableAddCol (ParserToken.Array, '[',
- '[',
- (int) ParserToken.ArrayPrime);
+ TableAddRow (parse_table, ParserToken.Array);
+ TableAddCol (parse_table, ParserToken.Array, '[',
+ '[',
+ (int) ParserToken.ArrayPrime);
- TableAddRow (ParserToken.ArrayPrime);
- TableAddCol (ParserToken.ArrayPrime, '"',
- (int) ParserToken.Value,
+ TableAddRow (parse_table, ParserToken.ArrayPrime);
+ TableAddCol (parse_table, ParserToken.ArrayPrime, '"',
+ (int) ParserToken.Value,
- (int) ParserToken.ValueRest,
- ']');
- TableAddCol (ParserToken.ArrayPrime, '[',
- (int) ParserToken.Value,
- (int) ParserToken.ValueRest,
- ']');
- TableAddCol (ParserToken.ArrayPrime, ']',
- ']');
- TableAddCol (ParserToken.ArrayPrime, '{',
- (int) ParserToken.Value,
- (int) ParserToken.ValueRest,
- ']');
- TableAddCol (ParserToken.ArrayPrime, (int) ParserToken.Number,
- (int) ParserToken.Value,
- (int) ParserToken.ValueRest,
- ']');
- TableAddCol (ParserToken.ArrayPrime, (int) ParserToken.True,
- (int) ParserToken.Value,
- (int) ParserToken.ValueRest,
- ']');
- TableAddCol (ParserToken.ArrayPrime, (int) ParserToken.False,
- (int) ParserToken.Value,
- (int) ParserToken.ValueRest,
- ']');
- TableAddCol (ParserToken.ArrayPrime, (int) ParserToken.Null,
- (int) ParserToken.Value,
- (int) ParserToken.ValueRest,
- ']');
+ (int) ParserToken.ValueRest,
+ ']');
+ TableAddCol (parse_table, ParserToken.ArrayPrime, '[',
+ (int) ParserToken.Value,
+ (int) ParserToken.ValueRest,
+ ']');
+ TableAddCol (parse_table, ParserToken.ArrayPrime, ']',
+ ']');
+ TableAddCol (parse_table, ParserToken.ArrayPrime, '{',
+ (int) ParserToken.Value,
+ (int) ParserToken.ValueRest,
+ ']');
+ TableAddCol (parse_table, ParserToken.ArrayPrime, (int) ParserToken.Number,
+ (int) ParserToken.Value,
+ (int) ParserToken.ValueRest,
+ ']');
+ TableAddCol (parse_table, ParserToken.ArrayPrime, (int) ParserToken.True,
+ (int) ParserToken.Value,
+ (int) ParserToken.ValueRest,
+ ']');
+ TableAddCol (parse_table, ParserToken.ArrayPrime, (int) ParserToken.False,
+ (int) ParserToken.Value,
+ (int) ParserToken.ValueRest,
+ ']');
+ TableAddCol (parse_table, ParserToken.ArrayPrime, (int) ParserToken.Null,
+ (int) ParserToken.Value,
+ (int) ParserToken.ValueRest,
+ ']');
- TableAddRow (ParserToken.Object);
- TableAddCol (ParserToken.Object, '{',
- '{',
- (int) ParserToken.ObjectPrime);
+ TableAddRow (parse_table, ParserToken.Object);
+ TableAddCol (parse_table, ParserToken.Object, '{',
+ '{',
+ (int) ParserToken.ObjectPrime);
- TableAddRow (ParserToken.ObjectPrime);
- TableAddCol (ParserToken.ObjectPrime, '"',
- (int) ParserToken.Pair,
- (int) ParserToken.PairRest,
- '}');
- TableAddCol (ParserToken.ObjectPrime, '}',
- '}');
+ TableAddRow (parse_table, ParserToken.ObjectPrime);
+ TableAddCol (parse_table, ParserToken.ObjectPrime, '"',
+ (int) ParserToken.Pair,
+ (int) ParserToken.PairRest,
+ '}');
+ TableAddCol (parse_table, ParserToken.ObjectPrime, '}',
+ '}');
- TableAddRow (ParserToken.Pair);
- TableAddCol (ParserToken.Pair, '"',
- (int) ParserToken.String,
- ':',
- (int) ParserToken.Value);
+ TableAddRow (parse_table, ParserToken.Pair);
+ TableAddCol (parse_table, ParserToken.Pair, '"',
+ (int) ParserToken.String,
+ ':',
+ (int) ParserToken.Value);
- TableAddRow (ParserToken.PairRest);
- TableAddCol (ParserToken.PairRest, ',',
- ',',
- (int) ParserToken.Pair,
- (int) ParserToken.PairRest);
- TableAddCol (ParserToken.PairRest, '}',
- (int) ParserToken.Epsilon);
+ TableAddRow (parse_table, ParserToken.PairRest);
+ TableAddCol (parse_table, ParserToken.PairRest, ',',
+ ',',
+ (int) ParserToken.Pair,
+ (int) ParserToken.PairRest);
+ TableAddCol (parse_table, ParserToken.PairRest, '}',
+ (int) ParserToken.Epsilon);
- TableAddRow (ParserToken.String);
- TableAddCol (ParserToken.String, '"',
- '"',
- (int) ParserToken.CharSeq,
- '"');
+ TableAddRow (parse_table, ParserToken.String);
+ TableAddCol (parse_table, ParserToken.String, '"',
+ '"',
+ (int) ParserToken.CharSeq,
+ '"');
- TableAddRow (ParserToken.Text);
- TableAddCol (ParserToken.Text, '[',
- (int) ParserToken.Array);
- TableAddCol (ParserToken.Text, '{',
- (int) ParserToken.Object);
+ TableAddRow (parse_table, ParserToken.Text);
+ TableAddCol (parse_table, ParserToken.Text, '[',
+ (int) ParserToken.Array);
+ TableAddCol (parse_table, ParserToken.Text, '{',
+ (int) ParserToken.Object);
- TableAddRow (ParserToken.Value);
- TableAddCol (ParserToken.Value, '"',
- (int) ParserToken.String);
- TableAddCol (ParserToken.Value, '[',
- (int) ParserToken.Array);
- TableAddCol (ParserToken.Value, '{',
- (int) ParserToken.Object);
- TableAddCol (ParserToken.Value, (int) ParserToken.Number,
- (int) ParserToken.Number);
- TableAddCol (ParserToken.Value, (int) ParserToken.True,
- (int) ParserToken.True);
- TableAddCol (ParserToken.Value, (int) ParserToken.False,
- (int) ParserToken.False);
- TableAddCol (ParserToken.Value, (int) ParserToken.Null,
- (int) ParserToken.Null);
+ TableAddRow (parse_table, ParserToken.Value);
+ TableAddCol (parse_table, ParserToken.Value, '"',
+ (int) ParserToken.String);
+ TableAddCol (parse_table, ParserToken.Value, '[',
+ (int) ParserToken.Array);
+ TableAddCol (parse_table, ParserToken.Value, '{',
+ (int) ParserToken.Object);
+ TableAddCol (parse_table, ParserToken.Value, (int) ParserToken.Number,
+ (int) ParserToken.Number);
+ TableAddCol (parse_table, ParserToken.Value, (int) ParserToken.True,
+ (int) ParserToken.True);
+ TableAddCol (parse_table, ParserToken.Value, (int) ParserToken.False,
+ (int) ParserToken.False);
+ TableAddCol (parse_table, ParserToken.Value, (int) ParserToken.Null,
+ (int) ParserToken.Null);
- TableAddRow (ParserToken.ValueRest);
- TableAddCol (ParserToken.ValueRest, ',',
- ',',
- (int) ParserToken.Value,
- (int) ParserToken.ValueRest);
- TableAddCol (ParserToken.ValueRest, ']',
- (int) ParserToken.Epsilon);
+ TableAddRow (parse_table, ParserToken.ValueRest);
+ TableAddCol (parse_table, ParserToken.ValueRest, ',',
+ ',',
+ (int) ParserToken.Value,
+ (int) ParserToken.ValueRest);
+ TableAddCol (parse_table, ParserToken.ValueRest, ']',
+ (int) ParserToken.Epsilon);
+
+ return parse_table;
}
- private static void TableAddCol (ParserToken row, int col,
+ private static void TableAddCol (IDictionary<int, IDictionary<int, int[]>> parse_table, ParserToken row, int col,
params int[] symbols)
{
parse_table[(int) row].Add (col, symbols);
}
- private static void TableAddRow (ParserToken rule)
+ private static void TableAddRow (IDictionary<int, IDictionary<int, int[]>> parse_table, ParserToken rule)
{
parse_table.Add ((int) rule, new Dictionary<int, int[]> ());
}
@@ -266,7 +269,7 @@
number.IndexOf ('E') != -1) {
double n_double;
- if (Double.TryParse (number, out n_double)) {
+ if (double.TryParse (number, NumberStyles.Any, CultureInfo.InvariantCulture, out n_double)) {
token = JsonToken.Double;
token_value = n_double;
@@ -275,7 +278,7 @@
}
int n_int32;
- if (Int32.TryParse (number, out n_int32)) {
+ if (int.TryParse (number, NumberStyles.Integer, CultureInfo.InvariantCulture, out n_int32)) {
token = JsonToken.Int;
token_value = n_int32;
@@ -283,7 +286,7 @@
}
long n_int64;
- if (Int64.TryParse (number, out n_int64)) {
+ if (long.TryParse (number, NumberStyles.Integer, CultureInfo.InvariantCulture, out n_int64)) {
token = JsonToken.Long;
token_value = n_int64;
@@ -291,7 +294,7 @@
}
ulong n_uint64;
- if (UInt64.TryParse(number, out n_uint64))
+ if (ulong.TryParse(number, NumberStyles.Integer, CultureInfo.InvariantCulture, out n_uint64))
{
token = JsonToken.Long;
token_value = n_uint64;
@@ -392,7 +395,9 @@
end_of_json = true;
if (reader_is_owned)
- reader.Close ();
+ {
+ using(reader){}
+ }
reader = null;
}
diff --git a/Assets/Plugins/LitJson/JsonWriter.cs b/Assets/Plugins/LitJson/JsonWriter.cs
index bdcf9c4..7a410b3 100644
--- a/Assets/Plugins/LitJson/JsonWriter.cs
+++ b/Assets/Plugins/LitJson/JsonWriter.cs
@@ -39,7 +39,7 @@
public class JsonWriter
{
#region Fields
- private static NumberFormatInfo number_format;
+ private static readonly NumberFormatInfo number_format;
private WriterContext context;
private Stack<WriterContext> ctx_stack;
@@ -50,6 +50,7 @@
private StringBuilder inst_string_builder;
private bool pretty_print;
private bool validate;
+ private bool lower_case_properties;
private TextWriter writer;
#endregion
@@ -75,6 +76,11 @@
public bool Validate {
get { return validate; }
set { validate = value; }
+ }
+
+ public bool LowerCaseProperties {
+ get { return lower_case_properties; }
+ set { lower_case_properties = value; }
}
#endregion
@@ -166,6 +172,7 @@
indent_value = 4;
pretty_print = false;
validate = true;
+ lower_case_properties = false;
ctx_stack = new Stack<WriterContext> ();
context = new WriterContext ();
@@ -216,7 +223,7 @@
writer.Write (',');
if (pretty_print && ! context.ExpectingValue)
- writer.Write ('\n');
+ writer.Write (Environment.NewLine);
}
private void PutString (string str)
@@ -365,6 +372,7 @@
context.ExpectingValue = false;
}
+ [CLSCompliant(false)]
public void Write (ulong number)
{
DoValidation (Condition.Value);
@@ -441,14 +449,17 @@
{
DoValidation (Condition.Property);
PutNewline ();
+ string propertyName = (property_name == null || !lower_case_properties)
+ ? property_name
+ : property_name.ToLowerInvariant();
- PutString (property_name);
+ PutString (propertyName);
if (pretty_print) {
- if (property_name.Length > context.Padding)
- context.Padding = property_name.Length;
+ if (propertyName.Length > context.Padding)
+ context.Padding = propertyName.Length;
- for (int i = context.Padding - property_name.Length;
+ for (int i = context.Padding - propertyName.Length;
i >= 0; i--)
writer.Write (' ');
diff --git a/Assets/Plugins/LitJson/Lexer.cs b/Assets/Plugins/LitJson/Lexer.cs
index 652d1f7..cb62d55 100644
--- a/Assets/Plugins/LitJson/Lexer.cs
+++ b/Assets/Plugins/LitJson/Lexer.cs
@@ -31,8 +31,8 @@
#region Fields
private delegate bool StateHandler (FsmContext ctx);
- private static int[] fsm_return_table;
- private static StateHandler[] fsm_handler_table;
+ private static readonly int[] fsm_return_table;
+ private static readonly StateHandler[] fsm_handler_table;
private bool allow_comments;
private bool allow_single_quoted_strings;
@@ -77,7 +77,7 @@
#region Constructors
static Lexer ()
{
- PopulateFsmTables ();
+ PopulateFsmTables (out fsm_handler_table, out fsm_return_table);
}
public Lexer (TextReader reader)
@@ -130,7 +130,7 @@
}
}
- private static void PopulateFsmTables ()
+ private static void PopulateFsmTables (out StateHandler[] fsm_handler_table, out int[] fsm_return_table)
{
// See section A.1. of the manual for details of the finite
// state machine.
diff --git a/Assets/Plugins/LitJson/Netstandard15Polyfill.cs b/Assets/Plugins/LitJson/Netstandard15Polyfill.cs
new file mode 100644
index 0000000..55b02a2
--- /dev/null
+++ b/Assets/Plugins/LitJson/Netstandard15Polyfill.cs
@@ -0,0 +1,24 @@
+#if NETSTANDARD1_5
+using System;
+using System.Reflection;
+namespace LitJson
+{
+ internal static class Netstandard15Polyfill
+ {
+ internal static Type GetInterface(this Type type, string name)
+ {
+ return type.GetTypeInfo().GetInterface(name);
+ }
+
+ internal static bool IsClass(this Type type)
+ {
+ return type.GetTypeInfo().IsClass;
+ }
+
+ internal static bool IsEnum(this Type type)
+ {
+ return type.GetTypeInfo().IsEnum;
+ }
+ }
+}
+#endif
\ No newline at end of file
diff --git a/Assets/Plugins/LitJson/Netstandard15Polyfill.cs.meta b/Assets/Plugins/LitJson/Netstandard15Polyfill.cs.meta
new file mode 100644
index 0000000..5bcec7b
--- /dev/null
+++ b/Assets/Plugins/LitJson/Netstandard15Polyfill.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 155770190c61cbb4dbbde393aec4c23e
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
diff --git a/Assets/Plugins/QHierarchy/Editor/QObjectList.cs b/Assets/Plugins/QHierarchy/Editor/QObjectList.cs
index 8f086ed..32a28cd 100644
--- a/Assets/Plugins/QHierarchy/Editor/QObjectList.cs
+++ b/Assets/Plugins/QHierarchy/Editor/QObjectList.cs
@@ -8,7 +8,7 @@
namespace qtools.qhierarchy
{
- [ExecuteInEditMode]
+ [ExecuteAlways]
[AddComponentMenu("")]
public class QObjectList: MonoBehaviour, ISerializationCallbackReceiver
{
diff --git a/Assets/PostProcessing/Runtime/PostProcessingBehaviour.cs b/Assets/PostProcessing/Runtime/PostProcessingBehaviour.cs
index 6f292d2..9b5bc3b 100644
--- a/Assets/PostProcessing/Runtime/PostProcessingBehaviour.cs
+++ b/Assets/PostProcessing/Runtime/PostProcessingBehaviour.cs
@@ -9,7 +9,7 @@
#if UNITY_5_4_OR_NEWER
[ImageEffectAllowedInSceneView]
#endif
- [RequireComponent(typeof(Camera)), DisallowMultipleComponent, ExecuteInEditMode]
+ [RequireComponent(typeof(Camera)), DisallowMultipleComponent, ExecuteAlways]
[AddComponentMenu("Effects/Post-Processing Behaviour", -1)]
public class PostProcessingBehaviour : MonoBehaviour
{
--
Gitblit v1.8.0