Classes | Public Types | Public Member Functions | Public Attributes | Private Types | Private Member Functions | Private Attributes | Friends | List of all members
google::protobuf::Map< Key, T > Class Template Reference

#include <arena.h>

Classes

class  const_iterator
 
class  InnerMap
 
class  iterator
 
class  KeyValuePair
 
class  MapAllocator
 

Public Types

using const_pointer = const value_type *
 
using const_reference = const value_type &
 
typedef hash< Key > hasher
 
using hasher = typename internal::TransparentSupport< Key >::hash
 
typedef Key key_type
 
using key_type = Key
 
typedef T mapped_type
 
using mapped_type = T
 
typedef value_typepointer
 
using pointer = value_type *
 
typedef value_typereference
 
using reference = value_type &
 
typedef size_t size_type
 
using size_type = size_t
 
typedef MapPair< Key, Tvalue_type
 
using value_type = MapPair< Key, T >
 

Public Member Functions

template<typename K = key_type>
Tat (const key_arg< K > &key)
 
template<typename K = key_type>
const Tat (const key_arg< K > &key) const
 
Tat (const key_type &key)
 
const Tat (const key_type &key) const
 
iterator begin ()
 
iterator begin ()
 
const_iterator begin () const
 
const_iterator begin () const
 
const_iterator cbegin () const
 
const_iterator cbegin () const
 
const_iterator cend () const
 
const_iterator cend () const
 
void clear ()
 
void clear ()
 
bool contains (const Key &key) const
 
template<typename K = key_type>
bool contains (const key_arg< K > &key) const
 
template<typename K = key_type>
size_type count (const key_arg< K > &key) const
 
size_type count (const key_type &key) const
 
bool empty () const
 
bool empty () const
 
iterator end ()
 
iterator end ()
 
const_iterator end () const
 
const_iterator end () const
 
template<typename K = key_type>
std::pair< iterator, iteratorequal_range (const key_arg< K > &key)
 
template<typename K = key_type>
std::pair< const_iterator, const_iteratorequal_range (const key_arg< K > &key) const
 
std::pair< iterator, iteratorequal_range (const key_type &key)
 
std::pair< const_iterator, const_iteratorequal_range (const key_type &key) const
 
template<typename K = key_type>
size_type erase (const key_arg< K > &key)
 
size_type erase (const key_type &key)
 
void erase (iterator first, iterator last)
 
void erase (iterator first, iterator last)
 
iterator erase (iterator pos)
 
iterator erase (iterator pos)
 
template<typename K = key_type>
iterator find (const key_arg< K > &key)
 
template<typename K = key_type>
const_iterator find (const key_arg< K > &key) const
 
iterator find (const key_type &key)
 
const_iterator find (const key_type &key) const
 
hasher hash_function () const
 
hasher hash_function () const
 
std::pair< iterator, boolinsert (const value_type &value)
 
std::pair< iterator, boolinsert (const value_type &value)
 
template<class InputIt >
void insert (InputIt first, InputIt last)
 
template<class InputIt >
void insert (InputIt first, InputIt last)
 
void insert (std::initializer_list< value_type > values)
 
void insert (std::initializer_list< value_type > values)
 
void InternalSwap (Map &other)
 
 Map ()
 
constexpr Map ()
 
 Map (Arena *arena)
 
 Map (Arena *arena)
 
template<class InputIt >
 Map (const InputIt &first, const InputIt &last)
 
template<class InputIt >
 Map (const InputIt &first, const InputIt &last)
 
 Map (const Map &other)
 
 Map (const Map &other)
 
 Map (Map &&other) noexcept
 
 Map (Map &&other) noexcept
 
Mapoperator= (const Map &other)
 
Mapoperator= (const Map &other)
 
Mapoperator= (Map &&other) noexcept
 
Mapoperator= (Map &&other) noexcept
 
template<typename K = key_type>
Toperator[] (const key_arg< K > &key)
 
Toperator[] (const key_type &key)
 
template<typename K = key_type, typename = typename std::enable_if<!std::is_integral<K>::value>::type>
Toperator[] (key_arg< K > &&key)
 
size_type size () const
 
size_type size () const
 
size_t SpaceUsedExcludingSelfLong () const
 
void swap (Map &other)
 
void swap (Map &other)
 
 ~Map ()
 
 ~Map ()
 

Public Attributes

const typedef value_typeconst_pointer
 
const typedef value_typeconst_reference
 

Private Types

typedef MapAllocator< KeyValuePairAllocator
 
using Allocator = internal::MapAllocator< void * >
 
typedef void DestructorSkippable_
 
