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