PluginFileHandler Class Reference

Collaboration diagram for PluginFileHandler:

Protected Member Functions
int	GetTextType (string text)
bool	IsString (string text)
bool	IsParam (string text)
bool	IsArray (string text)
bool	IsFloat (string text)
bool	IsInt (string text)
bool	IsBool (string text)
string	ParseToValueString (string param_value)
float	ParseToValueFloat (string param_value)
int	ParseToValueInt (string param_value)
bool	ParseToValueBool (string param_value)
array< ref CfgParam >	ParseToValueArray (string param_value)

Private Member Functions
void	PluginConfigHandler ()
override void	OnInit ()
override string	GetFileName ()
void	LoadConfigFile ()
void	SaveConfigToFile ()
CfgParam	GetParamByName (string name, int cfg_type)
array< ref CfgParam >	GetAllParams ()
void	ClearParams ()
void	RemoveParamByName (string name)
void	RenameParam (string name, string new_name)
bool	ParamExist (string name)
string	ParseParam (CfgParam param)
CfgParam	ParseText (string text)
void	PluginLocalHistoryBase ()
void	~PluginLocalHistoryBase ()
override void	OnInit ()
override string	GetFileName ()
void	AddNewLine (string text)
TStringArray	GetAllLines ()
TStringArray	GetLastLine ()
void	PluginLocalProfile ()
override string	GetFileName ()
override void	OnInit ()
bool	LoadConfigFile ()
void	SaveConfigToFile ()
bool	IsTextArray (string text)
TStringArray	ParseTextToParameter (string text)
TStringArray	ParseTextToArray (string text, out TStringArray ret)
array< ref map< string, string > >	ParseTextArrayToParameters (string text)
string	LoadParameter (string param_name)
TStringArray	LoadParameterArray (string param_name)
string	LoadSubParameter (string param_name, int sub_array_index, string sub_param_name)
void	SaveParameter (string param_name, string value, bool save_in_file=true)
void	SaveParameterArray (string param_name, TStringArray value, bool save_in_file=true)
void	SaveSubParameterInArray (string param_name, int sub_array_index, string sub_param_name, string sub_param_value, bool save_in_file=true)
void	RenameParameter (string old_name, string new_name, bool save_in_file=true)
void	RenameParameterArray (string old_name, string new_name, bool save_in_file=true)
void	RemoveParameter (string name, bool save_in_file=true)
void	RemoveParameterArray (string name, bool save_in_file=true)
void	SetParameterString (string name, string value, bool save_in_file=true)
void	SetParameterInt (string name, int value, bool save_in_file=true)
void	SetParameterFloat (string name, float value, bool save_in_file=true)
void	SetParameterBool (string name, bool value, bool save_in_file=true)
void	SetParameterArray (string name, TStringArray value, bool save_in_file=true)
void	SetSubParameterInArray (string param_name, int sub_array_index, string sub_param_name, string sub_param_value, bool save_in_file=true)
string	GetParameterString (string name)
int	GetParameterInt (string name)
float	GetParameterFloat (string name)
bool	GetParameterBool (string name)
TStringArray	GetParameterArray (string name)
string	GetSubParameterInArrayString (string param_name, int sub_array_index, string sub_param_name)
TStringArray	GetAllSubParametersInArrayString (string param_name, string sub_param_name)

Private Attributes
ref array< ref CfgParam >	m_CfgParams
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

Detailed Description

Definition at line 1 of file PluginConfigHandler.c.

Constructor & Destructor Documentation

~PluginLocalHistoryBase()

void PluginFileHandler::~PluginLocalHistoryBase ( )

inlineprivate

Definition at line 8 of file PluginLocalHistoryBase.c.

  {
  }

Member Function Documentation

AddNewLine()

void PluginFileHandler::AddNewLine ( string text )

inlineprivate

Definition at line 23 of file PluginLocalHistoryBase.c.

  {
    // replace newline to \\n
    text.Replace("\n", "\\n");
    m_FileContent.Insert(text);
    SaveFile();
  }

ClearParams()

void PluginFileHandler::ClearParams ( )

inlineprivate

Definition at line 69 of file PluginConfigHandler.c.

  {
    m_CfgParams.Clear();
  }

GetAllLines()

TStringArray PluginFileHandler::GetAllLines ( )

inlineprivate

Definition at line 31 of file PluginLocalHistoryBase.c.

  {
    // replace \\n to new line
    TStringArray console_history = new TStringArray;
    for (int i = 0; i < m_FileContent.Count(); i++)
    {
      string history_record = m_FileContent.Get(i);
      history_record.Replace("\\n", "\n");
      console_history.Insert(history_record);
    }
    return console_history;
  }

