using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using UnityEngine;
using Thousandto.Core.Base;

namespace Thousandto.Core.Base
{
    public class DataTable {

        public enum DataType {
            Nil,
            UserData,
            Bool,
            Integer,
            Int64,
            Double,
            String,
            Table,
        }

        public class Value {

            [StructLayout( LayoutKind.Explicit )]
            struct __Value {
                [FieldOffset( 0 )]
                internal DataType type;

                [FieldOffset( 4 )]
                internal bool bVal;

                [FieldOffset( 4 )]
                internal int iVal;

                [FieldOffset( 4 )]
                internal long iVal64;

                [FieldOffset( 4 )]
                internal double dVal;
            };
            __Value _val;

            System.Object obj; // pointer 8 bytes on 64bit OS

            public DataType valueType {
                get {
                    return _val.type;
                }
            }
            public Value() {
                _val.type = DataType.Nil;
            }
            public Value( bool value ) {
                _val.type = DataType.Bool;
                _val.bVal = value;
            }
            public Value( int value ) {
                _val.type = DataType.Integer;
                _val.iVal = value;
            }
            public Value( long value ) {
                _val.type = DataType.Int64;
                _val.iVal64 = value;
            }
            public Value( double value ) {
                _val.type = DataType.Double;
                _val.dVal = value;
            }
            public Value( String value ) {
                _val.type = DataType.String;
                obj = value ?? String.Empty;
            }
            public Value( DataTable value ) {
                _val.type = DataType.Table;
                obj = value;
            }
            public bool ToBoolean() {
                if ( _val.type == DataType.Bool ) {
                    return _val.bVal;
                } else if ( _val.type == DataType.Double ) {
                    return _val.dVal != 0 ? true : false;
                } else if ( _val.type == DataType.Integer ) {
                    return _val.iVal != 0 ? true : false;
                } else if ( _val.type == DataType.Int64 ) {
                    return _val.iVal64 != 0 ? true : false;
                } else if ( _val.type == DataType.String ) {
                    bool ret;
                    if ( bool.TryParse( obj as String, out ret ) ) {
                        return ret;
                    } else {
                        return false;
                    }
                } else {
                    return false;
                }
            }
            public long ToInt64() {
                if ( _val.type == DataType.Integer ) {
                    return (long)_val.iVal;
                } else if ( _val.type == DataType.Double ) {
                    return (long)_val.dVal;
                } else if ( _val.type == DataType.Int64 ) {
                    return (long)_val.iVal64;
                } else if ( _val.type == DataType.Bool ) {
                    return _val.bVal ? 1L : 0L;
                } else if ( _val.type == DataType.String ) {
                    long ret;
                    if ( long.TryParse( obj as String, out ret ) ) {
                        return ret;
                    } else {
                        return 0L;
                    }
                } else {
                    return 0L;
                }
            }
            public int ToInteger() {
                if ( _val.type == DataType.Integer ) {
                    return _val.iVal;
                } else if ( _val.type == DataType.Double ) {
                    return (int)_val.dVal;
                } else if ( _val.type == DataType.Int64 ) {
                    return (int)_val.iVal64;
                } else if ( _val.type == DataType.Bool ) {
                    return _val.bVal ? 1 : 0;
                } else if ( _val.type == DataType.String ) {
                    int ret;
                    if ( int.TryParse( obj as String, out ret ) ) {
                        return ret;
                    } else {
                        return 0;
                    }
                } else {
                    return 0;
                }
            }
            public double ToNumber() {
                if ( _val.type == DataType.Double ) {
                    return _val.dVal;
                } else if ( _val.type == DataType.Integer ) {
                    return _val.iVal;
                } else if ( _val.type == DataType.Int64 ) {
                    return _val.iVal64;
                } else if ( _val.type == DataType.Bool ) {
                    return _val.bVal ? 1 : 0;
                } else if ( _val.type == DataType.String ) {
                    double ret;
                    if ( double.TryParse( obj as String, out ret ) ) {
                        return ret;
                    } else {
                        return 0;
                    }
                } else {
                    return 0;
                }
            }
            public new String ToString() {
                if ( _val.type == DataType.String ) {
                    return obj as String;
                } else if ( _val.type == DataType.Integer ) {
                    return _val.iVal.ToString();
                } else if ( _val.type == DataType.Int64 ) {
                    return _val.iVal64.ToString();
                } else if ( _val.type == DataType.Double ) {
                    return _val.dVal.ToString();
                } else if ( _val.type == DataType.Bool ) {
                    return _val.bVal.ToString();
                } else if ( _val.type == DataType.UserData ) {
                    return obj.ToString();
                } else if ( _val.type == DataType.Table ) {
                    var table = obj as DataTable;
                    return table != null ? table.ToString( 0 ) : "null";
                } else {
                    return "null";
                }
            }
            public DataTable ToTable() {
                if ( _val.type == DataType.Table ) {
                    return obj as DataTable;
                } else {
                    return null;
                }
            }
            public System.Object ToUserData() {
                if ( _val.type == DataType.UserData ) {
                    return obj;
                } else {
                    return null;
                }
            }