using DestructorSkippable_ = void
 
typedef void InternalArenaConstructable_
 
using InternalArenaConstructable_ = void
 
template<typename LookupKey >
using key_arg = typename internal::TransparentSupport< key_type >::template key_arg< LookupKey >
 

Private Member Functions

Arenaarena () const
 
value_typeCreateValueTypeInternal (const Key &key)
 
value_typeCreateValueTypeInternal (const value_type &value)
 
void Init ()
 
void SetDefaultEnumValue (int default_enum_value)
 

Private Attributes

Arenaarena_
 
int default_enum_value_
 
InnerMapelements_
 
InnerMap elements_
 

Friends

class Arena
 
template<typename Derived , typename K , typename V , internal::WireFormatLite::FieldType key_wire_type, internal::WireFormatLite::FieldType value_wire_type, int default_enum_value>
class internal::MapFieldLite
 
template<typename Derived , typename K , typename V , internal::WireFormatLite::FieldType key_wire_type, internal::WireFormatLite::FieldType value_wire_type>
class internal::MapFieldLite
 

Detailed Description

template<typename Key, typename T>
class google::protobuf::Map< Key, T >

Definition at line 79 of file third_party/bloaty/third_party/protobuf/src/google/protobuf/arena.h.

Member Typedef Documentation

◆ Allocator [1/2]

template<typename Key , typename T >
typedef MapAllocator<KeyValuePair> google::protobuf::Map< Key, T >::Allocator
private

◆ Allocator [2/2]

template<typename Key , typename T >
using google::protobuf::Map< Key, T >::Allocator = internal::MapAllocator<void*>
private

◆ const_pointer

template<typename Key , typename T >
using google::protobuf::Map< Key, T >::const_pointer = const value_type*

◆ const_reference

template<typename Key , typename T >
using google::protobuf::Map< Key, T >::const_reference = const value_type&

◆ DestructorSkippable_ [1/2]

template<typename Key , typename T >
typedef void google::protobuf::Map< Key, T >::DestructorSkippable_
private

◆ DestructorSkippable_ [2/2]

template<typename Key , typename T >
using google::protobuf::Map< Key, T >::DestructorSkippable_ = void
private

◆ hasher [1/2]

template<typename Key , typename T >
typedef hash<Key> google::protobuf::Map< Key, T >::hasher

◆ hasher [2/2]

template<typename Key , typename T >
using google::protobuf::Map< Key, T >::hasher = typename internal::TransparentSupport<Key>::hash

◆ InternalArenaConstructable_ [1/2]

template<typename Key , typename T >
typedef void google::protobuf::Map< Key, T >::InternalArenaConstructable_
private

◆ InternalArenaConstructable_ [2/2]

template<typename Key , typename T >
using google::protobuf::Map< Key, T >::InternalArenaConstructable_ = void
private

◆ key_arg

template<typename Key , typename T >
template<typename LookupKey >
using google::protobuf::Map< Key, T >::key_arg = typename internal::TransparentSupport< key_type>::template key_arg<LookupKey>
private

◆ key_type [1/2]

template<typename Key , typename T >
typedef Key google::protobuf::Map< Key, T >::key_type

◆ key_type [2/2]

template<typename Key , typename T >
using google::protobuf::Map< Key, T >::key_type = Key

◆ mapped_type [1/2]

template<typename Key , typename T >
typedef T google::protobuf::Map< Key, T >::mapped_type

◆ mapped_type [2/2]

template<typename Key , typename T >
using google::protobuf::Map< Key, T >::mapped_type = T

◆ pointer [1/2]

template<typename Key , typename T >
typedef value_type* google::protobuf::Map< Key, T >::pointer

◆ pointer [2/2]

template<typename Key , typename T >
using google::protobuf::Map< Key, T >::pointer = value_type*

◆ reference [1/2]

template<typename Key , typename T >
typedef value_type& google::protobuf::Map< Key, T >::reference

◆ reference [2/2]

template<typename Key , typename T >
using google::protobuf::Map< Key, T >::reference = value_type&

◆ size_type [1/2]

template<typename Key , typename T >
typedef size_t google::protobuf::Map< Key, T >::size_type

◆ size_type [2/2]

template<typename Key , typename T >
using google::protobuf::Map< Key, T >::size_type = size_t

◆ value_type [1/2]

template<typename Key , typename T >
typedef MapPair<Key, T> google::protobuf::Map< Key, T >::value_type

◆ value_type [2/2]

template<typename Key , typename T >
using google::protobuf::Map< Key, T >::value_type = MapPair<Key, T>

