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