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< 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 128 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 127 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 193 of file stdmap_shims.h.

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

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

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

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

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

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

    {
      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

inline

Definition at line 276 of file stdmap_shims.h.

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

inline

Definition at line 171 of file stdmap_shims.h.

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

inline

Definition at line 178 of file stdmap_shims.h.

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

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

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

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

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

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

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

inline

Definition at line 282 of file stdmap_shims.h.

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

---

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

• fhiclcpp/fhiclcpp/stdmap_shims.h