Goby3  3.1.5a
2024.05.23
ordered_map< Key, T, IgnoredLess, Allocator > Struct Template Reference

a minimal map-like container that preserves insertion order More...

#include <goby/util/thirdparty/nlohmann/json.hpp>

Public Types

using key_type = Key
 
using mapped_type = T
 
using Container = std::vector< std::pair< const Key, T >, Allocator >
 
using iterator = typename Container::iterator
 
using const_iterator = typename Container::const_iterator
 
using size_type = typename Container::size_type
 
using value_type = typename Container::value_type
 
using key_compare = std::equal_to< Key >
 
template<typename InputIt >
using require_input_iter = typename std::enable_if< std::is_convertible< typename std::iterator_traits< InputIt >::iterator_category, std::input_iterator_tag >::value >::type
 

Public Member Functions

 ordered_map () noexcept(noexcept(Container()))
 
 ordered_map (const Allocator &alloc) noexcept(noexcept(Container(alloc)))
 
template<class It >
 ordered_map (It first, It last, const Allocator &alloc=Allocator())
 
 ordered_map (std::initializer_list< value_type > init, const Allocator &alloc=Allocator())
 
std::pair< iterator, boolemplace (const key_type &key, T &&t)
 
template<class KeyType , detail::enable_if_t< detail::is_usable_as_key_type< key_compare, key_type, KeyType >::value, int > = 0>
std::pair< iterator, boolemplace (KeyType &&key, T &&t)
 
T & operator[] (const key_type &key)
 
template<class KeyType , detail::enable_if_t< detail::is_usable_as_key_type< key_compare, key_type, KeyType >::value, int > = 0>
T & operator[] (KeyType &&key)
 
const T & operator[] (const key_type &key) const
 
template<class KeyType , detail::enable_if_t< detail::is_usable_as_key_type< key_compare, key_type, KeyType >::value, int > = 0>
const T & operator[] (KeyType &&key) const
 
T & at (const key_type &key)
 
template<class KeyType , detail::enable_if_t< detail::is_usable_as_key_type< key_compare, key_type, KeyType >::value, int > = 0>
T & at (KeyType &&key)
 
const T & at (const key_type &key) const
 
template<class KeyType , detail::enable_if_t< detail::is_usable_as_key_type< key_compare, key_type, KeyType >::value, int > = 0>
const T & at (KeyType &&key) const
 
size_type erase (const key_type &key)
 
template<class KeyType , detail::enable_if_t< detail::is_usable_as_key_type< key_compare, key_type, KeyType >::value, int > = 0>
size_type erase (KeyType &&key)
 
iterator erase (iterator pos)
 
iterator erase (iterator first, iterator last)
 
size_type count (const key_type &key) const
 
template<class KeyType , detail::enable_if_t< detail::is_usable_as_key_type< key_compare, key_type, KeyType >::value, int > = 0>
size_type count (KeyType &&key) const
 
iterator find (const key_type &key)
 
template<class KeyType , detail::enable_if_t< detail::is_usable_as_key_type< key_compare, key_type, KeyType >::value, int > = 0>
iterator find (KeyType &&key)
 
const_iterator find (const key_type &key) const
 
std::pair< iterator, boolinsert (value_type &&value)
 
std::pair< iterator, boolinsert (const value_type &value)
 
template<typename InputIt , typename = require_input_iter<InputIt>>
void insert (InputIt first, InputIt last)
 

Detailed Description

template<class Key, class T, class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
struct ordered_map< Key, T, IgnoredLess, Allocator >

a minimal map-like container that preserves insertion order

See also
https://json.nlohmann.me/api/ordered_map/

ordered_map: a minimal map-like container that preserves insertion order for use within nlohmann::basic_json<ordered_map>

Definition at line 3409 of file json.hpp.

Member Typedef Documentation

◆ const_iterator

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
using ordered_map< Key, T, IgnoredLess, Allocator >::const_iterator = typename Container::const_iterator

Definition at line 18915 of file json.hpp.

