PluginConfigViewer.c

Go to the documentation of this file.

class PluginConfigViewer extends PluginBase
{
  void PluginConfigViewer()
  {
  }
 
  string MakeTabs(int count, bool inheritance = false)
  {
    if (count == 0)
      return "";
 
    string tabs = "|--";
    if (inheritance)
      tabs = "|<<";
 
    for (int i = 0; i < count - 1; i++)
      tabs = "|  " + tabs;
 
    return tabs;
  }
 
  string GetOnlyChildPath(string config_class_path, string class_path)
  {
    int config_class_path_len = config_class_path.Length();
    int class_path_len = class_path.Length();
 
    if (class_path_len > config_class_path_len)
    {
      int start = config_class_path_len;
      int count = class_path_len - start;
 
      return class_path.Substring(start, count).Trim();
    }
    else
      return "";
  }
 
  string GetBaseClassPath(string config_class_path, string class_path, string config_class)
  {
    if (class_path == "")
      return "";
 
    int start = config_class_path.Length();
    int count = class_path.Length() - start;
    string class_path_without_config_class = GetOnlyChildPath(config_class_path, class_path);
 
    ref TStringArray full_path = new TStringArray;
    GetGame().ConfigGetFullPath(config_class_path, full_path);
 
    if (full_path.Count() > 1 && class_path_without_config_class != "")
      return GetBaseClassPathRecursive(config_class + " " + full_path.Get(1), class_path_without_config_class, config_class);
    else
      return "";
  }
 
  string GetBaseClassPathCombined(string child_path, string base_class)
  {
    int current = -1;
    int last = 0;
 
    while (true)
    {
      current = child_path.IndexOfFrom(last, " ");
      if (current > -1)
        last = current + 1;
      else
        break;
    }
 
    string result = child_path.Substring(0, last) + base_class;
    return result;
  }
 
  string GetBaseClassPathRecursive(string config_class_path, string class_path, string config_class)
  {
    if (ContainsFirstClass(config_class_path, class_path))
      return config_class_path + " " + class_path;
    else
    {
      ref TStringArray full_path = new TStringArray;
      GetGame().ConfigGetFullPath(config_class_path, full_path);
 
      if (full_path.Count() > 1)
        return GetBaseClassPathRecursive(config_class + " " + full_path.Get(1), class_path, config_class);
      else
        return "";
    }
  }
 
  bool ContainsFirstClass(string config_class_path, string class_path)
  {
    int start = class_path.IndexOf(" ");
    string name = class_path;
    if (start > -1)
      name = class_path.Substring(0, start);
 
    int cfg_class_count = GetGame().ConfigGetChildrenCount(config_class_path);
 
    for (int i = 0; i < cfg_class_count; i++)
    {
      string cfg_class_name = "";
      GetGame().ConfigGetChildName(config_class_path, i, cfg_class_name);
 
      if (cfg_class_name == name)
      {
        string full_name = config_class_path + " " + name;
        int type = GetGame().ConfigGetType(full_name);
 
        if (type == CT_CLASS)
          return true;
      }
    }
 
    if (start == -1)
      return false;
    else
    {
      string new_name = class_path.Substring(start + 1, class_path.Length() - (start + 1));
      return ContainsFirstClass(config_class_path + " " + name, new_name);
    }
  }
 
