Property.hpp

Go to the documentation of this file.

#ifndef SRC_CONFIGURATION_PROPERTY_HPP_
#define SRC_CONFIGURATION_PROPERTY_HPP_

#include <string>

#include <boost/lexical_cast.hpp>
#include <boost/function.hpp>

#include <boost/preprocessor/list.hpp>
#include <boost/preprocessor/tuple/to_list.hpp>

#include <typeinfo>
#include <map>
#include <sstream>

#include <iostream>

namespace mic {

namespace configuration {

template<typename T>
class LexicalTranslator {
public:
    static std::string toStr(const T & val) {
        try {
            return boost::lexical_cast<std::string>(val);
        } catch(...) {
            std::stringstream ss;
            ss << val;
            return ss.str();
        }
        return "";
    }

    static T fromStr(const std::string & str) {
        try {
            return boost::lexical_cast<T>(str);
        } catch (...) {
            std::stringstream ss(str);
            T ret;
            ss >> ret;
            return ret;
        }
        return T();
    }
};


class PropertyInterface {
public:

    PropertyInterface(const std::string & name_) :
        property_name(name_) {
    }

    virtual ~PropertyInterface() {}

    const std::string & name() const {
        return property_name;
    }

    virtual void setValue(const std::string & str) = 0;

    virtual std::string getValue() = 0;

private:
    std::string property_name;

};



template<class T, class Translator = LexicalTranslator<T> >
class Property : public PropertyInterface {
public:
    Property(const std::string& name_, const T & initializer_ = T(),
            std::string type_ = typeid(T).name()) : PropertyInterface(name_),
            property_value(initializer_), property_type(type_) {
    }

    T operator()() const {
        return property_value;
    }

    T operator()(T const & value_) {
        property_value = value_;
        return property_value;
    }

    operator T() const {
        return property_value;
    }

    Property<T>& operator=(T const & value_) {
        property_value = value_;
        return *this;
    }

    bool operator==(T const & value_) {
        return property_value == value_;
    }

    bool operator!=(T const & value_) {
        return property_value != value_;
    }


    virtual void setValue(const std::string & str) {
        property_value = Translator::fromStr(str);
    }

    virtual std::string getValue() {
        return Translator::toStr(property_value);
    }

    std::string type() const {
        return property_type;
    }


    friend std::ostream & operator<<(std::ostream & os, const Property & prop) {
        os << prop.property_value;
        return os;
    }

protected:
    T property_value;

    std::string property_type;

};


typedef std::pair<std::string, PropertyInterface *> PropertyPair;

} /* namespace configuration */
} /* namespace mic */



#endif /* SRC_CONFIGURATION_PROPERTY_HPP_ */