GetAllParams()

array< ref CfgParam > PluginFileHandler::GetAllParams ( )

inlineprivate

Definition at line 64 of file PluginConfigHandler.c.

  {
    return m_CfgParams;
  }

GetAllSubParametersInArrayString()

TStringArray PluginFileHandler::GetAllSubParametersInArrayString ( string param_name, string sub_param_name )

inlineprivate

Definition at line 514 of file PluginLocalProfile.c.

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

References STRING_EMPTY.

GetFileName() [1/3]

override string PluginFileHandler::GetFileName ( )

inlineprivate

Definition at line 17 of file PluginConfigHandler.c.

  {
    return CFG_FILE_USER_PROFILE;
  }

References CFG_FILE_USER_PROFILE.

Referenced by PluginBase::LoadFile(), and PluginBase::SaveFile().

GetFileName() [2/3]

override string PluginFileHandler::GetFileName ( )

inlineprivate

Definition at line 17 of file PluginLocalHistoryBase.c.

  {
    Error("Cannot call GetFileName on Base class PluginLocalHistoryBase");
    return STRING_EMPTY;
  }

References Error(), and STRING_EMPTY.

GetFileName() [3/3]

override string PluginFileHandler::GetFileName ( )

inlineprivate

Definition at line 16 of file PluginLocalProfile.c.

  {
    return CFG_FILE_USER_PROFILE;
  }

References CFG_FILE_USER_PROFILE.

GetLastLine()

TStringArray PluginFileHandler::GetLastLine ( )

inlineprivate

Definition at line 44 of file PluginLocalHistoryBase.c.

  {
    int count = m_FileContent.Count();
    string ret = "";
 
    if (count > 0)
      ret = m_FileContent.Get(count - 1);
 
    return NULL;
  }

GetParamByName()

CfgParam PluginFileHandler::GetParamByName ( string name, int cfg_type )

inlineprivate

Definition at line 46 of file PluginConfigHandler.c.

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

References CfgParam::CreateParam(), and name.

GetParameterArray()

TStringArray PluginFileHandler::GetParameterArray ( string name )

inlineprivate

Definition at line 482 of file PluginLocalProfile.c.

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

References name.

GetParameterBool()

bool PluginFileHandler::GetParameterBool ( string name )

inlineprivate

Definition at line 465 of file PluginLocalProfile.c.

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

References name.

GetParameterFloat()

float PluginFileHandler::GetParameterFloat ( string name )

inlineprivate

Definition at line 452 of file PluginLocalProfile.c.

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

References name.

GetParameterInt()

int PluginFileHandler::GetParameterInt ( string name )

inlineprivate

Definition at line 439 of file PluginLocalProfile.c.

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

References name.

GetParameterString()

string PluginFileHandler::GetParameterString ( string name )

inlineprivate

Definition at line 421 of file PluginLocalProfile.c.

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

References name, and STRING_EMPTY.

GetSubParameterInArrayString()

string PluginFileHandler::GetSubParameterInArrayString ( string param_name, int sub_array_index, string sub_param_name )

inlineprivate

Definition at line 497 of file PluginLocalProfile.c.

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

References STRING_EMPTY.

GetTextType()

int PluginFileHandler::GetTextType ( string text )

inlineprotected

Definition at line 265 of file PluginConfigHandler.c.

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

References CFG_TYPE_ARRAY, CFG_TYPE_BOOL, CFG_TYPE_FLOAT, CFG_TYPE_INT, CFG_TYPE_PARAM, and CFG_TYPE_STRING.

IsArray()

bool PluginFileHandler::IsArray ( string text )

inlineprotected

Definition at line 324 of file PluginConfigHandler.c.

  {
    if (GetTextType(text) == CFG_TYPE_ARRAY)
      return true;
 
    return false;
  }

References CFG_TYPE_ARRAY.

IsBool()

bool PluginFileHandler::IsBool ( string text )

inlineprotected

Definition at line 348 of file PluginConfigHandler.c.

  {
    if (GetTextType(text) == CFG_TYPE_BOOL)
      return true;
 
    return false;
  }

References CFG_TYPE_BOOL.

IsFloat()

bool PluginFileHandler::IsFloat ( string text )

inlineprotected

Definition at line 332 of file PluginConfigHandler.c.

  {
    if (GetTextType(text) == CFG_TYPE_FLOAT)
      return true;
 
    return false;
  }

References CFG_TYPE_FLOAT.

IsInt()

bool PluginFileHandler::IsInt ( string text )

inlineprotected