            public void SetUserData( System.Object val ) {
                _val.type = DataType.UserData;
                obj = val;
            }

            public void Set( bool val ) {
                if ( _val.type != DataType.Bool ) {
                    _val.type = DataType.Bool;
                    obj = null;
                }
                _val.bVal = val;
            }
            public void Set( int val ) {
                if ( _val.type != DataType.Integer ) {
                    _val.type = DataType.Integer;
                    obj = null;
                }
                _val.iVal = val;
            }
            public void Set( long val ) {
                if ( _val.type != DataType.Int64 ) {
                    _val.type = DataType.Int64;
                    obj = null;
                }
                _val.iVal64 = val;
            }
            public void Set( double val ) {
                if ( _val.type != DataType.Double ) {
                    _val.type = DataType.Double;
                    obj = null;
                }
                _val.dVal = val;
            }
            public void Set( float val ) {
                if ( _val.type != DataType.Double ) {
                    _val.type = DataType.Double;
                    obj = null;
                }
                _val.dVal = val;
            }
            public void Set( String val ) {
                _val.type = DataType.String;
                obj = val;
            }
            public void Set( DataTable val ) {
                _val.type = DataType.Table;
                obj = val;
            }
            public void Get( out bool val ) {
                val = ToBoolean();
            }
            public void Get( out int val ) {
                val = ToInteger();
            }
            public void Get( out long val ) {
                val = ToInt64();
            }
            public void Get( out double val ) {
                val = ToNumber();
            }
            public void Get( out float val ) {
                val = (float)ToNumber();
            }
            public void Get( out String val ) {
                val = ToString();
            }
            public void Get( out DataTable val ) {
                val = ToTable();
            }
        }

        internal static class ReaderInit {
            static ReaderInit() {
                Reader<Boolean>._invoke = s => s.ToBoolean();
                Reader<Char>._invoke = s => (Char)s.ToInteger();
                Reader<Byte>._invoke = s => (Byte)s.ToInteger();
                Reader<SByte>._invoke = s => (SByte)s.ToInteger();
                Reader<Int16>._invoke = s => (Int16)s.ToInteger();
                Reader<UInt16>._invoke = s => (UInt16)s.ToInteger();
                Reader<Int32>._invoke = s => s.ToInteger();
                Reader<UInt32>._invoke = s => (UInt32)s.ToInteger();
                Reader<Int64>._invoke = s => s.ToInt64();
                Reader<UInt64>._invoke = s => (UInt64)s.ToInt64();
                Reader<String>._invoke = s => s.ToString();
                Reader<Single>._invoke = s => (Single)s.ToNumber();
                Reader<Double>._invoke = s => s.ToNumber();
                Reader<DataTable>._invoke = s => s.ToTable();
                Reader<System.Object>._invoke = s => s.ToUserData();
            }
            public static void DoInit() {
            }
        }

        internal static class WriterInit {
            static WriterInit() {
                Writer<Boolean>._invoke = ( s, v ) => s.Set( v );
                Writer<Char>._invoke = ( s, v ) => s.Set( (int)v );
                Writer<Byte>._invoke = ( s, v ) => s.Set( (int)v );
                Writer<SByte>._invoke = ( s, v ) => s.Set( (int)v );
                Writer<Int16>._invoke = ( s, v ) => s.Set( (int)v );
                Writer<UInt16>._invoke = ( s, v ) => s.Set( (int)v );
                Writer<Int32>._invoke = ( s, v ) => s.Set( v );
                Writer<UInt32>._invoke = ( s, v ) => s.Set( (int)v );
                Writer<Int64>._invoke = ( s, v ) => s.Set( v );
                Writer<UInt64>._invoke = ( s, v ) => s.Set( (long)v );
                Writer<String>._invoke = ( s, v ) => s.Set( v );
                Writer<Single>._invoke = ( s, v ) => s.Set( (Double)v );
                Writer<Double>._invoke = ( s, v ) => s.Set( v );
                Writer<DataTable>._invoke = ( s, v ) => s.Set( v );
                Writer<System.Object>._invoke = ( s, v ) => s.SetUserData( v );
            }
            public static void DoInit() {
            }
        }

        public class Reader<T> {
            internal static MyFunc<Value, T> _invoke = null;
            internal static MyFunc<Value, T> _default = val => (T)val.ToUserData();
            public static MyFunc<Value, T> invoke
            {
                get {
                    return _invoke ?? _default;
                }
            }
            static Reader() {
                ReaderInit.DoInit();
            }
        }

        public class Writer<T> {
            internal static MyAction<Value, T> _invoke = null;
            internal static MyAction<Value, T> _default = (val, value) => val.SetUserData(value);
            public static MyAction<Value, T> invoke
            {
                get {
                    return _invoke ?? _default;
                }
            }
            static Writer() {
                WriterInit.DoInit();
            }
        }

        #region members
        Dictionary<String, Value> m_table = null;
        List<Value> m_array = null;
        #endregion

        void _CheckTable() {
            if ( m_table == null ) {
                m_table = new Dictionary<String, Value>();
            }
        }

        void _CheckArray() {
            if ( m_array == null ) {
                m_array = new List<Value>();
            }
        }

        public Value GetValue( String name ) {
            if ( m_table == null ) {
                return null;
            }
            Value val = null;
            if ( m_table.TryGetValue( name, out val ) ) {
                return val;
            }
            return null;
        }

        public Value GetValue( int index ) {
            if ( m_array != null && m_array.Count > index && index >= 0 ) {
                Value value = m_array[index];
                if ( value != null && value.valueType != DataType.Nil ) {
                    return value;
                }
            }
            return null;
        }

        #region getters
        public int GetInteger( String name ) {
            var val = GetValue( name );
            if ( val != null ) {
                return val.ToInteger();
            } else {
                return 0;
            }
        }

        public int GetInteger( int index ) {
            var val = GetValue( index );
            if ( val != null ) {
                return val.ToInteger();
            } else {
                return 0;
            }
        }

        public double GetNumber( String name ) {
            var val = GetValue( name );
            if ( val != null ) {
                return val.ToNumber();
            } else {
                return 0;
            }
        }

        public double GetNumber( int index ) {
            var val = GetValue( index );
            if ( val != null ) {
                return val.ToNumber();
            } else {
                return 0;
            }
        }

        public bool GetBoolean( String name ) {
            var val = GetValue( name );
            if ( val != null ) {
                return val.ToBoolean();
            } else {
                return false;
            }
        }

        public bool GetBoolean( int index ) {
            var val = GetValue( index );
            if ( val != null ) {
                return val.ToBoolean();
            } else {
                return false;
            }
        }

        public String GetString( String name ) {
            var val = GetValue( name );
            if ( val != null ) {
                return val.ToString();
            } else {
                return String.Empty;
            }
        }

        public String GetString( int index ) {
            var val = GetValue( index );
            if ( val != null ) {
                return val.ToString();
            } else {
                return String.Empty;
            }
        }

        public System.Object GetUserData( String name ) {
            var val = GetValue( name );
            if ( val != null ) {
                return val.ToUserData();
            } else {
                return null;
            }
        }

        public System.Object GetUserData( int index ) {
            var val = GetValue( index );
            if ( val != null ) {
                return val.ToUserData();
            } else {
                return null;
            }
        }

        public DataTable GetTable( String name ) {
            var val = GetValue( name );
            if ( val != null ) {
                return val.ToTable();
            } else {
                return null;
            }
        }

        public DataTable GetTable( int index ) {
            var val = GetValue( index );
            if ( val != null ) {
                return val.ToTable();
            } else {
                return null;
            }
        }
        #endregion

        public bool TryGet<T>( String name, out T value ) {
            var val = GetValue( name );
            if ( val != null ) {
                value = Reader<T>.invoke( val );
                return true;
            } else {
                value = default( T );
                return false;
            }
        }

        public bool TryGet<T>( int index, out T value ) {
            var val = GetValue( index );
            if ( val != null ) {
                value = Reader<T>.invoke( val );
                if ( value != null ) {
                    return true;
                } else {
                    return false;
                }
            } else {
                value = default( T );
                return false;
            }
        }

        public T Get<T>( String name ) {
            var val = GetValue( name );
            if ( val != null ) {
                return Reader<T>.invoke( val );
            } else {
                return default( T );
            }
        }

        public T Get<T>( int index ) {
            var val = GetValue( index );
            if ( val != null ) {
                return Reader<T>.invoke( val );
            } else {
                return default( T );
            }
        }

        public void Set<T>( String name, T value ) {
            _CheckTable();
            Value val = null;
            if ( m_table.TryGetValue( name, out val ) ) {
                Writer<T>.invoke( val, value );
            } else {
                val = new Value();
                Writer<T>.invoke( val, value );
                m_table.Add( name, val );
            }
        }

        public void SetArrayCapacity( int size ) {
            _CheckArray();
            if ( m_array.Capacity < size ) {
                m_array.Capacity = size;
            } else {
                m_array.TrimExcess();
            }
        }

