Nav2 Navigation Stack - jazzy  jazzy
ROS 2 Navigation Stack
Classes | Public Types | Public Member Functions | Static Public Attributes | List of all members
robin_hood::detail::Table< IsFlat, MaxLoadFactor100, Key, T, Hash, KeyEqual > Class Template Reference
Inheritance diagram for robin_hood::detail::Table< IsFlat, MaxLoadFactor100, Key, T, Hash, KeyEqual >:
Inheritance graph
[legend]
Collaboration diagram for robin_hood::detail::Table< IsFlat, MaxLoadFactor100, Key, T, Hash, KeyEqual >:
Collaboration graph
[legend]

Public Types

using key_type = Key
 
using mapped_type = T
 
using value_type = typename std::conditional< is_set, Key, robin_hood::pair< typename std::conditional< is_flat, Key, Key const >::type, T > >::type
 
using size_type = size_t
 
using hasher = Hash
 
using key_equal = KeyEqual
 
using Self = Table< IsFlat, MaxLoadFactor100, key_type, mapped_type, hasher, key_equal >
 
using iterator = Iter< false >
 
using const_iterator = Iter< true >
 

Public Member Functions

 Table (size_t ROBIN_HOOD_UNUSED(bucket_count), const Hash &h=Hash{}, const KeyEqual &equal=KeyEqual{}) noexcept(noexcept(Hash(h)) &&noexcept(KeyEqual(equal)))
 
template<typename Iter >
 Table (Iter first, Iter last, size_t ROBIN_HOOD_UNUSED(bucket_count)=0, const Hash &h=Hash{}, const KeyEqual &equal=KeyEqual{})
 
 Table (std::initializer_list< value_type > initlist, size_t ROBIN_HOOD_UNUSED(bucket_count)=0, const Hash &h=Hash{}, const KeyEqual &equal=KeyEqual{})
 
 Table (Table &&o) noexcept
 
Tableoperator= (Table &&o) noexcept
 
 Table (const Table &o)
 
Tableoperator= (Table const &o)
 
void swap (Table &o)
 
void clear ()
 
bool operator== (const Table &other) const
 
bool operator!= (const Table &other) const
 
template<typename Q = mapped_type>
std::enable_if<!std::is_void< Q >::value, Q & >::type operator[] (const key_type &key)
 
template<typename Q = mapped_type>
std::enable_if<!std::is_void< Q >::value, Q & >::type operator[] (key_type &&key)
 
template<typename Iter >
void insert (Iter first, Iter last)
 
void insert (std::initializer_list< value_type > ilist)
 
template<typename... Args>
std::pair< iterator, bool > emplace (Args &&... args)
 
template<typename... Args>
iterator emplace_hint (const_iterator position, Args &&... args)
 
template<typename... Args>
std::pair< iterator, bool > try_emplace (const key_type &key, Args &&... args)
 
template<typename... Args>
std::pair< iterator, bool > try_emplace (key_type &&key, Args &&... args)
 
template<typename... Args>
iterator try_emplace (const_iterator hint, const key_type &key, Args &&... args)
 
template<typename... Args>
iterator try_emplace (const_iterator hint, key_type &&key, Args &&... args)
 
template<typename Mapped >
std::pair< iterator, bool > insert_or_assign (const key_type &key, Mapped &&obj)
 
template<typename Mapped >
std::pair< iterator, bool > insert_or_assign (key_type &&key, Mapped &&obj)
 
template<typename Mapped >
iterator insert_or_assign (const_iterator hint, const key_type &key, Mapped &&obj)
 
template<typename Mapped >
iterator insert_or_assign (const_iterator hint, key_type &&key, Mapped &&obj)
 
std::pair< iterator, bool > insert (const value_type &keyval)
 
iterator insert (const_iterator hint, const value_type &keyval)
 
std::pair< iterator, bool > insert (value_type &&keyval)
 
