GetConfigRecursive()

TStringArray PluginBase::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 )

inlineprivate

См. определение в файле PluginConfigViewer.c строка 153

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

Перекрестные ссылки CGame::ConfigGetBaseName(), CGame::ConfigGetChildName(), CGame::ConfigGetChildrenCount(), CGame::ConfigGetFullPath(), CGame::ConfigGetTextArray(), CGame::ConfigGetType(), GetBaseClassPath(), GetBaseClassPathCombined(), GetConfigRecursive(), GetGame(), string::Length(), MakeTabs(), name, path, string::Substring() и string::ToLower().

Используется в GetConfig() и GetConfigRecursive().