RE::BSTScatterTable< Hash, KeyEqual, Traits, Allocator > Class Template Reference

#include <BSTHashMap.h>

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

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 requires(std
	~BSTScatterTable ()
BSTScatterTable &	operator= (const BSTScatterTable &a_rhs)
BSTScatterTable &	operator= (BSTScatterTable &&a_rhs) requires(std
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>
void	insert (InputIt a_first, InputIt a_last) requires(std
template<class... Args>
std::pair< iterator, bool >	emplace (Args &&... a_args) requires(std
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>

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>

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:

• CommonLibSSE/include/RE/B/BSTHashMap.h