        public bool Set<T>( int index, T value ) {
            if ( index < 0 ) {
                return false;
            }
            _CheckArray();
            int lack = index - m_array.Count + 1;
            for ( int i = 0; i < lack; ++i ) {
                m_array.Add( null );
            }
            var	val = m_array[index];
            if ( val == null ) {
                m_array[index] = val = new Value();
            }
            Writer<T>.invoke( val, value );
            return true;
        }

        public bool Contains( String name, DataType type = DataType.Nil ) {
            var val = GetValue( name );
            if ( val != null ) {
                return val.valueType == type && type != DataType.Nil ||
                    type == DataType.Nil && val.valueType != DataType.Nil;
            }
            return false;
        }

        public bool Contains( int index, DataType type = DataType.Nil ) {
            var val = GetValue( index );
            if ( val != null ) {
                return val.valueType == type && type != DataType.Nil ||
                    type == DataType.Nil && val.valueType != DataType.Nil;
            }
            return false;
        }

        public bool Add<T>( String name, T value ) {
            _CheckTable();
            if ( m_table.ContainsKey( name ) ) {
                return false;
            }
            var val = new Value();
            Writer<T>.invoke( val, value );
            m_table.Add( name, val );
            return true;
        }

        public List<String> GetTableKeys() {
            if ( m_table == null ) {
                return null;
            }
            return new List<string>(m_table.Keys); 
        }

        public void ClearArray() {
            if ( m_array != null ) {
                m_array.Clear();
            }
        }

        public void ClearTable() {
            if ( m_table != null ) {
                m_table.Clear();
            }
        }

        public void Clear() {
            if ( m_array != null ) {
                m_array.Clear();
                m_array.TrimExcess();
            }
            if ( m_table != null ) {
                m_table.Clear();
            }
        }

        public int GetArrayCount() {
            return m_array != null ? m_array.Count : 0;
        }
        public int GetTableCount() {
            return m_table != null ? m_table.Count : 0;
        }

        public bool Add<T>( int index, T value ) {
            return Set<T>( index, value );
        }

        public bool Remove( String name ) {
            return m_table != null && m_table.Remove( name );
        }

        public bool Remove( int index ) {
            if ( m_array != null &&
                m_array.Count > index ) {
                m_array[index] = new Value();
                return true;
            }
            return false;
        }

        internal String ToString( int level ) {
            StringBuilder _sb = new StringBuilder();
            if ( m_table != null ) {
                foreach ( var entry in m_table ) {
                    var name = entry.Key;
                    var val = entry.Value;
                    if ( level > 0 ) {
                        _sb.Append( '\t', level );
                    }
                    if ( val.valueType != DataType.Table ) {
                        _sb.Append( String.Format( "{0} = {1}\n", name, val.ToString() ) );
                    } else {
                        DataTable table = val.ToTable();
                        _sb.Append( String.Format( "{0}:\n", name ) );
                        _sb.Append( String.Format( "{0}\n", table.ToString( level + 1 ) ) );
                    }
                }
            }
            if ( m_array != null && m_array.Count > 0 ) {
                _sb.Append( '\n' );
                for ( int i = 0; i < m_array.Count; ++i ) {
                    var val = m_array[i];
                    if ( level > 0 ) {
                        _sb.Append( '\t', level );
                    }
                    if ( val.valueType != DataType.Nil ) {
                        if ( val.valueType != DataType.Table ) {
                            _sb.Append( String.Format( "[{0}] = {1}\n", i, val.ToString() ) );
                        } else {
                            DataTable table = val.ToTable();
                            _sb.Append( String.Format( "[{0}]:\n", i ) );
                            _sb.Append( String.Format( "{0}\n", table.ToString( level + 1 ) ) );
                        }
                    }
                }
            }
            return _sb.ToString();
        }

        public new String ToString() {
            return ToString( 0 );
        }
    }

    public class DataTableEx {

        public enum DataType {
            Nil,
            UserData,
            Bool,
            Integer,
            Double,
            String,
            Table,
            Vector2,
            Vector3,
            Vector4,
            Quaternion,
            Color4f,
            Color32,
        }

        public class Value {
            [StructLayout( LayoutKind.Explicit )]
            internal struct __Value {
                [FieldOffset( 0 )]
                internal DataType type;

                [FieldOffset( 4 )]
                internal bool bVal;

                [FieldOffset( 4 )]
                internal int iVal;

                [FieldOffset( 4 )]
                internal long iVal64;

                [FieldOffset( 4 )]
                internal double dVal;

                [FieldOffset( 4 )]
                internal Vector2 vec2;

                [FieldOffset( 4 )]
                internal Vector3 vec3;