  TStringArray GetConfigRecursive(string path, string name, string config_class_path, string config_class, local array<string> overridden, int depth = 0, local bool check_base_class_of_class = false)
  {
    string tabs = MakeTabs(depth + 1);
    string child_path = path;
    int count = GetGame().ConfigGetChildrenCount(child_path);
    int i = 0;
 
    bool name_printed = false;
 
    TStringArray result = new TStringArray;
 
    for (i = 0; i < count; i++)
    {
      string child_name = "";
      GetGame().ConfigGetChildName(child_path, i, child_name);
      string c_child_path = child_path + " " + child_name;
 
      string child_name_lower = child_name;
      child_name_lower.ToLower();
 
      if (overridden.Find(child_name_lower) == -1)
      {
        if (!name_printed)
        {
          result.Insert(":" + MakeTabs(depth, check_base_class_of_class) + "!" + name);
          name_printed = true;
        }
        overridden.Insert(child_name_lower);
 
        int type = GetGame().ConfigGetType(c_child_path);
 
        if (type != CT_CLASS)
        {
          if (type != CT_ARRAY)
            result.Insert("-" + tabs + "!" + child_name + " = " + GetGame().ConfigGetTextOut(c_child_path));
          else
          {
            result.Insert("-" + tabs + "!" + child_name + "[] = {");
 
            TStringArray strs = new TStringArray;
            GetGame().ConfigGetTextArray(c_child_path, strs);
            string tabs_array = MakeTabs(depth + 2);
            int j;
            for (j = 0; j < strs.Count(); j++)
              result.Insert("-" + tabs + "!" + child_name + "[]" + j.ToStringLen(6) + "~" + strs.Get(j) + ",");
 
            result.Insert("-" + tabs + "!" + child_name + "[]" + j.ToStringLen(6) + "~}");
          }
        }
        else
        {
          array<string> overridden_sub = new array<string>;
 
          if (GetGame().ConfigGetChildrenCount(c_child_path) > 0)
          {
            TStringArray config1 = GetConfigRecursive(c_child_path, child_name, config_class_path, config_class, overridden_sub, depth + 1);
            result.InsertAll(config1);
          }
          else
            result.Insert(":" + tabs + "!" + child_name);
 
          string cc_child_path = c_child_path;
          string c_config_class_path = config_class_path;
          string c_child_name = child_name;
 
          int cc = 0;
 
          while (true)
          {
            string base_class = "";
 
            GetGame().ConfigGetBaseName(cc_child_path, base_class);
 
            int start = c_config_class_path.Length() + 1;
            int len = cc_child_path.Length();
            len -= c_config_class_path.Length() + c_child_name.Length();
            len -= 2;
 
            if (base_class != "")
            {
              string only_child_path = "";
              if (len < 0)
                only_child_path = base_class;
              else
                only_child_path = cc_child_path.Substring(start, len) + " " + base_class;
 
              string c_base_child_path = GetBaseClassPathCombined(cc_child_path, base_class);
              string base_class_path = GetBaseClassPath(c_config_class_path, c_base_child_path, config_class);
 
              if (base_class_path != "")
              {
                TStringArray config2 = GetConfigRecursive(base_class_path, base_class, base_class_path, config_class, overridden_sub, depth + 1, true);
                result.InsertAll(config2);
              }
              else
              {
                TStringArray config3 = GetConfigRecursive(base_class, base_class, base_class, config_class, overridden_sub, depth + 1, true);
                result.InsertAll(config3);
 
                break;
              }
 
              cc_child_path = base_class_path;
              c_child_name = base_class;
              c_config_class_path = cc_child_path.Substring(0, cc_child_path.Length() - only_child_path.Length() - 1);
            }
            else
              break;
          }
        }
      }
    }
 
    if (name_printed)
      result.Insert(":" + MakeTabs(depth, check_base_class_of_class) + "#" + name);
 
    if (!check_base_class_of_class)
    {
      TStringArray full_path = new TStringArray;
      GetGame().ConfigGetFullPath(child_path, full_path);
 
      if (full_path.Count() > 1)
      {
        TStringArray config4 = GetConfigRecursive(config_class + " " + full_path.Get(1), full_path.Get(1), config_class + " " + full_path.Get(1), config_class, overridden, depth);
        result.InsertAll(config4);
      }
    }
    else
    {
      string class_base_class = "";
      GetGame().ConfigGetBaseName(child_path, class_base_class);
 
      if (class_base_class != "")
      {
        string base_child_path = GetBaseClassPathCombined(child_path, class_base_class);
        string cc_base_child_path = GetBaseClassPath(config_class_path, base_child_path, config_class);
 
        if (cc_base_child_path != "")
        {
          TStringArray config5 = GetConfigRecursive(cc_base_child_path, class_base_class, cc_base_child_path, config_class, overridden, depth, true);
          result.InsertAll(config5);
        }
        else
        {
          TStringArray config6 = GetConfigRecursive(class_base_class, class_base_class, class_base_class, config_class, overridden, depth, true);
          result.InsertAll(config6);
        }
      }
    }
 
    return result;
  }
 
