util/Map.h

#ifndef ROSE_Map_H
#define ROSE_Map_H
 
#include <boost/optional.hpp>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#endif
 
#include <stdexcept>
#include <map>
 
template<class Key, class T, class Compare=std::less<Key>, class Alloc=std::allocator<std::pair<const Key, T> > >
class Map: public std::map<Key, T, Compare, Alloc> {
public:
    typedef std::map<Key, T, Compare, Alloc> map_type;
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(map_type);
    }
#endif
 
public:
    // Constructors are the same as for std::map
    Map() {}
 
    explicit Map(const Compare& comp, const Alloc& alloc = Alloc())
        : map_type(comp, alloc) {}
 
    template <class InputIterator>
    Map(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Alloc& alloc = Alloc())
        : map_type(first, last, comp, alloc) {};
 
    Map(const Map& other)
        : map_type(other) {}
 
    Map& operator=(const Map&) = default;
 
    boost::optional<T> get(const Key &key) const {
        typename map_type::const_iterator found = this->find(key);
        return found==this->end() ? boost::optional<T>() : boost::optional<T>(found->second);
    }
    boost::optional<T> get(const Key &key) const  {…}
 
    const T& get_one(const Key &key) const {
        typename map_type::const_iterator found = this->find(key);
        if (found==this->end())
            throw std::domain_error("key not present in map");
        return found->second;
    }
    const T& get_one(const Key &key) const  {…}
    T& get_one(const Key &key) {
        typename map_type::iterator found = this->find(key);
        if (found==this->end())
            throw std::domain_error("key not present in map");
        return found->second;
    }
    T& get_one(const Key &key) {…}
    const T& get_value_or(const Key& key, const T& dflt) const {
        typename map_type::const_iterator found = this->find(key);
        return found==this->end() ? dflt : found->second;
    }
    const T& get_value_or(const Key& key, const T& dflt) const  {…}
    T& get_value_or(const Key& key, T& dflt) {
        typename map_type::iterator found = this->find(key);
        return found==this->end() ? dflt : found->second;
    }
    T& get_value_or(const Key& key, T& dflt) {…}
    bool exists(const Key &key) const { return this->find(key)!=this->end(); }
};
class Map: public std::map<Key, T, Compare, Alloc> {…};
 
#endif