Constructor & Destructor Documentation

◆ Map() [1/10]

template<typename Key , typename T >
google::protobuf::Map< Key, T >::Map ( )
inline

◆ Map() [2/10]

template<typename Key , typename T >
google::protobuf::Map< Key, T >::Map ( Arena arena)
inlineexplicit

◆ Map() [3/10]

template<typename Key , typename T >
google::protobuf::Map< Key, T >::Map ( const Map< Key, T > &  other)
inline

◆ Map() [4/10]

template<typename Key , typename T >
google::protobuf::Map< Key, T >::Map ( Map< Key, T > &&  other)
inlinenoexcept

◆ Map() [5/10]

template<typename Key , typename T >
template<class InputIt >
google::protobuf::Map< Key, T >::Map ( const InputIt &  first,
const InputIt &  last 
)
inline

◆ ~Map() [1/2]

template<typename Key , typename T >
google::protobuf::Map< Key, T >::~Map ( )
inline

◆ Map() [6/10]

template<typename Key , typename T >
constexpr google::protobuf::Map< Key, T >::Map ( )
inlineconstexpr

◆ Map() [7/10]

template<typename Key , typename T >
google::protobuf::Map< Key, T >::Map ( Arena arena)
inlineexplicit

◆ Map() [8/10]

template<typename Key , typename T >
google::protobuf::Map< Key, T >::Map ( const Map< Key, T > &  other)
inline

◆ Map() [9/10]

template<typename Key , typename T >
google::protobuf::Map< Key, T >::Map ( Map< Key, T > &&  other)
inlinenoexcept

◆ Map() [10/10]

template<typename Key , typename T >
template<class InputIt >
google::protobuf::Map< Key, T >::Map ( const InputIt &  first,
const InputIt &  last 
)
inline

◆ ~Map() [2/2]

template<typename Key , typename T >
google::protobuf::Map< Key, T >::~Map ( )
inline

Member Function Documentation

◆ arena()

template<typename Key , typename T >
Arena* google::protobuf::Map< Key, T >::arena ( ) const
inlineprivate

◆ at() [1/4]

template<typename Key , typename T >
template<typename K = key_type>
T& google::protobuf::Map< Key, T >::at ( const key_arg< K > &  key)
inline

◆ at() [2/4]

template<typename Key , typename T >
template<typename K = key_type>
const T& google::protobuf::Map< Key, T >::at ( const key_arg< K > &  key) const
inline

◆ at() [3/4]

template<typename Key , typename T >
T& google::protobuf::Map< Key, T >::at ( const key_type key)
inline

◆ at() [4/4]

template<typename Key , typename T >
const T& google::protobuf::Map< Key, T >::at ( const key_type key) const
inline

◆ begin() [1/4]

template<typename Key , typename T >
iterator google::protobuf::Map< Key, T >::begin ( )
inline

◆ begin() [2/4]

template<typename Key , typename T >
iterator google::protobuf::Map< Key, T >::begin ( )
inline

◆ begin() [3/4]

template<typename Key , typename T >
const_iterator google::protobuf::Map< Key, T >::begin ( ) const
inline

◆ begin() [4/4]

template<typename Key , typename T >
const_iterator google::protobuf::Map< Key, T >::begin ( ) const
inline

◆ cbegin() [1/2]

template<typename Key , typename T >
const_iterator google::protobuf::Map< Key, T >::cbegin ( ) const
inline

◆ cbegin() [2/2]

template<typename Key , typename T >
const_iterator google::protobuf::Map< Key, T >::cbegin ( ) const
inline

◆ cend() [1/2]

template<typename Key , typename T >
const_iterator google::protobuf::Map< Key, T >::cend ( ) const
inline

◆ cend() [2/2]

template<typename Key , typename T >
const_iterator google::protobuf::Map< Key, T >::cend ( ) const
inline

◆ clear() [1/2]

template<typename Key , typename T >
void google::protobuf::Map< Key, T >::clear ( )
inline

◆ clear() [2/2]

template<typename Key , typename T >
void google::protobuf::Map< Key, T >::clear ( )
inline

◆ contains() [1/2]

template<typename Key , typename T >
bool google::protobuf::Map< Key, T >::contains ( const Key &  key) const
inline

◆ contains() [2/2]

template<typename Key , typename T >
template<typename K = key_type>
bool google::protobuf::Map< Key, T >::contains ( const key_arg< K > &  key) const
inline

◆ count() [1/2]

template<typename Key , typename T >
template<typename K = key_type>
size_type google::protobuf::Map< Key, T >::count ( const key_arg< K > &  key) const
inline

