Detailed Description

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>
struct te::AnySet< HashFn, KeyEqual, Allocator >

AnySet is an associative container that contains a set of unique objects of any constructible type. Search, insertion, and removal have average constant-time complexity. Internally, the elements are not sorted in any particular order, but organized into buckets. Which bucket an element is placed into depends entirely on the hash of its value. This allows fast access to individual elements, since once a hash is computed, it refers to the exact bucket the element is placed into.

Container elements may not be modified (even by non const iterators) since modification could change an element's hash and corrupt the container.

AnySet meets the requirements of Container, AllocatorAwareContainer, and UnorderedAssociativeContainer.

Remarks: In order to provide certain functionality functionality and mimic the behavior of similar standard containers (such as std::unordered_set), AnySet must sacrifice some static type safety in the name of usability. For example, AnySet instances are always copy constructible. However, if an attempt is made to copy construct or assign (or similar) from an AnySet instance that contains instances of non-copy-constructible types, an exception is thrown.

Template Parameters

HashFn	- The type of the function object to use when computing the hash codes of elements.
KeyEqual	- The type of the function object to use when comparing elements for equality.
Allocator	- The type of the allocator to use when allocating the internal bucket table.

Remarks: The STL's allocator model is too rigid for AnySet to sanely support customized allocation of its internal nodes. Thus its internal elements/nodes are simply allocated using std::make_unique() (effectively using the keyword 'new'). Allocator support is only provided for the internal bucket table.

See also: AnyValue - User-visible value_type for AnySet instances.; AnyHash - The default value of HashFn. It is intended to be sufficiently extensible such that users should not need to roll their own HashFn types.

#include <AnySet.h>

Classes
struct	const_iterator
	Forward iterator type returned from const operations on AnySet instances. More...

struct	iterator
	Forward iterator type returned from non-const operations on AnySet instances. More...

Public Types
using	value_type = AnyValue< HashFn, KeyEqual >
	AnyValue.

using	size_type = typename vector_type::size_type
	Size type.

using	difference_type = typename vector_type::difference_type
	Difference type.

using	key_equal = KeyEqual
	Key equality comparator type.

using	hasher = HashFn
	Hash function type.

using	allocator_type = Allocator
	Allocator type.

using	key_type = value_type
	AnyValue. Here for consistency with std::unordered_set.

using	reference = value_type &
	Reference to AnyValue.

using	const_reference = const value_type &
	Reference to const AnyValue.

using	pointer = value_type *
	Pointer to AnyValue.

using	const_pointer = const value_type *
	Pointer to const AnyValue.

using	node_handle = std::unique_ptr< value_type >

using	local_iterator = BucketIterator< false >
	Iterator type suitable for traversal through an individual bucket.

using	const_local_iterator = BucketIterator< true >
	Const iterator type suitable for traversal through an individual bucket.

Public Member Functions
void	_assert_invariants (bool check_load_factor=false) const

Constructors
	AnySet ()
	Constructs an empty set with 1 bucket. Sets max_load_factor() to 1.0.

	AnySet (size_type bucket_count, const HashFn &hash=HashFn(), const KeyEqual &equal=KeyEqual(), const Allocator &alloc=Allocator())
	Construct an empty AnySet instance. Sets max_load_factor() to 1.0. More...

	AnySet (size_type bucket_count, const Allocator &alloc)
	Construct an empty AnySet instance. Sets max_load_factor() to 1.0. More...

	AnySet (size_type bucket_count, const HashFn &hash, const Allocator &alloc)
	Construct an empty AnySet instance. Sets max_load_factor() to 1.0. More...

template<class InputIt >
	AnySet (InputIt first, InputIt last, size_type bucket_count=0, const HashFn &hash=HashFn(), const KeyEqual &equal=KeyEqual(), const Allocator &alloc=Allocator())
	Construct an AnySet instance from the range [first, last). Sets max_load_factor() to 1.0. If multiple elements in the range compare equivalent, only the first encountered is inserted. More...

template<class InputIt >
	AnySet (InputIt first, InputIt last, size_type bucket_count, const Allocator &alloc)
	Construct an AnySet instance from the range [first, last). Sets max_load_factor() to 1.0. If multiple elements in the range compare equivalent, only the first encountered is inserted. More...

template<class InputIt >
	AnySet (InputIt first, InputIt last, size_type bucket_count, const HashFn &hash, const Allocator &alloc)
	Construct an AnySet instance from the range [first, last). Sets max_load_factor() to 1.0. If multiple elements in the range compare equivalent, only the first encountered is inserted. More...

	AnySet (const AnySet &other, const Allocator &alloc)
	Copy constructs an AnySet instance from other. Constructs the set with the copy of the contents of other. Copies the load factor, the predicate, and the hash function as well. More...

	AnySet (const AnySet &other)
	Copy constructs an AnySet instance from other. Constructs the set with the copy of the contents of other. Copies the load factor, the predicate, and the hash function as well. More...

	AnySet (AnySet &&other, const Allocator &alloc)
	Move constructs an AnySet instance from other. Constructs the set with the copy of the contents of other. Copies the load factor, the predicate, and the hash function as well. More...

	AnySet (AnySet &&other)
	Copy constructs an AnySet instance from other. Constructs the set with the copy of the contents of other. Copies the load factor, the predicate, and the hash function as well. More...

template<class T >
	AnySet (std::initializer_list< T > ilist, size_type bucket_count=0, const HashFn &hash=HashFn(), const KeyEqual &equal=KeyEqual(), const Allocator &alloc=Allocator())
	Construct an AnySet with the contents of the initializer list ilist. Same as AnySet(init.begin(), init.end()). Sets max_load_factor() to 1.0. If multiple elements in the list compare equivalent, only the first encountered is inserted. More...

template<class T >
	AnySet (std::initializer_list< T > ilist, size_type bucket_count, const Allocator &alloc)
	Construct an AnySet with the contents of the initializer list ilist. Same as AnySet(init.begin(), init.end()). Sets max_load_factor() to 1.0. If multiple elements in the list compare equivalent, only the first encountered is inserted. More...

template<class T >
	AnySet (std::initializer_list< T > ilist, size_type bucket_count, const HashFn &hash, const Allocator &alloc)
	Construct an AnySet with the contents of the initializer list ilist. Same as AnySet(init.begin(), init.end()). Sets max_load_factor() to 1.0. If multiple elements in the list compare equivalent, only the first encountered is inserted. More...

template<class ... T>
	AnySet (std::tuple< T ... > &&tup, size_type bucket_count=2 *(sizeof...(T)), const HashFn &hash=HashFn(), const KeyEqual &equal=KeyEqual(), const Allocator &alloc=Allocator())
	Construct an AnySet with the contents of the tuple tup. Sets max_load_factor() to 1.0. If multiple elements in the tuple have the same type and compare equivalent,only the first encountered is inserted. More...

template<class ... T>
	AnySet (std::tuple< T ... > &&tup, size_type bucket_count, const Allocator &alloc)
	Construct an AnySet with the contents of the tuple tup. Sets max_load_factor() to 1.0. If multiple elements in the tuple have the same type and compare equivalent,only the first encountered is inserted. More...

template<class ... T>
	AnySet (std::tuple< T ... > &&tup, size_type bucket_count, const HashFn &hash, const Allocator &alloc)
	Construct an AnySet with the contents of the tuple tup. Sets max_load_factor() to 1.0. If multiple elements in the tuple have the same type and compare equivalent,only the first encountered is inserted. More...

