shims::map< Key, T, Compare, Allocator > Class Template Reference

#include "stdmap_shims.h"

Classes
struct	iter
struct	iterator_tuple
struct	maps_tuple

Public Types
using	mapmap_t = typename std::map< const Key, T, Compare, Allocator >
using	listmap_t = typename std::list< std::pair< const Key, T >, Allocator >
using	size_type = typename mapmap_t::size_type
using	iterator_tag = std::input_iterator_tag
using	iterator = iter< iterator_tag, std::pair< const Key, T >>
using	const_iterator = iter< iterator_tag, const std::pair< const Key, T >>

Public Member Functions
T &	operator[] (Key const &key)
iterator	begin ()
const_iterator	begin () const
const_iterator	cbegin () const
iterator	end ()
const_iterator	end () const
const_iterator	cend () const
T &	at (Key const &key)
T const &	at (Key const &key) const
iterator	find (Key const &key)
const_iterator	find (Key const &key) const
size_t	erase (Key const &key)
bool	empty () const
size_type	size () const
iterator	erase (iterator it)
iterator	erase (const_iterator &it)
template<class... Args>
std::pair< iterator, bool >	emplace (Args &&...args)

Public Attributes
maps_tuple	_maps

Detailed Description

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
class shims::map< Key, T, Compare, Allocator >

Definition at line 21 of file stdmap_shims.h.

Member Typedef Documentation

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

using shims::map< Key, T, Compare, Allocator >::const_iterator = iter<iterator_tag, const std::pair<const Key, T>>

Definition at line 133 of file stdmap_shims.h.

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

using shims::map< Key, T, Compare, Allocator >::iterator = iter<iterator_tag, std::pair<const Key, T>>

Definition at line 132 of file stdmap_shims.h.

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

using shims::map< Key, T, Compare, Allocator >::iterator_tag = std::input_iterator_tag

Definition at line 43 of file stdmap_shims.h.

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

using shims::map< Key, T, Compare, Allocator >::listmap_t = typename std::list<std::pair<const Key, T>, Allocator>

Definition at line 24 of file stdmap_shims.h.

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

using shims::map< Key, T, Compare, Allocator >::mapmap_t = typename std::map<const Key, T, Compare, Allocator>

Definition at line 23 of file stdmap_shims.h.

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

using shims::map< Key, T, Compare, Allocator >::size_type = typename mapmap_t::size_type

Definition at line 41 of file stdmap_shims.h.

Member Function Documentation

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

T& shims::map< Key, T, Compare, Allocator >::at ( Key const &  key )

inline

Definition at line 199 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::_maps, shims::isSnippetMode(), shims::map< Key, T, Compare, Allocator >::maps_tuple::listmap, and shims::map< Key, T, Compare, Allocator >::maps_tuple::mapmap.

    {
      if (isSnippetMode()) {
        auto it =
          std::find_if(_maps.listmap.begin(),
                       _maps.listmap.end(),
                       [&key](auto& element) { return element.first == key; });
        if (it == _maps.listmap.end())
          throw std::out_of_range("Key <" + key + "> not found.");
        return it->second;
      } else {
        return _maps.mapmap.at(key);
      }
    }

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

T const& shims::map< Key, T, Compare, Allocator >::at ( Key const &  key ) const

inline

Definition at line 215 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::_maps, shims::isSnippetMode(), shims::map< Key, T, Compare, Allocator >::maps_tuple::listmap, and shims::map< Key, T, Compare, Allocator >::maps_tuple::mapmap.

    {
      if (isSnippetMode()) {
        auto it = std::find_if(
          _maps.listmap.cbegin(),
          _maps.listmap.cend(),
          [&key](auto const& element) { return element.first == key; });
        if (it == _maps.listmap.cend())
          throw std::out_of_range("Key <" + key + "> not found.");
        return it->second;
      } else {
        return _maps.mapmap.at(key);
      }
    }

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

iterator shims::map< Key, T, Compare, Allocator >::begin ( )

inline

Definition at line 155 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::_maps, evd::details::begin(), shims::isSnippetMode(), shims::map< Key, T, Compare, Allocator >::maps_tuple::listmap, and shims::map< Key, T, Compare, Allocator >::maps_tuple::mapmap.

Referenced by shims::map< Key, T, Compare, Allocator >::cbegin(), fhicl::detail::encode(), and fhicl::extended_value::set_prolog().

    {
      return isSnippetMode() ? iterator{std::begin(_maps.listmap)} :
                               iterator{std::begin(_maps.mapmap)};
    }

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

