UJeli.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using UnityEngine;

public class UJeli
{
    public string Name
    {
        get { return _name; }
        set { _name = value ?? ""; }
    }

    public int IntName
    {
        get { return int.Parse(_name); }
        set { _name = value.ToString(); }
    }

    public short ShortName
    {
        get { return short.Parse(_name); }
        set { _name = value.ToString(); }
    }

    public long LongName
    {
        get { return long.Parse(_name); }
        set { _name = value.ToString(); }
    }

    public byte ByteName
    {
        get { return byte.Parse(_name); }
        set { _name = value.ToString(); }
    }

    public sbyte SByteName
    {
        get { return sbyte.Parse(_name); }
        set { _name = value.ToString(); }
    }

    public char CharName
    {
        get { return char.Parse(_name); }
        set { _name = value.ToString(); }
    }

    public uint UIntName
    {
        get { return uint.Parse(_name); }
        set { _name = value.ToString(); }
    }

    public ushort UShortName
    {
        get { return ushort.Parse(_name); }
        set { _name = value.ToString(); }
    }

    public ulong ULongName
    {
        get { return ulong.Parse(_name); }
        set { _name = value.ToString(); }
    }

    public float FloatName
    {
        get { return float.Parse(_name); }
        set { _name = value.ToString(); }
    }

    public double DoubleName
    {
        get { return double.Parse(_name); }
        set { _name = value.ToString(); }
    }

    public bool BoolName
    {
        get { return bool.Parse(_name); }
        set { _name = value.ToString(); }
    }

    public DateTime TimeName
    {
        get { return DateTime.Parse(_name); }
        set { _name = value.ToString(); }
    }

    public Vector2 Vector2Name
    {
        get
        {
            string[] tokens = _name.Split();

            return new Vector2(float.Parse(tokens[0]), float.Parse(tokens[1]));
        }
        set { _name = value.x + " " + value.y; }
    }

    public Vector3 Vector3Name
    {
        get
        {
            string[] tokens = _name.Split();

            return new Vector3(float.Parse(tokens[0]), float.Parse(tokens[1]), float.Parse(tokens[2]));
        }
        set { _name = value.x + " " + value.y + " " + value.z; }
    }

    public Vector4 Vector4Name
    {
        get
        {
            string[] tokens = _name.Split();

            return new Vector4(float.Parse(tokens[0]), float.Parse(tokens[1]),
                float.Parse(tokens[2]), float.Parse(tokens[3]));
        }
        set { _name = value.x + " " + value.y + " " + value.z + " " + value.w; }
    }

    public Quaternion QuaternionName
    {
        get
        {
            string[] tokens = _name.Split();

            return new Quaternion(float.Parse(tokens[0]), float.Parse(tokens[1]),
                                    float.Parse(tokens[2]), float.Parse(tokens[3]));
        }
        set { _name = value.x + " " + value.y + " " + value.z + " " + value.w; }
    }

    public Ray RayName
    {
        get
        {
            string[] tokens = _name.Split();

            return new Ray(
                new Vector3(float.Parse(tokens[0]), float.Parse(tokens[0]), float.Parse(tokens[0])),
                new Vector3(float.Parse(tokens[0]), float.Parse(tokens[0]), float.Parse(tokens[0])));
        }
        set
        {
            _name = value.origin.x + " " + value.origin.y + " " + value.origin.z + " "
                + value.direction.x + " " + value.direction.y + " " + value.direction.z;
        }
    }

