KeyValue.hpp

// <KeyValue> -*- C++ -*-
 
#pragma once
 
#include <inttypes.h>
#include <vector>
#include <map>
 
#include <boost/mpl/for_each.hpp>
#include <boost/tokenizer.hpp>
//#include <boost/algorithm/string.hpp>
#include <boost/variant.hpp>
#include <boost/foreach.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/insert_range.hpp>
#include <boost/static_assert.hpp>
 
#include "sparta/utils/SpartaException.hpp"
 
 
namespace sparta
{
 
    /* \brief Macro to make the variant type for the different types that a
     * KeyValue can be.  In addition, a type name string list is created
     * which is parsed and turned into a global type/name map for pretty
     * printing.  This is better than saying, your type 'y' doesn't match
     * type 'i'.
     */
    #define MAKE_VARIANT_OVER(...)                                      \
        typedef boost::mpl::vector<__VA_ARGS__> VectorofTypes;          \
        typedef boost::make_variant_over<VectorofTypes>::type ValueVar; \
        static const std::string type_names = #__VA_ARGS__;
 
 
    MAKE_VARIANT_OVER(bool,
                      int32_t,
                      uint32_t,
                      int64_t,
                      uint64_t,
                      double,
                      std::string,
                      std::vector<bool>,
                      std::vector<int32_t>,
                      std::vector<uint32_t>,
                      std::vector<int64_t>,
                      std::vector<uint64_t>,
                      std::vector<double>,
                      std::vector<std::string>)
 
    
    typedef std::map<std::string, std::string> TypeToTypeNameMap;
 
 
    class KeyValue
    {
    public:
 
        static TypeToTypeNameMap GBL_type_name_map;
 
        template <class U>
        KeyValue(const std::string & key,
                 U val,
                 const std::string & desc="") :
            key_(key), value_(val), desc_(desc)
        {
 
            // Why am I allowed to do this?.
            // Variant constructor is to agressive. Holds type as bool.
            //ValueVar x((const char*)"12345");
            //std::cout << x.type().name() << std::endl;
            //std::cout << boost::get<const char*>(x) << std::endl;
 
            // While this is not valid:
            //ValueVar xv(std::pair<int,int>());
            //std::cout << boost::get<std::pair<int,int> >(xv).size() << std::endl;
        }
 
        std::string getKey() const {
            return key_;
        }
 
        void setDesc(const std::string& desc) {
            desc_ = desc;
        }
 
        std::string getDesc() const {
            return key_;
        }
 
        template<class T>
        const T getValue() const {
            try {
                return boost::get<T>(value_);
            }
            catch(const boost::bad_get & e) {
                std::string whatitis = "unknown";
                std::string whatyouwanted = "unknown";
                TypeToTypeNameMap::const_iterator it = GBL_type_name_map.find(value_.type().name());
                if(it != GBL_type_name_map.end()) {
                    whatitis = (*it).second;
                }
                it = GBL_type_name_map.find(typeid(T).name());
                if(it != GBL_type_name_map.end()) {
                    whatyouwanted = (*it).second;
                }
                std::cerr << "ERROR: Attempt to get a '" << whatyouwanted
                          << "' (" << typeid(T).name() << ") type on KeyValue '"
                          << key_ << "' that's a '" << whatitis << "'" << std::endl;
                throw;
            }
        }
 
        template<class T>
        void operator=(const T& rhp) {
            value_ = rhp;
        }
 
        template<class T>
        operator T() const {
            return getValue<T>();
        }
 
        template <typename T>
        static bool hasTypeNameFor() {
            TypeToTypeNameMap::const_iterator it = GBL_type_name_map.find(typeid(T).name());
            if(it != GBL_type_name_map.end()) {
                return true;
            }
            return false;
        }
 
        template <typename T>
        static const std::string& lookupTypeName() {
            TypeToTypeNameMap::const_iterator it = GBL_type_name_map.find(typeid(T).name());
            if(it != GBL_type_name_map.end()) {
                return (*it).second;
            }
            SpartaException e("Could not get compiler-independent type name for \"");
            e << typeid(T).name() << "\". Valid type keys are:";
            for(TypeToTypeNameMap::value_type& p : GBL_type_name_map){
                e << " " << p.first << ":" << p.second << " ";
            }
            throw e;
        }
 
        class TypeNameVisitor : public boost::static_visitor<const std::string&>
        {
        public:
            template <typename T>
            const std::string& operator()(const T&) const { return lookupTypeName<T>(); }
        };
 
        const std::string& getTypeName() const {
            return boost::apply_visitor(TypeNameVisitor(), value_);
        }
 
    protected:
 
        template<class T>
        T& getValueRef_() {
            try {
                return boost::get<T&>(value_);
            }
            catch(const boost::bad_get & e) {
                throw throwBadGet_<T>(e);
            }
        }
 
        template<class T>
        const T& getValueRef_() const {
            try {
                return boost::get<const T&>(value_);
            }
            catch(const boost::bad_get & e) {
                throw throwBadGet_<T>(e);
            }
        }
 
    private:
 
        template<class T>
        const boost::bad_get& throwBadGet_(const boost::bad_get& e) const {
            std::string whatitis = "unknown";
            std::string whatyouwanted = "unknown";
            TypeToTypeNameMap::const_iterator it = GBL_type_name_map.find(value_.type().name());
            if(it != GBL_type_name_map.end()) {
                whatitis = (*it).second;
            }
            it = GBL_type_name_map.find(typeid(T).name());
            if(it != GBL_type_name_map.end()) {
                whatyouwanted = (*it).second;
            }
            std::cerr << "ERROR: Attempt to get a '" << whatyouwanted
                      << "' (" << typeid(T).name() << ") type on KeyValue '"
                      << key_ << "' that's a '" << whatitis << "'" << std::endl;
            throw e;
        }
 
        const std::string key_;
        ValueVar value_;
        std::string desc_;
    }; // KeyValue
 
} // namespace sparta
 
 
#define SPARTA_KVPAIR_BODY \
    namespace sparta                                                      \
    {                                                                   \
        struct NameMapper                                               \
        {                                                               \
            template<class type>                                        \
            void operator()(type) {                                     \
                assert(current_type_ != tok_.end());                    \
                KeyValue::GBL_type_name_map[typeid(type).name()] = boost::trim_left_copy(*current_type_); \
                ++current_type_;                                        \
        }                                                               \
                                                                        \
        NameMapper() : tok_(type_names, boost::char_separator<char>(",")) \
        {                                                               \
            current_type_ = tok_.begin();                               \
            boost::mpl::for_each<ValueVar::types>(*this);                  \
        }                                                               \
                                                                        \
    private:                                                            \
        boost::tokenizer<boost::char_separator<char> >::iterator current_type_; \
        boost::tokenizer<boost::char_separator<char> > tok_;            \
    };                                                                  \
                                                                        \
    TypeToTypeNameMap KeyValue::GBL_type_name_map;                      \
    static NameMapper mapper;                                           \
    }