const_iterator shims::map< Key, T, Compare, Allocator >::begin ( ) const

inline

Definition at line 162 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::_maps, evd::details::begin(), shims::isSnippetMode(), shims::map< Key, T, Compare, Allocator >::maps_tuple::listmap, and shims::map< Key, T, Compare, Allocator >::maps_tuple::mapmap.

    {
      maps_tuple& maps = *const_cast<maps_tuple*>(&_maps);

      return isSnippetMode() ? const_iterator{std::begin(maps.listmap)} :
                               const_iterator{std::begin(maps.mapmap)};
    }

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

const_iterator shims::map< Key, T, Compare, Allocator >::cbegin ( ) const

inline

Definition at line 171 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::begin().

Referenced by fhicl::extended_value::to_string().

    {
      return begin();
    }

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

const_iterator shims::map< Key, T, Compare, Allocator >::cend ( ) const

inline

Definition at line 193 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::end().

Referenced by fhicl::extended_value::to_string().

    {
      return end();
    }

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

template<class... Args>

std::pair<iterator, bool> shims::map< Key, T, Compare, Allocator >::emplace ( Args &&...  args )

inline

Definition at line 315 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::_maps, shims::isSnippetMode(), shims::map< Key, T, Compare, Allocator >::maps_tuple::listmap, and shims::map< Key, T, Compare, Allocator >::maps_tuple::mapmap.

    {
      if (isSnippetMode()) {
        _maps.listmap.emplace_back(std::forward<Args>(args)...);
        return std::make_pair(iterator{std::prev(_maps.listmap.end())}, true);
      } else {
        auto result = _maps.mapmap.emplace(std::forward<Args>(args)...);
        return std::make_pair(iterator{result.first}, result.second);
      }
    }

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

bool shims::map< Key, T, Compare, Allocator >::empty ( void  ) const

inline

Definition at line 282 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::_maps, shims::isSnippetMode(), shims::map< Key, T, Compare, Allocator >::maps_tuple::listmap, and shims::map< Key, T, Compare, Allocator >::maps_tuple::mapmap.

    {
      return isSnippetMode() ? _maps.listmap.empty() : _maps.mapmap.empty();
    }

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

iterator shims::map< Key, T, Compare, Allocator >::end ( void  )

inline

Definition at line 177 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::_maps, evd::details::end(), shims::isSnippetMode(), shims::map< Key, T, Compare, Allocator >::maps_tuple::listmap, and shims::map< Key, T, Compare, Allocator >::maps_tuple::mapmap.

Referenced by shims::map< Key, T, Compare, Allocator >::cend(), fhicl::detail::encode(), fhicl::intermediate_table::exists(), fhicl::intermediate_table::find(), fhicl::intermediate_table::pre_insert_(), and fhicl::extended_value::set_prolog().

    {
      return isSnippetMode() ? iterator{std::end(_maps.listmap)} :
                               iterator{std::end(_maps.mapmap)};
    }

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

const_iterator shims::map< Key, T, Compare, Allocator >::end ( void  ) const

inline

Definition at line 184 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::_maps, evd::details::end(), shims::isSnippetMode(), shims::map< Key, T, Compare, Allocator >::maps_tuple::listmap, and shims::map< Key, T, Compare, Allocator >::maps_tuple::mapmap.

    {
      maps_tuple& maps = *const_cast<maps_tuple*>(&_maps);

      return isSnippetMode() ? const_iterator{std::end(maps.listmap)} :
                               const_iterator{std::end(maps.mapmap)};
    }

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

size_t shims::map< Key, T, Compare, Allocator >::erase ( Key const &  key )

inline

Definition at line 259 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::_maps, e, shims::isSnippetMode(), shims::map< Key, T, Compare, Allocator >::maps_tuple::listmap, and shims::map< Key, T, Compare, Allocator >::maps_tuple::mapmap.

Referenced by fhicl::intermediate_table::pre_insert_().

    {
      if (isSnippetMode()) {
        auto erase_count = size_t{0};
        auto i = _maps.listmap.begin();
        auto e = _maps.listmap.end();

        while (i != e) {
          if (key == i->first) {
            i = _maps.listmap.erase(i);
            ++erase_count;
          } else {
            i++;
          }
        }

        return erase_count;
      } else {
        return _maps.mapmap.erase(key);
      }
    }

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

iterator shims::map< Key, T, Compare, Allocator >::erase ( iterator  it )

inline