    public Matrix4x4 MatrixName
    {
        get
        {
            string[] tokens = _name.Split();

            var mat = new Matrix4x4();
            mat.m00 = float.Parse(tokens[0]);
            mat.m01 = float.Parse(tokens[1]);
            mat.m02 = float.Parse(tokens[2]);
            mat.m03 = float.Parse(tokens[3]);
            mat.m10 = float.Parse(tokens[4]);
            mat.m11 = float.Parse(tokens[5]);
            mat.m12 = float.Parse(tokens[6]);
            mat.m13 = float.Parse(tokens[7]);
            mat.m20 = float.Parse(tokens[8]);
            mat.m21 = float.Parse(tokens[9]);
            mat.m22 = float.Parse(tokens[10]);
            mat.m23 = float.Parse(tokens[11]);
            mat.m30 = float.Parse(tokens[12]);
            mat.m31 = float.Parse(tokens[13]);
            mat.m32 = float.Parse(tokens[14]);
            mat.m33 = float.Parse(tokens[15]);

            return mat;
        }
        set
        {
            _name = string.Join(" ", new string[] {
                value.m00.ToString(),
                value.m01.ToString(),
                value.m02.ToString(),
                value.m03.ToString(),
                value.m10.ToString(),
                value.m11.ToString(),
                value.m12.ToString(),
                value.m13.ToString(),
                value.m20.ToString(),
                value.m21.ToString(),
                value.m22.ToString(),
                value.m23.ToString(),
                value.m30.ToString(),
                value.m31.ToString(),
                value.m32.ToString(),
                value.m33.ToString()
            });
        }
    }

    public Color ColorName
    {
        get
        {
            string[] tokens = _name.Split();

            if (tokens.Length < 4)
                return new Color(float.Parse(tokens[0]), float.Parse(tokens[1]),
                                    float.Parse(tokens[2]));
            else return new Color(float.Parse(tokens[0]), float.Parse(tokens[1]),
                                    float.Parse(tokens[2]), float.Parse(tokens[3]));
        }
        set { _name = value.r + " " + value.g + " " + value.b + " " + value.a; }
    }
    
    public GameObject GameObjectName
    {
        get { return Sync.GetObject(int.Parse(Name)); }
        set { _name = Sync.GetObjectIndex(value).ToString(); }
    }

    public string Value
    {
        get { return _value; }
        set { _value = value ?? ""; }
    }

    public int IntValue
    {
        get { return int.Parse(_value); }
        set { _value = value.ToString(); }
    }

    public short ShortValue
    {
        get { return short.Parse(_value); }
        set { _value = value.ToString(); }
    }

    public long LongValue
    {
        get { return long.Parse(_value); }
        set { _value = value.ToString(); }
    }

    public byte ByteValue
    {
        get { return byte.Parse(_value); }
        set { _value = value.ToString(); }
    }

    public sbyte SByteValue
    {
        get { return sbyte.Parse(_value); }
        set { _value = value.ToString(); }
    }

    public char CharValue
    {
        get { return char.Parse(_value); }
        set { _value = value.ToString(); }
    }

    public uint UIntValue
    {
        get { return uint.Parse(_value); }
        set { _value = value.ToString(); }
    }

    public ushort UShortValue
    {
        get { return ushort.Parse(_value); }
        set { _value = value.ToString(); }
    }

    public ulong ULongValue
    {
        get { return ulong.Parse(_value); }
        set { _value = value.ToString(); }
    }

    public float FloatValue
    {
        get { return float.Parse(_value); }
        set { _value = value.ToString(); }
    }

    public double DoubleValue
    {
        get { return double.Parse(_value); }
        set { _value = value.ToString(); }
    }

    public bool BoolValue
    {
        get { return bool.Parse(_value); }
        set { _value = value.ToString(); }
    }

    public DateTime TimeValue
    {
        get { return DateTime.Parse(_value); }
        set { _value = value.ToString(); }
    }

    public Vector2 Vector2Value
    {
        get
        {
            string[] tokens = _value.Split();

            return new Vector2(float.Parse(tokens[0]), float.Parse(tokens[1]));
        }
        set { _value = value.x + " " + value.y; }
    }

    public Vector3 Vector3Value
    {
        get
        {
            string[] tokens = _value.Split();

            return new Vector3(float.Parse(tokens[0]), float.Parse(tokens[1]), float.Parse(tokens[2]));
        }
        set { _value = value.x + " " + value.y + " " + value.z; }
    }

    public Vector4 Vector4Value
    {
        get
        {
            string[] tokens = _value.Split();

            return new Vector4(float.Parse(tokens[0]), float.Parse(tokens[1]),
                float.Parse(tokens[2]), float.Parse(tokens[3]));
        }
        set { _value = value.x + " " + value.y + " " + value.z + " " + value.w; }
    }