Assignment
AnySet &	operator= (const AnySet &other)
	Copy assigns the contents of this AnySet instance from the contents of other. Copies the load factor, the predicate, the hash function, and allocator as well. More...

AnySet &	operator= (AnySet &&other) noexcept(std::is_nothrow_move_assignable_v< vector_type >)
	Move assigns the contents of this AnySet instance from the contents of other. Moves the load factor, the predicate, the hash function, and allocator as well. More...

template<class T >
AnySet &	operator= (std::initializer_list< T > ilist)
	Assigns the contents of this AnySet instance with the contents of ilist. More...

Iterators
const_iterator	cbegin () const
	Get a const_iterator to the first element in the set. More...

const_iterator	begin () const
	Get a const_iterator to the first element in the set. More...

iterator	begin ()
	Get a iterator to the first element in the set. More...

const_iterator	cend () const
	Get a past-the-end const_iterator for this set. More...

const_iterator	end () const
	Get a past-the-end const_iterator for this set. More...

iterator	end ()
	Get a past-the-end iterator for this set. More...

Capacity
bool	empty () const noexcept
	Checks if the set has no elements, i.e. whether begin() == end(). More...

size_type	size () const noexcept
	Gets the number of elements in the set, i.e. std::distance(begin(), end()). More...

size_type	max_size () const noexcept
	Get the maximum number of elements the container is able to hold due to system or library implementation limitations, i.e. std::distance(begin(), end()) for the largest container. More...

Modifiers
void	clear () noexcept
	Removes all elements from the container. Invalidates any references, pointers, or iterators referring to contained elements.

template<class T , class ... Args>
std::pair< iterator, bool >	emplace (Args &&... args)
	Inserts a new element into the container constructed in-place with the given args if there is no element with the same type and value in the container. More...

template<class T , class ... Args>
std::pair< iterator, bool >	emplace_hint ([[maybe_unused]] const_iterator hint, Args &&... args)
	Inserts a new element into the container constructed in-place with the given args if there is no element with the same type and value in the container, using an iterator hint as a suggestion for where the new element should be placed. More...

template<class T >
std::pair< iterator, bool >	insert (T &&value)
	Inserts an element into the set, if the set doesn't already contain an element with an equivalent value and type. More...

template<class T >
std::pair< iterator, bool >	insert ([[maybe_unused]] const_iterator hint, T &&value)
	Inserts an element into the set, if the set doesn't already contain an element with an equivalent value and type. More...

template<class It , class = std::enable_if_t< std::is_copy_constructible_v<typename std::iterator_traits<It>::value_type> or std::is_rvalue_reference_v<decltype(*std::declval<It>())> >>
size_type	insert (It first, It last)
	Inserts elements from the range [first, last) that do not already exist in the set. If multiple elements in the range have values that compare equivalent, and there is no such element already in the set, only the first encountered is inserted. More...

template<class T , class U , class ... V>
std::bitset< 2ull+sizeof...(V)>	insert (T &&first, U &&second, V &&... args)
	Inserts `args` if they do not already exist in the set. If multiple values in `args` have the same type and have values that compare equivalent, and there is no such element already in the set, only the first encountered is inserted. More...

template<class T , class = std::enable_if_t<std::is_copy_constructible_v<T>>>
size_type	insert (std::initializer_list< T > ilist)
	Inserts elements from the list `ilist` that do not already exist in the set. If multiple elements in the list have values that compare equivalent, and there is no such element already in the set, only the first encountered is inserted. More...

iterator	erase (const_iterator pos)
	Remove the element at the position pointed to by `pos` from the set. More...

iterator	erase (const_iterator first, const_iterator last)
	Remove elements in the range [`first`, `last`). More...

template<class T , class = std::enable_if_t<not (std::is_same_v<const_iterator, T> or std::is_same_v<iterator, T>)>>
size_type	erase (const T &value)
	Remove the element from the set whose type is the same type as `value` and whose value compares equal to `value`. More...

void	swap (AnySet &other) noexcept(std::is_nothrow_swappable_v< vector_type > and std::is_nothrow_swappable_v< pair_type >)
	Exchanges the contents of the set with those of other. Does not invoke any move, copy, or swap operations on individual elements. Additionally exchanges the hash functions, comparison functions, and max_load_factor()s of the sets. More...

AnySet &	update (const AnySet &other)
	Add copies of elements from `other`. More...

AnySet &	update (AnySet &&other)
	Moves elements from `other` into the set. More...

Lookup
template<class T >
size_type	count (const T &value) const
	Returns the number of elements with a value that have the same type as, and compare equal to the `value`, which is either 1 or 0 since AnySet does not allow duplicates. More...

template<class T >
const_iterator	find (const T &value) const
	Obtain a const_iterator to the element that has the same type as, and compares equal to the `value`. More...

template<class T >
iterator	find (const T &value)
	Obtain an iterator to the element that has the same type as, and compares equal to the `value`. More...

template<class T >
std::pair< const_iterator, const_iterator >	equal_range (const T &value) const
	Obtain a const_iterator range to the elements that have the same type as, and compares equal to the `value`. More...

template<class T >
std::pair< iterator, iterator >	equal_range (const T &value)
	Obtain an iterator range to the elements that have the same type as, and compares equal to the `value`. More...

bool	contains_value (const value_type &any_v) const
	Check if `this` contains the same value as another set. More...

bool	contains_value_eq (const value_type &any_v) const
	Check if `this` contains the same value as another set. More...

template<class T >
bool	contains (const T &value) const
	Check if `this` contains `value`. More...

template<class T >
bool	contains_eq (const T &value) const
	Check if `this` contains `value`. More...

Bucket Interface
const_local_iterator	cbegin (size_type buck) const
	Get a const_local_iterator to the first element in the bucket at index `buck`. More...

const_local_iterator	begin (size_type buck) const
	Get a const_local_iterator to the first element in the bucket at index `buck`. More...

local_iterator	begin (size_type buck)
	Get a local_iterator to the first element in the bucket at index `buck`. More...

const_local_iterator	cend (size_type buck) const
	Get a const_local_iterator to the element one past the least element in the bucket at index `buck`. More...

const_local_iterator	end (size_type buck) const
	Get a const_local_iterator to the element one past the least element in the bucket at index `buck`. More...

local_iterator	end (size_type buck)
	Get a local_iterator to the element one past the least element in the bucket at index `buck`. More...

size_type	bucket_count () const noexcept
	Get the number of buckets in the set. More...

size_type	max_bucket_count () const noexcept
	Get the maximum possible number of buckets in the set. More...

size_type	bucket_size (size_type buck) const
	Get the number of elements in the bucket at index `buck`. More...

template<class T >
size_type	bucket (const T &value) const
	Get the bucket index of `value`. More...

Hash Policy
void	max_load_factor (float f)
	Set the maximum possible number of buckets in the set. More...

float	max_load_factor () const noexcept
	Get the maximum allowable load factor for the set. More...

float	load_factor () const noexcept
	Get the load factor for the set. More...

void	rehash (size_type nbuckets)
	Sets the number of buckets to the smallest possible value that is at least as large as `nbuckets` and rehashes the container, i.e. puts the elements into appropriate buckets considering that total number of buckets has changed. If the new number of buckets makes load factor more than maximum load factor, then the new number of buckets is at least size() / max_load_factor(). More...

void	reserve (size_type count)
	Sets the number of buckets to the number needed to accomodate at least `count` elements without exceeding the maximum load factor and rehashes the container, i.e. puts the elements into appropriate buckets considering that total number of buckets has changed. Effectively calls rehash(std::ceil(count / max_load_factor())). More...

