public static List <List <float> > GetFloatTwoDList(string key, string field, List <List <float> > defaultVal = null)
        {
            List <List <float> > retVal = defaultVal;

            try
            {
                Dictionary <string, object> dict;
                if (ModifiedData.TryGetValue(key, out dict) && dict.ContainsKey(field))
                {
                    object temp;
                    if (dict.TryGetValue(field, out temp))
                    {
                        retVal = temp as List <List <float> >;
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.LogException(ex);
            }

            return(retVal);
        }
        public static string GetString(string key, string field, string defaultVal)
        {
            string retVal = defaultVal;

            try
            {
                Dictionary <string, object> dict;
                if (ModifiedData.TryGetValue(key, out dict) && dict.ContainsKey(field))
                {
                    object temp;
                    if (dict.TryGetValue(field, out temp))
                    {
                        retVal = temp.ToString();
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.LogException(ex);
            }

            return(retVal);
        }
        public static float GetFloat(string key, string field, float defaultVal)
        {
            float retVal = defaultVal;

            try
            {
                Dictionary <string, object> dict;
                if (ModifiedData.TryGetValue(key, out dict) && dict.ContainsKey(field))
                {
                    object temp;
                    if (dict.TryGetValue(field, out temp))
                    {
                        retVal = Convert.ToSingle(temp);
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.LogException(ex);
            }

            return(retVal);
        }
        public static List <List <Vector4> > GetVector4TwoDList(string key, string field, List <List <Vector4> > defaultVal = null)
        {
            List <List <Vector4> > retVal = defaultVal;

            try
            {
                Dictionary <string, object> dict;
                if (ModifiedData.TryGetValue(key, out dict) && dict.ContainsKey(field))
                {
                    object temp;
                    if (dict.TryGetValue(field, out temp))
                    {
                        retVal = (temp as List <List <GDEV4> >).ConvertAll(x => x.ConvertAll(y => (Vector4)y));
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.LogException(ex);
            }

            return(retVal);
        }
        public static void RegisterItem(string schema, string key)
        {
            Dictionary <string, object> dict;

            if (!ModifiedData.TryGetValue(key, out dict))
            {
                dict = new Dictionary <string, object>();
                dict.TryAddOrUpdateValue(GDMConstants.SchemaKey, schema);
                ModifiedData.TryAddOrUpdateValue(key, dict);

                HashSet <string> keys;
                if (dataKeysBySchema.TryGetValue(schema, out keys))
                {
                    keys.Add(key);
                }
                else
                {
                    keys = new HashSet <string>();
                    keys.Add(key);
                    dataKeysBySchema.Add(schema, keys);
                }
            }
        }
        public static Vector4 GetVector4(string key, string field, Vector4 defaultVal)
        {
            Vector4 retVal = defaultVal;

            try
            {
                Dictionary <string, object> dict;
                if (ModifiedData.TryGetValue(key, out dict) && dict.ContainsKey(field))
                {
                    object temp;
                    if (dict.TryGetValue(field, out temp))
                    {
                        retVal = (GDEV4)temp;
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.LogException(ex);
            }

            return(retVal);
        }
        public static List <Color> GetColorList(string key, string field, List <Color> defaultVal = null)
        {
            List <Color> retVal = defaultVal;

            try
            {
                Dictionary <string, object> dict;
                if (ModifiedData.TryGetValue(key, out dict) && dict.ContainsKey(field))
                {
                    object temp;
                    if (dict.TryGetValue(field, out temp))
                    {
                        retVal = (temp as List <GDEColor>).ConvertAll(x => (Color)x);
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.LogException(ex);
            }

            return(retVal);
        }
        public static bool GetBool(string key, string field, bool defaultVal)
        {
            bool retVal = defaultVal;

            try
            {
                Dictionary <string, object> dict;
                if (ModifiedData.TryGetValue(key, out dict) && dict.ContainsKey(field))
                {
                    object temp;
                    if (dict.TryGetValue(field, out temp))
                    {
                        retVal = Convert.ToBoolean(temp);
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.LogException(ex);
            }

            return(retVal);
        }
        public static List <Vector4> GetVector4List(string key, string field, List <Vector4> defaultVal = null)
        {
            List <Vector4> retVal = defaultVal;

            try
            {
                Dictionary <string, object> dict;
                if (ModifiedData.TryGetValue(key, out dict) && dict.ContainsKey(field))
                {
                    object temp;
                    if (dict.TryGetValue(field, out temp) && temp != null && temp.GetType().IsAssignableFrom(typeof(List <GDEV4>)))
                    {
                        retVal = (temp as List <GDEV4>).ConvertAll(x => (Vector4)x);
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.LogException(ex);
            }

            return(retVal);
        }
        public static Vector3 GetVector3(string key, string field, Vector3 defaultVal)
        {
            Vector3 retVal = defaultVal;

            try
            {
                Dictionary <string, object> dict;
                if (ModifiedData.TryGetValue(key, out dict) && dict.ContainsKey(field))
                {
                    object temp;
                    if (dict.TryGetValue(field, out temp) && temp.GetType().IsAssignableFrom(typeof(GDEV3)))
                    {
                        retVal = (GDEV3)temp;
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.LogException(ex);
            }

            return(retVal);
        }