pluginconfighandler.c

Go to the documentation of this file.

class PluginConfigHandler extends PluginFileHandler
{ 
 ref array<ref CfgParam> m_CfgParams;
 
 void PluginConfigHandler()
 {
 m_CfgParams = new array<ref CfgParam>;
 
 LoadConfigFile();
 }
 
 override void OnInit()
 {
 super.OnInit();
 }
 
 override string GetFileName()
 {
 return CFG_FILE_USER_PROFILE;
 }
 
 void LoadConfigFile()
 {
 LoadFile();
 
 m_CfgParams.Clear();
 
 for ( int j = 0; j < m_FileContent.Count(); j++ )
 {
 m_CfgParams.Insert( ParseText(m_FileContent.Get(j)) );
 } 
 }
 
 void SaveConfigToFile()
 {
 ClearFileNoSave();
 
 for ( int i = 0; i < m_CfgParams.Count(); ++i )
 {
 string s = ParseParam(m_CfgParams.Get(i));
 
 m_FileContent.Insert(s);
 }
 
 SaveFile();
 }
 
 CfgParam GetParamByName(string name, int cfg_type)
 {
 CfgParam param;
 
 for ( int i = 0; i < m_CfgParams.Count(); ++i )
 {
 param = m_CfgParams.Get(i);
 
 if ( param.GetName() == name )
 {
 return param;
 }
 }
 
 // cfg_type == -1 returns NULL
 param = CfgParam.CreateParam(name, cfg_type);
 m_CfgParams.Insert(param);
 return param;
 }
 
 array<ref CfgParam> GetAllParams()
 {
 return m_CfgParams;
 }
 
 void ClearParams()
 {
 m_CfgParams.Clear();
 }
 
 void RemoveParamByName( string name )
 {
 for ( int i = 0; i < m_CfgParams.Count(); ++i )
 {
 CfgParam param = m_CfgParams.Get(i);
 
 if ( param.GetName() == name )
 {
 m_CfgParams.Remove( i );
 return;
 }
 }
 }
 
 void RenameParam( string name, string new_name )
 {
 for ( int i = 0; i < m_CfgParams.Count(); ++i )
 {
 CfgParam param = m_CfgParams.Get(i);
 
 if ( param.GetName() == name )
 {
 param.SetName( new_name );
 return;
 }
 }
 }
 
 bool ParamExist(string name)
 {
 CfgParam param;
 
 for ( int i = 0; i < m_CfgParams.Count(); ++i )
 {
 param = m_CfgParams.Get(i);
 
 if ( param.GetName() == name )
 {
 return true;
 }
 }
 
 return false;
 }
 
 string ParseParam(CfgParam param)
 {
 string text = STRING_EMPTY;
 
 if ( param.GetName() != STRING_EMPTY )
 {
 text += param.GetName()+"=";
 }
 
 switch ( param.GetType() )
 {
 case CFG_TYPE_ARRAY:
 {
 CfgParamArray param_array = CfgParamArray.Cast( param );
 array<ref CfgParam> params = param_array.GetValues();
 
 text += "{";
 
 for ( int i = 0; i < params.Count(); ++i )
 {
 if ( i > 0 )
 {
 text += ",";
 }
 
 text += ParseParam(params.Get(i));
 }
 
 text += "}";
 
 break;
 }
 case CFG_TYPE_STRING:
 {
 CfgParamString param_string = CfgParamString.Cast( param );
 text += "\""+param_string.GetValue()+"\"";
 
 break;
 }
 case CFG_TYPE_INT:
 {
 CfgParamInt param_int = CfgParamInt.Cast( param );
 text += param_int.GetValue().ToString();
 
 break;
 }
 case CFG_TYPE_FLOAT:
 {
 CfgParamFloat param_float = CfgParamFloat.Cast( param );
 string s = param_float.GetValue().ToString();
 
 if ( s.IndexOf(".") == -1 )
 {
 s += ".0";
 }
 
 text += s;
 
 break;
 }
 case CFG_TYPE_BOOL:
 {
 CfgParamBool param_bool = CfgParamBool.Cast( param );
 
 if ( param_bool.GetValue() )
 {
 text += "true";
 }
 else
 {
 text += "false";
 }
 
 break;
 }
 }
 
 return text;
 }
 