Observers
hasher	hash_function () const
	Get a copy of the hash function. More...

key_equal	key_eq () const
	Get a copy of the equality comparison function. More...

allocator_type	get_allocator () const
	Get a copy of the allocator. More...

Node Interface
std::pair< node_handle, iterator >	pop (const_iterator pos_)
	Remove and return the element at the position pointed to by `pos` from the set. More...

node_handle	dup (const_iterator pos) const
	Copy and return the element at the position pointed to by `pos`. More...

std::pair< iterator, node_handle >	push (node_handle &&node)
	Insert the value pointed to by `node` to `this`. More...

std::tuple< iterator, iterator, bool >	splice (AnySet &other, const_iterator pos)
	Moves the element at position `pos` from `other` into `this`. More...

std::pair< iterator, iterator >	splice (AnySet &other, const_iterator first, const_iterator last)
	Moves the elements in the range [first, last) from `other` into `this`. More...

template<class T , class = std::enable_if_t<std::is_same_v<std::decay_t<T>, self_type>>>
auto	splice_or_copy (T &&other, const_iterator first, const_iterator last) -> std::pair< decltype(other.begin()), decltype(other.begin())>
	Copies or moves the elements in the range [first, last) from `other` into `this`. More...

template<class T , class = std::enable_if_t<std::is_same_v<std::decay_t<T>, self_type>>>
auto	splice_or_copy (T &&other, const_iterator pos) -> std::tuple< iterator, decltype(other.begin()), bool >
	Copies or moves the element at position `pos` from `other` into `this`. More...

Friends
Non-Member functions
void	swap (AnySet &left, AnySet &right)
	Calls left.swap(right). More...

bool	operator== (const AnySet &left, const AnySet &right)
	Compare the contents of two sets. More...

bool	operator!= (const AnySet &left, const AnySet &right)
	Compare the contents of two sets. More...

Related Functions
(Note that these are not member functions.)
template<class HashFn = te::AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<te::AnyValue<HashFn, KeyEqual>>, class ... Elements>
te::AnySet< HashFn, KeyEqual, Allocator >	make_anyset (Elements &&... elements)
	Helper function for creating an AnySet instance from a heterogeneous sequence of objects. More...

Member Typedef Documentation

◆ node_handle

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

using te::AnySet< HashFn, KeyEqual, Allocator >::node_handle = std::unique_ptr<value_type>

Node type to allow elements to persist after being removed, and for splicing between AnySet instances.

Constructor & Destructor Documentation

◆ AnySet() [1/16]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

te::AnySet< HashFn, KeyEqual, Allocator >::AnySet	(	size_type	bucket_count,
		const HashFn &	hash = `HashFn()`,
		const KeyEqual &	equal = `KeyEqual()`,
		const Allocator &	alloc = `Allocator()`
	)

inlineexplicit

Construct an empty AnySet instance. Sets max_load_factor() to 1.0.

Parameters

bucket_count	- Minimum number of buckets to initialize the set with.
hash	- Hash function to initialize the set with.
equal	- Equality comparison function to initialize the set with.
alloc	- Allocator to initialize the set with.

◆ AnySet() [2/16]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

te::AnySet< HashFn, KeyEqual, Allocator >::AnySet	(	size_type	bucket_count,
		const Allocator &	alloc
	)

inline

Construct an empty AnySet instance. Sets max_load_factor() to 1.0.

Parameters

bucket_count	- Minimum number of buckets to initialize the set with.
alloc	- Allocator to initialize the set with.

◆ AnySet() [3/16]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

te::AnySet< HashFn, KeyEqual, Allocator >::AnySet	(	size_type	bucket_count,
		const HashFn &	hash,
		const Allocator &	alloc
	)

inline

Construct an empty AnySet instance. Sets max_load_factor() to 1.0.

Parameters

bucket_count	- Minimum number of buckets to initialize the set with.
hash	- Hash function to initialize the set with.
alloc	- Allocator to initialize the set with.

◆ AnySet() [4/16]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class InputIt >

te::AnySet< HashFn, KeyEqual, Allocator >::AnySet	(	InputIt	first,
		InputIt	last,
		size_type	bucket_count = `0`,
		const HashFn &	hash = `HashFn()`,
		const KeyEqual &	equal = `KeyEqual()`,
		const Allocator &	alloc = `Allocator()`
	)

inline

Construct an AnySet instance from the range [first, last). Sets max_load_factor() to 1.0. If multiple elements in the range compare equivalent, only the first encountered is inserted.

Template Parameters

InputIt - Input iterator type.

Parameters

first	- Iterator to the first element in the range.
last	- Iterator one position past the last element in the range.
bucket_count	- Minimum number of buckets to initialize the set with.
hash	- Hash function to initialize the set with.
equal	- Equality comparison function to initialize the set with
alloc	- Allocator to initialize the set with.

◆ AnySet() [5/16]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class InputIt >

te::AnySet< HashFn, KeyEqual, Allocator >::AnySet	(	InputIt	first,
		InputIt	last,
		size_type	bucket_count,
		const Allocator &	alloc
	)

inline

Construct an AnySet instance from the range [first, last). Sets max_load_factor() to 1.0. If multiple elements in the range compare equivalent, only the first encountered is inserted.

Template Parameters

InputIt - Input iterator type.

Parameters

first	- Iterator to the first element in the range.
last	- Iterator one position past the last element in the range.
bucket_count	- Minimum number of buckets to initialize the set with.
alloc	- Allocator to initialize the set with.

◆ AnySet() [6/16]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class InputIt >

te::AnySet< HashFn, KeyEqual, Allocator >::AnySet	(	InputIt	first,
		InputIt	last,
		size_type	bucket_count,
		const HashFn &	hash,
		const Allocator &	alloc
	)

inline

Construct an AnySet instance from the range [first, last). Sets max_load_factor() to 1.0. If multiple elements in the range compare equivalent, only the first encountered is inserted.

Template Parameters

InputIt - Input iterator type.

Parameters

first	- Iterator to the first element in the range.
last	- Iterator one position past the last element in the range.
bucket_count	- Minimum number of buckets to initialize the set with.
hash	- Hash function to initialize the set with.
alloc	- Allocator to initialize the set with.

◆ AnySet() [7/16]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

te::AnySet< HashFn, KeyEqual, Allocator >::AnySet	(	const AnySet< HashFn, KeyEqual, Allocator > &	other,
		const Allocator &	alloc
	)

inline

Copy constructs an AnySet instance from other. Constructs the set with the copy of the contents of other. Copies the load factor, the predicate, and the hash function as well.

Parameters

other	- The set whose contents will be copied.
alloc	- Allocator to initialize the set with.

◆ AnySet() [8/16]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

te::AnySet< HashFn, KeyEqual, Allocator >::AnySet ( const AnySet< HashFn, KeyEqual, Allocator > & other )

inline

Copy constructs an AnySet instance from other. Constructs the set with the copy of the contents of other. Copies the load factor, the predicate, and the hash function as well.

Parameters

other - The set whose contents will be copied.

◆ AnySet() [9/16]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

te::AnySet< HashFn, KeyEqual, Allocator >::AnySet	(	AnySet< HashFn, KeyEqual, Allocator > &&	other,
		const Allocator &	alloc
	)

inline

Move constructs an AnySet instance from other. Constructs the set with the copy of the contents of other. Copies the load factor, the predicate, and the hash function as well.

