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 = std::map< const Key, T, Compare, Allocator >
using	listmap_t = 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< Key const, T >>
using	const_iterator = iter< iterator_tag, std::pair< Key const, T > const >

Public Member Functions
T &	operator[] (Key const &key)
iterator	begin () noexcept
const_iterator	begin () const noexcept
const_iterator	cbegin () const noexcept
iterator	end () noexcept
const_iterator	end () const noexcept
const_iterator	cend () const noexcept
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 noexcept
size_type	size () const noexcept
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, std::pair<Key const, T> const>

Definition at line 140 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<Key const, T>>

Definition at line 139 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 41 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 = 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 = 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 39 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 204 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 220 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 ( )

inlinenoexcept

Definition at line 162 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::_maps, util::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().

    {
      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

inlinenoexcept

Definition at line 169 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::_maps, util::begin(), and shims::isSnippetMode().

    {
      auto& 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

inlinenoexcept

Definition at line 177 of file stdmap_shims.h.

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

    {
      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

inlinenoexcept

Definition at line 198 of file stdmap_shims.h.

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

    {
      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 319 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 ( ) const

inlinenoexcept

Definition at line 287 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  )

inlinenoexcept

Definition at line 183 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::_maps, util::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().

    {
      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

inlinenoexcept

Definition at line 190 of file stdmap_shims.h.

References shims::map< Key, T, Compare, Allocator >::_maps, util::end(), and shims::isSnippetMode().

    {
      auto& 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 264 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.

    {
      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 299 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{}));
      }
      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 308 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 236 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(), and fhicl::intermediate_table::find().

    {
      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 249 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 148 of file stdmap_shims.h.

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

    {
      if (isSnippetMode()) {
        for (auto& [stored_key, value] : _maps.listmap) {
          if (stored_key == key)
            return value;
        }
        _maps.listmap.emplace_back(key, T{});
        return _maps.listmap.back().second;
      }
      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

inlinenoexcept

Definition at line 293 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 330 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