 CfgParam ParseText(string text)
 {
 string param_name = STRING_EMPTY;
 string param_value = text.Trim();;
 int text_type = GetTextType(param_value);
 
 //Log("ParseText -> text_type: "+itoa(text_type));
 
 if ( text_type == CFG_TYPE_PARAM )
 {
 int pos = param_value.IndexOf("=");
 
 if ( pos > 0 )
 {
 param_name = param_value.Substring(0, pos).Trim();
 int pos_end = param_value.Length() - pos;
 param_value = param_value.Substring(pos + 1, pos_end - 1).Trim();
 
 //Log("ParseText -> param -> "+param_name+" = "+param_value);
 
 CfgParam param = ParseText(param_value);
 param.SetName(param_name);
 
 return param;
 }
 }
 else if ( text_type == CFG_TYPE_ARRAY )
 { 
 //Log("ParseText -> array -> "+param_name+" = "+param_value);
 
 CfgParamArray param_array = new CfgParamArray(param_name);
 array<ref CfgParam> array_params = ParseToValueArray(param_value);
 param_array.SetParams(array_params);
 
 return param_array;
 }
 else if ( text_type == CFG_TYPE_STRING )
 { 
 //Log("ParseText -> string -> "+param_value);
 
 CfgParamString param_string = new CfgParamString(param_name);
 param_string.SetValue( ParseToValueString(param_value) );
 
 return param_string;
 }
 else if ( text_type == CFG_TYPE_INT )
 { 
 //Log("ParseText -> int -> "+param_name+" = "+param_value);
 
 CfgParamInt param_int = new CfgParamInt(param_name);
 param_int.SetValue( ParseToValueInt(param_value) );
 
 return param_int;
 }
 else if ( text_type == CFG_TYPE_FLOAT )
 {
 //Log("ParseText -> float -> "+param_name+" = "+param_value);
 
 CfgParamFloat param_float = new CfgParamFloat(param_name);
 param_float.SetValue( ParseToValueFloat(param_value) );
 
 return param_float;
 }
 else if ( text_type == CFG_TYPE_BOOL )
 {
 //Log("ParseText -> bool -> "+param_name+" = "+param_value);
 
 CfgParamBool param_bool = new CfgParamBool(param_name);
 param_bool.SetValue( ParseToValueBool(param_value) );
 
 return param_bool;
 }
 
 //Log("ParseText -> none -> "+param_name+" = "+param_value);
 
 return NULL;
 }
 
 protected int GetTextType(string text)
 { 
 int lenght = text.Length();
 
 // Check Array
 int pos1 = text.IndexOf("{");
 if ( pos1 == 0 && text.Substring(lenght - 1, 1) == "}" )
 {
 return CFG_TYPE_ARRAY;
 } 
 
 // Check String
 pos1 = text.IndexOf("\"");
 
 if ( pos1 == 0 && text.Substring(lenght - 1, 1) == "\"" )
 {
 string string_text = text.Substring(1, lenght - 2);
 if ( string_text.IndexOf("\"") == -1 )
 {
 return CFG_TYPE_STRING;
 }
 }
 
 // Check Param
 pos1 = text.IndexOf("=");
 if ( pos1 > -1 )
 {
 return CFG_TYPE_PARAM;
 }
 
 // Check Param True
 pos1 = text.IndexOf("true");
 if ( lenght == 4 && pos1 > -1 )
 {
 return CFG_TYPE_BOOL;
 }
 
 // Check Param False
 pos1 = text.IndexOf("false");
 if ( lenght == 5 && pos1 > -1 )
 {
 return CFG_TYPE_BOOL;
 }
 
 // Check Param Float
 pos1 = text.IndexOf(".");
 if ( pos1 > -1 )
 {
 return CFG_TYPE_FLOAT;
 }
 
 // Is Int
 return CFG_TYPE_INT;
 }
 
 protected bool IsString(string text)
 {
 if ( GetTextType(text) == CFG_TYPE_STRING )
 {
 return true;
 }
 
 return false;
 }
 