◆ Container

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
using ordered_map< Key, T, IgnoredLess, Allocator >::Container = std::vector<std::pair<const Key, T>, Allocator>

Definition at line 18913 of file json.hpp.

◆ iterator

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
using ordered_map< Key, T, IgnoredLess, Allocator >::iterator = typename Container::iterator

Definition at line 18914 of file json.hpp.

◆ key_compare

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
using ordered_map< Key, T, IgnoredLess, Allocator >::key_compare = std::equal_to<Key>

Definition at line 18921 of file json.hpp.

◆ key_type

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
using ordered_map< Key, T, IgnoredLess, Allocator >::key_type = Key

Definition at line 18911 of file json.hpp.

◆ mapped_type

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
using ordered_map< Key, T, IgnoredLess, Allocator >::mapped_type = T

Definition at line 18912 of file json.hpp.

◆ require_input_iter

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
template<typename InputIt >
using ordered_map< Key, T, IgnoredLess, Allocator >::require_input_iter = typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category, std::input_iterator_tag>::value>::type

Definition at line 19224 of file json.hpp.

◆ size_type

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
using ordered_map< Key, T, IgnoredLess, Allocator >::size_type = typename Container::size_type

Definition at line 18916 of file json.hpp.

◆ value_type

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
using ordered_map< Key, T, IgnoredLess, Allocator >::value_type = typename Container::value_type

Definition at line 18917 of file json.hpp.

Constructor & Destructor Documentation

◆ ordered_map() [1/4]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
ordered_map< Key, T, IgnoredLess, Allocator >::ordered_map ( )
inlinenoexcept

Definition at line 18926 of file json.hpp.

◆ ordered_map() [2/4]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
ordered_map< Key, T, IgnoredLess, Allocator >::ordered_map ( const Allocator &  alloc)
inlineexplicitnoexcept

Definition at line 18927 of file json.hpp.

◆ ordered_map() [3/4]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
template<class It >
ordered_map< Key, T, IgnoredLess, Allocator >::ordered_map ( It  first,
It  last,
const Allocator &  alloc = Allocator() 
)
inline

Definition at line 18929 of file json.hpp.

◆ ordered_map() [4/4]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
ordered_map< Key, T, IgnoredLess, Allocator >::ordered_map ( std::initializer_list< value_type init,
const Allocator &  alloc = Allocator() 
)
inline

Definition at line 18931 of file json.hpp.

Member Function Documentation

◆ at() [1/4]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
T& ordered_map< Key, T, IgnoredLess, Allocator >::at ( const key_type key)
inline

Definition at line 18986 of file json.hpp.

◆ at() [2/4]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
const T& ordered_map< Key, T, IgnoredLess, Allocator >::at ( const key_type key) const
inline

Definition at line 19014 of file json.hpp.

◆ at() [3/4]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
template<class KeyType , detail::enable_if_t< detail::is_usable_as_key_type< key_compare, key_type, KeyType >::value, int > = 0>
T& ordered_map< Key, T, IgnoredLess, Allocator >::at ( KeyType &&  key)
inline

Definition at line 19001 of file json.hpp.

◆ at() [4/4]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
template<class KeyType , detail::enable_if_t< detail::is_usable_as_key_type< key_compare, key_type, KeyType >::value, int > = 0>
const T& ordered_map< Key, T, IgnoredLess, Allocator >::at ( KeyType &&  key) const
inline

Definition at line 19029 of file json.hpp.

◆ count() [1/2]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
size_type ordered_map< Key, T, IgnoredLess, Allocator >::count ( const key_type key) const
inline

Definition at line 19140 of file json.hpp.

◆ count() [2/2]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
template<class KeyType , detail::enable_if_t< detail::is_usable_as_key_type< key_compare, key_type, KeyType >::value, int > = 0>
size_type ordered_map< Key, T, IgnoredLess, Allocator >::count ( KeyType &&  key) const
inline

Definition at line 19154 of file json.hpp.