◆ count() [2/2]

template<typename Key , typename T >
size_type google::protobuf::Map< Key, T >::count ( const key_type key) const
inline

◆ CreateValueTypeInternal() [1/2]

template<typename Key , typename T >
value_type* google::protobuf::Map< Key, T >::CreateValueTypeInternal ( const Key &  key)
inlineprivate

◆ CreateValueTypeInternal() [2/2]

template<typename Key , typename T >
value_type* google::protobuf::Map< Key, T >::CreateValueTypeInternal ( const value_type value)
inlineprivate

◆ empty() [1/2]

template<typename Key , typename T >
bool google::protobuf::Map< Key, T >::empty ( ) const
inline

◆ empty() [2/2]

template<typename Key , typename T >
bool google::protobuf::Map< Key, T >::empty ( ) const
inline

◆ end() [1/4]

template<typename Key , typename T >
iterator google::protobuf::Map< Key, T >::end ( )
inline

◆ end() [2/4]

template<typename Key , typename T >
iterator google::protobuf::Map< Key, T >::end ( )
inline

◆ end() [3/4]

template<typename Key , typename T >
const_iterator google::protobuf::Map< Key, T >::end ( ) const
inline

◆ end() [4/4]

template<typename Key , typename T >
const_iterator google::protobuf::Map< Key, T >::end ( ) const
inline

◆ equal_range() [1/4]

template<typename Key , typename T >
template<typename K = key_type>
std::pair<iterator, iterator> google::protobuf::Map< Key, T >::equal_range ( const key_arg< K > &  key)
inline

◆ equal_range() [2/4]

template<typename Key , typename T >
template<typename K = key_type>
std::pair<const_iterator, const_iterator> google::protobuf::Map< Key, T >::equal_range ( const key_arg< K > &  key) const
inline

◆ equal_range() [3/4]

template<typename Key , typename T >
std::pair<iterator, iterator> google::protobuf::Map< Key, T >::equal_range ( const key_type key)
inline

◆ equal_range() [4/4]

template<typename Key , typename T >
std::pair<const_iterator, const_iterator> google::protobuf::Map< Key, T >::equal_range ( const key_type key) const
inline

◆ erase() [1/6]

template<typename Key , typename T >
template<typename K = key_type>
size_type google::protobuf::Map< Key, T >::erase ( const key_arg< K > &  key)
inline

◆ erase() [2/6]

template<typename Key , typename T >
size_type google::protobuf::Map< Key, T >::erase ( const key_type key)
inline

◆ erase() [3/6]

template<typename Key , typename T >
void google::protobuf::Map< Key, T >::erase ( iterator  first,
iterator  last 
)
inline

◆ erase() [4/6]

template<typename Key , typename T >
void google::protobuf::Map< Key, T >::erase ( iterator  first,
iterator  last 
)
inline

◆ erase() [5/6]

template<typename Key , typename T >
iterator google::protobuf::Map< Key, T >::erase ( iterator  pos)
inline

◆ erase() [6/6]

template<typename Key , typename T >
iterator google::protobuf::Map< Key, T >::erase ( iterator  pos)
inline

◆ find() [1/4]

template<typename Key , typename T >
template<typename K = key_type>
iterator google::protobuf::Map< Key, T >::find ( const key_arg< K > &  key)
inline

◆ find() [2/4]

template<typename Key , typename T >
template<typename K = key_type>
const_iterator google::protobuf::Map< Key, T >::find ( const key_arg< K > &  key) const
inline

◆ find() [3/4]

template<typename Key , typename T >
iterator google::protobuf::Map< Key, T >::find ( const key_type key)
inline

◆ find() [4/4]

template<typename Key , typename T >
const_iterator google::protobuf::Map< Key, T >::find ( const key_type key) const
inline

◆ hash_function() [1/2]

template<typename Key , typename T >
hasher google::protobuf::Map< Key, T >::hash_function ( ) const
inline

◆ hash_function() [2/2]

template<typename Key , typename T >
hasher google::protobuf::Map< Key, T >::hash_function ( ) const
inline

◆ Init()

template<typename Key , typename T >
void google::protobuf::Map< Key, T >::Init ( )
inlineprivate

◆ insert() [1/6]

template<typename Key , typename T >
std::pair<iterator, bool> google::protobuf::Map< Key, T >::insert ( const value_type value)
inline

◆ insert() [2/6]

template<typename Key , typename T >
std::pair<iterator, bool> google::protobuf::Map< Key, T >::insert ( const value_type value)
inline

◆ insert() [3/6]

