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

---

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/StringParser.h"
#include "Util/IOBuffer.h"
#include "Persistency/File.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(CString definition)
    {
        Parse(definition);
    }

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

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

    }

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

    double
    GetDouble(CString name, double defaultValue = 0.) const
    {
        String val = GetString(name);
        if (val == "")
            return defaultValue;
        return atof(val);
    }

    int
    GetInt(CString name, int defaultValue = 0) const
    {
        String val = GetString(name);
        if (val == "")
            return defaultValue;
        return atoi(val);
    }

    bool
    GetBool(CString name, bool defaultValue = false) const
    {
        String val = GetString(name);
        if (val == "")
            return defaultValue;
        return StringToBool(val);
    }

    void
    Remove(CString name)
    {
        for (int i=mNames.size()-1 ; i>=0 ; i--)
        {
            if (mNames[i] == name)
            {
                mNames.erase(mNames.begin()+i);
                mValues.erase(mValues.begin()+i);
            }
        }
    }

    int
    Add(CString name, double value)
    {
        return Add(name, MakeString(value));
    }

    int
    Add(CString name, CString 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
    {
        String res;
        for (int i=0 ; i<mNames.size() ; i++)
            res += mNames[i] + "=" + mValues[i] + " ";
        buf->Puts(res);
    }

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

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

    String
    GetName(int i) const
    {
        return mNames[i];
    }

    String
    GetValue(int i) const
    {
        return mValues[i];
    }

    int
    GetIndexOfName(CString name) const
    {
        for (int i=0 ; i<mNames.size() ; i++)
            if (mNames[i] == name)
                return i;
        return Size();
    }

    int
    Diff(const PropertySet* arg) const
    {
        if (Size() != arg->Size())
        {
            ILOG_ERROR("Diff: Size differs: " << Size() << " vs " <<
                       arg->Size());
            return 1;
        }
        int nDiff = 0;
        for (int i=0 ; i<Size() ; i++)
        {
            String name = GetName(i);
            int argIndex = arg->GetIndexOfName(name);
            if (argIndex == arg->Size())
            {
                ILOG_DEBUG("arg doesn't have " << name);
                nDiff++;
                continue;
            }
            String value = GetValue(i);
            String argValue = arg->GetValue(argIndex);
            if (value != argValue)
            {
                ILOG_DEBUG("prop " << name << " differs " << value <<
                           " vs " << argValue);
                nDiff++;
            }
        }
        if (nDiff > 0)
            ILOG_ERROR("Found " << nDiff << " differences");
        return nDiff;
    }

private:

    std::vector<String> mNames;
    std::vector<String> mValues;

    ILOG_CLASS;
};

ILOG_CLASS_INIT(PropertySet, Impala.Util);

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

void
Read(PropertySet* props, IOBuffer* buf)
{
    ILOG_FUNCTION(Impala.Util.PropertySet.Read);
    if (buf == 0 || !buf->Valid())
    {
        ILOG_ERROR("Invalid io buffer");
        return;
    }
    String line = buf->ReadLine();
    if (line.find(':', 0) != String::npos)
    {
        // old style best file
        StringParser p(line);
        String s = p.GetString(':', true);
        if (s != "value")
        {
            ILOG_ERROR("Parse error in bestfile: "<< s <<" unexpected");
            return;
        }
        props->Add("value", p.GetDouble());
        line = buf->ReadLine();
    }
    
    // read normal propertyset; assume all is on one line
    PropertySet readProps(line);
    Append(props, &readProps);
}

bool
Read(PropertySet* props, Persistency::File file)
{
    ILOG_FUNCTION(Impala.Util.PropertySet.Read);
    IOBuffer* buf = file.GetReadBuffer();
    if (buf)
    {
        Read(props, buf);
        delete buf;
        return true;
    }
    return false;
}

bool
Write(PropertySet* props, IOBuffer* buf)
{
    ILOG_FUNCTION(Impala.Util.PropertySet.Write);
    if(buf == 0 || !buf->Valid())
    {
        ILOG_ERROR("invalid io buffer");
        return false;
    }
    buf->Puts(props->GetDescription());
    return true;
}

bool
Write(PropertySet* props, Persistency::File file)
{
    IOBuffer* buf = file.GetWriteBuffer();
    if (buf)
    {
        Write(props, buf);
        delete buf;
        return true;
    }
    return false;
}

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

} //namespace Util
} //namespace Impala

#endif

---