Класс PluginFileHandler

Защищенные члены
int	GetTextType (string text)
bool	IsString (string text)
bool	IsParam (string text)
bool	IsArray (string text)
bool	IsFloat (string text)
bool	IsInt (string text)
bool	IsBool (string text)
string	ParseToValueString (string param_value)
float	ParseToValueFloat (string param_value)
int	ParseToValueInt (string param_value)
bool	ParseToValueBool (string param_value)
array< ref CfgParam >	ParseToValueArray (string param_value)

Закрытые члены
void	PluginConfigHandler ()
override void	OnInit ()
override string	GetFileName ()
void	LoadConfigFile ()
void	SaveConfigToFile ()
CfgParam	GetParamByName (string name, int cfg_type)
array< ref CfgParam >	GetAllParams ()
void	ClearParams ()
void	RemoveParamByName (string name)
void	RenameParam (string name, string new_name)
bool	ParamExist (string name)
string	ParseParam (CfgParam param)
CfgParam	ParseText (string text)
void	PluginLocalHistoryBase ()
void	~PluginLocalHistoryBase ()
override void	OnInit ()
override string	GetFileName ()
void	AddNewLine (string text)
TStringArray	GetAllLines ()
TStringArray	GetLastLine ()
void	PluginLocalProfile ()
override string	GetFileName ()
override void	OnInit ()
bool	LoadConfigFile ()
void	SaveConfigToFile ()
bool	IsTextArray (string text)
TStringArray	ParseTextToParameter (string text)
TStringArray	ParseTextToArray (string text, out TStringArray ret)
array< ref map< string, string > >	ParseTextArrayToParameters (string text)
string	LoadParameter (string param_name)
TStringArray	LoadParameterArray (string param_name)
string	LoadSubParameter (string param_name, int sub_array_index, string sub_param_name)
void	SaveParameter (string param_name, string value, bool save_in_file=true)
void	SaveParameterArray (string param_name, TStringArray value, bool save_in_file=true)
void	SaveSubParameterInArray (string param_name, int sub_array_index, string sub_param_name, string sub_param_value, bool save_in_file=true)
void	RenameParameter (string old_name, string new_name, bool save_in_file=true)
void	RenameParameterArray (string old_name, string new_name, bool save_in_file=true)
void	RemoveParameter (string name, bool save_in_file=true)
void	RemoveParameterArray (string name, bool save_in_file=true)
void	SetParameterString (string name, string value, bool save_in_file=true)
void	SetParameterInt (string name, int value, bool save_in_file=true)
void	SetParameterFloat (string name, float value, bool save_in_file=true)
void	SetParameterBool (string name, bool value, bool save_in_file=true)
void	SetParameterArray (string name, TStringArray value, bool save_in_file=true)
void	SetSubParameterInArray (string param_name, int sub_array_index, string sub_param_name, string sub_param_value, bool save_in_file=true)
string	GetParameterString (string name)
int	GetParameterInt (string name)
float	GetParameterFloat (string name)
bool	GetParameterBool (string name)
TStringArray	GetParameterArray (string name)
string	GetSubParameterInArrayString (string param_name, int sub_array_index, string sub_param_name)
TStringArray	GetAllSubParametersInArrayString (string param_name, string sub_param_name)

Закрытые данные
ref array< ref CfgParam >	m_CfgParams
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

Подробное описание

Конструктор(ы)

~PluginLocalHistoryBase()

void ~PluginLocalHistoryBase ( )

inlineprivate

    {
    }

Методы

AddNewLine()

void AddNewLine ( string text )

inlineprivate

    {
        // replace newline to \\n
        text.Replace("\n", "\\n" );
        m_FileContent.Insert(text);
        SaveFile();
    }

ClearParams()

void ClearParams ( )

inlineprivate

    {
        m_CfgParams.Clear();
    }

GetAllLines()

TStringArray GetAllLines ( )

