source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/Environment.cpp @ 2829

#include "Environment.h"


using namespace std;


namespace CHCDemoEngine
{


bool Environment::GetFloatParam(std::string &str, float &val) const
{
        map<string, string>::const_iterator it = mParams.find(str);

        if (it == mParams.end()) // parameter not found
                return false;
        
        val = (float)atof((*it).second.c_str());

        return true;
}


bool Environment::GetIntParam(std::string &str, int &val) const
{
        map<string, string>::const_iterator it = mParams.find(str);

        if (it == mParams.end()) // parameter not found
                return false;
        
        val = atoi((*it).second.c_str());

        return true;
}


bool Environment::GetBoolParam(std::string &str, bool &val) const
{
        map<string, string>::const_iterator it = mParams.find(str);

        if (it == mParams.end()) // parameter not found
                return false;
        
        val = (bool)atoi((*it).second.c_str());

        return true;
}


bool Environment::GetVectorParam(std::string &str, Vector3 &val) const
{
        map<string, string>::const_iterator it = mParams.find(str);

        static vector<string> tokens;
        tokens.clear();

        if (it == mParams.end()) // parameter not found
                return false;
        
        // parse vector values
        Tokenize((*it).second, tokens);

        val.x = (float)atof(tokens[0].c_str());
        val.y = (float)atof(tokens[1].c_str());
        val.z = (float)atof(tokens[2].c_str());

        return true;
}


bool Environment::Read(const string &filename)
{
        FILE *file;
        if ((file = fopen(filename.c_str(), "rt")) == NULL)
                return false;

        char str[256];

        while (fgets(str, 256, file) != NULL)
        {
                // this line is empty or a comment
                if ((strlen(str) <= 1) || (str[0] == '#'))
                        continue;

                static vector<string> tokens;
                tokens.clear();

                Tokenize(str, tokens, "=");

                if (tokens.size() == 1)
                        cerr << "parsing failed at: " << tokens[0] << endl;
                // store parameter
                mParams[tokens[0]] = tokens[1];
        }

        return true;
}


void Environment::Tokenize(const string& str,
                                                   vector<string> &tokens,
                                                   const string &delim) const
{
    // skip delimiters the string begins with
    string::size_type lastPos = str.find_first_not_of(delim, 0);
    // find next delimiter
    string::size_type pos = str.find_first_of(delim, lastPos);

        // find tokens until string has been completely parsed
    while ((string::npos != pos) || (string::npos != lastPos))
    {
        // add new token
        tokens.push_back(str.substr(lastPos, pos - lastPos));
        // skip delimiters, go to start of next token
        lastPos = str.find_first_not_of(delim, pos);
        // found next delimiter
        pos = str.find_first_of(delim, lastPos);
    }
}


}