    public Quaternion QuaternionValue
    {
        get
        {
            string[] tokens = _value.Split();

            return new Quaternion(float.Parse(tokens[0]), float.Parse(tokens[1]),
                                    float.Parse(tokens[2]), float.Parse(tokens[3]));
        }
        set { _value = value.x + " " + value.y + " " + value.z + " " + value.w; }
    }

    public Ray RayValue
    {
        get
        {
            string[] tokens = _value.Split();

            return new Ray(
                new Vector3(float.Parse(tokens[0]), float.Parse(tokens[0]), float.Parse(tokens[0])),
                new Vector3(float.Parse(tokens[0]), float.Parse(tokens[0]), float.Parse(tokens[0])));
        }
        set
        {
            _value = value.origin.x + " " + value.origin.y + " " + value.origin.z + " "
                + value.direction.x + " " + value.direction.y + " " + value.direction.z;
        }
    }

    public Matrix4x4 MatrixValue
    {
        get
        {
            string[] tokens = _value.Split();

            var mat = new Matrix4x4();
            mat.m00 = float.Parse(tokens[0]);
            mat.m01 = float.Parse(tokens[1]);
            mat.m02 = float.Parse(tokens[2]);
            mat.m03 = float.Parse(tokens[3]);
            mat.m10 = float.Parse(tokens[4]);
            mat.m11 = float.Parse(tokens[5]);
            mat.m12 = float.Parse(tokens[6]);
            mat.m13 = float.Parse(tokens[7]);
            mat.m20 = float.Parse(tokens[8]);
            mat.m21 = float.Parse(tokens[9]);
            mat.m22 = float.Parse(tokens[10]);
            mat.m23 = float.Parse(tokens[11]);
            mat.m30 = float.Parse(tokens[12]);
            mat.m31 = float.Parse(tokens[13]);
            mat.m32 = float.Parse(tokens[14]);
            mat.m33 = float.Parse(tokens[15]);

            return mat;
        }
        set
        {
            _value = string.Join(" ", new string[] {
                value.m00.ToString(),
                value.m01.ToString(),
                value.m02.ToString(),
                value.m03.ToString(),
                value.m10.ToString(),
                value.m11.ToString(),
                value.m12.ToString(),
                value.m13.ToString(),
                value.m20.ToString(),
                value.m21.ToString(),
                value.m22.ToString(),
                value.m23.ToString(),
                value.m30.ToString(),
                value.m31.ToString(),
                value.m32.ToString(),
                value.m33.ToString()
            });
        }
    }

    public Color ColorValue
    {
        get
        {
            string[] tokens = _value.Split();

            if (tokens.Length < 4)
                return new Color(float.Parse(tokens[0]), float.Parse(tokens[1]),
                                    float.Parse(tokens[2]));
            else return new Color(float.Parse(tokens[0]), float.Parse(tokens[1]),
                                    float.Parse(tokens[2]), float.Parse(tokens[3]));
        }
        set { _value = value.r + " " + value.g + " " + value.b + " " + value.a; }
    }
    
    public GameObject GameObjectValue
    {
        get { return Sync.GetObject(int.Parse(Value)); }
        set { _value = Sync.GetObjectIndex(value).ToString(); }
    }

    public UJeli[] Children
    {
        get { return GetChildren(); }
    }

    public string[] ChildNames
    {
        get { return (from child in _children select child.Name).ToArray(); }
    }

    public string[] ChildValues
    {
        get { return (from child in _children select child.Value).ToArray(); }
    }

    public UJeli Parent
    {
        get { return _parent; }
    }

    private static string[] newLines =
        new string[] { "\r\n", "\r", "\n", "\n\r" };

    string _name;
    string _value;
    UJeli _parent;
    List<UJeli> _children;

