pluginlocalprofile.c

Go to the documentation of this file.

class PluginLocalProfile extends PluginFileHandler
{
    ref map<string, string>                     m_ConfigParams;
    ref map<string, ref TStringArray>               m_ConfigParamsArray;
    ref map<string, ref map<string, string>>        m_ConfigParamsInArray;
    ref map<string, ref array<ref map<string, string>>> m_ConfigParamsArrayInArray;
    
    void PluginLocalProfile()
    {
        m_ConfigParams              = new map<string, string>;
        m_ConfigParamsArray         = new map<string, ref TStringArray>;
        m_ConfigParamsInArray       = new map<string, ref map<string, string>>;
        m_ConfigParamsArrayInArray  = new map<string, ref array<ref map<string, string>>>;
    }
 
    override string GetFileName()
    {
        return CFG_FILE_USER_PROFILE;
    }
 
    override void OnInit()
    {
        super.OnInit();
        
        LoadConfigFile();
    }
    
    bool LoadConfigFile()
    {
        TStringArray file_content = GetFileContent();
        
        string line_content = "";
        string param_name = "";
        string param_value = "";
        TStringArray param_content;
        int pos_sep = -1;
        
        for ( int i = 0; i < file_content.Count(); ++i )
        {
            line_content = file_content.Get(i);
            
            param_content = ParseTextToParameter(line_content);
        
            if ( param_content.Count() == 0 )
            {
                PrintString(GetFileName()+"("+i.ToString()+"): Error in config -> Maybe missing '=' !");
                return false;           
            }
            
            param_name  = param_content.Get(0);
            param_value = param_content.Get(1);
            
            //{{name = apple, damage = 0.5, quantity = 2},{name = banana, damage = 0.5, quantity = 2}}
            
            TStringArray array_items = new TStringArray;
            ParseTextToArray(param_value, array_items);
            //{name = apple, damage = 0.5, quantity = 2}
            //{name = banana, damage = 0.5, quantity = 2}
            
            TStringArray array_content_raw = new TStringArray;
            
            if ( array_items.Count() > 0 )
            {
                m_ConfigParamsArray.Set(param_name, array_items);
                
                for ( int j = 0; j < array_items.Count(); ++j )
                {
                    string array_content = array_items.Get(j);
                    //{name = apple, damage = 0.5, quantity = 2}
                    
                    array_content_raw.Clear();
                    
                    ParseTextToArray(array_content, array_content_raw);
                    //name = apple
                    //damage = 0.5
                    //quantity = 2
                    
                    if ( array_content_raw.Count() > 0 )
                    {
                        if ( !m_ConfigParamsArrayInArray.Contains(param_name) )
                        {
                            m_ConfigParamsArrayInArray.Set(param_name, new array<ref map<string, string>>);
                        }
                        
                        array<ref map<string, string>> params_in_array = m_ConfigParamsArrayInArray.Get(param_name);                    
                        map<string, string> parameters = new map<string, string>;
                        
                        for ( int k = 0; k < array_content_raw.Count(); ++k )
                        {
                            string params = array_content_raw.Get(k);
                            TStringArray p = ParseTextToParameter(params);
                            
                            if ( p.Count() == 2 )
                            {
                                parameters.Set(p.Get(0), p.Get(1));
                            }
                        }
                        
                        params_in_array.Insert(parameters);                 
                    }
                }
            }
            else
            {
                m_ConfigParams.Set(param_name, param_value);
            }
        }
        
        return true;
    }
 