                [FieldOffset( 4 )]
                internal Vector4 vec4;

                [FieldOffset( 4 )]
                internal Quaternion quat;

                [FieldOffset( 4 )]
                internal Color color4f;

                [FieldOffset( 4 )]
                internal Color32 color32;
            };
            internal __Value _val;

            System.Object obj; // pointer 8 bytes on 64bit OS

            public DataType valueType {
                get {
                    return _val.type;
                }
            }
            public Value() {
                _val.type = DataType.Nil;
            }
            public Value( bool value ) {
                _val.type = DataType.Bool;
                _val.bVal = value;
            }
            public Value( int value ) {
                _val.type = DataType.Integer;
                _val.iVal = value;
            }
            public Value( double value ) {
                _val.type = DataType.Double;
                _val.dVal = value;
            }
            public Value( String value ) {
                _val.type = DataType.String;
                obj = value ?? String.Empty;
            }
            public Value( DataTableEx value ) {
                _val.type = DataType.Table;
                obj = value;
            }
            public Value( Vector2 value ) {
                _val.type = DataType.Vector2;
                _val.vec2 = value;
            }
            public Value( Vector3 value ) {
                _val.type = DataType.Vector3;
                _val.vec3 = value;
            }
            public Value( Vector4 value ) {
                _val.type = DataType.Vector4;
                _val.vec4 = value;
            }
            public Value( Quaternion value ) {
                _val.type = DataType.Quaternion;
                _val.quat = value;
            }
            public Value( Color value ) {
                _val.type = DataType.Color4f;
                _val.color4f = value;
            }
            public Value( Color32 value ) {
                _val.type = DataType.Color32;
                _val.color32 = value;
            }
            public bool ToBoolean() {
                if ( _val.type == DataType.Bool ) {
                    return _val.bVal;
                } else if ( _val.type == DataType.Double ) {
                    return _val.dVal != 0 ? true : false;
                } else if ( _val.type == DataType.Integer ) {
                    return _val.iVal != 0 ? true : false;
                } else if ( _val.type == DataType.String ) {
                    bool ret;
                    if ( bool.TryParse( obj as String, out ret ) ) {
                        return ret;
                    } else {
                        return false;
                    }
                } else {
                    return false;
                }
            }
            public int ToInteger() {
                if ( _val.type == DataType.Integer ) {
                    return _val.iVal;
                } else if ( _val.type == DataType.Double ) {
                    return (int)_val.dVal;
                } else if ( _val.type == DataType.Bool ) {
                    return _val.bVal ? 1 : 0;
                } else if ( _val.type == DataType.String ) {
                    int ret;
                    if ( int.TryParse( obj as String, out ret ) ) {
                        return ret;
                    } else {
                        return 0;
                    }
                } else {
                    return 0;
                }
            }
            public double ToNumber() {
                if ( _val.type == DataType.Double ) {
                    return _val.dVal;
                } else if ( _val.type == DataType.Integer ) {
                    return _val.iVal;
                } else if ( _val.type == DataType.Bool ) {
                    return _val.bVal ? 1 : 0;
                } else if ( _val.type == DataType.String ) {
                    double ret;
                    if ( double.TryParse( obj as String, out ret ) ) {
                        return ret;
                    } else {
                        return 0;
                    }
                } else {
                    return 0;
                }
            }
            public new String ToString() {
                if ( _val.type == DataType.String ) {
                    return obj as String;
                } else if ( _val.type == DataType.Integer ) {
                    return _val.iVal.ToString();
                } else if ( _val.type == DataType.Double ) {
                    return _val.dVal.ToString();
                } else if ( _val.type == DataType.Bool ) {
                    return _val.bVal.ToString();
                } else {
                    return String.Empty;
                }
            }
            public DataTableEx ToTable() {
                if ( _val.type == DataType.Table ) {
                    return obj as DataTableEx;
                } else {
                    return null;
                }
            }
            public System.Object ToUserData() {
                if ( _val.type == DataType.UserData ) {
                    return obj;
                } else {
                    return null;
                }
            }

            public void SetUserData( System.Object val ) {
                _val.type = DataType.UserData;
                obj = val;
            }