◆ emplace() [1/2]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
std::pair<iterator, bool> ordered_map< Key, T, IgnoredLess, Allocator >::emplace ( const key_type key,
T &&  t 
)
inline

Definition at line 18934 of file json.hpp.

◆ emplace() [2/2]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
template<class KeyType , detail::enable_if_t< detail::is_usable_as_key_type< key_compare, key_type, KeyType >::value, int > = 0>
std::pair<iterator, bool> ordered_map< Key, T, IgnoredLess, Allocator >::emplace ( KeyType &&  key,
T &&  t 
)
inline

Definition at line 18949 of file json.hpp.

◆ erase() [1/4]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
size_type ordered_map< Key, T, IgnoredLess, Allocator >::erase ( const key_type key)
inline

Definition at line 19042 of file json.hpp.

◆ erase() [2/4]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
iterator ordered_map< Key, T, IgnoredLess, Allocator >::erase ( iterator  first,
iterator  last 
)
inline

Definition at line 19087 of file json.hpp.

◆ erase() [3/4]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
iterator ordered_map< Key, T, IgnoredLess, Allocator >::erase ( iterator  pos)
inline

Definition at line 19082 of file json.hpp.

◆ erase() [4/4]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
template<class KeyType , detail::enable_if_t< detail::is_usable_as_key_type< key_compare, key_type, KeyType >::value, int > = 0>
size_type ordered_map< Key, T, IgnoredLess, Allocator >::erase ( KeyType &&  key)
inline

Definition at line 19063 of file json.hpp.

◆ find() [1/3]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
iterator ordered_map< Key, T, IgnoredLess, Allocator >::find ( const key_type key)
inline

Definition at line 19166 of file json.hpp.

◆ find() [2/3]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
const_iterator ordered_map< Key, T, IgnoredLess, Allocator >::find ( const key_type key) const
inline

Definition at line 19192 of file json.hpp.

◆ find() [3/3]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
template<class KeyType , detail::enable_if_t< detail::is_usable_as_key_type< key_compare, key_type, KeyType >::value, int > = 0>
iterator ordered_map< Key, T, IgnoredLess, Allocator >::find ( KeyType &&  key)
inline

Definition at line 19180 of file json.hpp.

◆ insert() [1/3]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
std::pair<iterator, bool> ordered_map< Key, T, IgnoredLess, Allocator >::insert ( const value_type value)
inline

Definition at line 19209 of file json.hpp.

◆ insert() [2/3]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
template<typename InputIt , typename = require_input_iter<InputIt>>
void ordered_map< Key, T, IgnoredLess, Allocator >::insert ( InputIt  first,
InputIt  last 
)
inline

Definition at line 19227 of file json.hpp.

◆ insert() [3/3]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
std::pair<iterator, bool> ordered_map< Key, T, IgnoredLess, Allocator >::insert ( value_type &&  value)
inline

Definition at line 19204 of file json.hpp.

◆ operator[]() [1/4]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
T& ordered_map< Key, T, IgnoredLess, Allocator >::operator[] ( const key_type key)
inline

Definition at line 18962 of file json.hpp.

◆ operator[]() [2/4]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
const T& ordered_map< Key, T, IgnoredLess, Allocator >::operator[] ( const key_type key) const
inline

Definition at line 18974 of file json.hpp.

◆ operator[]() [3/4]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
template<class KeyType , detail::enable_if_t< detail::is_usable_as_key_type< key_compare, key_type, KeyType >::value, int > = 0>
T& ordered_map< Key, T, IgnoredLess, Allocator >::operator[] ( KeyType &&  key)
inline

Definition at line 18969 of file json.hpp.

◆ operator[]() [4/4]

template<class Key , class T , class IgnoredLess = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
template<class KeyType , detail::enable_if_t< detail::is_usable_as_key_type< key_compare, key_type, KeyType >::value, int > = 0>
const T& ordered_map< Key, T, IgnoredLess, Allocator >::operator[] ( KeyType &&  key) const
inline

Definition at line 18981 of file json.hpp.


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