    void SaveConfigToFile()
    {
        ClearFileNoSave();
        
        int i;
        int j;
        int k;
        
        string variable_name;
        string variable_value;
        string text;
        TStringArray variable_array;
        
        for ( i = 0; i < m_ConfigParams.Count(); ++i)
        {
            variable_name = m_ConfigParams.GetKey(i);
            variable_value = m_ConfigParams.GetElement(i);
            
            text = variable_name + " = " + variable_value;
            
            AddNewLineNoSave(text);
        }
        
        for ( i = 0; i < m_ConfigParamsArray.Count(); ++i)
        {
            variable_name = m_ConfigParamsArray.GetKey(i);
            variable_array = m_ConfigParamsArray.GetElement(i);
            
            if ( m_ConfigParamsArrayInArray.Contains(variable_name) )
            {
                continue;
            }
            
            text = variable_name + " = {";
            
            for ( j = 0; j < variable_array.Count(); ++j )
            {
                if ( j > 0 )
                {
                    text += ",";
                }
                
                text += variable_array.Get(j);          
            }
            
            text += "}";
            
            AddNewLineNoSave(text);
        }
        
        for ( i = 0; i < m_ConfigParamsArrayInArray.Count(); ++i)
        {
            variable_name                               = m_ConfigParamsArrayInArray.GetKey(i);
            array<ref map<string, string>>  variable_param  = m_ConfigParamsArrayInArray.GetElement(i);
            
            text = variable_name + " = {";
            
            if ( variable_param != NULL )
            {
                for ( j = 0; j < variable_param.Count(); ++j )
                {
                    if ( j > 0 )
                    {
                        text += ",";
                    }           
                    text += "{";
                    
                    map<string, string> params = variable_param.Get(j);
                    for ( k = 0; k < params.Count(); ++k )
                    {
                        if ( k > 0 )
                        {
                            text += ",";
                        }
                        
                        string param_name = params.GetKey(k);
                        string param_value = params.GetElement(k);
                        
                        text += param_name+"="+param_value;
                    }
                    
                    text += "}";
                }
            }
            
            text += "}";
            
            AddNewLineNoSave(text);
        }
        
        SaveFile();
    }
    
    bool IsTextArray(string text)
    {
        if ( text.Length() > 0 && text.Substring(0, 1) == "{" )
        {
            if ( text.Substring(text.Length() - 1, 1) == "}" )
            {
                return true;
            }
        }
        
        return false;
    }
    
    TStringArray ParseTextToParameter(string text)
    {
        TStringArray ret = new TStringArray;
        
        int pos = text.IndexOf("=");
            
        if ( pos > 0 )
        {
            string param_name = text.Substring(0, pos).Trim();
            int pos_end = text.Length() - pos;
            string param_value = text.Substring(pos + 1, pos_end - 1).Trim();
            
            int lenght = param_value.Length();
            if (lenght > 1 && param_value.Substring(0, 1) == "\"" && param_value.Substring(lenght - 1, 1) == "\"" )
            {
                param_value = param_value.Substring(1, lenght - 2);
            }
            
            ret.Insert(param_name);
            ret.Insert(param_value);
        }
        
        return ret;
    }
 
    TStringArray ParseTextToArray(string text, out TStringArray ret)
    {
        if ( !IsTextArray(text) )
        {
            return NULL;
        }
        
        text = text.Substring(1, text.Length() - 2);
        
        int pos_array_start = text.IndexOf("{");
        int pos_array_end = text.IndexOf("}");
        
        if ( pos_array_start > -1 && pos_array_end > -1 )
        {       
            while ( true )
            {
                string array_value = text.Substring(pos_array_start , pos_array_end - pos_array_start + 1  );
                ret.Insert(array_value);
                
                pos_array_start = text.IndexOfFrom(pos_array_end, "{");
                pos_array_end = text.IndexOfFrom(pos_array_start, "}");
                
                if ( pos_array_start == -1 )
                {
                    break;
                }
            }
        }
        else
        {
            text.Split(",", ret);
        }
        
        return ret;
    }
 
    array<ref map<string, string>> ParseTextArrayToParameters(string text)
    {
        TStringArray array_items = new TStringArray;
        ParseTextToArray(text, array_items);
        
        array<ref map<string, string>> ret = new array<ref map<string, string>>;
        
        map<string, string> ret_param = new map<string, string>;
        
        for ( int i = 0; i < array_items.Count(); ++i )
        {
            string param = array_items.Get(i);
            TStringArray t_param = ParseTextToParameter(param);
            
            string param_name = t_param.Get(0);
            string param_value = t_param.Get(1);
            
            ret_param.Set(param_name, param_value);
        }
        
        ret.Insert(ret_param);  
        
        return ret;
    }
    