Parameters

other	- The set whose contents will be copied.
alloc	- Allocator to initialize the set with.

◆ AnySet() [10/16]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

te::AnySet< HashFn, KeyEqual, Allocator >::AnySet ( AnySet< HashFn, KeyEqual, Allocator > && other )

inline

Copy constructs an AnySet instance from other. Constructs the set with the copy of the contents of other. Copies the load factor, the predicate, and the hash function as well.

Parameters

other - The set whose contents will be copied.

◆ AnySet() [11/16]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T >

te::AnySet< HashFn, KeyEqual, Allocator >::AnySet	(	std::initializer_list< T >	ilist,
		size_type	bucket_count = `0`,
		const HashFn &	hash = `HashFn()`,
		const KeyEqual &	equal = `KeyEqual()`,
		const Allocator &	alloc = `Allocator()`
	)

inline

Construct an AnySet with the contents of the initializer list ilist. Same as AnySet(init.begin(), init.end()). Sets max_load_factor() to 1.0. If multiple elements in the list compare equivalent, only the first encountered is inserted.

Template Parameters

T	- Type of the elements in the initializer list which will be added to the set.

Parameters

ilist	- Initializer list to initialize the elements of the set with.
bucket_count	- Minimum number of buckets to initialize the set with.
hash	- Hash function to initialize the set with.
equal	- Equality comparison function to initialize the set with
alloc	- Allocator to initialize the set with.

◆ AnySet() [12/16]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T >

te::AnySet< HashFn, KeyEqual, Allocator >::AnySet	(	std::initializer_list< T >	ilist,
		size_type	bucket_count,
		const Allocator &	alloc
	)

inline

Construct an AnySet with the contents of the initializer list ilist. Same as AnySet(init.begin(), init.end()). Sets max_load_factor() to 1.0. If multiple elements in the list compare equivalent, only the first encountered is inserted.

Template Parameters

T	- Type of the elements in the initializer list which will be added to the set.

Parameters

ilist	- Initializer list to initialize the elements of the set with.
bucket_count	- Minimum number of buckets to initialize the set with.
alloc	- Allocator to initialize the set with.

◆ AnySet() [13/16]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T >

te::AnySet< HashFn, KeyEqual, Allocator >::AnySet	(	std::initializer_list< T >	ilist,
		size_type	bucket_count,
		const HashFn &	hash,
		const Allocator &	alloc
	)

inline

Construct an AnySet with the contents of the initializer list ilist. Same as AnySet(init.begin(), init.end()). Sets max_load_factor() to 1.0. If multiple elements in the list compare equivalent, only the first encountered is inserted.

Template Parameters

T	- Type of the elements in the initializer list which will be added to the set.

Parameters

ilist	- Initializer list to initialize the elements of the set with.
bucket_count	- Minimum number of buckets to initialize the set with.
hash	- Hash function to initialize the set with.
alloc	- Allocator to initialize the set with.

◆ AnySet() [14/16]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class ... T>

te::AnySet< HashFn, KeyEqual, Allocator >::AnySet	(	std::tuple< T ... > &&	tup,
		size_type	bucket_count = `2 * (sizeof...(T))`,
		const HashFn &	hash = `HashFn()`,
		const KeyEqual &	equal = `KeyEqual()`,
		const Allocator &	alloc = `Allocator()`
	)

inline

Construct an AnySet with the contents of the tuple tup. Sets max_load_factor() to 1.0. If multiple elements in the tuple have the same type and compare equivalent,only the first encountered is inserted.

Template Parameters

T	- Parameter pack types of the tuple elements that will be used to initialize the set.

Parameters

ilist	- Initializer list to initialize the elements of the set with.
bucket_count	- Minimum number of buckets to initialize the set with.
hash	- Hash function to initialize the set with.
equal	- Equality comparison function to initialize the set with
alloc	- Allocator to initialize the set with.

◆ AnySet() [15/16]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class ... T>

te::AnySet< HashFn, KeyEqual, Allocator >::AnySet	(	std::tuple< T ... > &&	tup,
		size_type	bucket_count,
		const Allocator &	alloc
	)

inline

Construct an AnySet with the contents of the tuple tup. Sets max_load_factor() to 1.0. If multiple elements in the tuple have the same type and compare equivalent,only the first encountered is inserted.

Template Parameters

T	- Parameter pack types of the tuple elements that will be used to initialize the set.

Parameters

ilist	- Initializer list to initialize the elements of the set with.
bucket_count	- Minimum number of buckets to initialize the set with.
alloc	- Allocator to initialize the set with.

◆ AnySet() [16/16]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class ... T>

te::AnySet< HashFn, KeyEqual, Allocator >::AnySet	(	std::tuple< T ... > &&	tup,
		size_type	bucket_count,
		const HashFn &	hash,
		const Allocator &	alloc
	)

inline

Construct an AnySet with the contents of the tuple tup. Sets max_load_factor() to 1.0. If multiple elements in the tuple have the same type and compare equivalent,only the first encountered is inserted.

Template Parameters

T	- Parameter pack types of the tuple elements that will be used to initialize the set.

Parameters

ilist	- Initializer list to initialize the elements of the set with.
bucket_count	- Minimum number of buckets to initialize the set with.
hash	- Hash function to initialize the set with.
alloc	- Allocator to initialize the set with.

Member Function Documentation

◆ begin() [1/4]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

const_iterator te::AnySet< HashFn, KeyEqual, Allocator >::begin ( ) const

inline

Get a const_iterator to the first element in the set.

Returns: const_iterator to the first element in the set.

◆ begin() [2/4]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

iterator te::AnySet< HashFn, KeyEqual, Allocator >::begin ( )

inline

Get a iterator to the first element in the set.

Returns: iterator to the first element in the set.

◆ begin() [3/4]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

const_local_iterator te::AnySet< HashFn, KeyEqual, Allocator >::begin ( size_type buck ) const

inline

Get a const_local_iterator to the first element in the bucket at index buck.

Parameters

buck	- Index of the bucket.

Returns: const_local_iterator to the first element in the bucket at index buck.

◆ begin() [4/4]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

local_iterator te::AnySet< HashFn, KeyEqual, Allocator >::begin ( size_type buck )

inline

Get a local_iterator to the first element in the bucket at index buck.

Parameters

buck	- Index of the bucket.

Returns: local_iterator to the first element in the bucket at index buck.

◆ bucket()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T >

size_type te::AnySet< HashFn, KeyEqual, Allocator >::bucket ( const T & value ) const

inline

Get the bucket index of value.

Parameters

value - Value whose bucket is to be returned.

Returns: Index of the bucket in which value belongs.

◆ bucket_count()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

size_type te::AnySet< HashFn, KeyEqual, Allocator >::bucket_count ( ) const

inlinenoexcept

Get the number of buckets in the set.

Returns: The number of buckets in the set.

◆ bucket_size()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

size_type te::AnySet< HashFn, KeyEqual, Allocator >::bucket_size ( size_type buck ) const

inline

Get the number of elements in the bucket at index buck.

Parameters

buck	- Index of the bucket.

Returns: The number of elements in the bucket.

◆ cbegin() [1/2]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

const_iterator te::AnySet< HashFn, KeyEqual, Allocator >::cbegin ( ) const

inline

Get a const_iterator to the first element in the set.

Returns: const_iterator to the first element in the set.

◆ cbegin() [2/2]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

const_local_iterator te::AnySet< HashFn, KeyEqual, Allocator >::cbegin ( size_type buck ) const

