Dictionary.h

Go to the documentation of this file.

// Copyright 2024-2025 Julien Lamy, ICube, Université de Strasbourg-CNRS.
// Part of msl, distributed under the terms of the MIT license.
 
#ifndef _5724fb56_798a_4131_aeb5_cbcdcbe26c97
#define _5724fb56_798a_4131_aeb5_cbcdcbe26c97
 
#include <initializer_list>
#include <memory>
#include <string>
#include <unordered_map>
 
#include <boost/any.hpp>
 
namespace msl
{
 
#define DECLARE_POINTERS(name) \
 \
    using Pointer = std::shared_ptr<name>; \
 \
    using ConstPointer = std::shared_ptr<name const>;
 
class Dictionary
{
public:
    using container = std::unordered_map<std::string, boost::any>;
    
    using value_type = container::value_type;
    
    using iterator = container::iterator;
    using const_iterator = container::const_iterator;
    
    DECLARE_POINTERS(Dictionary);
    
    static std::shared_ptr<Dictionary> New(
        std::initializer_list<value_type> && data)
    {
        return std::make_shared<Dictionary>(data);
    }
    
    Dictionary(std::initializer_list<container::value_type> values);
    
    Dictionary() = default;
    Dictionary(Dictionary const &) = default;
    Dictionary(Dictionary &&) = default;
    Dictionary & operator=(Dictionary const &) = default;
    Dictionary & operator=(Dictionary &&) = default;
    ~Dictionary() = default;
    
    container::mapped_type get(std::string const & key) const;
    
    template<typename T>
    T const & get(std::string const & key) const
    {
        try
        {
            return boost::any_cast<T const &>(this->_dictionary.at(key));
        }
        catch(std::out_of_range const &)
        {
            throw std::out_of_range("No such key: '"+key+"'");
        }
        catch(boost::bad_any_cast const &)
        {
            throw std::runtime_error("Wrong type for key: '"+key+"'");
        }
    }
    
    template<typename T>
    T & get(std::string const & key)
    {
        try
        {
            return boost::any_cast<T &>(this->_dictionary.at(key));
        }
        catch(std::out_of_range const &)
        {
            throw std::out_of_range("No such key: '"+key+"'");
        }
        catch(boost::bad_any_cast const &)
        {
            throw std::runtime_error("Wrong type for key: '"+key+"'");
        }
    }
    
    bool has(std::string const & key) const;
    
    boost::typeindex::type_info const & type(std::string const & key) const;
    
    template<typename T>
    Dictionary & set(std::string const & key, T && value)
    {
        this->_dictionary[key] = value;
        return *this;
    }
    
    bool empty() const;
    
    size_t size() const;
    
    iterator begin();
    const_iterator begin() const;
    const_iterator cbegin() const;
    
    iterator end();
    const_iterator end() const;
    const_iterator cend() const;
    
    Dictionary & clear();
    
    Dictionary & insert(std::initializer_list<value_type> && data);
    
private:
    container _dictionary;
};
 
}
 
#endif // _5724fb56_798a_4131_aeb5_cbcdcbe26c97