inlineprivate

    {
        // replace \\n to new line
        TStringArray console_history = new TStringArray;
        for ( int i = 0; i < m_FileContent.Count(); i++)
        {
            string history_record = m_FileContent.Get(i);
            history_record.Replace("\\n", "\n");
            console_history.Insert( history_record );
        }
        return console_history;
    }

GetAllParams()

array< ref CfgParam > GetAllParams ( )

inlineprivate

    {
        return m_CfgParams;
    }

GetAllSubParametersInArrayString()

TStringArray GetAllSubParametersInArrayString ( string param_name, string sub_param_name )

inlineprivate

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

Перекрестные ссылки STRING_EMPTY.

GetFileName() [1/3]

override string GetFileName ( )

inlineprivate

    {
        return CFG_FILE_USER_PROFILE;
    }

Перекрестные ссылки CFG_FILE_USER_PROFILE.

Используется в PluginBase::LoadFile() и PluginBase::SaveFile().

GetFileName() [2/3]

override string GetFileName ( )

inlineprivate

    {
        Error( "Cannot call GetFileName on Base class PluginLocalHistoryBase" );
        return STRING_EMPTY;
    }

Перекрестные ссылки Error() и STRING_EMPTY.

GetFileName() [3/3]

override string GetFileName ( )

inlineprivate

    {
        return CFG_FILE_USER_PROFILE;
    }

Перекрестные ссылки CFG_FILE_USER_PROFILE.

GetLastLine()

TStringArray GetLastLine ( )

inlineprivate

    {
        int count = m_FileContent.Count();
        string ret = "";
        
        if ( count > 0 )
        {
            ret = m_FileContent.Get(count - 1);
        }
        
        return NULL;
    }

GetParamByName()

CfgParam GetParamByName ( string name, int cfg_type )

inlineprivate

    {
        CfgParam param;
        
        for ( int i = 0; i < m_CfgParams.Count(); ++i )
        {
            param = m_CfgParams.Get(i);
            
            if ( param.GetName() == name )
            {
                return param;
            }
        }
        
        // cfg_type == -1 returns NULL
        param = CfgParam.CreateParam(name, cfg_type);
        m_CfgParams.Insert(param);
        return param;
    }

Перекрестные ссылки CfgParam::CreateParam() и name.

GetParameterArray()

TStringArray GetParameterArray ( string name )

inlineprivate

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

Перекрестные ссылки name.

GetParameterBool()

bool GetParameterBool ( string name )

inlineprivate

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

Перекрестные ссылки name.

GetParameterFloat()

float GetParameterFloat ( string name )

inlineprivate

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

Перекрестные ссылки name.

GetParameterInt()

int GetParameterInt ( string name )

inlineprivate

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

Перекрестные ссылки name.

GetParameterString()

string GetParameterString ( string name )

inlineprivate

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

Перекрестные ссылки name и STRING_EMPTY.

GetSubParameterInArrayString()

string GetSubParameterInArrayString ( string param_name, int sub_array_index, string sub_param_name )

inlineprivate

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

Перекрестные ссылки STRING_EMPTY.

GetTextType()

int GetTextType ( string text )

inlineprotected

    {   
        int lenght = text.Length();
            
        // Check Array
        int pos1 = text.IndexOf("{");
        if ( pos1 == 0 && text.Substring(lenght - 1, 1) == "}" )
        {
            return CFG_TYPE_ARRAY;
        }   
            
        // Check String
        pos1 = text.IndexOf("\"");
        
        if ( pos1 == 0 && text.Substring(lenght - 1, 1) == "\"" )
        {
            string string_text = text.Substring(1, lenght - 2);
            if ( string_text.IndexOf("\"") == -1 )
            {
                return CFG_TYPE_STRING;
            }
        }
        
        // Check Param
        pos1 = text.IndexOf("=");
        if ( pos1 > -1 )
        {
            return CFG_TYPE_PARAM;
        }
        
        // Check Param True
        pos1 = text.IndexOf("true");
        if ( lenght == 4 && pos1 > -1 )
        {
            return CFG_TYPE_BOOL;
        }
        
        // Check Param False
        pos1 = text.IndexOf("false");
        if ( lenght == 5 && pos1 > -1 )
        {
            return CFG_TYPE_BOOL;
        }
        
        // Check Param Float
        pos1 = text.IndexOf(".");
        if ( pos1 > -1 )
        {
            return CFG_TYPE_FLOAT;
        }
        
        // Is Int
        return CFG_TYPE_INT;
    }