inline

Get a const_local_iterator to the first element in the bucket at index buck.

Parameters

buck	- Index of the bucket.

Returns: const_local_iterator to the first element in the bucket at index buck.

◆ cend() [1/2]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

const_iterator te::AnySet< HashFn, KeyEqual, Allocator >::cend ( ) const

inline

Get a past-the-end const_iterator for this set.

Returns: const_iterator 1 past the last element in the set.

◆ cend() [2/2]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

const_local_iterator te::AnySet< HashFn, KeyEqual, Allocator >::cend ( size_type buck ) const

inline

Get a const_local_iterator to the element one past the least element in the bucket at index buck.

Parameters

buck	- Index of the bucket.

Returns: const_local_iterator to the element one past the least element in the bucket at index buck.

◆ contains()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T >

bool te::AnySet< HashFn, KeyEqual, Allocator >::contains ( const T & value ) const

inline

Check if this contains value.

Parameters

value - Value to search for.

Returns: true if this set contains an element whose type as is the same as values's type and whose value compares equal to value using the KeyEqual comparator.

◆ contains_eq()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T >

bool te::AnySet< HashFn, KeyEqual, Allocator >::contains_eq ( const T & value ) const

inline

Check if this contains value.

Parameters

value - Value to search for.

Returns: true if this set contains an element whose type as is the same as value's type and whose value compares equal to value using operator==().

◆ contains_value()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

bool te::AnySet< HashFn, KeyEqual, Allocator >::contains_value ( const value_type & any_v ) const

inline

Check if this contains the same value as another set.

Parameters

any_v - AnyValue<Hash, KeyEqual> instance to search for.

Returns: true if this set contains an element whose type as is the same as any_v's value's type and whose value compares equal to the value of any_v using the KeyEqual comparator.

◆ contains_value_eq()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

bool te::AnySet< HashFn, KeyEqual, Allocator >::contains_value_eq ( const value_type & any_v ) const

inline

Check if this contains the same value as another set.

Parameters

any_v - AnyValue<Hash, KeyEqual> instance to search for.

Returns: true if this set contains an element whose type as is the same as any_v's value's type and whose value compares equal to the value of any_v using operator==().

◆ count()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T >

size_type te::AnySet< HashFn, KeyEqual, Allocator >::count ( const T & value ) const

inline

Returns the number of elements with a value that have the same type as, and compare equal to the value, which is either 1 or 0 since AnySet does not allow duplicates.

Parameters

value - The value to obtain the count of in the set.

Returns: The number of elements found.

◆ dup()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

node_handle te::AnySet< HashFn, KeyEqual, Allocator >::dup ( const_iterator pos ) const

inline

Copy and return the element at the position pointed to by pos.

Parameters

pos	- Iterator to the element to pop.

Returns: A node_handle that points to the copied element.

Note: If the value at pos is an instance of a type that does not satisfy CopyConstructible, this function throws a te::NoCopyConstructorError.

◆ emplace()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T , class ... Args>

std::pair<iterator, bool> te::AnySet< HashFn, KeyEqual, Allocator >::emplace ( Args &&... args )

inline

Inserts a new element into the container constructed in-place with the given args if there is no element with the same type and value in the container.

Parameters

args	- Arguments to forward to the constructor of the element.

Template Parameters

T	- Type of the element to emplace. Must be a constructible non-reference type.

Returns: Returns a pair consisting of an iterator to the inserted element, or the already-existing element if no insertion happened, and a bool denoting whether the insertion took place. true for insertion, false for no insertion.

Remarks: AnySet follows the convention of STL node-based containers where emplacement is implemented by first allocating a new node, constructing the element within the allocated node, and then inserting. This means that AnySet::emplace() allocates a node even when insertion fails (i.e. the element already exists in the set).

Emplacement is the only way of inserting objects of non-movable, non-copyable types into an AnySet instance.

Note: References, pointers, and iterators remain valid after emplacement, however the values pointed to by iterators may change.

◆ emplace_hint()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T , class ... Args>

std::pair<iterator, bool> te::AnySet< HashFn, KeyEqual, Allocator >::emplace_hint	(	[[maybe_unused] ] const_iterator	hint,
		Args &&...	args
	)

inline

Inserts a new element into the container constructed in-place with the given args if there is no element with the same type and value in the container, using an iterator hint as a suggestion for where the new element should be placed.

Template Parameters

T	- Type of the element to emplace. Must be a constructible non-reference type.

Parameters

args	- Arguments to forward to the constructor of the element.
hint	- Iterator, used as a suggestion as to where to insert the new element.

Returns: Returns a pair consisting of an iterator to the inserted element, or the already-existing element if no insertion happened, and a bool denoting whether the insertion took place. true for insertion, false for no insertion.

Remarks: This member function is provided for consistency. The hint argument is ignored and instead this function simply calls AnySet::emplace<T>(forward<Args>(args)...).

AnySet follows the convention of STL node-based containers where emplacement is implemented by first allocating a new node, constructing the element within the allocated node, and then inserting. This means that AnySet::emplace() allocates a node even when insertion fails (i.e. the element already exists in the set).

Emplacement is the only way of inserting objects of non-movable, non-copyable types into an AnySet instance.

Note: References, pointers, and iterators remain valid after emplacement, however the values pointed to by iterators may change.

◆ empty()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

bool te::AnySet< HashFn, KeyEqual, Allocator >::empty ( ) const

inlinenoexcept

Checks if the set has no elements, i.e. whether begin() == end().

Returns: true if the set is empty, false otherwise.

◆ end() [1/4]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

const_iterator te::AnySet< HashFn, KeyEqual, Allocator >::end ( ) const

inline

Get a past-the-end const_iterator for this set.

Returns: const_iterator 1 past the last element in the set.

◆ end() [2/4]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

iterator te::AnySet< HashFn, KeyEqual, Allocator >::end ( )

inline

Get a past-the-end iterator for this set.

Returns: iterator 1 past the last element in the set.

◆ end() [3/4]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

const_local_iterator te::AnySet< HashFn, KeyEqual, Allocator >::end ( size_type buck ) const

inline

Get a const_local_iterator to the element one past the least element in the bucket at index buck.

Parameters

buck	- Index of the bucket.

Returns: const_local_iterator to the element one past the least element in the bucket at index buck.

◆ end() [4/4]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

local_iterator te::AnySet< HashFn, KeyEqual, Allocator >::end ( size_type buck )

inline

Get a local_iterator to the element one past the least element in the bucket at index buck.

Parameters

buck	- Index of the bucket.

Returns: local_iterator to the element one past the least element in the bucket at index buck.

◆ equal_range() [1/2]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T >

std::pair<const_iterator, const_iterator> te::AnySet< HashFn, KeyEqual, Allocator >::equal_range ( const T & value ) const

inline

Obtain a const_iterator range to the elements that have the same type as, and compares equal to the value.

Parameters

value - The value to obtain find.

Returns: std::pair containing a pair of const_iterators defining the requested range. If there are no such elements, past-the-end (see cend()) const_iterators are returned as both elements of the pair.

◆ equal_range() [2/2]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T >

std::pair<iterator, iterator> te::AnySet< HashFn, KeyEqual, Allocator >::equal_range ( const T & value )

inline

Obtain an iterator range to the elements that have the same type as, and compares equal to the value.

Parameters

value - The value to obtain find.

Returns: std::pair containing a pair of iterators defining the requested range. If there are no such elements, past-the-end (see end()) iterators are returned as both elements of the pair.

