Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Dec 27, 2007, 9:38:55 PM (17 years ago)
Author:
landauf
Message:

intern changes in the ConfigValueContainer

File:
1 edited

Legend:

Unmodified
Added
Removed
  • code/branches/FICN/src/orxonox/core/ConfigValueContainer.cc

    r698 r703  
    4949        this->type_ = Int;
    5050
    51         this->defvalueString_ = number2String(defvalue, "0");                   // Try to convert the default-value to a string
    52         this->searchConfigFileLine();                                           // Search the entry in the config-file
    53 
    54         std::string valueString = this->parseValueString();                     // Parses the value string from the config-file-entry
    55         if (!string2Number(this->value_.value_int_, valueString, defvalue))     // Try to convert the string to a value
    56             this->setConfigFileEntyToDefault();                                 // The conversion failed
     51        this->defvalueString_ = number2String(defvalue, "0");                       // Try to convert the default-value to a string
     52        this->searchConfigFileLine();                                               // Search the entry in the config-file
     53
     54        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
     55        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
     56            this->resetConfigFileEntry();                                           // The conversion failed
    5757    }
    5858
     
    7070        this->type_ = uInt;
    7171
    72         this->defvalueString_ = number2String(defvalue, "0");                   // Try to convert the default-value to a string
    73         this->searchConfigFileLine();                                           // Search the entry in the config-file
    74 
    75         std::string valueString = this->parseValueString();                     // Parses the value string from the config-file-entry
    76         if (!string2Number(this->value_.value_uint_, valueString, defvalue))    // Try to convert the string to a value
    77             this->setConfigFileEntyToDefault();                                 // The conversion failed
     72        this->defvalueString_ = number2String(defvalue, "0");                       // Try to convert the default-value to a string
     73        this->searchConfigFileLine();                                               // Search the entry in the config-file
     74
     75        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
     76        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
     77            this->resetConfigFileEntry();                                           // The conversion failed
    7878    }
    7979
     
    9191        this->type_ = Char;
    9292
    93         this->defvalueString_ = number2String((int)defvalue, "0");              // Try to convert the default-value to a string
    94         this->searchConfigFileLine();                                           // Search the entry in the config-file
    95 
    96         std::string valueString = this->parseValueString();                     // Parses the value string from the config-file-entry
    97         // I used value_int_ instead of value_char_ to avoid number <-> char confusion in the config-file
    98         if (!string2Number(this->value_.value_int_, valueString, (int)defvalue))// Try to convert the string to a value
    99             this->setConfigFileEntyToDefault();                                 // The conversion failed
     93        this->defvalueString_ = number2String((int)defvalue, "0");                  // Try to convert the default-value to a string
     94        this->searchConfigFileLine();                                               // Search the entry in the config-file
     95
     96        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
     97        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
     98            this->resetConfigFileEntry();                                           // The conversion failed
    10099    }
    101100
     
    113112        this->type_ = uChar;
    114113
    115         this->defvalueString_ = number2String((unsigned int)defvalue, "0");     // Try to convert the default-value to a string
    116         this->searchConfigFileLine();                                           // Search the entry in the config-file
    117 
    118         std::string valueString = this->parseValueString();                     // Parses the value string from the config-file-entry
    119         // I used value_uint_ instead of value_uchar_ to avoid number <-> char confusion in the config-file
    120         if (!string2Number(this->value_.value_uint_, valueString, (unsigned int)defvalue)) // Try to convert the string to a value
    121             this->setConfigFileEntyToDefault();                                 // The conversion failed
     114        this->defvalueString_ = number2String((unsigned int)defvalue, "0");         // Try to convert the default-value to a string
     115        this->searchConfigFileLine();                                               // Search the entry in the config-file
     116
     117        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
     118        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
     119            this->resetConfigFileEntry();                                           // The conversion failed
    122120    }
    123121
     
    135133        this->type_ = Float;
    136134
    137         this->defvalueString_ = number2String(defvalue, "0.000000");            // Try to convert the default-value to a string
    138         this->searchConfigFileLine();                                           // Search the entry in the config-file
    139 
    140         std::string valueString = this->parseValueString();                     // Parses the value string from the config-file-entry
    141         if (!string2Number(this->value_.value_float_, valueString, defvalue))   // Try to convert the string to a value
    142             this->setConfigFileEntyToDefault();                                 // The conversion failed
     135        this->defvalueString_ = number2String(defvalue, "0.000000");                // Try to convert the default-value to a string
     136        this->searchConfigFileLine();                                               // Search the entry in the config-file
     137
     138        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
     139        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
     140            this->resetConfigFileEntry();                                           // The conversion failed
    143141    }
    144142
     
    156154        this->type_ = Double;
    157155
    158         this->defvalueString_ = number2String(defvalue, "0.000000");            // Try to convert the default-value to a string
    159         this->searchConfigFileLine();                                           // Search the entry in the config-file
    160 
    161         std::string valueString = this->parseValueString();                     // Parses the value string from the config-file-entry
    162         if (!string2Number(this->value_.value_double_, valueString, defvalue))  // Try to convert the string to a value
    163             this->setConfigFileEntyToDefault();                                 // The conversion failed
     156        this->defvalueString_ = number2String(defvalue, "0.000000");                // Try to convert the default-value to a string
     157        this->searchConfigFileLine();                                               // Search the entry in the config-file
     158
     159        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
     160        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
     161            this->resetConfigFileEntry();                                           // The conversion failed
     162    }
     163
     164    /**
     165        @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
     166        @param value This is only needed to determine the right type.
     167        @param classname The name of the class the variable belongs to
     168        @param varname The name of the variable
     169        @param defvalue The default-value
     170    */
     171    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, long double defvalue)
     172    {
     173        this->classname_ = classname;
     174        this->varname_ = varname;
     175        this->type_ = LongDouble;
     176
     177        this->defvalueString_ = number2String(defvalue, "0.000000");                // Try to convert the default-value to a string
     178        this->searchConfigFileLine();                                               // Search the entry in the config-file
     179
     180        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
     181        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
     182            this->resetConfigFileEntry();                                           // The conversion failed
    164183    }
    165184
     
    183202            this->defvalueString_ = "false";
    184203
    185         this->searchConfigFileLine();                                           // Search the entry in the config-file
    186 
    187         std::string valueString = this->parseValueString();                     // Parses the value string from the config-file-entry
    188 
    189         // Try to parse the value-string - is it a word?
    190         if (valueString.find("true") < valueString.size()
    191          || valueString.find("True") < valueString.size()
    192          || valueString.find("yes") < valueString.size()
    193          || valueString.find("Yes") < valueString.size())
    194             this->value_.value_bool_ = true;
    195         else if (valueString.find("false") < valueString.size()
    196               || valueString.find("False") < valueString.size()
    197               || valueString.find("no") < valueString.size()
    198               || valueString.find("No") < valueString.size())
    199             this->value_.value_bool_ = false;
    200         else
    201         {
    202             // Its not a known word - is it a number?
    203             std::string valueString = this->parseValueString();                     // Parses the value string from the config-file-entry
    204             if (!string2Number(this->value_.value_bool_, valueString, defvalue))    // Try to convert the string to a value
    205                 this->setConfigFileEntyToDefault();                                 // The conversion failed
    206         }
     204        this->searchConfigFileLine();                                               // Search the entry in the config-file
     205        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
     206        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
     207            this->resetConfigFileEntry();                                           // The conversion failed
    207208    }
    208209
     
    220221        this->type_ = String;
    221222
    222         this->defvalueString_ = "\"" + defvalue + "\"";                         // Convert the string to a "config-file-string" with quotes
    223 
    224         this->searchConfigFileLine();                                           // Search the entry in the config-file
    225         std::string valueString = this->parseValueString(false);                // Parses the value string from the config-file-entry
    226 
    227         // Strip the quotes
    228         unsigned int pos1 = valueString.find("\"") + 1;
    229         unsigned int pos2 = valueString.find("\"", pos1);
    230 
    231         // Check if the entry was correctly quoted
    232         if (pos1 < valueString.length() && pos2 < valueString.length() && !(valueString.find("\"", pos2 + 1) < valueString.length()))
    233         {
    234             // It was - get the string between the quotes
    235             valueString = valueString.substr(pos1, pos2 - pos1);
    236             this->value_string_ = valueString;
    237         }
    238         else
    239         {
    240             // It wasn't - use the default-value and restore the entry in the config-file.
    241             this->value_string_ = defvalue;
    242             this->setConfigFileEntyToDefault();
    243         }
     223        this->defvalueString_ = "\"" + defvalue + "\"";                             // Convert the string to a "config-file-string" with quotes
     224        this->searchConfigFileLine();                                               // Search the entry in the config-file
     225        std::string valueString = this->parseValueString(false);                    // Parses the value string from the config-file-entry
     226        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
     227            this->resetConfigFileEntry();                                           // The conversion failed
    244228    }
    245229
     
    257241        this->type_ = ConstChar;
    258242
    259         this->defvalueString_ = "\"" + std::string(defvalue) + "\"";            // Convert the string to a "config-file-string" with quotes
    260 
    261         this->searchConfigFileLine();                                           // Search the entry in the config-file
    262         std::string valueString = this->parseValueString(false);                // Parses the value string from the config-file-entry
    263 
    264         // Strip the quotes
    265         unsigned int pos1 = valueString.find("\"") + 1;
    266         unsigned int pos2 = valueString.find("\"", pos1);
    267 
    268         // Check if the entry was correctly quoted
    269         if (pos1 < valueString.length() && pos2 < valueString.length() && !(valueString.find("\"", pos2 + 1) < valueString.length()))
    270         {
    271             // It was - get the string between the quotes
    272             valueString = valueString.substr(pos1, pos2 - pos1);
    273             this->value_string_ = valueString;
    274         }
    275         else
    276         {
    277             // It wasn't - use the default-value and restore the entry in the config-file.
    278             this->value_string_ = defvalue;
    279             this->setConfigFileEntyToDefault();
    280         }
     243        this->defvalueString_ = "\"" + std::string(defvalue) + "\"";                // Convert the string to a "config-file-string" with quotes
     244        this->searchConfigFileLine();                                               // Search the entry in the config-file
     245        std::string valueString = this->parseValueString(false);                    // Parses the value string from the config-file-entry
     246        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
     247            this->resetConfigFileEntry();                                           // The conversion failed
    281248    }
    282249
     
    301268            this->defvalueString_ = "(0,0)";
    302269
    303         this->searchConfigFileLine();                                           // Search the entry in the config-file
    304         std::string valueString = this->parseValueString();                     // Parses the value string from the config-file-entry
    305 
    306         // Strip the value-string
    307         unsigned int pos1 = valueString.find("(") + 1;
    308         unsigned int pos2 = valueString.find(")", pos1);
    309 
    310         // Try to convert the stripped value-string to Vector2
    311         if (pos1 < valueString.length() && pos2 < valueString.length() && pos1 < pos2)
    312         {
    313             valueString = valueString.substr(pos1, pos2 - pos1);
    314             std::vector<std::string> tokens = tokenize(valueString, ",");
    315             if (!string2Number(this->value_vector2_.x, tokens[0], defvalue.x))
    316                 this->setConfigFileEntyToDefault();
    317             if (!string2Number(this->value_vector2_.y, tokens[1], defvalue.y))
    318                 this->setConfigFileEntyToDefault();
    319         }
    320         else
    321         {
    322             this->value_vector2_ = defvalue;
    323             this->setConfigFileEntyToDefault();
    324         }
     270        this->searchConfigFileLine();                                               // Search the entry in the config-file
     271        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
     272        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
     273            this->resetConfigFileEntry();                                           // The conversion failed
    325274    }
    326275
     
    345294            this->defvalueString_ = "(0,0,0)";
    346295
    347         this->searchConfigFileLine();                                           // Search the entry in the config-file
    348         std::string valueString = this->parseValueString();                     // Parses the value string from the config-file-entry
    349 
    350         // Strip the value-string
    351         unsigned int pos1 = valueString.find("(") + 1;
    352         unsigned int pos2 = valueString.find(")", pos1);
    353 
    354         // Try to convert the stripped value-string to Vector3
    355         if (pos1 < valueString.length() && pos2 < valueString.length() && pos1 < pos2)
    356         {
    357             valueString = valueString.substr(pos1, pos2 - pos1);
    358             std::vector<std::string> tokens = tokenize(valueString, ",");
    359             if (!string2Number(this->value_vector3_.x, tokens[0], defvalue.x))
    360                 this->setConfigFileEntyToDefault();
    361             if (!string2Number(this->value_vector3_.y, tokens[1], defvalue.y))
    362                 this->setConfigFileEntyToDefault();
    363             if (!string2Number(this->value_vector3_.z, tokens[2], defvalue.z))
    364                 this->setConfigFileEntyToDefault();
    365         }
    366         else
    367         {
    368             this->value_vector3_ = defvalue;
    369             this->setConfigFileEntyToDefault();
    370         }
     296        this->searchConfigFileLine();                                               // Search the entry in the config-file
     297        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
     298        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
     299            this->resetConfigFileEntry();                                           // The conversion failed
    371300    }
    372301
     
    391320            this->defvalueString_ = "(0,0,0,0)";
    392321
    393         this->searchConfigFileLine();                                           // Search the entry in the config-file
    394         std::string valueString = this->parseValueString();                     // Parses the value string from the config-file-entry
    395 
     322        this->searchConfigFileLine();                                               // Search the entry in the config-file
     323        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
     324        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
     325            this->resetConfigFileEntry();                                           // The conversion failed
     326    }
     327
     328    /**
     329        @brief Parses a given std::string into a value of the type of the associated variable and assigns it.
     330        @param input The string to convert
     331        @return True if the string was successfully parsed
     332    */
     333    bool ConfigValueContainer::parseSting(const std::string& input)
     334    {
     335        if (this->type_ == ConfigValueContainer::Int)
     336            return this->parseSting(input, this->value_.value_int_);
     337        else if (this->type_ == ConfigValueContainer::uInt)
     338            return this->parseSting(input, this->value_.value_uint_);
     339        else if (this->type_ == ConfigValueContainer::Char)
     340            return this->parseSting(input, this->value_.value_char_);
     341        else if (this->type_ == ConfigValueContainer::uChar)
     342            return this->parseSting(input, this->value_.value_uchar_);
     343        else if (this->type_ == ConfigValueContainer::Float)
     344            return this->parseSting(input, this->value_.value_float_);
     345        else if (this->type_ == ConfigValueContainer::Double)
     346            return this->parseSting(input, this->value_.value_double_);
     347        else if (this->type_ == ConfigValueContainer::LongDouble)
     348            return this->parseSting(input, this->value_.value_long_double_);
     349        else if (this->type_ == ConfigValueContainer::Bool)
     350            return this->parseSting(input, this->value_.value_bool_);
     351        else if (this->type_ == ConfigValueContainer::String)
     352            return this->parseSting(input, this->value_string_);
     353        else if (this->type_ == ConfigValueContainer::ConstChar)
     354            return this->parseSting(input, this->value_string_);
     355        else if (this->type_ == ConfigValueContainer::Vector2)
     356            return this->parseSting(input, this->value_vector2_);
     357        else if (this->type_ == ConfigValueContainer::Vector3)
     358            return this->parseSting(input, this->value_vector3_);
     359        else if (this->type_ == ConfigValueContainer::ColourValue)
     360            return this->parseSting(input, this->value_colourvalue_);
     361
     362        return false;
     363    }
     364
     365    /**
     366        @brief Parses a given std::string into a value of the type int and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
     367        @param input The string to convert
     368        @param defvalue The default-value
     369        @return True if the string was successfully parsed
     370    */
     371    bool ConfigValueContainer::parseSting(const std::string& input, int defvalue)
     372    {
     373        return string2Number(this->value_.value_int_, input, defvalue);
     374    }
     375
     376    /**
     377        @brief Parses a given std::string into a value of the type unsigned int and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
     378        @param input The string to convert
     379        @param defvalue The default-value
     380        @return True if the string was successfully parsed
     381    */
     382    bool ConfigValueContainer::parseSting(const std::string& input, unsigned int defvalue)
     383    {
     384        return string2Number(this->value_.value_uint_, input, defvalue);
     385    }
     386
     387    /**
     388        @brief Parses a given std::string into a value of the type char and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
     389        @param input The string to convert
     390        @param defvalue The default-value
     391        @return True if the string was successfully parsed
     392    */
     393    bool ConfigValueContainer::parseSting(const std::string& input, char defvalue)
     394    {
     395        // I used value_int_ instead of value_char_ to avoid number <-> char confusion in the config-file
     396        return string2Number(this->value_.value_int_, input, (int)defvalue);
     397    }
     398
     399    /**
     400        @brief Parses a given std::string into a value of the type unsigned char and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
     401        @param input The string to convert
     402        @param defvalue The default-value
     403        @return True if the string was successfully parsed
     404    */
     405    bool ConfigValueContainer::parseSting(const std::string& input, unsigned char defvalue)
     406    {
     407        // I used value_uint_ instead of value_uchar_ to avoid number <-> char confusion in the config-file
     408        return string2Number(this->value_.value_uint_, input, (unsigned int)defvalue);
     409    }
     410
     411    /**
     412        @brief Parses a given std::string into a value of the type float and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
     413        @param input The string to convert
     414        @param defvalue The default-value
     415        @return True if the string was successfully parsed
     416    */
     417    bool ConfigValueContainer::parseSting(const std::string& input, float defvalue)
     418    {
     419        return string2Number(this->value_.value_float_, input, defvalue);
     420    }
     421
     422    /**
     423        @brief Parses a given std::string into a value of the type double and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
     424        @param input The string to convert
     425        @param defvalue The default-value
     426        @return True if the string was successfully parsed
     427    */
     428    bool ConfigValueContainer::parseSting(const std::string& input, double defvalue)
     429    {
     430        return string2Number(this->value_.value_double_, input, defvalue);
     431    }
     432
     433    /**
     434        @brief Parses a given std::string into a value of the type long double and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
     435        @param input The string to convert
     436        @param defvalue The default-value
     437        @return True if the string was successfully parsed
     438    */
     439    bool ConfigValueContainer::parseSting(const std::string& input, long double defvalue)
     440    {
     441        return string2Number(this->value_.value_long_double_, input, defvalue);
     442    }
     443
     444    /**
     445        @brief Parses a given std::string into a value of the type bool and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
     446        @param input The string to convert
     447        @param defvalue The default-value
     448        @return True if the string was successfully parsed
     449    */
     450    bool ConfigValueContainer::parseSting(const std::string& input, bool defvalue)
     451    {
     452        // Try to parse the value-string - is it a word?
     453        if (input.find("true") < input.size()
     454         || input.find("True") < input.size()
     455         || input.find("yes") < input.size()
     456         || input.find("Yes") < input.size())
     457            this->value_.value_bool_ = true;
     458        else if (input.find("false") < input.size()
     459              || input.find("False") < input.size()
     460              || input.find("no") < input.size()
     461              || input.find("No") < input.size())
     462            this->value_.value_bool_ = false;
     463        else
     464        {
     465            // Its not a known word - is it a number?
     466            return string2Number(this->value_.value_bool_, input, defvalue);
     467        }
     468
     469        return true;
     470    }
     471
     472    /**
     473        @brief Parses a given std::string into a value of the type std::string and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
     474        @param input The string to convert
     475        @param defvalue The default-value
     476        @return True if the string was successfully parsed
     477    */
     478    bool ConfigValueContainer::parseSting(const std::string& input, const std::string& defvalue)
     479    {
     480        // Strip the quotes
     481        unsigned int pos1 = input.find("\"") + 1;
     482        unsigned int pos2 = input.find("\"", pos1);
     483
     484        // Check if the entry was correctly quoted
     485        if (pos1 < input.length() && pos2 < input.length() && !(input.find("\"", pos2 + 1) < input.length()))
     486        {
     487            // It was - get the string between the quotes
     488            this->value_string_ = input.substr(pos1, pos2 - pos1);
     489            return true;
     490        }
     491
     492        // It wasn't - use the default-value and restore the entry in the config-file.
     493        this->value_string_ = defvalue;
     494        return false;
     495    }
     496
     497    /**
     498        @brief Parses a given std::string into a value of the type const char* and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
     499        @param input The string to convert
     500        @param defvalue The default-value
     501        @return True if the string was successfully parsed
     502    */
     503    bool ConfigValueContainer::parseSting(const std::string& input, const char* defvalue)
     504    {
     505        // Strip the quotes
     506        unsigned int pos1 = input.find("\"") + 1;
     507        unsigned int pos2 = input.find("\"", pos1);
     508
     509        // Check if the entry was correctly quoted
     510        if (pos1 < input.length() && pos2 < input.length() && !(input.find("\"", pos2 + 1) < input.length()))
     511        {
     512            // It was - get the string between the quotes
     513            this->value_string_ = input.substr(pos1, pos2 - pos1);
     514            return true;
     515        }
     516
     517        // It wasn't - use the default-value and restore the entry in the config-file.
     518        this->value_string_ = defvalue;
     519        return false;
     520    }
     521
     522    /**
     523        @brief Parses a given std::string into a value of the type Ogre::Vector2 and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
     524        @param input The string to convert
     525        @param defvalue The default-value
     526        @return True if the string was successfully parsed
     527    */
     528    bool ConfigValueContainer::parseSting(const std::string& input, const Ogre::Vector2& defvalue)
     529    {
    396530        // Strip the value-string
    397         unsigned int pos1 = valueString.find("(") + 1;
    398         unsigned int pos2 = valueString.find(")", pos1);
     531        unsigned int pos1 = input.find("(") + 1;
     532        unsigned int pos2 = input.find(")", pos1);
     533
     534        // Try to convert the stripped value-string to Vector2
     535        if (pos1 < input.length() && pos2 < input.length() && pos1 < pos2)
     536        {
     537            std::vector<std::string> tokens = tokenize(input.substr(pos1, pos2 - pos1), ",");
     538            if (!string2Number(this->value_vector2_.x, tokens[0], defvalue.x))
     539            {
     540                this->value_vector2_ = defvalue;
     541                return false;
     542            }
     543            if (!string2Number(this->value_vector2_.y, tokens[1], defvalue.y))
     544            {
     545                this->value_vector2_ = defvalue;
     546                return false;
     547            }
     548
     549            return true;
     550        }
     551
     552        this->value_vector2_ = defvalue;
     553        return false;
     554    }
     555
     556    /**
     557        @brief Parses a given std::string into a value of the type Ogre::Vector3 and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
     558        @param input The string to convert
     559        @param defvalue The default-value
     560        @return True if the string was successfully parsed
     561    */
     562    bool ConfigValueContainer::parseSting(const std::string& input, const Ogre::Vector3& defvalue)
     563    {
     564        // Strip the value-string
     565        unsigned int pos1 = input.find("(") + 1;
     566        unsigned int pos2 = input.find(")", pos1);
    399567
    400568        // Try to convert the stripped value-string to Vector3
    401         if (pos1 < valueString.length() && pos2 < valueString.length() && pos1 < pos2)
    402         {
    403             valueString = valueString.substr(pos1, pos2 - pos1);
    404             std::vector<std::string> tokens = tokenize(valueString, ",");
     569        if (pos1 < input.length() && pos2 < input.length() && pos1 < pos2)
     570        {
     571            std::vector<std::string> tokens = tokenize(input.substr(pos1, pos2 - pos1), ",");
     572            if (!string2Number(this->value_vector3_.x, tokens[0], defvalue.x))
     573            {
     574                this->value_vector3_ = defvalue;
     575                return false;
     576            }
     577            if (!string2Number(this->value_vector3_.y, tokens[1], defvalue.y))
     578            {
     579                this->value_vector3_ = defvalue;
     580                return false;
     581            }
     582            if (!string2Number(this->value_vector3_.z, tokens[2], defvalue.z))
     583            {
     584                this->value_vector3_ = defvalue;
     585                return false;
     586            }
     587
     588            return true;
     589        }
     590
     591        this->value_vector3_ = defvalue;
     592        return false;
     593    }
     594
     595    /**
     596        @brief Parses a given std::string into a value of the type Ogre::ColourValue and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
     597        @param input The string to convert
     598        @param defvalue The default-value
     599        @return True if the string was successfully parsed
     600    */
     601    bool ConfigValueContainer::parseSting(const std::string& input, const Ogre::ColourValue& defvalue)
     602    {
     603        // Strip the value-string
     604        unsigned int pos1 = input.find("(") + 1;
     605        unsigned int pos2 = input.find(")", pos1);
     606
     607        // Try to convert the stripped value-string to Vector3
     608        if (pos1 < input.length() && pos2 < input.length() && pos1 < pos2)
     609        {
     610            std::vector<std::string> tokens = tokenize(input.substr(pos1, pos2 - pos1), ",");
    405611            if (!string2Number(this->value_colourvalue_.r, tokens[0], defvalue.r))
    406                 this->setConfigFileEntyToDefault();
     612            {
     613                this->value_colourvalue_ = defvalue;
     614                return false;
     615            }
    407616            if (!string2Number(this->value_colourvalue_.g, tokens[1], defvalue.g))
    408                 this->setConfigFileEntyToDefault();
     617            {
     618                this->value_colourvalue_ = defvalue;
     619                return false;
     620            }
    409621            if (!string2Number(this->value_colourvalue_.b, tokens[2], defvalue.b))
    410                 this->setConfigFileEntyToDefault();
     622            {
     623                this->value_colourvalue_ = defvalue;
     624                return false;
     625            }
    411626            if (!string2Number(this->value_colourvalue_.a, tokens[3], defvalue.a))
    412                 this->setConfigFileEntyToDefault();
    413         }
    414         else
    415         {
    416             this->value_colourvalue_ = defvalue;
    417             this->setConfigFileEntyToDefault();
    418         }
    419     }
    420 
    421     /**
    422         @brief Sets the corresponding enty in the config-file back to the default value.
    423     */
    424     void ConfigValueContainer::setConfigFileEntyToDefault()
     627            {
     628                this->value_colourvalue_ = defvalue;
     629                return false;
     630            }
     631
     632            return true;
     633        }
     634
     635        this->value_colourvalue_ = defvalue;
     636        return false;
     637    }
     638
     639    /**
     640        @brief Sets the corresponding entry in the config-file back to the default value.
     641    */
     642    void ConfigValueContainer::resetConfigFileEntry()
    425643    {
    426644        (*this->configFileLine_) = this->varname_ + "=" + this->defvalueString_;
     
    428646    }
    429647
     648    /**
     649        @brief Sets the value of the variable back to the default value.
     650    */
     651    void ConfigValueContainer::resetConfigValue()
     652    {
     653        parseSting(this->defvalueString_);
     654    }
    430655
    431656    /**
Note: See TracChangeset for help on using the changeset viewer.