            public void Set( bool val ) {
                if ( _val.type != DataType.Bool ) {
                    _val.type = DataType.Bool;
                    obj = null;
                }
                _val.bVal = val;
            }
            public void Set( int val ) {
                if ( _val.type != DataType.Integer ) {
                    _val.type = DataType.Integer;
                    obj = null;
                }
                _val.iVal = val;
            }
            public void Set( double val ) {
                if ( _val.type != DataType.Double ) {
                    _val.type = DataType.Double;
                    obj = null;
                }
                _val.dVal = val;
            }
            public void Set( float val ) {
                if ( _val.type != DataType.Double ) {
                    _val.type = DataType.Double;
                    obj = null;
                }
                _val.dVal = val;
            }
            public void Set( String val ) {
                _val.type = DataType.String;
                obj = val;
            }
            public void Set( DataTableEx val ) {
                _val.type = DataType.Table;
                obj = val;
            }
            public void Set( Vector2 val ) {
                _val.type = DataType.Vector2;
                _val.vec2 = val;
            }
            public void Set( Vector3 val ) {
                _val.type = DataType.Vector3;
                _val.vec3 = val;
            }
            public void Set( Vector4 val ) {
                _val.type = DataType.Vector4;
                _val.vec4 = val;
            }
            public void Set( Quaternion val ) {
                _val.type = DataType.Quaternion;
                _val.quat = val;
            }
            public void Set( Color val ) {
                _val.type = DataType.Color4f;
                _val.color4f = val;
            }
            public void Set( Color32 val ) {
                _val.type = DataType.Color32;
                _val.color32 = val;
            }
            public void Get( out bool val ) {
                val = ToBoolean();
            }
            public void Get( out int val ) {
                val = ToInteger();
            }
            public void Get( out double val ) {
                val = ToNumber();
            }
            public void Get( out float val ) {
                val = (float)ToNumber();
            }
            public void Get( out String val ) {
                val = ToString();
            }
            public void Get( out DataTableEx val ) {
                val = ToTable();
            }
            public void Get( out Vector2 val ) {
                if ( _val.type == DataType.Vector2 ) {
                    val = _val.vec2;
                } else {
                    val = Vector2.zero;
                }
            }
            public void Get( out Vector3 val ) {
                if ( _val.type == DataType.Vector3 ) {
                    val = _val.vec3;
                } else {
                    val = Vector3.zero;
                }
            }
            public void Get( out Vector4 val ) {
                if ( _val.type == DataType.Vector4 ) {
                    val = _val.vec4;
                } else {
                    val = Vector4.zero;
                }
            }
            public void Get( out Quaternion val ) {
                if ( _val.type == DataType.Quaternion ) {
                    val = _val.quat;
                } else {
                    val = Quaternion.identity;
                }
            }
            public void Get( out Color val ) {
                if ( _val.type == DataType.Color4f ) {
                    val = _val.color4f;
                } else {
                    val = default( Color );
                }
            }
            public void Get( out Color32 val ) {
                if ( _val.type == DataType.Color32 ) {
                    val = _val.color32;
                } else {
                    val = default( Color32 );
                }
            }
        }

        internal static class ReaderInit {
            static ReaderInit() {
                Reader<Boolean>._invoke = s => s.ToBoolean();
                Reader<Char>._invoke = s => (Char)s.ToInteger();
                Reader<Byte>._invoke = s => (Byte)s.ToInteger();
                Reader<SByte>._invoke = s => (SByte)s.ToInteger();
                Reader<Int16>._invoke = s => (Int16)s.ToInteger();
                Reader<UInt16>._invoke = s => (UInt16)s.ToInteger();
                Reader<Int32>._invoke = s => s.ToInteger();
                Reader<UInt32>._invoke = s => (UInt32)s.ToInteger();
                Reader<String>._invoke = s => s.ToString();
                Reader<Single>._invoke = s => (Single)s.ToNumber();
                Reader<Double>._invoke = s => s.ToNumber();
                Reader<DataTableEx>._invoke = s => s.ToTable();
                Reader<System.Object>._invoke = s => s.ToUserData();
                Reader<Vector2>._invoke = s => {
                    if ( s.valueType == DataType.Vector2 ) {
                        return s._val.vec2;
                    } else {
                        return Vector2.zero;
                    }
                };
                Reader<Vector3>._invoke = s => {
                    if ( s.valueType == DataType.Vector3 ) {
                        return s._val.vec3;
                    } else {
                        return Vector3.zero;
                    }
                };
                Reader<Vector4>._invoke = s => {
                    if ( s.valueType == DataType.Vector4 ) {
                        return s._val.vec4;
                    } else {
                        return Vector4.zero;
                    }
                };
                Reader<Quaternion>._invoke = s => {
                    if ( s.valueType == DataType.Quaternion ) {
                        return s._val.quat;
                    } else {
                        return Quaternion.identity;
                    }
                };
                Reader<Color>._invoke = s => {
                    if ( s.valueType == DataType.Color4f ) {
                        return s._val.color4f;
                    } else {
                        return default( Color );
                    }
                };
                Reader<Color32>._invoke = s => {
                    if ( s.valueType == DataType.Color32 ) {
                        return s._val.color32;
                    } else {
                        return default( Color32 );
                    }
                };
            }
            public static void DoInit() {
            }
        }