 protected bool IsParam(string text)
 {
 if ( GetTextType(text) == CFG_TYPE_PARAM )
 {
 return true;
 }
 
 return false;
 }
 
 protected bool IsArray(string text)
 {
 if ( GetTextType(text) == CFG_TYPE_ARRAY )
 {
 return true;
 }
 
 return false;
 }
 
 protected bool IsFloat(string text)
 {
 if ( GetTextType(text) == CFG_TYPE_FLOAT )
 {
 return true;
 }
 
 return false;
 }
 
 protected bool IsInt(string text)
 {
 if ( GetTextType(text) == CFG_TYPE_INT )
 {
 return true;
 }
 
 return false;
 }
 
 protected bool IsBool(string text)
 {
 if ( GetTextType(text) == CFG_TYPE_BOOL )
 {
 return true;
 }
 
 return false;
 }
 
 protected string ParseToValueString(string param_value)
 { 
 return param_value.Substring(1, param_value.Length() - 2);
 }
 
 protected float ParseToValueFloat(string param_value)
 {
 return param_value.ToFloat();
 }
 
 protected int ParseToValueInt(string param_value)
 {
 return param_value.ToInt();
 }
 
 protected bool ParseToValueBool(string param_value)
 {
 if ( param_value.Contains("true") )
 {
 return true;
 }
 
 return false;
 }
 
 protected array<ref CfgParam> ParseToValueArray(string param_value)
 {
 array<ref CfgParam> param_parent = new array<ref CfgParam>;
 
 TStringArray strings = new TStringArray;
 
 array<int> a = new array<int>;
 array<int> b = new array<int>;
 
 int pos_a = 0;
 int pos_b = 0;
 int element = 0;
 int value_start = 0;
 int value_end = 0;
 
 while ( pos_a > -1 || pos_b > -1 )
 {
 pos_a = param_value.IndexOfFrom(pos_a, "{" );
 if ( pos_a > -1 )
 {
 a.Insert(pos_a);
 pos_a++;
 }
 
 pos_b = param_value.IndexOfFrom(pos_b, "}" );
 if ( pos_b > -1 )
 {
 b.Insert(pos_b);
 pos_b++;
 }
 } 
 
 pos_a = 0;
 pos_b = 0;
 
 for ( pos_a = 0; pos_a < a.Count(); ++pos_a )
 {
 if ( a.Get(pos_a) > b.Get(pos_b) )
 {
 element--;
 
 if ( element <= 1 )
 {
 value_end = b.Get(pos_b) - value_start + 1;
 
 //Log("1 -> "+substr(param_value, value_start, value_end))
 
 strings.Insert( param_value.Substring(value_start, value_end) );
 
 value_start = b.Get(pos_b) + 1;
 }
 
 pos_a--;
 pos_b++;
 }
 else if ( a.Get(pos_a) < b.Get(pos_b) )
 {
 if ( pos_a == a.Count() - 1 && pos_b < b.Count() - 1 )
 {
 element--;
 
 if ( element == 0 )
 {
 value_end = b.Get(pos_b) - value_start;
 
 //Log("2 -> "+substr(param_value, value_start + 1, value_end))
 
 strings.Insert( param_value.Substring(value_start + 1, value_end) );
 
 value_start = b.Get(pos_b) + 1;
 }
 
 pos_a--;
 pos_b++;
 }
 else
 {
 element++;
 
 if ( element == 2 )
 {
 value_start = a.Get(pos_a);
 }
 } 
 }
 }
 
 //Log(param_value+" => "+itoa(a.Count())+" / "+itoa(b.Count())+" count: "+itoa(strings.Count()));
 
 if ( strings.Count() == 0 )
 {
 //Log(param_value+" -> ZERO {}");
 
 string param_value_content = param_value.Substring(1, param_value.Length() - 2);
 
 //Log(param_value+" -> Trimmed -> "+param_value_content);
 
 param_value_content.Split(",", strings);
 }
 
 for ( int i = 0; i < strings.Count(); ++i )
 {
 string str = strings.Get(i);
 
 //Log("To Parse => "+str);
 
 CfgParam param = ParseText(str);
 
 param_parent.Insert(param); 
 }
 
 return param_parent;
 }
}