  TStringArray GetConfig(string class_path, string filter_char)
  {
    int i;
    TStringArray filtered = new TStringArray;
 
    if (class_path != "")
    {
      PluginDeveloper module_dev = PluginDeveloper.Cast(GetPlugin(PluginDeveloper));
 
      TStringArray path_nodes = new TStringArray;
      class_path.Split(" ", path_nodes);
 
      if (path_nodes.Count() >= 3)
      {
        string c_class_path = path_nodes.Get(0) + " " + path_nodes.Get(1) + " " + path_nodes.Get(2);
 
        array<string> overridden = new array<string>;
        string config_class = path_nodes.Get(1);
        string class_name = path_nodes.Get(2);
 
        TStringArray result = GetConfigRecursive(c_class_path, class_name, c_class_path, config_class, overridden);
 
        TStringArray nested_start = new TStringArray;
        TStringArray nested_end = new TStringArray;
        TStringArray nested_inherited_start = new TStringArray;
        TStringArray nested_inherited_end = new TStringArray;
        string tabs = MakeTabs(1);
        string tabs_inherited = MakeTabs(1, true);
        string check_tabs = MakeTabs(path_nodes.Count() - 1, true);
 
        nested_start.Insert(":!");
        nested_end.Insert(":#");
        nested_inherited_start.Insert(":!");
        nested_inherited_end.Insert(":#");
 
        string last_node = filter_char + MakeTabs(nested_start.Count()) + "!";
 
        if (path_nodes.Count() == 3)
          last_node = filter_char + MakeTabs(1) + "!";
        else
        {
          for (i = 1; i < path_nodes.Count() - 2; i++)
          {
            tabs = MakeTabs(i);
            tabs_inherited = MakeTabs(i, true);
 
            string path_node = path_nodes.Get(i + 2);
            path_node.ToLower();
 
            nested_start.Insert(":" + tabs + "!" + path_node);
            nested_end.Insert(":" + tabs + "#" + path_node);
            nested_inherited_start.Insert(":" + tabs_inherited + "!" + path_node);
            nested_inherited_end.Insert(":" + tabs_inherited + "#" + path_node);
          }
 
          last_node = filter_char + MakeTabs(i) + "!";
        }
 
        int current_nest = 0;
 
        for (i = 0; i < result.Count(); i++)
        {
          string current = result.Get(i);
          string current_lower = current;
          current_lower.ToLower();
 
          int len_current = current.Length();
 
          if (current_nest < nested_start.Count())
          {
            int len_start = nested_start.Get(current_nest).Length();
 
            if (len_current >= len_start)
            {
              string prefix_start = current_lower;
 
              if (current_nest == 0)
                prefix_start = current_lower.Substring(0, len_start);
 
              if (prefix_start == nested_start.Get(current_nest) || prefix_start == nested_inherited_start.Get(current_nest))
              {
                current_nest++;
                continue;
              }
            }
          }
 
          if (current_nest >= 1)
          {
            int len_end = nested_end.Get(current_nest - 1).Length();
 
            if (len_current >= len_end)
            {
              string prefix_end = current_lower;
 
              if (current_nest == 0)
                prefix_start = current_lower.Substring(0, len_start);
 
              if (prefix_end == nested_end.Get(current_nest - 1) || prefix_end == nested_inherited_end.Get(current_nest - 1))
                current_nest--;
            }
          }
 
          if (current_nest == nested_start.Count())
          {
            string first_char = current.Substring(0, 1);
 
            if (first_char == filter_char)
            {
              int bang_pos = current.IndexOf("!");
 
              if (bang_pos > -1)
              {
                int len_last_node = last_node.Length();
 
                if (len_current >= len_last_node)
                {
                  string prefix_current = current_lower.Substring(0, len_last_node);
 
                  if (last_node == prefix_current)
                    filtered.Insert(current.Substring(bang_pos + 1, current.Length() - (bang_pos + 1)));
                }
              }
            }
          }
        }
 
        TStringArray without_duplications = new TStringArray;
 
        map<string, string> lowered = new map<string, string>;
 
        for (i = 0; i < filtered.Count(); i++)
        {
          string c = filtered.Get(i);
          string lower_c = c;
          lower_c.ToLower();
 
          if (without_duplications.Find(lower_c) < 0)
          {
            without_duplications.Insert(lower_c);
 
            if (lower_c != c)
              lowered.Set(lower_c, c);
          }
        }
 
        module_dev.SortStringArray(without_duplications);
 
        for (i = 0; i < without_duplications.Count(); i++)
        {
          string cc = without_duplications.Get(i);
 
          if (lowered.Contains(cc))
            cc = lowered.Get(cc);
 
          int tilda_index = cc.IndexOf("~");
          if (tilda_index > -1)
          {
            string spaces = "    ";
            if (cc.IndexOf("~}") > -1)
              spaces = "";
            cc = spaces + cc.Substring(tilda_index + 1, cc.Length() - (tilda_index + 1));
          }
 
          without_duplications.Set(i, cc);
        }
 
        return without_duplications;
      }
      else if (filter_char == ":")
      {
        int cnt_config = GetGame().ConfigGetChildrenCount(class_path);
 
        for (i = 0; i < cnt_config; i++)
        {
          string config_name = "";
          GetGame().ConfigGetChildName(class_path, i, config_name);
          filtered.Insert(config_name);
        }
 
        module_dev.SortStringArray(filtered);
      }
    }
    else if (filter_char == ":")
    {
      filtered.Insert("configfile");
      filtered.Insert("missionconfigfile");
    }
 
    return filtered;
  }
 
  TStringArray GetConfigVariables(string class_path)
  {
    return GetConfig(class_path, "-");
  }
 
  TStringArray GetConfigHierarchy(string class_path)
  {
    return GetConfig(class_path, ":");
  }
 
  string GetBaseClasses(string path, string item)
  {
    string adjustedPath = path;
    bool run = true;
    TStringArray resultArr = new TStringArray();
    resultArr.Insert(item);
    while (run)
    {
      //Print("checking for path:'" + adjustedPath +"'");
      string baseClass = "";
      run = GetGame().ConfigGetBaseName(adjustedPath, baseClass);
      if (baseClass)
      {
        TStringArray strs = new TStringArray;
        adjustedPath.Split(" ", strs);
        strs.Remove(strs.Count() - 1);
        strs.Insert(baseClass);
 
        adjustedPath = string.Join(" ", strs);
        resultArr.Insert(baseClass);
        if (adjustedPath == path)
          break;
      }
 
    }
    string result;
    resultArr.Invert();
    foreach (int i, string str: resultArr)
    {
      if (i != 0)
        result += " >> " + str;
      else
        result += str;
    }
 
    return result;
  }
 
 
}