Definition at line 340 of file PluginConfigHandler.c.

  {
    if (GetTextType(text) == CFG_TYPE_INT)
      return true;
 
    return false;
  }

References CFG_TYPE_INT.

IsParam()

bool PluginFileHandler::IsParam ( string text )

inlineprotected

Definition at line 316 of file PluginConfigHandler.c.

  {
    if (GetTextType(text) == CFG_TYPE_PARAM)
      return true;
 
    return false;
  }

References CFG_TYPE_PARAM.

IsString()

bool PluginFileHandler::IsString ( string text )

inlineprotected

Definition at line 308 of file PluginConfigHandler.c.

  {
    if (GetTextType(text) == CFG_TYPE_STRING)
      return true;
 
    return false;
  }

References CFG_TYPE_STRING.

IsTextArray()

bool PluginFileHandler::IsTextArray ( string text )

inlineprivate

Definition at line 191 of file PluginLocalProfile.c.

  {
    if (text.Length() > 0 && text.Substring(0, 1) == "{")
    {
      if (text.Substring(text.Length() - 1, 1) == "}")
        return true;
    }
 
    return false;
  }

LoadConfigFile() [1/2]

void PluginFileHandler::LoadConfigFile ( )

inlineprivate

Definition at line 22 of file PluginConfigHandler.c.

  {
    LoadFile();
 
    m_CfgParams.Clear();
 
    for (int j = 0; j < m_FileContent.Count(); j++)
      m_CfgParams.Insert(ParseText(m_FileContent.Get(j)));
  }

LoadConfigFile() [2/2]

bool PluginFileHandler::LoadConfigFile ( )

inlineprivate

Definition at line 28 of file PluginLocalProfile.c.

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

References PluginLocalProfile::GetFileName(), and PrintString().

LoadParameter()

string PluginFileHandler::LoadParameter ( string param_name )

inlineprivate

Definition at line 280 of file PluginLocalProfile.c.

  {
    string ret_value = STRING_EMPTY;
 
    if (m_ConfigParams.Contains(param_name))
      ret_value = m_ConfigParams.Get(param_name);
 
    return ret_value;
  }

References STRING_EMPTY.

LoadParameterArray()

TStringArray PluginFileHandler::LoadParameterArray ( string param_name )

inlineprivate

Definition at line 290 of file PluginLocalProfile.c.

  {
    if (m_ConfigParamsArray.Contains(param_name))
      return m_ConfigParamsArray.Get(param_name);
 
    return NULL;
  }

LoadSubParameter()

string PluginFileHandler::LoadSubParameter ( string param_name, int sub_array_index, string sub_param_name )

inlineprivate

Definition at line 298 of file PluginLocalProfile.c.

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

References STRING_EMPTY.

OnInit() [1/3]

override void PluginFileHandler::OnInit ( )

inlineprivate

Definition at line 12 of file PluginConfigHandler.c.

  {
    super.OnInit();
  }

OnInit() [2/3]

override void PluginFileHandler::OnInit ( )

inlineprivate

Definition at line 12 of file PluginLocalHistoryBase.c.

  {
    super.OnInit();
  }

OnInit() [3/3]

override void PluginFileHandler::OnInit ( )

inlineprivate

Definition at line 21 of file PluginLocalProfile.c.

  {
    super.OnInit();
 
    LoadConfigFile();
  }

ParamExist()

bool PluginFileHandler::ParamExist ( string name )

inlineprivate

Definition at line 102 of file PluginConfigHandler.c.

  {
    CfgParam param;
 
    for (int i = 0; i < m_CfgParams.Count(); ++i)
    {
      param = m_CfgParams.Get(i);
 
      if (param.GetName() == name)
        return true;
    }
 
    return false;
  }

References name.

ParseParam()

string PluginFileHandler::ParseParam ( CfgParam param )

inlineprivate

Definition at line 117 of file PluginConfigHandler.c.

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

References CFG_TYPE_ARRAY, CFG_TYPE_BOOL, CFG_TYPE_FLOAT, CFG_TYPE_INT, CFG_TYPE_STRING, and STRING_EMPTY.

ParseText()

CfgParam PluginFileHandler::ParseText ( string text )

inlineprivate

Definition at line 187 of file PluginConfigHandler.c.

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

References CFG_TYPE_ARRAY, CFG_TYPE_BOOL, CFG_TYPE_FLOAT, CFG_TYPE_INT, CFG_TYPE_PARAM, CFG_TYPE_STRING, and STRING_EMPTY.

ParseTextArrayToParameters()

array< ref map< string, string > > PluginFileHandler::ParseTextArrayToParameters ( string text )

inlineprivate

Definition at line 255 of file PluginLocalProfile.c.

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