    public static UJeli Parse (string text)
    {
        UJeli node = new UJeli();
        int tabs = -1;

        foreach (string line in text.Split(newLines, StringSplitOptions.RemoveEmptyEntries))
        {
            if (line.TrimStart().StartsWith("//"))
                continue;

            int newTabs = CountTabs(line);

            if (newTabs > tabs)
            {
                node = node.AddChild();
            }
            else if (newTabs < tabs)
            {
                UJeli sibling = node;

                while (newTabs < tabs)
                {
                    sibling = sibling.Parent;
                    tabs--;
                }

                if (sibling.Parent != null)
                    node = sibling.Parent.AddChild();
                else return node;
            }
            else
            {
                if (node.Parent != null)
                    node = node.Parent.AddChild();
                else if (node._name != "")
                    return node;
            }

            tabs = newTabs;

            string rest = line.Substring(tabs);
            int space = rest.IndexOf("=");

            if (space != -1)
            {
                node._name = rest.Substring(0, space).Trim();
                node._value = rest.Substring(space + 1).Trim();
            }
            else node._name = rest;
        }

        while (node.Parent != null)
        {
            node = node.Parent;
        }

        return node;
    }

    public static UJeli Load (string fileName)
    {
        string fullFileName = fileName;

        if (File.Exists(fullFileName))
            return Parse(File.ReadAllText(fullFileName));
        else return null;
    }

    static string WriteNode (UJeli node, int tabs)
    {
        string text = "";

        for (int i = 0; i < tabs; i++)
        {
            text += "\t";
        }

        if (tabs != -1)
        {
            text += node._name;

            if (node._value != "")
                text += " = " + node._value;

            text += "\n";
        }

        foreach (UJeli c in node.GetChildren())
        {
            text += WriteNode(c, tabs + 1);
        }

        return text;
    }

    static int CountTabs (string text)
    {
        int numTabs = 0;

        while (numTabs < text.Length && text[numTabs] == '\t')
        {
            numTabs++;
        }

        return numTabs;
    }

    public UJeli () : this("") { }

    public UJeli (object name) : this(name, "") { }

    public UJeli (object name, object value)
    {
        _children = new List<UJeli>();

        if (name != null)
        {
            if (name is Vector2)
                Vector2Name = (Vector2)name;
            else if (name is Vector3)
                Vector3Name = (Vector3)name;
            else if (name is Quaternion)
                QuaternionName = (Quaternion)name;
            else if (name is Color)
                ColorName = (Color)name;
            else if (name is GameObject)
                IntName = Sync.GetObjectIndex((GameObject)name);
            else _name = name.ToString();
        }
        else _name = "";

        if (value != null)
        {
            if (value is Vector2)
                Vector2Value = (Vector2)value;
            else if (value is Vector3)
                Vector3Value = (Vector3)value;
            else if (value is Quaternion)
                QuaternionValue = (Quaternion)value;
            else if (value is Color)
                ColorValue = (Color)value;
            else if (value is GameObject)
                IntValue = Sync.GetObjectIndex((GameObject)value);
            else _value = value.ToString();
        }
        else _value = "";
    }

    public UJeli this[string name]
    {
        get { return GetChild(name, 0); }
    }

    public UJeli this[string name, int index]
    {
        get { return GetChild(name, index); }
    }

    public UJeli this[int index]
    {
        get { return GetChild(index); }
    }

    public UJeli Clone ()
    {
        UJeli clone = Parse(ToString());
        clone._name = _name;
        clone._value = _value;
        return clone;
    }

    public T GetEnumName<T> ()
    {
        return GetEnumName<T>(false);
    }

    public T GetEnumName<T> (bool ignoreCase)
    {
        return (T)Enum.Parse(typeof(T), _name, ignoreCase);
    }

    public T GetEnumValue<T> ()
    {
        return GetEnumValue<T>(false);
    }

    public T GetEnumValue<T> (bool ignoreCase)
    {
        return (T)Enum.Parse(typeof(T), _value, ignoreCase);
    }

    public T[] GetChildNames<T> (Func<string, T> convert)
    {
        return (from child in _children select convert(child.Name)).ToArray();
    }

    public T[] GetChildValues<T> (Func<string, T> convert)
    {
        return (from child in _children select convert(child.Value)).ToArray();
    }

    public Dictionary<string, string> GetChildDictionary ()
    {
        return GetChildDictionary<string, string>(x => x, x => x);
    }

    public Dictionary<string, T> GetChildDictionaryStringNames<T> (Func<string, T> convertValue)
    {
        return GetChildDictionary<string, T>(x => x, convertValue);
    }

    public Dictionary<T, string> GetChildDictionaryStringValues<T> (Func<string, T> convertName)
    {
        return GetChildDictionary<T, string>(convertName, x => x);
    }

