|| || || || || || || ||

---

PropertySet.h

Go to the documentation of this file.

#ifndef Impala_Util_PropertySet_h
#define Impala_Util_PropertySet_h

#include "Basis/String.h"
#include "Util/IOBuffer.h"

namespace Impala
{
namespace Util
{

class PropertySet
{
public:
    /* please note that copy contructor or functions are not necessary because
       we only have 'simple' data members (i.e. no pointers) */
    PropertySet()
    {
    }

    PropertySet(const std::string& definition)
    {
        Parse(definition);
    }

    void Clear()
    {
        mNames.clear();
        mValues.clear();
    }

    void Parse(const std::string& definition)
    {
        Clear();
        std::istringstream iss(definition);
        //parse defintion string to initialise params
        while(!iss.eof())
        {
            std::string pair;
            iss >> pair;
            if(pair.length() > 0)
            {
                std::string::size_type pos = pair.find('=');
                if(pos == std::string::npos)
                    break;
                std::string name;
                std::string value;
                name = pair.substr(0,pos);
                value = pair.substr(pos+1);
                Add(name, value);
            }
        }

    }

    std::string GetString(const std::string& name, const std::string defaultValue = "") const
    {
        for(int i=0 ; i<mNames.size() ; ++i)
            if(mNames[i] == name)
                return mValues[i];
        return defaultValue;
    }

    double GetDouble(const std::string& name, double defaultValue = 0.) const
    {
        std::string val = GetString(name);
        if(val == "")
            return defaultValue;
        return atof(val);
    }

    int GetInt(const std::string& name, int defaultValue = 0) const
    {
        std::string val = GetString(name);
        if(val == "")
            return defaultValue;
        return atoi(val);
    }

    bool GetBool(const std::string& name, bool defaultValue = false) const
    {
        std::string val = GetString(name);
        if(val == "")
            return defaultValue;
        return StringToBool(val);
    }

    int Add(const std::string& name, double value)
    {
        return Add(name, MakeString(value));
    }

    int Add(const std::string& name, const std::string& value)
    {
        int i;
        for(i=0 ; i<mNames.size() ; ++i)
            if(mNames[i] == name)
            {
                mValues[i] = value;
                return i;
            }
        mNames.push_back(name);
        mValues.push_back(value);
        return i;
    }

    void Print(std::ostream& os) const
    {
        for(int i=0 ; i<mNames.size() ; ++i)
            os << mNames[i] << "=" << mValues[i] << " ";
    }

    void Print(IOBuffer* buf) const
    {
        std::string res;
        for(int i=0 ; i<mNames.size() ; ++i)
            res += mNames[i] + "=" + mValues[i] +" ";
        buf->Puts(res);
    }

    std::string GetDescription() const
    {
        std::ostringstream oss;
        Print(oss);
        return oss.str();
    }

    int Size() const
    {
        return mNames.size();
    }

    std::string GetName(int i) const
    {
        return mNames[i];
    }

    std::string GetValue(int i) const
    {
        return mValues[i];
    }

private:
    std::vector<std::string> mNames;
    std::vector<std::string> mValues;
};

void Append(PropertySet* dst, const PropertySet* src)
{
    int i;
    for(i=0 ; i<src->Size() ; ++i)
        dst->Add(src->GetName(i), src->GetValue(i));
}

std::ostream& operator<< (std::ostream& os, const PropertySet& ps)
{
    ps.Print(os);
    return os;
}

}//namespace Util
}//namespace Impala

#endif

---