        internal static class WriterInit {
            static WriterInit() {
                Writer<Boolean>._invoke = ( s, v ) => s.Set( v );
                Writer<Char>._invoke = ( s, v ) => s.Set( (int)v );
                Writer<Byte>._invoke = ( s, v ) => s.Set( (int)v );
                Writer<SByte>._invoke = ( s, v ) => s.Set( (int)v );
                Writer<Int16>._invoke = ( s, v ) => s.Set( (int)v );
                Writer<UInt16>._invoke = ( s, v ) => s.Set( (int)v );
                Writer<Int32>._invoke = ( s, v ) => s.Set( v );
                Writer<UInt32>._invoke = ( s, v ) => s.Set( (int)v );
                Writer<String>._invoke = ( s, v ) => s.Set( v );
                Writer<Single>._invoke = ( s, v ) => s.Set( (Double)v );
                Writer<Double>._invoke = ( s, v ) => s.Set( v );
                Writer<DataTableEx>._invoke = ( s, v ) => s.Set( v );
                Writer<System.Object>._invoke = ( s, v ) => s.SetUserData( v );
                Writer<Vector2>._invoke = ( s, v ) => s.Set( v );
                Writer<Vector3>._invoke = ( s, v ) => s.Set( v );
                Writer<Vector4>._invoke = ( s, v ) => s.Set( v );
                Writer<Quaternion>._invoke = ( s, v ) => s.Set( v );
                Writer<Color>._invoke = ( s, v ) => s.Set( v );
                Writer<Color32>._invoke = ( s, v ) => s.Set( v );
            }
            public static void DoInit() {
            }
        }

        internal class Reader<T> {
            internal static MyFunc<Value, T> _invoke = null;
            internal static MyFunc<Value, T> _default = val => (T)val.ToUserData();
            public static MyFunc<Value, T> invoke
            {
                get {
                    return _invoke ?? _default;
                }
            }
            static Reader() {
                ReaderInit.DoInit();
            }
        }

        internal class Writer<T> {
            internal static MyAction<Value, T> _invoke = null;
            internal static MyAction<Value, T> _default = (val, value) => val.SetUserData(value);
            public static MyAction<Value, T> invoke
            {
                get {
                    return _invoke ?? _default;
                }
            }
            static Writer() {
                WriterInit.DoInit();
            }
        }

        #region members
        Dictionary<String, Value> m_table = new Dictionary<String, Value>();
        List<Value> m_array = new List<Value>();
        #endregion

        void _CheckTable() {
            if ( m_table == null ) {
                m_table = new Dictionary<String, Value>();
            }
        }

        void _CheckArray() {
            if ( m_array == null ) {
                m_array = new List<Value>();
            }
        }

        public Value GetValue( String name ) {
            Value val = null;
            if ( m_table.TryGetValue( name, out val ) ) {
                return val;
            }
            return null;
        }

        public Value GetValue( int index ) {
            if ( m_array.Count > index && index >= 0 ) {
                return m_array[index];
            }
            return null;
        }

        #region getters
        public int GetInteger( String name ) {
            var val = GetValue( name );
            if ( val != null ) {
                return val.ToInteger();
            } else {
                return 0;
            }
        }

        public int GetInteger( int index ) {
            var val = GetValue( index );
            if ( val != null ) {
                return val.ToInteger();
            } else {
                return 0;
            }
        }

        public double GetNumber( String name ) {
            var val = GetValue( name );
            if ( val != null ) {
                return val.ToNumber();
            } else {
                return 0;
            }
        }

        public double GetNumber( int index ) {
            var val = GetValue( index );
            if ( val != null ) {
                return val.ToNumber();
            } else {
                return 0;
            }
        }

        public bool GetBoolean( String name ) {
            var val = GetValue( name );
            if ( val != null ) {
                return val.ToBoolean();
            } else {
                return false;
            }
        }

        public bool GetBoolean( int index ) {
            var val = GetValue( index );
            if ( val != null ) {
                return val.ToBoolean();
            } else {
                return false;
            }
        }

        public String GetString( String name ) {
            var val = GetValue( name );
            if ( val != null ) {
                return val.ToString();
            } else {
                return String.Empty;
            }
        }

        public String GetString( int index ) {
            var val = GetValue( index );
            if ( val != null ) {
                return val.ToString();
            } else {
                return String.Empty;
            }
        }

        public System.Object GetUserData( String name ) {
            var val = GetValue( name );
            if ( val != null ) {
                return val.ToUserData();
            } else {
                return null;
            }
        }

        public System.Object GetUserData( int index ) {
            var val = GetValue( index );
            if ( val != null ) {
                return val.ToUserData();
            } else {
                return null;
            }
        }

