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;
 }
}