◆ erase() [1/3]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

iterator te::AnySet< HashFn, KeyEqual, Allocator >::erase ( const_iterator pos )

inline

Remove the element at the position pointed to by pos from the set.

Parameters

pos	- Iterator to the element to erase.

Returns: Iterator to the element following the erased element.

Note: Unlike std::unordered_set, erasure invalidates only iterators to the element following the erased element. The iterator returned by erase() is a suitable replacement for the invalidated iterator.

◆ erase() [2/3]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

iterator te::AnySet< HashFn, KeyEqual, Allocator >::erase	(	const_iterator	first,
		const_iterator	last
	)

inline

Remove elements in the range [first, last).

Parameters

first	- Iterator to the first element in the range to erase.
last	- Iterator one position past the last element to erase.

Returns: Iterator to the element following the last erased element.

Note: Unlike std::unordered_set, erasure invalidates only iterators to the element following the erased element. The iterator returned by erase() is a suitable replacement for the invalidated iterator.; For range-erasure, this specifically means that the returned iterator is a suitable replacement for iterators equivalent to the last parameter.

◆ erase() [3/3]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T , class = std::enable_if_t<not (std::is_same_v<const_iterator, T> or std::is_same_v<iterator, T>)>>

size_type te::AnySet< HashFn, KeyEqual, Allocator >::erase ( const T & value )

inline

Remove the element from the set whose type is the same type as value and whose value compares equal to value.

Parameters

value - Value of the element to erase.

Returns: The number of elements erased (zero or one).

Note: Unlike std::unordered_set, erasure invalidates only iterators to the element following the erased element. The iterator returned by erase() is a suitable replacement for the invalidated iterator.

◆ find() [1/2]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T >

const_iterator te::AnySet< HashFn, KeyEqual, Allocator >::find ( const T & value ) const

inline

Obtain a const_iterator to the element that has the same type as, and compares equal to the value.

Parameters

value - The value to obtain find.

Returns: const_iterator to the element found, or this->cend() if no such element exists.

◆ find() [2/2]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T >

iterator te::AnySet< HashFn, KeyEqual, Allocator >::find ( const T & value )

inline

Obtain an iterator to the element that has the same type as, and compares equal to the value.

Parameters

value - The value to obtain find.

Returns: iterator to the element found, or this->end() if no such element exists.

◆ get_allocator()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

allocator_type te::AnySet< HashFn, KeyEqual, Allocator >::get_allocator ( ) const

inline

Get a copy of the allocator.

Returns: A copy of the allocator.

◆ hash_function()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

hasher te::AnySet< HashFn, KeyEqual, Allocator >::hash_function ( ) const

inline

Get a copy of the hash function.

Returns: A copy of hash function.

◆ insert() [1/5]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T >

std::pair<iterator, bool> te::AnySet< HashFn, KeyEqual, Allocator >::insert ( T && value )

inline

Inserts an element into the set, if the set doesn't already contain an element with an equivalent value and type.

Parameters

value - element value to insert.

Returns: Returns a pair consisting of an iterator to the inserted element, or the already-existing element if no insertion happened, and a bool denoting whether the insertion took place. true for insertion, false for no insertion.

Note: References, pointers, and iterators remain valid after insertion, however the values pointed to by iterators may change.

◆ insert() [2/5]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T >

std::pair<iterator, bool> te::AnySet< HashFn, KeyEqual, Allocator >::insert	(	[[maybe_unused] ] const_iterator	hint,
		T &&	value
	)

inline

Inserts an element into the set, if the set doesn't already contain an element with an equivalent value and type.

Parameters

value - element value to insert.

Returns: Returns a pair consisting of an iterator to the inserted element, or the already-existing element if no insertion happened, and a bool denoting whether the insertion took place. true for insertion, false for no insertion.

Remarks: This member function is provided for consistency. The hint argument is ignored and instead this function simply calls AnySet::insert<T>(forward<T>(value)).

Note: References, pointers, and iterators remain valid after insertion, however the values pointed to by iterators may change.

◆ insert() [3/5]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class It , class = std::enable_if_t< std::is_copy_constructible_v<typename std::iterator_traits<It>::value_type> or std::is_rvalue_reference_v<decltype(*std::declval<It>())> >>

size_type te::AnySet< HashFn, KeyEqual, Allocator >::insert	(	It	first,
		It	last
	)

inline

Inserts elements from the range [first, last) that do not already exist in the set. If multiple elements in the range have values that compare equivalent, and there is no such element already in the set, only the first encountered is inserted.

Parameters

first	- Iterator to first element in the range.
last	- Iterator one position past the last element in the range.

Remarks: Range insertion assumes that all elements in the range [first, last) do not already exist in the set and will preemptively reallocate the internal bucket array accordingly to satisfy the current max_load_factor() if first and last are not input iterators.

Note: References, pointers, and iterators remain valid after insertion, however the values pointed to by iterators may change.

◆ insert() [4/5]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T , class U , class ... V>

std::bitset<2ull + sizeof...(V)> te::AnySet< HashFn, KeyEqual, Allocator >::insert	(	T &&	first,
		U &&	second,
		V &&...	args
	)

inline

Inserts args if they do not already exist in the set. If multiple values in args have the same type and have values that compare equivalent, and there is no such element already in the set, only the first encountered is inserted.

Parameters

first	- first value to insert into the set.
second	- second value to insert into the set.
args	- subsequent values to insert into the set.

Remarks: Variadic argument insertion assumes that all of the arguments do not already exist in the set and will preemptively reallocate the internal bucket array accordingly to satisfy the current max_load_factor().

Returns: A bitset where the ith bit is set to true iff the ith argument was successfully inserted.

Note: References, pointers, and iterators remain valid after insertion, however the values pointed to by iterators may change.

◆ insert() [5/5]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T , class = std::enable_if_t<std::is_copy_constructible_v<T>>>

size_type te::AnySet< HashFn, KeyEqual, Allocator >::insert ( std::initializer_list< T > ilist )

inline

Inserts elements from the list ilist that do not already exist in the set. If multiple elements in the list have values that compare equivalent, and there is no such element already in the set, only the first encountered is inserted.

Parameters

ilist - Initializer list of elements to insert into the set.

Remarks: Initializer-list insertion assumes that all elements in the list do not already exist in the set and will preemptively reallocate the internal bucket array accordingly to satisfy the current max_load_factor().

Returns: The number of values successfully inserted.

Note: References, pointers, and iterators remain valid after insertion, however the values pointed to by iterators may change.

◆ key_eq()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

key_equal te::AnySet< HashFn, KeyEqual, Allocator >::key_eq ( ) const

inline

Get a copy of the equality comparison function.

Returns: A copy of the equality comparison function.

◆ load_factor()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

float te::AnySet< HashFn, KeyEqual, Allocator >::load_factor ( ) const

inlinenoexcept

Get the load factor for the set.

Returns: The load factor for the set.

◆ max_bucket_count()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

size_type te::AnySet< HashFn, KeyEqual, Allocator >::max_bucket_count ( ) const

inlinenoexcept

Get the maximum possible number of buckets in the set.

Returns: The maximum possible number of buckets in the set.

◆ max_load_factor() [1/2]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

void te::AnySet< HashFn, KeyEqual, Allocator >::max_load_factor ( float f )

inline

Set the maximum possible number of buckets in the set.

Parameters

f	- The new load factor. Must be a positive number.

Returns: The maximum possible number of buckets in the set.

