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

#include <json.hpp>

Inheritance diagram for ordered_map< Key, T, IgnoredLess, Allocator >:

Collaboration diagram for ordered_map< Key, T, IgnoredLess, Allocator >:

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 (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, bool >	emplace (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, bool >	emplace (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, bool >	insert (value_type &&value)

std::pair< iterator, bool >	insert (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

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

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

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

src/vendor/nlohmann/json.hpp

Public Types

Public Member Functions

Detailed Description