        public DataTableEx GetTable( String name ) {
            var val = GetValue( name );
            if ( val != null ) {
                return val.ToTable();
            } else {
                return null;
            }
        }

        public DataTableEx GetTable( int index ) {
            var val = GetValue( index );
            if ( val != null ) {
                return val.ToTable();
            } else {
                return null;
            }
        }
        #endregion

        public bool TryGet<T>( String name, out T value ) {
            var val = GetValue( name );
            if ( val != null ) {
                value = Reader<T>.invoke( val );
                return true;
            } else {
                value = default( T );
                return false;
            }
        }

        public T Get<T>( String name ) {
            var val = GetValue( name );
            if ( val != null ) {
                return Reader<T>.invoke( val );
            } else {
                return default( T );
            }
        }

        public T Get<T>( int index ) {
            var val = GetValue( index );
            if ( val != null ) {
                return Reader<T>.invoke( val );
            } else {
                return default( T );
            }
        }

        public void Set<T>( String name, T value ) {
            _CheckTable();
            Value val = null;
            if ( m_table.TryGetValue( name, out val ) ) {
                Writer<T>.invoke( val, value );
            } else {
                val = new Value();
                Writer<T>.invoke( val, value );
                m_table.Add( name, val );
            }
        }

        public bool Set<T>( int index, T value ) {
            if ( index < 0 ) {
                return false;
            }
            int lack = index - m_array.Count + 1;
            for ( int i = 0; i < lack; ++i ) {
                m_array.Add( null );
            }
            var	val = m_array[index];
            if ( val == null ) {
                m_array[index] = val = new Value();
            }
            Writer<T>.invoke( val, value );
            return true;
        }

        public bool Contains( String name, DataType type = DataType.Nil ) {
            var val = GetValue( name );
            if ( val != null ) {
                return val.valueType == type && type != DataType.Nil ||
                    type == DataType.Nil && val.valueType != DataType.Nil;
            }
            return false;
        }

        public bool Contains( int index, DataType type = DataType.Nil ) {
            var val = GetValue( index );
            if ( val != null ) {
                return val.valueType == type && type != DataType.Nil ||
                    type == DataType.Nil && val.valueType != DataType.Nil;
            }
            return false;
        }

        public bool Add<T>( String name, T value ) {
            if ( m_table.ContainsKey( name ) ) {
                return false;
            }
            var val = new Value();
            Writer<T>.invoke( val, value );
            m_table.Add( name, val );
            return true;
        }

        public List<string> GetTableKeys() {
            if ( m_table == null || m_table.Keys == null )
                return null;

            return new List<string>( m_table.Keys);;
        }

        public void ClearArray() {
            m_array.Clear();
        }

        public void ClearTable() {
            m_table.Clear();
        }

        public void Clear() {
            m_array.Clear();
            m_table.Clear();
        }

        public int GetArrayCount() {
            return m_array.Count;
        }

        public int GetTableCount() {
            return m_table.Count;
        }

        public bool Add<T>( int index, T value ) {
            return Set<T>( index, value );
        }

        public bool Remove( String name ) {
            return m_table.Remove( name );
        }

        public bool Remove( int index ) {
            if ( m_array != null &&
                m_array.Count > index ) {
                m_array[index] = new Value();
                return true;
            }
            return false;
        }

        internal String ToString( int level ) {
            StringBuilder _sb = new StringBuilder();
            foreach ( var entry in m_table ) {
                var name = entry.Key;
                var val = entry.Value;
                if ( level > 0 ) {
                    _sb.Append( '\t', level );
                }
                if ( val.valueType != DataType.Table ) {
                    _sb.Append( String.Format( "{0} = {1}\n", name, val.ToString() ) );
                } else {
                    DataTableEx table = val.ToTable();
                    _sb.Append( String.Format( "{0}:\n", name ) );
                    _sb.Append( String.Format( "{0}\n", table.ToString( level + 1 ) ) );
                }
            }
            if ( m_array.Count > 0 ) {
                _sb.Append( '\n' );
                for ( int i = 0; i < m_array.Count; ++i ) {
                    var val = m_array[i];
                    if ( level > 0 ) {
                        _sb.Append( '\t', level );
                    }
                    if ( val.valueType != DataType.Nil ) {
                        if ( val.valueType != DataType.Table ) {
                            _sb.Append( String.Format( "[{0}] = {1}\n", i, val.ToString() ) );
                        } else {
                            DataTableEx table = val.ToTable();
                            _sb.Append( String.Format( "[{0}]:\n", i ) );
                            _sb.Append( String.Format( "{0}\n", table.ToString( level + 1 ) ) );
                        }
                    }
                }
            }
            return _sb.ToString();
        }

        public new String ToString() {
            return ToString( 0 );
        }
    }
}