◆ max_load_factor() [2/2]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

float te::AnySet< HashFn, KeyEqual, Allocator >::max_load_factor ( ) const

inlinenoexcept

Get the maximum allowable load factor for the set.

Returns: The maximum allowable load factor for the set.

◆ max_size()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

size_type te::AnySet< HashFn, KeyEqual, Allocator >::max_size ( ) const

inlinenoexcept

Get the maximum number of elements the container is able to hold due to system or library implementation limitations, i.e. std::distance(begin(), end()) for the largest container.

Returns: Maximum number of elements.

◆ operator=() [1/3]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

AnySet& te::AnySet< HashFn, KeyEqual, Allocator >::operator= ( const AnySet< HashFn, KeyEqual, Allocator > & other )

inline

Copy assigns the contents of this AnySet instance from the contents of other. Copies the load factor, the predicate, the hash function, and allocator as well.

Parameters

other - The set whose contents will be copied.

Exceptions

te::NoCopyConstructorError if other contains an element of non-copy-constructible type.

Returns: *this;

◆ operator=() [2/3]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

AnySet& te::AnySet< HashFn, KeyEqual, Allocator >::operator= ( AnySet< HashFn, KeyEqual, Allocator > && other )

inlinenoexcept

Move assigns the contents of this AnySet instance from the contents of other. Moves the load factor, the predicate, the hash function, and allocator as well.

Parameters

other - The set whose contents will be moved.

Returns: *this;

◆ operator=() [3/3]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T >

AnySet& te::AnySet< HashFn, KeyEqual, Allocator >::operator= ( std::initializer_list< T > ilist )

inline

Assigns the contents of this AnySet instance with the contents of ilist.

Parameters

ilist - The initializer list whose contents will be copied.

Returns: *this;

◆ pop()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

std::pair<node_handle, iterator> te::AnySet< HashFn, KeyEqual, Allocator >::pop ( const_iterator pos_ )

inline

Remove and return the element at the position pointed to by pos from the set.

Parameters

pos	- Iterator to the element to pop.

Returns: A std::pair whose first member is a node_handle that points to the removed element, and whose second member is an iterator to the element following the popped element.

Note: Invalidates any iterators to the element after the popped element. Use the iterator returned by this function in place of those. Iterators to the popped element will point to the element after the popped element and are not invalidated. If the returned node_handle is subsequently added to a set by calling 'push()' any invalidated iterators are subsequently "re-validated", but will point to a (possibly past-the-end) element in the set in which the node_handle was pushed.

◆ push()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

std::pair<iterator, node_handle> te::AnySet< HashFn, KeyEqual, Allocator >::push ( node_handle && node )

inline

Insert the value pointed to by node to this.

Parameters

node	- node_handle pointing to the element to add.

Returns: A std::pair whose first member is an iterator to the inserted node or the the element that prevented the insertion, and a node_handle that points to null if the insertion was successful, or node if it was unsuccessful. In otherwords, the caller gets the node back only if it couldn't be inserted.

Note: No iterators are invalidated.

◆ rehash()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

void te::AnySet< HashFn, KeyEqual, Allocator >::rehash ( size_type nbuckets )

inline

Sets the number of buckets to the smallest possible value that is at least as large as nbuckets and rehashes the container, i.e. puts the elements into appropriate buckets considering that total number of buckets has changed. If the new number of buckets makes load factor more than maximum load factor, then the new number of buckets is at least size() / max_load_factor().

Parameters

nbuckets - The new number of buckets in the container after rehashing.

Remarks: The current implementation uses only powers-of-two for the bucket count.

◆ reserve()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

void te::AnySet< HashFn, KeyEqual, Allocator >::reserve ( size_type count )

inline

Sets the number of buckets to the number needed to accomodate at least count elements without exceeding the maximum load factor and rehashes the container, i.e. puts the elements into appropriate buckets considering that total number of buckets has changed. Effectively calls rehash(std::ceil(count / max_load_factor())).

Parameters

count - The number of elements to reserve space for.

Remarks: The current implementation uses only powers-of-two for the bucket count.

◆ size()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

size_type te::AnySet< HashFn, KeyEqual, Allocator >::size ( ) const

inlinenoexcept

Gets the number of elements in the set, i.e. std::distance(begin(), end()).

Returns: The number of elements in the set.

◆ splice() [1/2]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

std::tuple<iterator, iterator, bool> te::AnySet< HashFn, KeyEqual, Allocator >::splice	(	AnySet< HashFn, KeyEqual, Allocator > &	other,
		const_iterator	pos
	)

inline

Moves the element at position pos from other into this.

Parameters

other	- The set to move the element from.
pos	- Iterator to the element to move.

Returns: A std::tuple whose first member is an iterator to the position in this where the element was inserted or the element that prevented the insertion, whose second member is an iterator to the position in other of the element after the element at position pos, and whose third member is a bool indicating whether the move occurred.

Note: No iterators are invalidated by this function.; No element copy or move constructors are invoked by this function. The element is moved by splicing internal node objects from other into this.; If an exception is thrown due to a failure to allocate enough buckets for the new element, both this and other are unmodified. (conditional rollback semantics)

◆ splice() [2/2]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

std::pair<iterator, iterator> te::AnySet< HashFn, KeyEqual, Allocator >::splice	(	AnySet< HashFn, KeyEqual, Allocator > &	other,
		const_iterator	first,
		const_iterator	last
	)

inline

Moves the elements in the range [first, last) from other into this.

Parameters

other	- The set to move the element from.
first	- Iterator to the first element to move.
last	- Iterator to the element after the last element to move.

Returns: An iterator range to the elements in other, that were not moved into this.

Note: No iterators are invalidated by this function.; No element copy or move constructors are invoked by this function. The element is moved by splicing internal node objects from other into this.; If an exception is thrown due to a failure to allocate enough buckets for the new element, both this and other are unmodified. (conditional rollback semantics)

◆ splice_or_copy() [1/2]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T , class = std::enable_if_t<std::is_same_v<std::decay_t<T>, self_type>>>

auto te::AnySet< HashFn, KeyEqual, Allocator >::splice_or_copy	(	T &&	other,
		const_iterator	first,
		const_iterator	last
	)		-> std::pair<decltype(other.begin()), decltype(other.begin())>

inline

Copies or moves the elements in the range [first, last) from other into this.

Elements are only moved from other if other is an rvalue reference to non-const. If other is a reference to const AnySet, then elements are copied.

Parameters

other	- The set to move the element from.
first	- Iterator to the first element to move.
last	- Iterator to the element after the last element to move.

Returns: An iterator range to the elements in other, that were not moved into this. If other is not an rvalue, no elements are moved and thus the returned range is simple [first, last).

Note: No iterators are invalidated by this function.; No element copy or move constructors are invoked by this function. The element is moved by splicing internal node objects from other into this.; If an exception is thrown due to a failure to allocate enough buckets for the new element, both this and other are unmodified. (conditional rollback semantics); If other is const and any value in the range [first, last) is an instance of a type that does not satisfy CopyConstructible, this function throws a te::NoCopyConstructorError. If this occurs, only the elements preceding that value will have been added to this.

◆ splice_or_copy() [2/2]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

template<class T , class = std::enable_if_t<std::is_same_v<std::decay_t<T>, self_type>>>

auto te::AnySet< HashFn, KeyEqual, Allocator >::splice_or_copy	(	T &&	other,
		const_iterator	pos
	)		-> std::tuple<iterator, decltype(other.begin()), bool>