template<typename Key , typename T >
template<class InputIt >
void google::protobuf::Map< Key, T >::insert ( InputIt  first,
InputIt  last 
)
inline

◆ insert() [4/6]

template<typename Key , typename T >
template<class InputIt >
void google::protobuf::Map< Key, T >::insert ( InputIt  first,
InputIt  last 
)
inline

◆ insert() [5/6]

template<typename Key , typename T >
void google::protobuf::Map< Key, T >::insert ( std::initializer_list< value_type values)
inline

◆ insert() [6/6]

template<typename Key , typename T >
void google::protobuf::Map< Key, T >::insert ( std::initializer_list< value_type values)
inline

◆ InternalSwap()

template<typename Key , typename T >
void google::protobuf::Map< Key, T >::InternalSwap ( Map< Key, T > &  other)
inline

◆ operator=() [1/4]

template<typename Key , typename T >
Map& google::protobuf::Map< Key, T >::operator= ( const Map< Key, T > &  other)
inline

◆ operator=() [2/4]

template<typename Key , typename T >
Map& google::protobuf::Map< Key, T >::operator= ( const Map< Key, T > &  other)
inline

◆ operator=() [3/4]

template<typename Key , typename T >
Map& google::protobuf::Map< Key, T >::operator= ( Map< Key, T > &&  other)
inlinenoexcept

◆ operator=() [4/4]

template<typename Key , typename T >
Map& google::protobuf::Map< Key, T >::operator= ( Map< Key, T > &&  other)
inlinenoexcept

◆ operator[]() [1/3]

template<typename Key , typename T >
template<typename K = key_type>
T& google::protobuf::Map< Key, T >::operator[] ( const key_arg< K > &  key)
inline

◆ operator[]() [2/3]

template<typename Key , typename T >
T& google::protobuf::Map< Key, T >::operator[] ( const key_type key)
inline

◆ operator[]() [3/3]

template<typename Key , typename T >
template<typename K = key_type, typename = typename std::enable_if<!std::is_integral<K>::value>::type>
T& google::protobuf::Map< Key, T >::operator[] ( key_arg< K > &&  key)
inline

◆ SetDefaultEnumValue()

template<typename Key , typename T >
void google::protobuf::Map< Key, T >::SetDefaultEnumValue ( int  default_enum_value)
inlineprivate

◆ size() [1/2]

template<typename Key , typename T >
size_type google::protobuf::Map< Key, T >::size ( ) const
inline

◆ size() [2/2]

template<typename Key , typename T >
size_type google::protobuf::Map< Key, T >::size ( ) const
inline

◆ SpaceUsedExcludingSelfLong()

template<typename Key , typename T >
size_t google::protobuf::Map< Key, T >::SpaceUsedExcludingSelfLong ( ) const
inline

◆ swap() [1/2]

template<typename Key , typename T >
void google::protobuf::Map< Key, T >::swap ( Map< Key, T > &  other)
inline

◆ swap() [2/2]

template<typename Key , typename T >
void google::protobuf::Map< Key, T >::swap ( Map< Key, T > &  other)
inline

Friends And Related Function Documentation

◆ Arena

template<typename Key , typename T >
Arena
friend

◆ internal::MapFieldLite [1/2]

template<typename Key , typename T >
template<typename Derived , typename K , typename V , internal::WireFormatLite::FieldType key_wire_type, internal::WireFormatLite::FieldType value_wire_type, int default_enum_value>
friend class internal::MapFieldLite
friend

◆ internal::MapFieldLite [2/2]

template<typename Key , typename T >
template<typename Derived , typename K , typename V , internal::WireFormatLite::FieldType key_wire_type, internal::WireFormatLite::FieldType value_wire_type>
class internal::MapFieldLite
friend

Member Data Documentation

◆ arena_

template<typename Key , typename T >
Arena* google::protobuf::Map< Key, T >::arena_
private

◆ const_pointer

template<typename Key , typename T >
const typedef value_type* google::protobuf::Map< Key, T >::const_pointer

◆ const_reference

template<typename Key , typename T >
const typedef value_type& google::protobuf::Map< Key, T >::const_reference

◆ default_enum_value_

template<typename Key , typename T >
int google::protobuf::Map< Key, T >::default_enum_value_
private

◆ elements_ [1/2]

template<typename Key , typename T >
InnerMap* google::protobuf::Map< Key, T >::elements_
private

◆ elements_ [2/2]

template<typename Key , typename T >
InnerMap google::protobuf::Map< Key, T >::elements_
private

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


grpc
Author(s):
autogenerated on Fri May 16 2025 03:03:11