Перекрестные ссылки CFG_TYPE_ARRAY, CFG_TYPE_BOOL, CFG_TYPE_FLOAT, CFG_TYPE_INT, CFG_TYPE_PARAM и CFG_TYPE_STRING.

IsArray()

bool IsArray ( string text )

inlineprotected

    {
        if ( GetTextType(text) == CFG_TYPE_ARRAY )
        {
            return true;
        }
        
        return false;
    }

Перекрестные ссылки CFG_TYPE_ARRAY.

IsBool()

bool IsBool ( string text )

inlineprotected

    {
        if ( GetTextType(text) == CFG_TYPE_BOOL )
        {
            return true;
        }
        
        return false;
    }

Перекрестные ссылки CFG_TYPE_BOOL.

IsFloat()

bool IsFloat ( string text )

inlineprotected

    {
        if ( GetTextType(text) == CFG_TYPE_FLOAT )
        {
            return true;
        }
        
        return false;
    }

Перекрестные ссылки CFG_TYPE_FLOAT.

IsInt()

bool IsInt ( string text )

inlineprotected

    {
        if ( GetTextType(text) == CFG_TYPE_INT )
        {
            return true;
        }
        
        return false;
    }

Перекрестные ссылки CFG_TYPE_INT.

IsParam()

bool IsParam ( string text )

inlineprotected

    {
        if ( GetTextType(text) == CFG_TYPE_PARAM )
        {
            return true;
        }
        
        return false;
    }

Перекрестные ссылки CFG_TYPE_PARAM.

IsString()

bool IsString ( string text )

inlineprotected

    {
        if ( GetTextType(text) == CFG_TYPE_STRING )
        {
            return true;
        }
        
        return false;
    }

Перекрестные ссылки CFG_TYPE_STRING.

IsTextArray()

bool IsTextArray ( string text )

inlineprivate

    {
        if ( text.Length() > 0 && text.Substring(0, 1) == "{" )
        {
            if ( text.Substring(text.Length() - 1, 1) == "}" )
            {
                return true;
            }
        }
        
        return false;
    }

LoadConfigFile() [1/2]

void LoadConfigFile ( )

inlineprivate

    {
        LoadFile();
        
        m_CfgParams.Clear();
        
        for ( int j = 0; j < m_FileContent.Count(); j++ )
        {
            m_CfgParams.Insert( ParseText(m_FileContent.Get(j)) );
        }   
    }

LoadConfigFile() [2/2]

bool LoadConfigFile ( )

inlineprivate

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

Перекрестные ссылки PluginLocalProfile::GetFileName() и PrintString().

LoadParameter()

string LoadParameter ( string param_name )

inlineprivate

    {
        string ret_value = STRING_EMPTY;
        
        if ( m_ConfigParams.Contains(param_name) )
        {
            ret_value = m_ConfigParams.Get(param_name);
        }
 
        return ret_value;
    }

Перекрестные ссылки STRING_EMPTY.

LoadParameterArray()

TStringArray LoadParameterArray ( string param_name )

inlineprivate

    {
        if ( m_ConfigParamsArray.Contains(param_name) )
        {
            return m_ConfigParamsArray.Get(param_name);
        }
 
        return NULL;
    }

LoadSubParameter()

string LoadSubParameter ( string param_name, int sub_array_index, string sub_param_name )

inlineprivate

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

Перекрестные ссылки STRING_EMPTY.

OnInit() [1/3]

override void OnInit ( )

inlineprivate

    {
        super.OnInit();
    }

OnInit() [2/3]

override void OnInit ( )

inlineprivate

    {
        super.OnInit();
    }

OnInit() [3/3]

override void OnInit ( )

inlineprivate

    {
        super.OnInit();
        
        LoadConfigFile();
    }

ParamExist()

bool ParamExist ( string name )

inlineprivate

    {
        CfgParam param;
        
        for ( int i = 0; i < m_CfgParams.Count(); ++i )
        {
            param = m_CfgParams.Get(i);
            
            if ( param.GetName() == name )
            {
                return true;
            }
        }
        
        return false;
    }

Перекрестные ссылки name.

ParseParam()

string ParseParam ( CfgParam param )

inlineprivate

    {
        string text = STRING_EMPTY;
        
        if ( param.GetName() != STRING_EMPTY )
        {
            text += param.GetName()+"=";
        }
        
        switch ( param.GetType() )
        {
            case CFG_TYPE_ARRAY:
            {
                CfgParamArray param_array = CfgParamArray.Cast( param );
                array<ref CfgParam> params = param_array.GetValues();
                
                text += "{";
                
                for ( int i = 0; i < params.Count(); ++i )
                {
                    if ( i > 0 )
                    {
                        text += ",";
                    }
                    
                    text += ParseParam(params.Get(i));
                }
                
                text += "}";
                
                break;
            }
            case CFG_TYPE_STRING:
            {
                CfgParamString param_string = CfgParamString.Cast( param );
                text += "\""+param_string.GetValue()+"\"";
                
                break;
            }
            case CFG_TYPE_INT:
            {
                CfgParamInt param_int = CfgParamInt.Cast( param );
                text += param_int.GetValue().ToString();
                
                break;
            }
            case CFG_TYPE_FLOAT:
            {
                CfgParamFloat param_float = CfgParamFloat.Cast( param );
                string s = param_float.GetValue().ToString();
                
                if ( s.IndexOf(".") == -1 )
                {
                    s += ".0";
                }
                
                text += s;
                
                break;
            }
            case CFG_TYPE_BOOL:
            {
                CfgParamBool param_bool = CfgParamBool.Cast( param );
                
                if ( param_bool.GetValue() )
                {
                    text += "true";
                }
                else
                {
                    text += "false";
                }
                
                break;
            }
        }
        
        return text;
    }

Перекрестные ссылки CFG_TYPE_ARRAY, CFG_TYPE_BOOL, CFG_TYPE_FLOAT, CFG_TYPE_INT, CFG_TYPE_STRING и STRING_EMPTY.

ParseText()

CfgParam ParseText ( string text )