    string LoadParameter(string param_name)
    {
        string ret_value = STRING_EMPTY;
        
        if ( m_ConfigParams.Contains(param_name) )
        {
            ret_value = m_ConfigParams.Get(param_name);
        }
 
        return ret_value;
    }
 
    TStringArray LoadParameterArray(string param_name)
    {
        if ( m_ConfigParamsArray.Contains(param_name) )
        {
            return m_ConfigParamsArray.Get(param_name);
        }
 
        return NULL;
    }
 
    string LoadSubParameter(string param_name, int sub_array_index, string sub_param_name)
    {
        string                      ret_value = STRING_EMPTY;
        map<string, string>         param;
        array<ref map<string, string>>  sub_arrays;
        
        if ( m_ConfigParamsArrayInArray.Contains(param_name) )
        {
            sub_arrays = m_ConfigParamsArrayInArray.Get(param_name);
            
            if ( sub_arrays != NULL )
            {
                if ( sub_array_index < sub_arrays.Count() )
                {
                    param = sub_arrays.Get(sub_array_index);
                    
                    if ( param.Contains(sub_param_name) )
                    {
                        ret_value = param.Get(sub_param_name);
                    }
                }       
            }
        }
        
        return ret_value;
    }
    
    void SaveParameter(string param_name, string value, bool save_in_file = true)
    {
        if ( param_name == "" || param_name == "scene_editor_scene" )
        {
            Log("SaveParameter: "+param_name+" = "+value, "");
        }
        
        m_ConfigParams.Set(param_name, value);
        
        if ( save_in_file )
        {
            SaveConfigToFile(); 
        }
    }
 
    void SaveParameterArray(string param_name, TStringArray value, bool save_in_file = true)
    {
        m_ConfigParamsArray.Set(param_name, value);
        
        if ( save_in_file )
        {
            SaveConfigToFile(); 
        }
    }
 
    void SaveSubParameterInArray(string param_name, int sub_array_index, string sub_param_name, string sub_param_value, bool save_in_file = true)
    {
        array<ref map<string, string>> sub_arrays = m_ConfigParamsArrayInArray.Get(param_name);
        map<string, string> sub_parameter = sub_arrays.Get(sub_array_index);
        sub_parameter.Set(sub_param_name, sub_param_value); 
        
        if ( save_in_file )
        {
            SaveConfigToFile(); 
        }
    }
    
    void RenameParameter(string old_name, string new_name, bool save_in_file = true)
    {
        if ( m_ConfigParams.Contains(old_name) )
        {
            m_ConfigParams.ReplaceKey(old_name, new_name);
            
            if ( save_in_file )
            {
                SaveConfigToFile(); 
            }
        }
    }
 
    void RenameParameterArray(string old_name, string new_name, bool save_in_file = true)
    {
        if ( m_ConfigParamsArray.Contains(old_name) )
        {
            m_ConfigParamsArray.ReplaceKey(old_name, new_name);
            
            if ( save_in_file )
            {
                SaveConfigToFile(); 
            }
        }
    }
 
    void RemoveParameter(string name, bool save_in_file = true)
    {
        m_ConfigParams.Remove(name);
        
        if ( save_in_file )
        {
            SaveConfigToFile(); 
        }
    }
 
    void RemoveParameterArray(string name, bool save_in_file = true)
    {
        m_ConfigParamsArray.Remove(name);
        
        if ( save_in_file )
        {
            SaveConfigToFile(); 
        }
    }
    
    void SetParameterString(string name, string value, bool save_in_file = true)
    {
        string s = "\""+value+"\"";
        SaveParameter(name, s, save_in_file);
    }
 
    void SetParameterInt(string name, int value, bool save_in_file = true)
    {
        SaveParameter(name, value.ToString(), save_in_file);
    }
 