    public Dictionary<T1, T2> GetChildDictionary<T1, T2> (
        Func<string, T1> convertName, Func<string, T2> convertValue)
    {
        Dictionary<T1, T2> dict = new Dictionary<T1, T2>();

        foreach (UJeli child in _children)
        {
            dict[convertName(child.Name)] = convertValue(child.Value);
        }

        return dict;
    }

    public void GenerateChildren<T> (IEnumerable<T> nameObjects)
    {
        GenerateChildren<T>(nameObjects, null);
    }

    public void GenerateChildren<T> (IEnumerable<T> nameObjects, Func<T, string> convert)
    {
        if (convert == null)
            convert = o => o.ToString();

        foreach (T nameObject in nameObjects)
        {
            AddChild(convert(nameObject));
        }
    }

    public void GenerateChildren<T1, T2> (IDictionary<T1, T2> childDict)
    {
        GenerateChildren<T1, T2>(childDict, null, null);
    }

    public void GenerateChildrenSimpleNames<T1, T2> (IDictionary<T1, T2> childDict,
        Func<T2, string> convertValue)
    {
        GenerateChildren<T1, T2>(childDict, null, convertValue);
    }

    public void GenerateChildrenSimpleValues<T1, T2> (IDictionary<T1, T2> childDict,
        Func<T1, string> convertName)
    {
        GenerateChildren<T1, T2>(childDict, convertName, null);
    }

    public void GenerateChildren<T1, T2> (IDictionary<T1, T2> childDict,
        Func<T1, string> convertName, Func<T2, string> convertValue)
    {
        if (convertName == null)
            convertName = o => o.ToString();

        if (convertValue == null)
            convertValue = o => o.ToString();

        foreach (var pair in childDict)
        {
            AddChild(convertName(pair.Key), convertValue(pair.Value));
        }
    }

    public UJeli AddChild ()
    {
        return AddChild(new UJeli());
    }

    public UJeli AddChild (string name)
    {
        return AddChild(new UJeli(name));
    }

    public UJeli AddChild (string name, object value)
    {
        return AddChild(new UJeli(name, value));
    }

    public UJeli AddChild (UJeli child)
    {
        _children.Add(child);
        child._parent = this;
        return child;
    }

    public bool HasChild (string name)
    {
        return GetChild(name) != null;
    }

    public UJeli GetChild (string name, int index)
    {
        int i = 0;

        foreach (UJeli c in _children)
        {
            if (c._name.Equals(name) && i++ == index)
                return c;
        }

        return null;
    }

    public UJeli GetChild (string name)
    {
        return GetChild(name, 0);
    }

    public UJeli GetChild (int index)
    {
        if (index < _children.Count)
            return _children[index];

        return null;
    }

    public UJeli[] GetChildren ()
    {
        return _children.ToArray();
    }

    public UJeli[] GetChildren (string name)
    {
        List<UJeli> matches = new List<UJeli>();

        foreach (UJeli c in _children)
        {
            if (c._name == name)
                matches.Add(c);
        }

        return matches.ToArray();
    }

    public int CountChildren ()
    {
        return _children.Count;
    }

    public int CountChildren (string name)
    {
        return GetChildren(name).Length;
    }

    public void RemoveChild (string name, int index)
    {
        RemoveChild(GetChild(name, index));
    }

    public void RemoveChild (string name)
    {
        RemoveChild(GetChild(name));
    }

    public void RemoveChild (int index)
    {
        RemoveChild(GetChild(index));
    }

    public void RemoveChild (UJeli child)
    {
        _children.Remove(child);
    }

    public void RemoveChildren (string name)
    {
        foreach (UJeli c in GetChildren(name))
        {
            RemoveChild(c);
        }
    }

    public void ClearChildren ()
    {
        _children.Clear();
    }

    public void Save (string fileName)
    {
        string folder = Directory.GetParent(fileName).FullName;

        if (!Directory.Exists(folder))
            Directory.CreateDirectory(folder);

        File.WriteAllText(fileName, ToString());
    }

    public override string ToString ()
    {
        return WriteNode(this, -1);
    }
}