inlineprivate

    {
        string param_name = STRING_EMPTY;
        string param_value = text.Trim();;
        int text_type = GetTextType(param_value);
        
        //Log("ParseText -> text_type: "+itoa(text_type));
        
        if ( text_type == CFG_TYPE_PARAM )
        {
            int pos = param_value.IndexOf("=");
            
            if ( pos > 0 )
            {
                param_name = param_value.Substring(0, pos).Trim();
                int pos_end = param_value.Length() - pos;
                param_value = param_value.Substring(pos + 1, pos_end - 1).Trim();
                
                //Log("ParseText -> param -> "+param_name+" = "+param_value);
                
                CfgParam param = ParseText(param_value);
                param.SetName(param_name);
                
                return param;
            }
        }
        else if ( text_type == CFG_TYPE_ARRAY )
        {               
            //Log("ParseText -> array -> "+param_name+" = "+param_value);
 
            CfgParamArray param_array = new CfgParamArray(param_name);
            array<ref CfgParam> array_params = ParseToValueArray(param_value);
            param_array.SetParams(array_params);
            
            return param_array;
        }
        else if ( text_type == CFG_TYPE_STRING )
        {                   
            //Log("ParseText -> string -> "+param_value);
            
            CfgParamString param_string = new CfgParamString(param_name);
            param_string.SetValue( ParseToValueString(param_value) );
            
            return param_string;
        }
        else if ( text_type == CFG_TYPE_INT )
        {                   
            //Log("ParseText -> int -> "+param_name+" = "+param_value);
            
            CfgParamInt param_int = new CfgParamInt(param_name);
            param_int.SetValue( ParseToValueInt(param_value) );
            
            return param_int;
        }
        else if ( text_type == CFG_TYPE_FLOAT )
        {
            //Log("ParseText -> float -> "+param_name+" = "+param_value);
            
            CfgParamFloat param_float = new CfgParamFloat(param_name);
            param_float.SetValue( ParseToValueFloat(param_value) );
            
            return param_float;
        }
        else if ( text_type == CFG_TYPE_BOOL )
        {
            //Log("ParseText -> bool -> "+param_name+" = "+param_value);
            
            CfgParamBool param_bool = new CfgParamBool(param_name);
            param_bool.SetValue( ParseToValueBool(param_value) );
            
            return param_bool;
        }
        
        //Log("ParseText -> none -> "+param_name+" = "+param_value);
        
        return NULL;
    }

Перекрестные ссылки CFG_TYPE_ARRAY, CFG_TYPE_BOOL, CFG_TYPE_FLOAT, CFG_TYPE_INT, CFG_TYPE_PARAM, CFG_TYPE_STRING и STRING_EMPTY.

ParseTextArrayToParameters()

array< ref map< string, string > > ParseTextArrayToParameters ( string text )

inlineprivate

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

ParseTextToArray()

TStringArray ParseTextToArray ( string text, out TStringArray ret )

inlineprivate

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

ParseTextToParameter()

TStringArray ParseTextToParameter ( string text )

inlineprivate

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

ParseToValueArray()

array< ref CfgParam > ParseToValueArray ( string param_value )

inlineprotected

    {
        array<ref CfgParam> param_parent = new array<ref CfgParam>;
        
        TStringArray strings = new TStringArray;
        
        array<int> a = new array<int>;
        array<int> b = new array<int>;
 
        int pos_a = 0;
        int pos_b = 0;
        int element = 0;
        int value_start = 0;
        int value_end = 0;
        
        while ( pos_a > -1 ||  pos_b > -1 )
        {
            pos_a = param_value.IndexOfFrom(pos_a, "{" );
            if ( pos_a > -1 )
            {
                a.Insert(pos_a);
                pos_a++;
            }
            
            pos_b = param_value.IndexOfFrom(pos_b, "}" );
            if ( pos_b > -1 )
            {
                b.Insert(pos_b);
                pos_b++;
            }
        }   
        
        pos_a = 0;
        pos_b = 0;
        
        for ( pos_a = 0; pos_a < a.Count(); ++pos_a )
        {
            if ( a.Get(pos_a) > b.Get(pos_b) )
            {
                element--;
                
                if ( element <= 1 )
                {
                    value_end = b.Get(pos_b) - value_start + 1;
                    
                    //Log("1 -> "+substr(param_value, value_start, value_end))
                    
                    strings.Insert( param_value.Substring(value_start, value_end) );
                    
                    value_start = b.Get(pos_b) + 1;
                }
                
                pos_a--;
                pos_b++;
            }
            else if ( a.Get(pos_a) < b.Get(pos_b) )
            {
                if ( pos_a == a.Count() - 1 && pos_b < b.Count() - 1 )
                {
                    element--;
                
                    if ( element == 0 )
                    {
                        value_end = b.Get(pos_b) - value_start;
                        
                        //Log("2 -> "+substr(param_value, value_start + 1, value_end))
                        
                        strings.Insert( param_value.Substring(value_start + 1, value_end) );
                        
                        value_start = b.Get(pos_b) + 1;
                    }
                    
                    pos_a--;
                    pos_b++;
                }
                else
                {
                    element++;
                
                    if ( element == 2 )
                    {
                        value_start = a.Get(pos_a);
                    }
                }           
            }
        }
        
        //Log(param_value+" => "+itoa(a.Count())+" / "+itoa(b.Count())+"    count: "+itoa(strings.Count()));
        
        if ( strings.Count() == 0 )
        {
            //Log(param_value+" -> ZERO {}");
            
            string param_value_content = param_value.Substring(1, param_value.Length() - 2);
            
            //Log(param_value+" -> Trimmed -> "+param_value_content);
            
            param_value_content.Split(",", strings);
        }
        
        for ( int i = 0; i < strings.Count(); ++i )
        {
            string str = strings.Get(i);
            
            //Log("To Parse => "+str);
            
            CfgParam param = ParseText(str);
            
            param_parent.Insert(param);     
        }
        
        return param_parent;
    }

