GetConfig()

TStringArray PluginBase::GetConfig ( string class_path, string filter_char )

inlineprivate

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

    {
        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 = g_Game.ConfigGetChildrenCount( class_path );
                
                for ( i = 0; i < cnt_config; i++ )
                {
                    string config_name = "";
                    g_Game.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;
    }

Перекрестные ссылки class_name, g_Game, GetConfigRecursive(), GetPlugin(), string::IndexOf(), string::Length(), MakeTabs(), PluginDeveloper(), string::Split(), string::Substring() и string::ToLower().

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