Clone method added. Changelog extracted

Bunny83 · web-flow · commit a5df8b85ae56 · 2019-12-10T18:10:45.000+01:00
Added Clone() method to allow cloning of a whole node tree.

Extracted the changelog into a seperate Changelog.txt file
diff --git a/SimpleJSON.cs b/SimpleJSON.cs
@@ -8,104 +8,11 @@
  * Written by Bunny83 
  * 2012-06-09
  * 
- * [2012-06-09 First Version]
- * - provides strongly typed node classes and lists / dictionaries
- * - provides easy access to class members / array items / data values
- * - the parser now properly identifies types. So generating JSON with this framework should work.
- * - only double quotes (") are used for quoting strings.
- * - provides "casting" properties to easily convert to / from those types:
- *   int / float / double / bool
- * - provides a common interface for each node so no explicit casting is required.
- * - the parser tries to avoid errors, but if malformed JSON is parsed the result is more or less undefined
- * - It can serialize/deserialize a node tree into/from an experimental compact binary format. It might
- *   be handy if you want to store things in a file and don't want it to be easily modifiable
- * 
- * [2012-12-17 Update]
- * - Added internal JSONLazyCreator class which simplifies the construction of a JSON tree
- *   Now you can simple reference any item that doesn't exist yet and it will return a JSONLazyCreator
- *   The class determines the required type by it's further use, creates the type and removes itself.
- * - Added binary serialization / deserialization.
- * - Added support for BZip2 zipped binary format. Requires the SharpZipLib ( http://www.icsharpcode.net/opensource/sharpziplib/ )
- *   The usage of the SharpZipLib library can be disabled by removing or commenting out the USE_SharpZipLib define at the top
- * - The serializer uses different types when it comes to store the values. Since my data values
- *   are all of type string, the serializer will "try" which format fits best. The order is: int, float, double, bool, string.
- *   It's not the most efficient way but for a moderate amount of data it should work on all platforms.
- * 
- * [2017-03-08 Update]
- * - Optimised parsing by using a StringBuilder for token. This prevents performance issues when large
- *   string data fields are contained in the json data.
- * - Finally refactored the badly named JSONClass into JSONObject.
- * - Replaced the old JSONData class by distict typed classes ( JSONString, JSONNumber, JSONBool, JSONNull ) this
- *   allows to propertly convert the node tree back to json without type information loss. The actual value
- *   parsing now happens at parsing time and not when you actually access one of the casting properties.
- * 
- * [2017-04-11 Update]
- * - Fixed parsing bug where empty string values have been ignored.
- * - Optimised "ToString" by using a StringBuilder internally. This should heavily improve performance for large files
- * - Changed the overload of "ToString(string aIndent)" to "ToString(int aIndent)"
- * 
- * [2017-11-29 Update]
- * - Removed the IEnumerator implementations on JSONArray & JSONObject and replaced it with a common
- *   struct Enumerator in JSONNode that should avoid garbage generation. The enumerator always works
- *   on KeyValuePair<string, JSONNode>, even for JSONArray.
- * - Added two wrapper Enumerators that allows for easy key or value enumeration. A JSONNode now has
- *   a "Keys" and a "Values" enumerable property. Those are also struct enumerators / enumerables
- * - A KeyValuePair<string, JSONNode> can now be implicitly converted into a JSONNode. This allows
- *   a foreach loop over a JSONNode to directly access the values only. Since KeyValuePair as well as
- *   all the Enumerators are structs, no garbage is allocated.
- * - To add Linq support another "LinqEnumerator" is available through the "Linq" property. This
- *   enumerator does implement the generic IEnumerable interface so most Linq extensions can be used
- *   on this enumerable object. This one does allocate memory as it's a wrapper class.
- * - The Escape method now escapes all control characters (# < 32) in strings as uncode characters
- *   (\uXXXX) and if the static bool JSONNode.forceASCII is set to true it will also escape all
- *   characters # > 127. This might be useful if you require an ASCII output. Though keep in mind
- *   when your strings contain many non-ascii characters the strings become much longer (x6) and are
- *   no longer human readable.
- * - The node types JSONObject and JSONArray now have an "Inline" boolean switch which will default to
- *   false. It can be used to serialize this element inline even you serialize with an indented format
- *   This is useful for arrays containing numbers so it doesn't place every number on a new line
- * - Extracted the binary serialization code into a seperate extension file. All classes are now declared
- *   as "partial" so an extension file can even add a new virtual or abstract method / interface to
- *   JSONNode and override it in the concrete type classes. It's of course a hacky approach which is
- *   generally not recommended, but i wanted to keep everything tightly packed.
- * - Added a static CreateOrGet method to the JSONNull class. Since this class is immutable it could
- *   be reused without major problems. If you have a lot null fields in your data it will help reduce
- *   the memory / garbage overhead. I also added a static setting (reuseSameInstance) to JSONNull
- *   (default is true) which will change the behaviour of "CreateOrGet". If you set this to false
- *   CreateOrGet will not reuse the cached instance but instead create a new JSONNull instance each time.
- *   I made the JSONNull constructor private so if you need to create an instance manually use
- *   JSONNull.CreateOrGet()
- * 
- * [2018-01-09 Update]
- * - Changed all double.TryParse and double.ToString uses to use the invariant culture to avoid problems
- *   on systems with a culture that uses a comma as decimal point.
- * 
- * [2018-01-26 Update]
- * - Added AsLong. Note that a JSONNumber is stored as double and can't represent all long values. However
- *   storing it as string would work.
- * - Added static setting "JSONNode.longAsString" which controls the default type that is used by the
- *   LazyCreator when using AsLong
- * 
- * [2018-04-25 Update]
- *  - Added support for parsing single values (JSONBool, JSONString, JSONNumber, JSONNull) as top level value.
- * 
- * [2019-02-18 Update]
- *  - Added HasKey(key) and GetValueOrDefault(key, default) to the JSONNode class to provide way to read
- *    values conditionally without creating a LazyCreator
- * 
- * [2019-03-25 Update]
- *  - Added static setting "allowLineComments" to the JSONNode class which is true by default. This allows
- *    "//" line comments when parsing json text as long as it's not within quoted text. All text after // up
- *    to the end of the line is completely ignored / skipped. This makes it easier to create human readable
- *    and editable files. Note that stripped comments are not read, processed or preserved in any way. So
- *    this feature is only relevant for human created files.
- *  - Explicitly strip BOM (Byte Order Mark) when parsing to avoid getting it leaked into a single primitive
- *    value. That's a rare case but better safe than sorry.
- *  - Allowing adding the empty string as key
+ * Changelog now external. See Changelog.txt
  * 
  * The MIT License (MIT)
  * 
- * Copyright (c) 2012-2017 Markus Göbel (Bunny83)
+ * Copyright (c) 2012-2019 Markus Göbel (Bunny83)
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -176,7 +83,8 @@ public Enumerator(Dictionary<string, JSONNode>.Enumerator aDictEnum)
             }
             public KeyValuePair<string, JSONNode> Current
             {
-                get {
+                get
+                {
                     if (type == Type.Array)
                         return new KeyValuePair<string, JSONNode>(string.Empty, m_Array.Current);
                     else if (type == Type.Object)
@@ -301,6 +209,11 @@ public virtual JSONNode Remove(JSONNode aNode)
             return aNode;
         }
 
+        public virtual JSONNode Clone()
+        {
+            return null;
+        }
+
         public virtual IEnumerable<JSONNode> Children
         {
             get
@@ -359,7 +272,7 @@ public virtual double AsDouble
             get
             {
                 double v = 0.0;
-                if (double.TryParse(Value,NumberStyles.Float, CultureInfo.InvariantCulture, out v))
+                if (double.TryParse(Value, NumberStyles.Float, CultureInfo.InvariantCulture, out v))
                     return v;
                 return 0.0;
             }
@@ -525,7 +438,8 @@ public override int GetHashCode()
         private static StringBuilder m_EscapeBuilder;
         internal static StringBuilder EscapeBuilder
         {
-            get {
+            get
+            {
                 if (m_EscapeBuilder == null)
                     m_EscapeBuilder = new StringBuilder();
                 return m_EscapeBuilder;
@@ -739,7 +653,7 @@ public static JSONNode Parse(string aJSON)
                         }
                         break;
                     case '/':
-                        if (allowLineComments && !QuoteMode && i + 1 < aJSON.Length && aJSON[i+1] == '/')
+                        if (allowLineComments && !QuoteMode && i + 1 < aJSON.Length && aJSON[i + 1] == '/')
                         {
                             while (++i < aJSON.Length && aJSON[i] != '\n' && aJSON[i] != '\r') ;
                             break;
@@ -838,6 +752,20 @@ public override JSONNode Remove(JSONNode aNode)
             return aNode;
         }
 
+        public override JSONNode Clone()
+        {
+            var node = new JSONArray();
+            node.m_List.Capacity = m_List.Capacity;
+            foreach(var n in m_List)
+            {
+                if (n != null)
+                    node.Add(n.Clone());
+                else
+                    node.Add(null);
+            }
+            return node;
+        }
+
         public override IEnumerable<JSONNode> Children
         {
             get
@@ -981,6 +909,16 @@ public override JSONNode Remove(JSONNode aNode)
             }
         }
 
+        public override JSONNode Clone()
+        {
+            var node = new JSONObject();
+            foreach (var n in m_Dict)
+            {
+                node.Add(n.Key, n.Value.Clone());
+            }
+            return node;
+        }
+
         public override bool HasKey(string aKey)
         {
             return m_Dict.ContainsKey(aKey);
@@ -1056,6 +994,10 @@ public JSONString(string aData)
         {
             m_Data = aData;
         }
+        public override JSONNode Clone()
+        {
+            return new JSONString(m_Data);
+        }
 
         internal override void WriteToStringBuilder(StringBuilder aSB, int aIndent, int aIndentInc, JSONTextMode aMode)
         {
@@ -1120,6 +1062,11 @@ public JSONNumber(string aData)
             Value = aData;
         }
 
+        public override JSONNode Clone()
+        {
+            return new JSONNumber(m_Data);
+        }
+
         internal override void WriteToStringBuilder(StringBuilder aSB, int aIndent, int aIndentInc, JSONTextMode aMode)
         {
             aSB.Append(Value);
@@ -1187,6 +1134,11 @@ public JSONBool(string aData)
             Value = aData;
         }
 
+        public override JSONNode Clone()
+        {
+            return new JSONBool(m_Data);
+        }
+
         internal override void WriteToStringBuilder(StringBuilder aSB, int aIndent, int aIndentInc, JSONTextMode aMode)
         {
             aSB.Append((m_Data) ? "true" : "false");
@@ -1233,6 +1185,11 @@ public override bool AsBool
             set { }
         }
 
+        public override JSONNode Clone()
+        {
+            return CreateOrGet();
+        }
+
         public override bool Equals(object obj)
         {
             if (object.ReferenceEquals(this, obj))