Definition at line 294 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::_maps, shims::map< Key, T, Compare, Allocator >::iter< Category, TT, Distance, Pointer, Reference >::get(), shims::isSnippetMode(), shims::map< Key, T, Compare, Allocator >::maps_tuple::listmap, and shims::map< Key, T, Compare, Allocator >::maps_tuple::mapmap.

    {
      if (isSnippetMode()) {
        return _maps.listmap.erase(it.get(typename listmap_t::iterator{}));
      } else {
        return _maps.mapmap.erase(it.get(typename mapmap_t::iterator{}));
      }
    }

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

iterator shims::map< Key, T, Compare, Allocator >::erase ( const_iterator &  it )

inline

Definition at line 304 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::_maps, shims::map< Key, T, Compare, Allocator >::iter< Category, TT, Distance, Pointer, Reference >::get(), shims::isSnippetMode(), shims::map< Key, T, Compare, Allocator >::maps_tuple::listmap, and shims::map< Key, T, Compare, Allocator >::maps_tuple::mapmap.

    {
      if (isSnippetMode()) {
        return _maps.listmap.erase(it.get(typename listmap_t::iterator{}));
      } else {
        return _maps.mapmap.erase(it.get(typename mapmap_t::iterator{}));
      }
    }

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

iterator shims::map< Key, T, Compare, Allocator >::find ( Key const &  key )

inline

Definition at line 231 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::_maps, shims::isSnippetMode(), shims::map< Key, T, Compare, Allocator >::maps_tuple::listmap, and shims::map< Key, T, Compare, Allocator >::maps_tuple::mapmap.

Referenced by fhicl::intermediate_table::erase(), fhicl::intermediate_table::exists(), fhicl::intermediate_table::find(), and fhicl::intermediate_table::pre_insert_().

    {
      if (isSnippetMode()) {
        return std::find_if(
          _maps.listmap.begin(), _maps.listmap.end(), [&key](auto& element) {
            return element.first == key;
          });
      } else {
        return _maps.mapmap.find(key);
      }
    }

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

const_iterator shims::map< Key, T, Compare, Allocator >::find ( Key const &  key ) const

inline

Definition at line 244 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::_maps, shims::isSnippetMode(), shims::map< Key, T, Compare, Allocator >::maps_tuple::listmap, and shims::map< Key, T, Compare, Allocator >::maps_tuple::mapmap.

    {
      maps_tuple& maps = *const_cast<maps_tuple*>(&_maps);

      if (isSnippetMode()) {
        return std::find_if(
          maps.listmap.begin(),
          maps.listmap.end(),
          [&key](auto const& element) { return element.first == key; });
      } else {
        return maps.mapmap.find(key);
      }
    }

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

T& shims::map< Key, T, Compare, Allocator >::operator[] ( Key const &  key )

inline

Definition at line 140 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::_maps, shims::isSnippetMode(), shims::map< Key, T, Compare, Allocator >::maps_tuple::listmap, and shims::map< Key, T, Compare, Allocator >::maps_tuple::mapmap.

    {
      if (isSnippetMode()) {
        for (auto& element : _maps.listmap) {
          if (element.first == key)
            return element.second;
        }
        _maps.listmap.emplace_back(std::make_pair(key, T{}));
        return _maps.listmap.back().second;
      } else {
        return _maps.mapmap[key];
      }
    }

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

size_type shims::map< Key, T, Compare, Allocator >::size ( void  ) const

inline

Definition at line 288 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::_maps, shims::isSnippetMode(), shims::map< Key, T, Compare, Allocator >::maps_tuple::listmap, and shims::map< Key, T, Compare, Allocator >::maps_tuple::mapmap.

    {
      return isSnippetMode() ? _maps.listmap.size() : _maps.mapmap.size();
    }

Member Data Documentation

template<class Key , class T , class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

maps_tuple shims::map< Key, T, Compare, Allocator >::_maps

Definition at line 326 of file stdmap_shims.h.

Referenced by shims::map< Key, T, Compare, Allocator >::at(), shims::map< Key, T, Compare, Allocator >::begin(), shims::map< Key, T, Compare, Allocator >::emplace(), shims::map< Key, T, Compare, Allocator >::empty(), shims::map< Key, T, Compare, Allocator >::end(), shims::map< Key, T, Compare, Allocator >::erase(), shims::map< Key, T, Compare, Allocator >::find(), shims::map< Key, T, Compare, Allocator >::operator[](), and shims::map< Key, T, Compare, Allocator >::size().

---

The documentation for this class was generated from the following file:

• fhiclcpp/stdmap_shims.h