ParseTextToArray()

TStringArray PluginFileHandler::ParseTextToArray ( string text, out TStringArray ret )

inlineprivate

Definition at line 225 of file PluginLocalProfile.c.

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

ParseTextToParameter()

TStringArray PluginFileHandler::ParseTextToParameter ( string text )

inlineprivate

Definition at line 202 of file PluginLocalProfile.c.

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

ParseToValueArray()

array< ref CfgParam > PluginFileHandler::ParseToValueArray ( string param_value )

inlineprotected

Definition at line 379 of file PluginConfigHandler.c.

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

ParseToValueBool()

bool PluginFileHandler::ParseToValueBool ( string param_value )

inlineprotected

Definition at line 371 of file PluginConfigHandler.c.

  {
    if (param_value.Contains("true"))
      return true;
 
    return false;
  }

ParseToValueFloat()

float PluginFileHandler::ParseToValueFloat ( string param_value )

inlineprotected

Definition at line 361 of file PluginConfigHandler.c.

  {
    return param_value.ToFloat();
  }

ParseToValueInt()

int PluginFileHandler::ParseToValueInt ( string param_value )

inlineprotected

Definition at line 366 of file PluginConfigHandler.c.

  {
    return param_value.ToInt();
  }

ParseToValueString()

string PluginFileHandler::ParseToValueString ( string param_value )

inlineprotected

Definition at line 356 of file PluginConfigHandler.c.

  {
    return param_value.Substring(1, param_value.Length() - 2);
  }

PluginConfigHandler()

void PluginFileHandler::PluginConfigHandler ( )

inlineprivate

Definition at line 5 of file PluginConfigHandler.c.

  {
    m_CfgParams = new array<ref CfgParam>;
 
    LoadConfigFile();
  }

PluginLocalHistoryBase()

void PluginFileHandler::PluginLocalHistoryBase ( )

inlineprivate

Definition at line 3 of file PluginLocalHistoryBase.c.

  {
    m_ReadOnly = false;
  }

PluginLocalProfile()

void PluginFileHandler::PluginLocalProfile ( )

inlineprivate

Definition at line 8 of file PluginLocalProfile.c.

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

RemoveParamByName()

void PluginFileHandler::RemoveParamByName ( string name )

inlineprivate

Definition at line 74 of file PluginConfigHandler.c.

  {
    for (int i = 0; i < m_CfgParams.Count(); ++i)
    {
      CfgParam param = m_CfgParams.Get(i);
 
      if (param.GetName() == name)
      {
        m_CfgParams.Remove(i);
        return;
      }
    }
  }

References name.

RemoveParameter()

void PluginFileHandler::RemoveParameter ( string name, bool save_in_file = true )

inlineprivate

Definition at line 374 of file PluginLocalProfile.c.

  {
    m_ConfigParams.Remove(name);
 
    if (save_in_file)
      SaveConfigToFile();
  }

References name.

RemoveParameterArray()

void PluginFileHandler::RemoveParameterArray ( string name, bool save_in_file = true )

inlineprivate

Definition at line 382 of file PluginLocalProfile.c.

  {
    m_ConfigParamsArray.Remove(name);
 
    if (save_in_file)
      SaveConfigToFile();
  }

References name.

RenameParam()

void PluginFileHandler::RenameParam ( string name, string new_name )

inlineprivate

Definition at line 88 of file PluginConfigHandler.c.

  {
    for (int i = 0; i < m_CfgParams.Count(); ++i)
    {
      CfgParam param = m_CfgParams.Get(i);
 
      if (param.GetName() == name)
      {
        param.SetName(new_name);
        return;
      }
    }
  }

References name.

RenameParameter()

void PluginFileHandler::RenameParameter ( string old_name, string new_name, bool save_in_file = true )

inlineprivate

Definition at line 352 of file PluginLocalProfile.c.

  {
    if (m_ConfigParams.Contains(old_name))
    {
      m_ConfigParams.ReplaceKey(old_name, new_name);
 
      if (save_in_file)
        SaveConfigToFile();
    }
  }

RenameParameterArray()

void PluginFileHandler::RenameParameterArray ( string old_name, string new_name, bool save_in_file = true )

inlineprivate

Definition at line 363 of file PluginLocalProfile.c.

  {
    if (m_ConfigParamsArray.Contains(old_name))
    {
      m_ConfigParamsArray.ReplaceKey(old_name, new_name);
 
      if (save_in_file)
        SaveConfigToFile();
    }
  }

SaveConfigToFile() [1/2]

void PluginFileHandler::SaveConfigToFile ( )

inlineprivate