inline

Copies or moves the element at position pos from other into this.

Elements are only moved from other if other is an rvalue reference to non-const. If other is a reference to const AnySet, then elements are copied.

Parameters

other	- The set to copy or move the element from.
pos	- Iterator to the element to move.

Returns: A std::tuple whose first member is an iterator to the position in this where the element was inserted or the element that prevented the insertion, whose second member is an iterator (or const_iterator, if other is const) to the position in other of the element after the element at position pos, and whose third member is a bool indicating whether the copy/move occurred.

Note: No iterators are invalidated by this function.; No element copy or move constructors are invoked by this function if other is a non-const rvalue. In that case, the element is moved by splicing an internal node object from other into this.; If an exception is thrown due to a failure to allocate enough buckets for the new element, both this and other are unmodified. (conditional rollback semantics); If other is const and the value at position pos is an instance of a type that does not satisfy CopyConstructible, then this function throws a te::NoCopyConstructorError. If this occurs, this and other are unmodified. (conditional rollback semantics)

◆ swap()

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

void te::AnySet< HashFn, KeyEqual, Allocator >::swap ( AnySet< HashFn, KeyEqual, Allocator > & other )

inlinenoexcept

Exchanges the contents of the set with those of other. Does not invoke any move, copy, or swap operations on individual elements. Additionally exchanges the hash functions, comparison functions, and max_load_factor()s of the sets.

Parameters

other - The set to exchange contents with.

Note: All iterators and references remain valid. 'begin()' iterators do not change their allegiance.

◆ update() [1/2]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

AnySet& te::AnySet< HashFn, KeyEqual, Allocator >::update ( const AnySet< HashFn, KeyEqual, Allocator > & other )

inline

Add copies of elements from other.

Parameters

other - Set whose contents are to be added to the given set.

Returns: *this.

Note: If other contains an element whose type does not satisfy CopyConstructible, this function throws a te::NoCopyConstructorError.; If an exception is thrown while this function is executing, this will be only partially updated.

◆ update() [2/2]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

AnySet& te::AnySet< HashFn, KeyEqual, Allocator >::update ( AnySet< HashFn, KeyEqual, Allocator > && other )

inline

Moves elements from other into the set.

Parameters

other - Set whose contents are to be moved to the given set.

Returns: *this.

Note: No element copy or move constructors are invoked by this function. Elements are moved by splicing internal node objects from other into this.; If an exception is thrown while this function is executing, this will be only partially updated and other will be missing any elements that added to this.; No iterators are invalidated by this function, but iterators pointing into other may point to into this after the call to this function. Whether or not a particular iterator is past-the-end, and in which set it is past-the-end, may be changed.

Remarks: This function effectively erases any elements contained in this from other.

Friends And Related Function Documentation

◆ make_anyset()

template<class HashFn = te::AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<te::AnyValue<HashFn, KeyEqual>>, class ... Elements>

te::AnySet< HashFn, KeyEqual, Allocator > make_anyset ( Elements &&... elements )

Template Parameters

HashFn	- The type of the function object for the AnySet instance created. (optional)
KeyEqual	- The type of the function object for the AnySet instance created. (optional)
Allocator	- The type of the allocator for the AnySet instance created. (optional)

Parameters

elements - Parameter pack of values to initialize the set's contents with.

Returns: A newly-constructed AnySet instance that contains the provided elements.

◆ operator!=

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

bool operator!=	(	const AnySet< HashFn, KeyEqual, Allocator > &	left,
		const AnySet< HashFn, KeyEqual, Allocator > &	right
	)

friend

Compare the contents of two sets.

Parameters

left	- Set whose contents are to be swapped with `right`.
right	- Set whose contents are to be swapped with `left`.

Returns: false if every element in left is contained in right and vice-versa, using operator== to test for element equality, otherwise true.

Note: If either set contains one or more objects of a type that does not satisfy the EqualityComparable concept, this function returns true.

◆ operator==

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

bool operator==	(	const AnySet< HashFn, KeyEqual, Allocator > &	left,
		const AnySet< HashFn, KeyEqual, Allocator > &	right
	)

friend

Compare the contents of two sets.

Parameters

left	- Set whose contents are to be swapped with `right`.
right	- Set whose contents are to be swapped with `left`.

Returns: true if every element in left is contained in right and vice-versa, using operator== to test for element equality, otherwise false.

Note: If either set contains one or more objects of a type that does not satisfy the EqualityComparable concept, this function returns false.

◆ swap

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>

void swap	(	AnySet< HashFn, KeyEqual, Allocator > &	left,
		AnySet< HashFn, KeyEqual, Allocator > &	right
	)

friend

Calls left.swap(right).

Parameters

left	- Set whose contents are to be swapped with `right`.
right	- Set whose contents are to be swapped with `left`.

Inheritance diagram for te::AnySet< HashFn, KeyEqual, Allocator >:

[legend]

Collaboration diagram for te::AnySet< HashFn, KeyEqual, Allocator >:

[legend]

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

/home/tim/Projects/AnySet/include/anyset/AnySet.h

Detailed Description

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>> struct te::AnySet< HashFn, KeyEqual, Allocator >

Classes

Public Types

Public Member Functions

Friends

Related Functions

Member Typedef Documentation

◆ node_handle

Constructor & Destructor Documentation

◆ AnySet() [1/16]

◆ AnySet() [2/16]

◆ AnySet() [3/16]

◆ AnySet() [4/16]

◆ AnySet() [5/16]

◆ AnySet() [6/16]

◆ AnySet() [7/16]

◆ AnySet() [8/16]

◆ AnySet() [9/16]

◆ AnySet() [10/16]

◆ AnySet() [11/16]

◆ AnySet() [12/16]

◆ AnySet() [13/16]

◆ AnySet() [14/16]

◆ AnySet() [15/16]

◆ AnySet() [16/16]

Member Function Documentation

◆ begin() [1/4]

◆ begin() [2/4]

◆ begin() [3/4]

◆ begin() [4/4]

◆ bucket()

◆ bucket_count()

◆ bucket_size()

◆ cbegin() [1/2]

◆ cbegin() [2/2]

◆ cend() [1/2]

◆ cend() [2/2]

◆ contains()

◆ contains_eq()

◆ contains_value()

◆ contains_value_eq()

◆ count()

◆ dup()

◆ emplace()

◆ emplace_hint()

◆ empty()

◆ end() [1/4]

◆ end() [2/4]

◆ end() [3/4]

◆ end() [4/4]

◆ equal_range() [1/2]

◆ equal_range() [2/2]

◆ erase() [1/3]

◆ erase() [2/3]

◆ erase() [3/3]

◆ find() [1/2]

◆ find() [2/2]

◆ get_allocator()

◆ hash_function()

◆ insert() [1/5]

◆ insert() [2/5]

◆ insert() [3/5]

◆ insert() [4/5]

◆ insert() [5/5]

◆ key_eq()

◆ load_factor()

◆ max_bucket_count()

◆ max_load_factor() [1/2]

◆ max_load_factor() [2/2]

◆ max_size()

◆ operator=() [1/3]

◆ operator=() [2/3]

◆ operator=() [3/3]

◆ pop()

◆ push()

◆ rehash()

◆ reserve()

◆ size()

◆ splice() [1/2]

template<class HashFn = AnyHash, class KeyEqual = std::equal_to<>, class Allocator = std::allocator<AnyValue<HashFn, KeyEqual>>>
struct te::AnySet< HashFn, KeyEqual, Allocator >