    void SetParameterFloat(string name, float value, bool save_in_file = true)
    {
        SaveParameter(name, value.ToString(), save_in_file);
    }
 
    void SetParameterBool(string name, bool value, bool save_in_file = true)
    {
        SaveParameter(name, value.ToString(), save_in_file);
    }
 
    void SetParameterArray(string name, TStringArray value, bool save_in_file = true)
    {
        SaveParameterArray(name, value, save_in_file);
    }
 
    void SetSubParameterInArray(string param_name, int sub_array_index, string sub_param_name, string sub_param_value, bool save_in_file = true)
    {
        SaveSubParameterInArray(param_name, sub_array_index, sub_param_name, sub_param_value, save_in_file);
    }
    
    string GetParameterString(string name)
    {
        string loaded_param = LoadParameter(name);
        string ret_value = STRING_EMPTY;
        
        if ( loaded_param != "" )
        {
            TStringArray arr = new TStringArray;
            loaded_param.Split("\"", arr);
            if ( arr.Count() > 0 )
            {
                ret_value = arr.Get(0); 
            }
        }
        else
        {
            SetParameterString(name, ret_value);
        }
        
        return ret_value;
    }
 
    int GetParameterInt(string name)
    {
        string loaded_param = LoadParameter(name);
        int ret_value = 0;
        
        if ( loaded_param != "" )
        {
            ret_value = loaded_param.ToInt();
        }
        else
        {
            SetParameterInt(name, ret_value);
        }
        
        return ret_value;   
    }
 
    float GetParameterFloat(string name)
    {
        string loaded_param = LoadParameter(name);
        float ret_value = 0;
        
        if ( loaded_param != "" )
        {
            ret_value = loaded_param.ToFloat();
        }
        else
        {
            SetParameterFloat(name, ret_value);
        }
        
        return ret_value;
    }
 
    bool GetParameterBool(string name)
    {
        string loaded_param = LoadParameter(name);
        bool ret_value = false;
        
        if ( loaded_param != "" )
        {
            int v = loaded_param.ToInt();
            if ( v == 1 )
            {
                ret_value = true;
            }
        }
        else
        {
            SetParameterBool(name, ret_value);
        }
        
        return ret_value;
    }
 
    TStringArray GetParameterArray(string name)
    {
        TStringArray ret_value;
        
        if ( m_ConfigParamsArray.Contains(name) )
        {
            ret_value = m_ConfigParamsArray.Get(name);
        }
        else
        {
            ret_value = new TStringArray;
            SetParameterArray(name, ret_value);
        }
        
        return ret_value;
    }
 
    string GetSubParameterInArrayString(string param_name, int sub_array_index, string sub_param_name)
    {
        string loaded_param = LoadSubParameter(param_name, sub_array_index, sub_param_name);
        string ret_value = STRING_EMPTY;
        
        TStringArray arr = new TStringArray;
        
        if ( loaded_param != "" )
        {
            arr.Clear();
            loaded_param.Split("\"", arr);
            ret_value = arr.Get(1);         
        }
        
        return ret_value;
    }
 
    TStringArray GetAllSubParametersInArrayString(string param_name, string sub_param_name)
    {
        TStringArray ret_value = NULL;
        
        if ( m_ConfigParamsArrayInArray.Contains(param_name) )
        {
            ret_value = new TStringArray;
            
            array<ref map<string, string>> arrays_in_parameter = m_ConfigParamsArrayInArray.Get(param_name);
            
            for ( int i = 0; i < arrays_in_parameter.Count(); ++i )
            {           
                map<string, string> sub_parameter = arrays_in_parameter.Get(i);
                
                string sub_param = STRING_EMPTY;
                
                if ( sub_parameter.Contains(sub_param_name) )
                {
                    sub_param = sub_parameter.Get(sub_param_name);
                }
                
                ret_value.Insert(sub_param);
            }
        }
        
        return ret_value;
    }
}