iterator insert (const_iterator hint, value_type &&keyval)
 
size_t count (const key_type &key) const
 
template<typename OtherKey , typename Self_ = Self>
std::enable_if< Self_::is_transparent, size_t >::type count (const OtherKey &key) const
 
bool contains (const key_type &key) const
 
template<typename OtherKey , typename Self_ = Self>
std::enable_if< Self_::is_transparent, bool >::type contains (const OtherKey &key) const
 
template<typename Q = mapped_type>
std::enable_if<!std::is_void< Q >::value, Q & >::type at (key_type const &key)
 
template<typename Q = mapped_type>
std::enable_if<!std::is_void< Q >::value, Q const & >::type at (key_type const &key) const
 
const_iterator find (const key_type &key) const
 
template<typename OtherKey >
const_iterator find (const OtherKey &key, is_transparent_tag) const
 
template<typename OtherKey , typename Self_ = Self>
std::enable_if< Self_::is_transparent, const_iterator >::type find (const OtherKey &key) const
 
iterator find (const key_type &key)
 
template<typename OtherKey >
iterator find (const OtherKey &key, is_transparent_tag)
 
template<typename OtherKey , typename Self_ = Self>
std::enable_if< Self_::is_transparent, iterator >::type find (const OtherKey &key)
 
iterator begin ()
 
const_iterator begin () const
 
const_iterator cbegin () const
 
iterator end ()
 
const_iterator end () const
 
const_iterator cend () const
 
iterator erase (const_iterator pos)
 
iterator erase (iterator pos)
 
size_t erase (const key_type &key)
 
void rehash (size_t c)
 
void reserve (size_t c)
 
void compact ()
 
size_type size () const noexcept
 
size_type max_size () const noexcept
 
 ROBIN_HOOD (NODISCARD) bool empty() const noexcept
 
float max_load_factor () const noexcept
 
float load_factor () const noexcept
 
 ROBIN_HOOD (NODISCARD) size_t mask() const noexcept
 
 ROBIN_HOOD (NODISCARD) size_t calcMaxNumElementsAllowed(size_t maxElements) const noexcept
 
 ROBIN_HOOD (NODISCARD) size_t calcNumBytesInfo(size_t numElements) const noexcept
 
size_t calcNumElementsWithBuffer (size_t numElements) const noexcept
 
 ROBIN_HOOD (NODISCARD) size_t calcNumBytesTotal(size_t numElements) const
 
- Public Member Functions inherited from robin_hood::detail::WrapHash< Hash >
 WrapHash (Hash const &o) noexcept(noexcept(Hash(std::declval< Hash const & >())))
 
- Public Member Functions inherited from robin_hood::detail::WrapKeyEqual< KeyEqual >
 WrapKeyEqual (KeyEqual const &o) noexcept(noexcept(KeyEqual(std::declval< KeyEqual const & >())))
 

Static Public Attributes

static constexpr bool is_flat = IsFlat
 
static constexpr bool is_map = !std::is_void<T>::value
 
static constexpr bool is_set = !is_map
 
static constexpr bool is_transparent
 

Detailed Description

template<bool IsFlat, size_t MaxLoadFactor100, typename Key, typename T, typename Hash, typename KeyEqual>
class robin_hood::detail::Table< IsFlat, MaxLoadFactor100, Key, T, Hash, KeyEqual >

Definition at line 911 of file robin_hood.h.

Member Data Documentation

◆ is_transparent

template<bool IsFlat, size_t MaxLoadFactor100, typename Key , typename T , typename Hash , typename KeyEqual >
constexpr bool robin_hood::detail::Table< IsFlat, MaxLoadFactor100, Key, T, Hash, KeyEqual >::is_transparent
staticconstexpr
Initial value:
=
has_is_transparent<Hash>::value && has_is_transparent<KeyEqual>::value

Definition at line 923 of file robin_hood.h.


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