CommonLibSSE (Parapets fork)
Loading...
Searching...
No Matches
Classes | Public Types | Public Member Functions | List of all members
RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator > Class Template Reference

#include <BSTHashMap.h>

Inheritance diagram for RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >:
RE::AttackAnimationArrayMap

Public Types

using traits_type = Traits
 
using key_type = typename Traits::key_type
 
using mapped_type = typename Traits::mapped_type
 
using value_type = typename Traits::value_type
 
using size_type = std::uint32_t
 
using difference_type = std::int32_t
 
using hasher = Hash
 
using key_equal = KeyEqual
 
using reference = value_type &
 
using const_reference = const value_type &
 
using pointer = value_type *
 
using const_pointer = const value_type *
 
using allocator_type = Allocator< sizeof(entry_type), alignof(entry_type)>
 
using iterator = iterator_base< value_type >
 
using const_iterator = iterator_base< const value_type >
 

Public Member Functions

 BSTScatterTable ()=default
 
 BSTScatterTable (const BSTScatterTable &a_rhs)
 
 BSTScatterTable (BSTScatterTable &&a_rhs) noexcept
 
 ~BSTScatterTable ()
 
BSTScatterTable & operator= (const BSTScatterTable &a_rhs)
 
BSTScatterTable & operator= (BSTScatterTable &&a_rhs)
 
iterator begin () noexcept
 
const_iterator begin () const noexcept
 
const_iterator cbegin () const noexcept
 
iterator end () noexcept
 
const_iterator end () const noexcept
 
const_iterator cend () const noexcept
 
bool empty () const noexcept
 
size_type size () const noexcept
 
void clear ()
 
std::pair< iterator, bool > insert (const value_type &a_value)
 
std::pair< iterator, bool > insert (value_type &&a_value)
 
template<std::input_iterator InputIt>
requires (std::convertible_to<std::iter_reference_t<InputIt>, const_reference>)
void insert (InputIt a_first, InputIt a_last)
 
template<class... Args>
requires (std::constructible_from<value_type, Args...>)
std::pair< iterator, bool > emplace (Args &&... a_args)
 
iterator erase (const_iterator a_pos)
 
iterator erase (iterator a_pos)
 
size_type erase (const key_type &a_key)
 
iterator find (const key_type &a_key)
 
const_iterator find (const key_type &a_key) const
 
bool contains (const key_type &a_key) const
 
void reserve (size_type a_count)
 

Member Typedef Documentation

◆ allocator_type

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
using RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::allocator_type = Allocator<sizeof(entry_type), alignof(entry_type)>

◆ const_iterator

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
using RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::const_iterator = iterator_base<const value_type>

◆ const_pointer

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
using RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::const_pointer = const value_type*

◆ const_reference

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
using RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::const_reference = const value_type&

◆ difference_type

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
using RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::difference_type = std::int32_t

◆ hasher

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
using RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::hasher = Hash

◆ iterator

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
using RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::iterator = iterator_base<value_type>

◆ key_equal

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
using RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::key_equal = KeyEqual

◆ key_type

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
using RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::key_type = typename Traits::key_type

◆ mapped_type

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
using RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::mapped_type = typename Traits::mapped_type

◆ pointer

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
using RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::pointer = value_type*

◆ reference

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
using RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::reference = value_type&

◆ size_type

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
using RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::size_type = std::uint32_t

◆ traits_type

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
using RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::traits_type = Traits

◆ value_type

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
using RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::value_type = typename Traits::value_type

Constructor & Destructor Documentation

◆ BSTScatterTable() [1/3]

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::BSTScatterTable ( )
default

◆ BSTScatterTable() [2/3]

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::BSTScatterTable ( const BSTScatterTable< Hash, KeyEqual, Traits, Allocator > &  a_rhs)
inline

◆ BSTScatterTable() [3/3]

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::BSTScatterTable ( BSTScatterTable< Hash, KeyEqual, Traits, Allocator > &&  a_rhs)
inlinenoexcept

◆ ~BSTScatterTable()

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::~BSTScatterTable ( )
inline

Member Function Documentation

◆ begin() [1/2]

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
const_iterator RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::begin ( ) const
inlinenoexcept

◆ begin() [2/2]

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
iterator RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::begin ( )
inlinenoexcept

◆ cbegin()

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
const_iterator RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::cbegin ( ) const
inlinenoexcept

◆ cend()

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
const_iterator RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::cend ( ) const
inlinenoexcept

◆ clear()

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
void RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::clear ( )
inline

◆ contains()

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
bool RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::contains ( const key_type &  a_key) const
inline

◆ emplace()

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
template<class... Args>
requires (std::constructible_from<value_type, Args...>)
std::pair< iterator, bool > RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::emplace ( Args &&...  a_args)
inline

◆ empty()

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
bool RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::empty ( ) const
inlinenoexcept

◆ end() [1/2]

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
const_iterator RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::end ( ) const
inlinenoexcept

◆ end() [2/2]

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
iterator RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::end ( )
inlinenoexcept

◆ erase() [1/3]

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
size_type RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::erase ( const key_type &  a_key)
inline

◆ erase() [2/3]

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
iterator RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::erase ( const_iterator  a_pos)
inline

◆ erase() [3/3]

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
iterator RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::erase ( iterator  a_pos)
inline

◆ find() [1/2]

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
iterator RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::find ( const key_type &  a_key)
inline

◆ find() [2/2]

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
const_iterator RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::find ( const key_type &  a_key) const
inline

◆ insert() [1/3]

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
std::pair< iterator, bool > RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::insert ( const value_type &  a_value)
inline

◆ insert() [2/3]

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
template<std::input_iterator InputIt>
requires (std::convertible_to<std::iter_reference_t<InputIt>, const_reference>)
void RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::insert ( InputIt  a_first,
InputIt  a_last 
)
inline

◆ insert() [3/3]

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
std::pair< iterator, bool > RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::insert ( value_type &&  a_value)
inline

◆ operator=() [1/2]

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
BSTScatterTable & RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::operator= ( BSTScatterTable< Hash, KeyEqual, Traits, Allocator > &&  a_rhs)
inline

◆ operator=() [2/2]

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
BSTScatterTable & RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::operator= ( const BSTScatterTable< Hash, KeyEqual, Traits, Allocator > &  a_rhs)
inline

◆ reserve()

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
void RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::reserve ( size_type  a_count)
inline

◆ size()

template<class Hash , class KeyEqual , class Traits , template< std::size_t, std::size_t > class Allocator>
size_type RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator >::size ( ) const
inlinenoexcept
The documentation for this class was generated from the following file: