Example #1
0
        /// <summary>
        /// Attempt to create JSON node representation from given input.
        /// </summary>
        /// <remarks>
        /// <para>This method uses type information from input to determine which type of
        /// nodes seem best suited. Common basic data types are supported along with
        /// objects, structures, lists, native arrays and even dictionaries. Dictionary
        /// support is limited to those with string type keys (<c>Dictionary&lt;string, YourType&gt;></c>).</para>
        /// <para>Input value is simply cloned if it is already a <see cref="JsonNode"/>.</para>
        /// </remarks>
        /// <example>
        /// <para>Create JSON object from a generic dictionary:</para>
        /// <code language="csharp"><![CDATA[
        /// // Prepare an example data structure.
        /// var lookupTable = new Dictionary<string, int>();
        /// lookupTable["Player"] = 42;
        /// lookupTable["Boss1"] = 72;
        /// lookupTable["Whale"] = 128;
        ///
        /// // Convert example data structure into a JSON object.
        /// var jsonObject = JsonNode.FromObject(lookupTable);
        ///
        /// // Read node from JSON object.
        /// var playerNode = jsonObject["Player"] as JsonLongNode;
        /// Debug.Log(playerNode.Value); // 42
        /// ]]></code>
        /// <para>Once you have a node representation of your data you can then proceed
        /// to output this to a JSON encoded text file:</para>
        /// <code language="csharp"><![CDATA[
        /// File.WriteAllText(outputPath, jsonObject.ToString());
        /// ]]></code>
        /// <para>The resulting text file would then look something like this:</para>
        /// <code language="json"><![CDATA[
        /// {
        ///     "Player": 42,
        ///     "Boss1": 72,
        ///     "Whale": 128
        /// }
        /// ]]></code>
        /// </example>
        /// <param name="value">Input value, array, collection, object instance, etc.</param>
        /// <returns>
        /// The new <see cref="JsonNode"/> instance; or a value of <c>null</c> if input
        /// was itself a value of <c>null</c>.
        /// </returns>
        /// <exception cref="System.Exception">
        /// If a problem was encountered whilst attempting to create node representation
        /// from input value.
        /// </exception>
        /// <seealso cref="ConvertTo{T}()"/>
        /// <seealso cref="ConvertTo(Type)"/>
        public static JsonNode ConvertFrom(object value)
        {
            if (value == null)
            {
                return(null);
            }

            var valueNode = value as JsonNode;

            if (valueNode != null)
            {
                return(valueNode.Clone());
            }

            var type     = value.GetType();
            var metaType = MetaType.FromType(type);

            switch (metaType.TargetNodeType)
            {
            case MetaType.NodeType.Integer:
                if (Type.GetTypeCode(type) == TypeCode.UInt64)
                {
                    return(new JsonIntegerNode((long)Convert.ToUInt64(value, CultureInfo.InvariantCulture)));
                }
                else
                {
                    return(new JsonIntegerNode(Convert.ToInt64(value, CultureInfo.InvariantCulture)));
                }

            case MetaType.NodeType.Double:
                return(new JsonDoubleNode(Convert.ToDouble(value, CultureInfo.InvariantCulture)));

            case MetaType.NodeType.Boolean:
                return(new JsonBooleanNode(Convert.ToBoolean(value, CultureInfo.InvariantCulture)));

            case MetaType.NodeType.String:
                return(new JsonStringNode(Convert.ToString(value, CultureInfo.InvariantCulture)));

            case MetaType.NodeType.Array:
                if (type.IsArray)
                {
                    return(JsonArrayNode.FromArray((object[])value));
                }
                else
                {
                    return(JsonArrayNode.FromCollection((IEnumerable)value));
                }

            case MetaType.NodeType.Object:
                if (metaType.IsDictionaryStyleCollection)
                {
                    return(FromDictionaryStyleCollection((ICollection)value, metaType));
                }
                else
                {
                    return(JsonObjectNode.FromInstance(value));
                }

            default:
                throw new InvalidOperationException("Was unable to convert input value.");
            }
        }