ParseToValueBool()

bool ParseToValueBool ( string param_value )

inlineprotected

    {
        if ( param_value.Contains("true") )
        {
            return true;
        }
        
        return false;
    }

ParseToValueFloat()

float ParseToValueFloat ( string param_value )

inlineprotected

    {
        return param_value.ToFloat();
    }

ParseToValueInt()

int ParseToValueInt ( string param_value )

inlineprotected

    {
        return param_value.ToInt();
    }

ParseToValueString()

string ParseToValueString ( string param_value )

inlineprotected

    {   
        return param_value.Substring(1, param_value.Length() - 2);
    }

PluginConfigHandler()

void PluginConfigHandler ( )

inlineprivate

    {
        m_CfgParams = new array<ref CfgParam>;
        
        LoadConfigFile();
    }

PluginLocalHistoryBase()

void PluginLocalHistoryBase ( )

inlineprivate

    {
        m_ReadOnly = false;
    }

PluginLocalProfile()

void PluginLocalProfile ( )

inlineprivate

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

RemoveParamByName()

void RemoveParamByName ( string name )

inlineprivate

    {
        for ( int i = 0; i < m_CfgParams.Count(); ++i )
        {
            CfgParam param = m_CfgParams.Get(i);
            
            if ( param.GetName() == name )
            {
                m_CfgParams.Remove( i );
                return;
            }
        }
    }

Перекрестные ссылки name.

RemoveParameter()

void RemoveParameter ( string name, bool save_in_file = true )

inlineprivate

    {
        m_ConfigParams.Remove(name);
        
        if ( save_in_file )
        {
            SaveConfigToFile(); 
        }
    }

Перекрестные ссылки name.

RemoveParameterArray()

void RemoveParameterArray ( string name, bool save_in_file = true )

inlineprivate

    {
        m_ConfigParamsArray.Remove(name);
        
        if ( save_in_file )
        {
            SaveConfigToFile(); 
        }
    }

Перекрестные ссылки name.

RenameParam()

void RenameParam ( string name, string new_name )

inlineprivate

    {
        for ( int i = 0; i < m_CfgParams.Count(); ++i )
        {
            CfgParam param = m_CfgParams.Get(i);
            
            if ( param.GetName() == name )
            {
                param.SetName( new_name );
                return;
            }
        }
    }

Перекрестные ссылки name.

RenameParameter()

void RenameParameter ( string old_name, string new_name, bool save_in_file = true )

inlineprivate

    {
        if ( m_ConfigParams.Contains(old_name) )
        {
            m_ConfigParams.ReplaceKey(old_name, new_name);
            
            if ( save_in_file )
            {
                SaveConfigToFile(); 
            }
        }
    }

RenameParameterArray()

void RenameParameterArray ( string old_name, string new_name, bool save_in_file = true )

