Пример #1
0
 /// <summary>
 /// Merges two objects recursively
 /// </summary>
 /// <param name="arr1"></param>
 /// <param name="arr2"></param>
 /// <param name="overwrite">whether to overwrite</param>
 /// <returns></returns>
 public static JsonObject array_merge_recursive(JsonObject arr1, JsonObject arr2, bool overwrite = false)
 {
     return(JsonObjectFactory.merge(arr1, arr2, overwrite, true));
 }
        /// <summary>
        /// Merges two JsonObjects into one.
        /// </summary>
        /// <param name="obj1"></param>
        /// <param name="obj2"></param>
        /// <param name="overwrite">whether second should overwrite first</param>
        /// <param name="recursive">whether merge should be recursive for the same keys</param>
        /// <returns></returns>
        public static JsonObject merge(JsonObject obj1, JsonObject obj2, bool overwrite = false, bool recursive = false)
        {
            JsonObject newObj = null;

            // for arrays we just insert elements from the second array to the first one and return a new array
            if (obj1.isArray() && obj2.isArray())
            {
                newObj = JsonObjectFactory.mergeArrays(obj1, obj2);
                return(newObj);
            }

            newObj = new JsonObject();

            string[] keys1 = obj1.getKeys();
            string[] keys2 = obj2.getKeys();
            string[] keys  = keys1.Union(keys2).ToArray();

            Object temp = null;
            string type = "";

            foreach (string key in keys)
            {
                string type1       = "";
                string type2       = "";
                Object temp1Object = obj1.get(key, ref type1);
                Object temp2Object = obj2.get(key, ref type2);

                // recursive merging for objects only
                if (recursive && (type1 == "JsonObject" && type2 == "JsonObject"))
                {
                    JsonObject temp1 = (JsonObject)temp1Object;
                    JsonObject temp2 = (JsonObject)temp2Object;
                    type = "JsonObject";
                    temp = JsonObjectFactory.merge(temp1, temp2, overwrite, recursive);
                }
                // special treatment for arrays
                else if (type1 == "JsonArray" && type2 == "JsonArray")
                {
                    JsonObject temp1 = (JsonObject)temp1Object;
                    JsonObject temp2 = (JsonObject)temp2Object;
                    type = "JsonArray";
                    temp = JsonObjectFactory.merge(temp1, temp2);
                }
                // for the rest we simple insert the value depending on overwrite parameter
                // overwrite is enabled and value is in the second object
                else if (overwrite && Tools.in_array(key, keys2))
                {
                    temp = obj2.get(key, ref type);
                }
                // value is in the first object
                else if (Tools.in_array(key, keys1))
                {
                    temp = obj1.get(key, ref type);
                }
                // value is in the second object only
                else if (Tools.in_array(key, keys2))
                {
                    temp = obj2.get(key, ref type);
                }

                if (type == "JsonObject" || type == "JsonArray")
                {
                    temp = ((JsonObject)temp).Clone();
                }

                newObj.set(type, key, temp);
                continue;
            }

            return(newObj);
        }