Parameter.h

浏览该文件的文档.

/*
 * Parameter.h
 *
 *  Created on: 2013-2-28
 *      Author: fasiondog
 */

#ifndef PARAMETER_H_
#define PARAMETER_H_

#include <iostream>
#include <stdexcept>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <boost/any.hpp>

#include "../config.h"

#if HKU_SUPPORT_SERIALIZATION
#include <boost/lexical_cast.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/split_member.hpp>
#include <boost/serialization/nvp.hpp>
#endif


#ifndef DATATYPE_H_
    #ifndef HKU_API
    #define HKU_API
    #endif
#endif

namespace hku {

#ifndef DATATYPE_H_
    using std::string;
    using std::map;
    using std::vector;
    typedef vector<string> StringList;
#endif


class HKU_API Parameter {
    HKU_API friend std::ostream& operator <<(std::ostream &os,
            const Parameter& param);

public:
    Parameter();
    Parameter(const Parameter&);
    virtual ~Parameter();

    Parameter& operator=(const Parameter&);

    static bool support(const boost::any&);

    StringList getNameList() const;

    string getValueList() const;

    string getNameValueList() const;

    bool have(const string& name) const {
        return m_params.count(name) == 0 ? false : true;
    }

    template <typename ValueType>
    void set(const string& name, const ValueType& value);

    template <typename ValueType>
    ValueType get(const string& name) const;

private:
    typedef map<string, boost::any> param_map_t;
    param_map_t m_params;

//================================
// 序列化支持
//================================
#if HKU_SUPPORT_SERIALIZATION
private:
    friend class boost::serialization::access;

    struct ItemRecord {
        friend class boost::serialization::access;

        ItemRecord() {}
        ItemRecord(const string& name, const boost::any& arg): name(name) {
            if (arg.type() == typeid(bool)) {
                type = "bool";
                bool x = boost::any_cast<bool>(arg);
                value = boost::lexical_cast<string>(x);
            } else if (arg.type() == typeid(int)) {
                type = "int";
                int x = boost::any_cast<int>(arg);
                value = boost::lexical_cast<string>(x);
            } else if (arg.type() == typeid(double)) {
                type = "double";
                double x = boost::any_cast<double>(arg);
                value = boost::lexical_cast<string>(x);
            } else if (arg.type() == typeid(string)) {
                type = "string";
                value = boost::any_cast<string>(arg);
            } else {
                type = "Unknown";
                value = "Unknown";
            }
        }

        string name;
        string type;
        string value;

        template<class Archive>
        void serialize(Archive & ar, const unsigned int version) {
            ar & BOOST_SERIALIZATION_NVP(name);
            ar & BOOST_SERIALIZATION_NVP(type);
            ar & BOOST_SERIALIZATION_NVP(value);
        }
    };

    template<class Archive>
    void save(Archive & ar, const unsigned int version) const{
        namespace bs = boost::serialization;
        size_t total = m_params.size();
        ar & bs::make_nvp<size_t>("count", total);
        param_map_t::const_iterator iter = m_params.begin();
        for (; iter != m_params.end(); ++iter) {
            ItemRecord record(iter->first, iter->second);
            ar & bs::make_nvp<ItemRecord>("Item", record);
        }
    }

    template<class Archive>
    void load(Archive & ar, const unsigned int version)  {
        namespace bs = boost::serialization;
        size_t total = 0;
        ar & bs::make_nvp<size_t>("count", total);
        ItemRecord record;
        for (size_t i = 0; i < total; i++) {
            ar & bs::make_nvp<ItemRecord>("Item", record);

            if (record.type == "bool") {
                m_params[record.name] = boost::lexical_cast<bool>(record.value);
            } else if (record.type == "int") {
                m_params[record.name] = boost::lexical_cast<int>(record.value);
            } else if (record.type == "double") {
                m_params[record.name] = boost::lexical_cast<double>(record.value);
            } else if (record.type == "string") {
                m_params[record.name] = record.value;
            } else {
                std::cout << "Unknown type! [Parameter::load]" << std::endl;
            }
        }
    }
    BOOST_SERIALIZATION_SPLIT_MEMBER()
#endif /* HKU_SUPPORT_SERIALIZATION */
};


#define PARAMETER_SUPPORT protected: \
    Parameter m_params; \
    public: \
    const Parameter& getParameter() const { \
        return m_params; \
    } \
    \
    void setParameter(const Parameter& param) { \
        m_params = param; \
    } \
    \
    bool haveParam(const string& name) const { \
        return m_params.have(name); \
    } \
    \
    template <typename ValueType> \
    void setParam(const string& name, const ValueType& value) { \
        m_params.set<ValueType>(name, value); \
    } \
    \
    template <typename ValueType> \
    ValueType getParam(const string& name) const { \
        return m_params.get<ValueType>(name); \
    }


template <typename ValueType>
ValueType Parameter::get(const string& name) const {
    param_map_t::const_iterator iter;
    iter = m_params.find(name);
    if (iter == m_params.end()) {
        throw std::out_of_range("out_of_range in Parameter::get : " + name);
    }
    return boost::any_cast<ValueType>(iter->second);
}


template <typename ValueType>
void Parameter::set(const string& name, const ValueType& value) {
    if( !have(name)){
        if (!support(value)){
            throw std::logic_error("Unsuport Type! " + name);
            return;
        }
        m_params[name] = value;
        return;
    }

    if (m_params[name].type() != typeid(ValueType)) {
        throw std::logic_error("Mismatching type! " + name);
        return;
    }

    m_params[name] = value;
}


HKU_API bool operator==(const Parameter&, const Parameter&);
HKU_API bool operator!=(const Parameter&, const Parameter&);
HKU_API bool operator<(const Parameter&, const Parameter&);

} /* namespace hku */
#endif /* PARAMETER_H_ */