inlineprivate

    {
        if ( m_ConfigParamsArray.Contains(old_name) )
        {
            m_ConfigParamsArray.ReplaceKey(old_name, new_name);
            
            if ( save_in_file )
            {
                SaveConfigToFile(); 
            }
        }
    }

SaveConfigToFile() [1/2]

void SaveConfigToFile ( )

inlineprivate

    {
        ClearFileNoSave();
        
        for ( int i = 0; i < m_CfgParams.Count(); ++i )
        {
            string s = ParseParam(m_CfgParams.Get(i));
 
            m_FileContent.Insert(s);
        }
        
        SaveFile();
    }

SaveConfigToFile() [2/2]

void SaveConfigToFile ( )

inlineprivate

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

SaveParameter()

void SaveParameter ( string param_name, string value, bool save_in_file = true )

inlineprivate

    {
        if ( param_name == "" || param_name == "scene_editor_scene" )
        {
            Log("SaveParameter: "+param_name+" = "+value, "");
        }
        
        m_ConfigParams.Set(param_name, value);
        
        if ( save_in_file )
        {
            SaveConfigToFile(); 
        }
    }

Перекрестные ссылки Log().

SaveParameterArray()

void SaveParameterArray ( string param_name, TStringArray value, bool save_in_file = true )

inlineprivate

    {
        m_ConfigParamsArray.Set(param_name, value);
        
        if ( save_in_file )
        {
            SaveConfigToFile(); 
        }
    }

SaveSubParameterInArray()

void SaveSubParameterInArray ( string param_name, int sub_array_index, string sub_param_name, string sub_param_value, bool save_in_file = true )

inlineprivate

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

SetParameterArray()

void SetParameterArray ( string name, TStringArray value, bool save_in_file = true )

inlineprivate

    {
        SaveParameterArray(name, value, save_in_file);
    }

Перекрестные ссылки name.

SetParameterBool()

void SetParameterBool ( string name, bool value, bool save_in_file = true )

inlineprivate

    {
        SaveParameter(name, value.ToString(), save_in_file);
    }

Перекрестные ссылки name.

SetParameterFloat()

void SetParameterFloat ( string name, float value, bool save_in_file = true )

inlineprivate

    {
        SaveParameter(name, value.ToString(), save_in_file);
    }

Перекрестные ссылки name.

SetParameterInt()

void SetParameterInt ( string name, int value, bool save_in_file = true )

inlineprivate

    {
        SaveParameter(name, value.ToString(), save_in_file);
    }

Перекрестные ссылки name.

SetParameterString()

void SetParameterString ( string name, string value, bool save_in_file = true )

inlineprivate

    {
        string s = "\""+value+"\"";
        SaveParameter(name, s, save_in_file);
    }

Перекрестные ссылки name.

SetSubParameterInArray()

void SetSubParameterInArray ( string param_name, int sub_array_index, string sub_param_name, string sub_param_value, bool save_in_file = true )

inlineprivate

    {
        SaveSubParameterInArray(param_name, sub_array_index, sub_param_name, sub_param_value, save_in_file);
    }

Поля

m_CfgParams

ref array<ref CfgParam> m_CfgParams

private

m_ConfigParams

ref map<string, string> m_ConfigParams

private

m_ConfigParamsArray

ref map<string, ref TStringArray> m_ConfigParamsArray

private

m_ConfigParamsArrayInArray

ref map<string, ref array<ref map<string, string> > > m_ConfigParamsArrayInArray

private

m_ConfigParamsInArray

ref map<string, ref map<string, string> > m_ConfigParamsInArray

private

---

Объявления и описания членов классов находятся в файлах:

• D:/Ishodniki/scripts/4_World/Plugins/PluginBase/PluginFileHandler/PluginConfigHandler.c
• D:/Ishodniki/scripts/4_World/Plugins/PluginBase/PluginFileHandler/PluginLocalProfile.c
• D:/Ishodniki/scripts/4_World/Plugins/PluginBase/PluginFileHandler/PluginLocalHistoryBase.c