Definition at line 32 of file PluginConfigHandler.c.

  {
    ClearFileNoSave();
 
    for (int i = 0; i < m_CfgParams.Count(); ++i)
    {
      string s = ParseParam(m_CfgParams.Get(i));
 
      m_FileContent.Insert(s);
    }
 
    SaveFile();
  }

SaveConfigToFile() [2/2]

void PluginFileHandler::SaveConfigToFile ( )

inlineprivate

Definition at line 106 of file PluginLocalProfile.c.

  {
    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();
  }

SaveParameter()

void PluginFileHandler::SaveParameter ( string param_name, string value, bool save_in_file = true )

inlineprivate

Definition at line 323 of file PluginLocalProfile.c.

  {
    if (param_name == "" || param_name == "scene_editor_scene")
      Log("SaveParameter: " + param_name + " = " + value, "");
 
    m_ConfigParams.Set(param_name, value);
 
    if (save_in_file)
      SaveConfigToFile();
  }

References Log().

SaveParameterArray()

void PluginFileHandler::SaveParameterArray ( string param_name, TStringArray value, bool save_in_file = true )

inlineprivate

Definition at line 334 of file PluginLocalProfile.c.

  {
    m_ConfigParamsArray.Set(param_name, value);
 
    if (save_in_file)
      SaveConfigToFile();
  }

SaveSubParameterInArray()

void PluginFileHandler::SaveSubParameterInArray ( string param_name, int sub_array_index, string sub_param_name, string sub_param_value, bool save_in_file = true )

inlineprivate

Definition at line 342 of file PluginLocalProfile.c.

  {
    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();
  }

SetParameterArray()

void PluginFileHandler::SetParameterArray ( string name, TStringArray value, bool save_in_file = true )

inlineprivate

Definition at line 411 of file PluginLocalProfile.c.

  {
    SaveParameterArray(name, value, save_in_file);
  }

References name.

SetParameterBool()

void PluginFileHandler::SetParameterBool ( string name, bool value, bool save_in_file = true )

inlineprivate

Definition at line 406 of file PluginLocalProfile.c.

  {
    SaveParameter(name, value.ToString(), save_in_file);
  }

References name.

SetParameterFloat()

void PluginFileHandler::SetParameterFloat ( string name, float value, bool save_in_file = true )

inlineprivate

Definition at line 401 of file PluginLocalProfile.c.

  {
    SaveParameter(name, value.ToString(), save_in_file);
  }

References name.

SetParameterInt()

void PluginFileHandler::SetParameterInt ( string name, int value, bool save_in_file = true )

inlineprivate

Definition at line 396 of file PluginLocalProfile.c.

  {
    SaveParameter(name, value.ToString(), save_in_file);
  }

References name.

SetParameterString()

void PluginFileHandler::SetParameterString ( string name, string value, bool save_in_file = true )

inlineprivate

Definition at line 390 of file PluginLocalProfile.c.

  {
    string s = "\"" + value + "\"";
    SaveParameter(name, s, save_in_file);
  }

References name.

SetSubParameterInArray()

void PluginFileHandler::SetSubParameterInArray ( string param_name, int sub_array_index, string sub_param_name, string sub_param_value, bool save_in_file = true )

inlineprivate

Definition at line 416 of file PluginLocalProfile.c.

  {
    SaveSubParameterInArray(param_name, sub_array_index, sub_param_name, sub_param_value, save_in_file);
  }

Member Data Documentation

m_CfgParams

ref array<ref CfgParam> PluginFileHandler::m_CfgParams

private

Definition at line 3 of file PluginConfigHandler.c.

m_ConfigParams

ref map<string, string> PluginFileHandler::m_ConfigParams

private

Definition at line 3 of file PluginLocalProfile.c.

m_ConfigParamsArray

ref map<string, ref TStringArray> PluginFileHandler::m_ConfigParamsArray

private

Definition at line 4 of file PluginLocalProfile.c.

m_ConfigParamsArrayInArray

ref map<string, ref array<ref map<string, string> > > PluginFileHandler::m_ConfigParamsArrayInArray

private

Definition at line 6 of file PluginLocalProfile.c.

m_ConfigParamsInArray

ref map<string, ref map<string, string> > PluginFileHandler::m_ConfigParamsInArray

private

Definition at line 5 of file PluginLocalProfile.c.

---

The documentation for this class was generated from the following files:

• scripts/4_World/Plugins/PluginBase/PluginFileHandler/PluginConfigHandler.c
• scripts/4_World/Plugins/PluginBase/PluginFileHandler/PluginLocalProfile.c
• scripts/4_World/Plugins/PluginBase/PluginFileHandler/PluginLocalHistoryBase.c