dx

Assets/Infinity Code/Real World Terrain/Scripts/JSON/RealWorldTerrainJsonValue.cs

@@ -0,0 +1,263 @@
+/*     INFINITY CODE 2013-2019      */
+/*   http://www.infinity-code.com   */
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Reflection;
+using System.Text;
+using InfinityCode.RealWorldTerrain.Utils;
+using UnityEngine;
+
+namespace InfinityCode.RealWorldTerrain.JSON
+{
+    /// <summary>
+    /// The wrapper for JSON value.
+    /// </summary>
+    public class RealWorldTerrainJsonValue : RealWorldTerrainJsonItem
+    {
+        private ValueType _type;
+        private object _value;
+
+        public override RealWorldTerrainJsonItem this[string key]
+        {
+            get { return null; }
+        }
+
+        public override RealWorldTerrainJsonItem this[int index]
+        {
+            get { return null; }
+        }
+
+        /// <summary>
+        /// Gets / sets the current value
+        /// </summary>
+        public object value
+        {
+            get { return _value; }
+            set
+            {
+#if !UNITY_WP_8_1 || UNITY_EDITOR
+                if (value == null || value is DBNull)
+#else
+                if (value == null)
+#endif
+                {
+                    _type = ValueType.NULL;
+                    _value = value;
+                }
+                else if (value is string)
+                {
+                    _type = ValueType.STRING;
+                    _value = value;
+                }
+                else if (value is double)
+                {
+                    _type = ValueType.DOUBLE;
+                    _value = (double) value;
+                }
+                else if (value is float)
+                {
+                    _type = ValueType.DOUBLE;
+                    _value = (double) (float) value;
+                }
+                else if (value is bool)
+                {
+                    _type = ValueType.BOOLEAN;
+                    _value = value;
+                }
+                else if (value is long)
+                {
+                    _type = ValueType.LONG;
+                    _value = value;
+                }
+                else if (value is int || value is short || value is byte)
+                {
+                    _type = ValueType.LONG;
+                    _value = Convert.ChangeType(value, typeof(long));
+                }
+                else throw new Exception("Unknown type of value.");
+            }
+        }
+
+        /// <summary>
+        /// Get the type of value
+        /// </summary>
+        public ValueType type
+        {
+            get { return _type; }
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="value">Value</param>
+        public RealWorldTerrainJsonValue(object value)
+        {
+            this.value = value;
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="value">Value</param>
+        /// <param name="type">Type of value</param>
+        public RealWorldTerrainJsonValue(object value, ValueType type)
+        {
+            _value = value;
+            _type = type;
+        }
+
+        public override object Deserialize(Type type, BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public)
+        {
+            return Value(type);
+        }
+
+        public override RealWorldTerrainJsonItem GetAll(string key)
+        {
+            return null;
+        }
+
+        public override void ToJSON(StringBuilder b)
+        {
+            if (_type == ValueType.STRING) WriteString(b);
+            else if (_type == ValueType.NULL) b.Append("null");
+            else if (_type == ValueType.BOOLEAN) b.Append((bool) _value ? "true" : "false");
+            else if (_type == ValueType.DOUBLE) b.Append(((double) value).ToString(RealWorldTerrainCultureInfo.cultureInfo));
+            else b.Append(value);
+        }
+
+        public override IEnumerator<RealWorldTerrainJsonItem> GetEnumerator()
+        {
+            yield return this;
+        }
+
+        public override string ToString()
+        {
+            if (type == ValueType.DOUBLE) return ((double) value).ToString(RealWorldTerrainCultureInfo.cultureInfo);
+            return value.ToString();
+        }
+
+        public override object Value(Type t)
+        {
+            if (_type == ValueType.NULL || _value == null)
+            {
+                if (RealWorldTerrainReflectionHelper.IsValueType(t)) return Activator.CreateInstance(t);
+                return null;
+            }
+
+            if (t == typeof(string)) return Convert.ChangeType(_value, t);
+
+            if (_type == ValueType.BOOLEAN)
+            {
+                if (t == typeof(bool)) return Convert.ChangeType(_value, t);
+            }
+            else if (_type == ValueType.DOUBLE)
+            {
+                if (t == typeof(double)) return Convert.ChangeType(_value, t, RealWorldTerrainCultureInfo.numberFormat);
+                if (t == typeof(float)) return Convert.ChangeType((double) _value, t, RealWorldTerrainCultureInfo.numberFormat);
+            }
+            else if (_type == ValueType.LONG)
+            {
+                if (t == typeof(long)) return Convert.ChangeType(_value, t);
+#if UNITY_EDITOR
+                if (t.IsSubclassOf(typeof(UnityEngine.Object)))
+                {
+                    return UnityEditor.EditorUtility.InstanceIDToObject((int) (long) _value);
+                }
+#endif
+
+                try
+                {
+                    return Convert.ChangeType((long) _value, t);
+                }
+                catch (Exception e)
+                {
+                    Debug.Log(e.Message + "\n" + e.StackTrace);
+                    return null;
+                }
+            }
+            else if (_type == ValueType.STRING)
+            {
+                MethodInfo method = RealWorldTerrainReflectionHelper.GetMethod(t, "Parse", new[] {typeof(string), typeof(IFormatProvider)});
+                if (method != null) return method.Invoke(null, new object[] {value, RealWorldTerrainCultureInfo.numberFormat});
+
+                method = RealWorldTerrainReflectionHelper.GetMethod(t, "Parse", new[] {typeof(string)});
+                return method.Invoke(null, new[] {value});
+            }
+
+            StringBuilder builder = new StringBuilder();
+            ToJSON(builder);
+            throw new InvalidCastException(t.FullName + "\n" + builder);
+        }
+
+        private void WriteString(StringBuilder b)
+        {
+            b.Append('\"');
+
+            string s = value as string;
+
+            int runIndex = -1;
+            int l = s.Length;
+            for (var index = 0; index < l; ++index)
+            {
+                var c = s[index];
+
+                if (c >= ' ' && c < 128 && c != '\"' && c != '\\')
+                {
+                    if (runIndex == -1) runIndex = index;
+
+                    continue;
+                }
+
+                if (runIndex != -1)
+                {
+                    b.Append(s, runIndex, index - runIndex);
+                    runIndex = -1;
+                }
+
+                switch (c)
+                {
+                    case '\t':
+                        b.Append("\\t");
+                        break;
+                    case '\r':
+                        b.Append("\\r");
+                        break;
+                    case '\n':
+                        b.Append("\\n");
+                        break;
+                    case '"':
+                    case '\\':
+                        b.Append('\\');
+                        b.Append(c);
+                        break;
+                    default:
+                        b.Append("\\u");
+                        b.Append(((int) c).ToString("X4", NumberFormatInfo.InvariantInfo));
+                        break;
+                }
+            }
+
+            if (runIndex != -1) b.Append(s, runIndex, s.Length - runIndex);
+            b.Append('\"');
+        }
+
+        public static implicit operator string(RealWorldTerrainJsonValue val)
+        {
+            return val.ToString();
+        }
+
+        /// <summary>
+        /// Type of value
+        /// </summary>
+        public enum ValueType
+        {
+            DOUBLE,
+            LONG,
+            STRING,
+            BOOLEAN,
+            NULL
+        }
+    }
+}