Standard namespace extensions for original::alternative. More...

Classes
struct	formatter< T >
	std::formatter specialization for printable types More...

struct	hash< T >
	std::hash specialization for HashTraits types More...

struct	tuple_element< I, original::couple< F, S > >
	Specialization of tuple_element for couple to enable structured bindings. More...

struct	tuple_element< I, original::tuple< TYPES... > >
	Specialization of tuple_element for tuple to enable structured bindings. More...

struct	tuple_size< original::couple< F, S > >
	Specialization of tuple_size for couple to enable structured bindings. More...

struct	tuple_size< original::tuple< TYPES... > >
	Specialization of tuple_size for tuple to enable structured bindings. More...

Functions
template<typename TYPE >
void	swap (original::objPoolAllocator< TYPE > &lhs, original::objPoolAllocator< TYPE > &rhs) noexcept
	Specialization of std::swap for objPoolAllocator.

template<typename TYPE , typename ALLOC >
void	swap (original::array< TYPE, ALLOC > &lhs, original::array< TYPE, ALLOC > &rhs) noexcept
	Specialization of std::swap for array.

template<typename ALLOC >
void	swap (original::bitSet< ALLOC > &lhs, original::bitSet< ALLOC > &rhs) noexcept
	Specialization of std::swap for original::bitSet.

template<typename TYPE , typename ALLOC >
void	swap (original::blocksList< TYPE, ALLOC > &lhs, original::blocksList< TYPE, ALLOC > &rhs) noexcept
	Specialization of std::swap for original::blocksList.

template<typename TYPE , typename ALLOC >
void	swap (original::chain< TYPE, ALLOC > &lhs, original::chain< TYPE, ALLOC > &rhs) noexcept
	Specialization of std::swap for original::chain.

template<typename TYPE , template< typename, typename > typename SERIAL, template< typename > typename ALLOC>
void	swap (original::containerAdapter< TYPE, SERIAL, ALLOC > &lhs, original::containerAdapter< TYPE, SERIAL, ALLOC > &rhs) noexcept
	Specialization of std::swap for original::containerAdapter.

template<typename F , typename S >
void	swap (original::couple< F, S > &lhs, original::couple< F, S > &rhs) noexcept
	Specialization of std::swap for original::couple.

template<std::size_t I, typename F , typename S >
constexpr auto &	get (original::couple< F, S > &c) noexcept
	Structured binding support - get for non-const lvalue reference.

template<std::size_t I, typename F , typename S >
constexpr const auto &	get (const original::couple< F, S > &c) noexcept
	Structured binding support - get for const lvalue reference.

template<std::size_t I, typename F , typename S >
constexpr auto &&	get (original::couple< F, S > &&c) noexcept
	Structured binding support - get for rvalue reference.

template<typename K_TYPE , typename V_TYPE , typename HASH , typename ALLOC >
void	swap (original::hashMap< K_TYPE, V_TYPE, HASH, ALLOC > &lhs, original::hashMap< K_TYPE, V_TYPE, HASH, ALLOC > &rhs) noexcept
	std::swap specialization for hashMap

template<typename K_TYPE , typename V_TYPE , typename COMPARE , typename ALLOC >
void	swap (original::treeMap< K_TYPE, V_TYPE, COMPARE, ALLOC > &lhs, original::treeMap< K_TYPE, V_TYPE, COMPARE, ALLOC > &rhs) noexcept
	std::swap specialization for treeMap

template<typename K_TYPE , typename V_TYPE , typename COMPARE , typename ALLOC >
void	swap (original::JMap< K_TYPE, V_TYPE, COMPARE, ALLOC > &lhs, original::JMap< K_TYPE, V_TYPE, COMPARE, ALLOC > &rhs) noexcept
	std::swap specialization for JMap

template<typename TYPE >
void	swap (original::alternative< TYPE > &lhs, original::alternative< TYPE > &rhs) noexcept
	Specialization of std::swap for original::alternative.

template<typename T > requires original::ExtendsOf<original::printable, T>
std::string	to_string (const T &t)
	std::to_string overload for printable-derived types

template<typename TYPE , typename HASH , typename ALLOC >
void	swap (original::hashSet< TYPE, HASH, ALLOC > &lhs, original::hashSet< TYPE, HASH, ALLOC > &rhs) noexcept
	std::swap specialization for hashSet

template<typename TYPE , typename COMPARE , typename ALLOC >
void	swap (original::treeSet< TYPE, COMPARE, ALLOC > &lhs, original::treeSet< TYPE, COMPARE, ALLOC > &rhs) noexcept
	std::swap specialization for treeSet

template<typename TYPE , typename COMPARE , typename ALLOC >
void	swap (original::JSet< TYPE, COMPARE, ALLOC > &lhs, original::JSet< TYPE, COMPARE, ALLOC > &rhs) noexcept
	std::swap specialization for JSet

template<typename... TYPES>
void	swap (original::tuple< TYPES... > &lhs, original::tuple< TYPES... > &rhs) noexcept

template<std::size_t I, typename... TYPES>
constexpr auto &	get (original::tuple< TYPES... > &t) noexcept
	Structured binding support - get for non-const lvalue reference.

template<std::size_t I, typename... TYPES>
constexpr const auto &	get (const original::tuple< TYPES... > &t) noexcept
	Structured binding support - get for const lvalue reference.

template<std::size_t I, typename... TYPES>
constexpr auto &&	get (original::tuple< TYPES... > &&t) noexcept
	Structured binding support - get for rvalue reference.

template<typename TYPE , typename ALLOC >
void	swap (original::vector< TYPE, ALLOC > &lhs, original::vector< TYPE, ALLOC > &rhs) noexcept

Detailed Description

Standard namespace extensions for original::alternative.

Standard namespace extensions for printable integration.

Function Documentation

◆ get() [1/6]

template<std::size_t I, typename F , typename S >

constexpr const auto & std::get ( const original::couple< F, S > & c )

constexprnoexcept

Structured binding support - get for const lvalue reference.

Template Parameters

I	Index of element (0 or 1)
F	Type of first element
S	Type of second element

Parameters

c	couple to get element from

Returns: Const reference to the requested element

Note: noexcept qualified

◆ get() [2/6]

template<std::size_t I, typename... TYPES>

constexpr const auto & std::get ( const original::tuple< TYPES... > & t )

constexprnoexcept

Structured binding support - get for const lvalue reference.

Template Parameters

I	Index of element
TYPES	Variadic template parameter list of element types

Parameters

t	tuple to get element from

Returns: Const reference to the requested element

Note: noexcept qualified

◆ get() [3/6]

template<std::size_t I, typename F , typename S >

constexpr auto && std::get ( original::couple< F, S > && c )

constexprnoexcept

Structured binding support - get for rvalue reference.

Template Parameters

I	Index of element (0 or 1)
F	Type of first element
S	Type of second element

Parameters

c	couple to get element from

Returns: Rvalue reference to the requested element

Note: noexcept qualified

◆ get() [4/6]

template<std::size_t I, typename F , typename S >

constexpr auto & std::get ( original::couple< F, S > & c )

constexprnoexcept

Structured binding support - get for non-const lvalue reference.

Template Parameters

I	Index of element (0 or 1)
F	Type of first element
S	Type of second element

Parameters

c	couple to get element from

Returns: Reference to the requested element

Note: noexcept qualified

Examples: /home/runner/work/original/original/src/core/tuple.h.

◆ get() [5/6]

template<std::size_t I, typename... TYPES>

constexpr auto && std::get ( original::tuple< TYPES... > && t )

constexprnoexcept

Structured binding support - get for rvalue reference.

Template Parameters

I	Index of element
TYPES	Variadic template parameter list of element types

Parameters

t	tuple to get element from

Returns: Rvalue reference to the requested element

Note: noexcept qualified

◆ get() [6/6]

template<std::size_t I, typename... TYPES>

constexpr auto & std::get ( original::tuple< TYPES... > & t )

constexprnoexcept

Structured binding support - get for non-const lvalue reference.

Template Parameters

I	Index of element
TYPES	Variadic template parameter list of element types

Parameters

t	tuple to get element from

Returns: Reference to the requested element

Note: noexcept qualified

◆ swap() [1/14]

template<typename TYPE >

void std::swap	(	original::alternative< TYPE > &	lhs,
		original::alternative< TYPE > &	rhs
	)

noexcept

Specialization of std::swap for original::alternative.

Template Parameters

TYPE	The value type of the alternative

Parameters

lhs	First alternative to swap
rhs	Second alternative to swap

Note: No-throw guarantee if alternative<TYPE>::swap is noexcept

Enables ADL-friendly swapping with standard algorithms

◆ swap() [2/14]

template<typename TYPE , typename ALLOC >

void std::swap	(	original::array< TYPE, ALLOC > &	lhs,
		original::array< TYPE, ALLOC > &	rhs
	)

noexcept

Specialization of std::swap for array.

Template Parameters

TYPE	Type of elements in the array
ALLOC	Allocator type used by the array

Parameters

lhs	First array to swap
rhs	Second array to swap

◆ swap() [3/14]

template<typename ALLOC >

void std::swap	(	original::bitSet< ALLOC > &	lhs,
		original::bitSet< ALLOC > &	rhs
	)

noexcept

Specialization of std::swap for original::bitSet.

Template Parameters

ALLOC Allocator type

Parameters

lhs	Left bitSet
rhs	Right bitSet

◆ swap() [4/14]

template<typename TYPE , typename ALLOC >

void std::swap	(	original::blocksList< TYPE, ALLOC > &	lhs,
		original::blocksList< TYPE, ALLOC > &	rhs
	)

noexcept

Specialization of std::swap for original::blocksList.

Template Parameters

TYPE	Element type
ALLOC	Allocator type

Parameters

lhs	Left blocksList
rhs	Right blocksList

◆ swap() [5/14]

template<typename TYPE , typename ALLOC >

void std::swap	(	original::chain< TYPE, ALLOC > &	lhs,
		original::chain< TYPE, ALLOC > &	rhs
	)

noexcept

Specialization of std::swap for original::chain.

Template Parameters

TYPE	Element type
ALLOC	Allocator type

Parameters

lhs	Left chain
rhs	Right chain

◆ swap() [6/14]

template<typename TYPE , template< typename, typename > typename SERIAL, template< typename > typename ALLOC>

void std::swap	(	original::containerAdapter< TYPE, SERIAL, ALLOC > &	lhs,
		original::containerAdapter< TYPE, SERIAL, ALLOC > &	rhs
	)

noexcept

Specialization of std::swap for original::containerAdapter.

Template Parameters

TYPE	Element type
SERIAL	Underlying container type
ALLOC	Allocator type

Parameters

lhs	Left container adapter
rhs	Right container adapter

◆ swap() [7/14]

template<typename F , typename S >

void std::swap	(	original::couple< F, S > &	lhs,
		original::couple< F, S > &	rhs
	)

noexcept

Specialization of std::swap for original::couple.

Template Parameters

F	Type of first element
S	Type of second element

Parameters

lhs	Left couple
rhs	Right couple

◆ swap() [8/14]

template<typename K_TYPE , typename V_TYPE , typename HASH , typename ALLOC >

void std::swap	(	original::hashMap< K_TYPE, V_TYPE, HASH, ALLOC > &	lhs,
		original::hashMap< K_TYPE, V_TYPE, HASH, ALLOC > &	rhs
	)

noexcept

std::swap specialization for hashMap

Template Parameters

K_TYPE	Key type (must be hashable and copyable)
V_TYPE	Value type (must be copyable and movable)
HASH	Hash function type (default: hash<K_TYPE>)
ALLOC	Allocator type for memory management

Parameters

lhs	First hashMap to swap
rhs	Second hashMap to swap

Note: No-throw guarantee if hashMap::swap is noexcept

Provides standard library integration for hashMap by specializing std::swap. This enables:

ADL-friendly swapping in generic code
Use with standard algorithms (std::sort, std::rotate, etc.)
Consistent behavior with standard containers

The implementation delegates to hashMap::swap() to ensure proper handling of:

Bucket array exchange
Size counter swapping
Hash function transfer
Allocator propagation according to ALLOC traits

Iterator Invalidation: All iterators from both maps are invalidated Exception Safety: No-throw if hashMap::swap is noexcept

See also: hashMap::swap For the underlying swap implementation; std::swap For the general swap algorithm; <algorithm> For standard algorithms that use swap

◆ swap() [9/14]

template<typename TYPE , typename HASH , typename ALLOC >

void std::swap	(	original::hashSet< TYPE, HASH, ALLOC > &	lhs,
		original::hashSet< TYPE, HASH, ALLOC > &	rhs
	)

noexcept

std::swap specialization for hashSet

Template Parameters

TYPE	Element type
HASH	Hash function type
ALLOC	Allocator type

Parameters

lhs	First hashSet to swap
rhs	Second hashSet to swap

Note: No-throw guarantee if hashSet::swap is noexcept

Enables ADL-friendly swapping for use with standard algorithms and containers. Delegates to hashSet::swap for actual implementation.

Example usage with standard algorithms:

hashSet<int> set1, set2;
std::swap(set1, set2);  // Uses this specialization
std::sort(/* ... * /, [](auto& a, auto& b) {
    std::swap(a, b);    // Also uses this specialization
});

◆ swap() [10/14]

template<typename K_TYPE , typename V_TYPE , typename COMPARE , typename ALLOC >

void std::swap	(	original::JMap< K_TYPE, V_TYPE, COMPARE, ALLOC > &	lhs,
		original::JMap< K_TYPE, V_TYPE, COMPARE, ALLOC > &	rhs
	)

noexcept

std::swap specialization for JMap

Template Parameters

K_TYPE	Key type (must be comparable and copyable)
V_TYPE	Value type (must be copyable and movable)
COMPARE	Comparison function type (default: increaseComparator<K_TYPE>)
ALLOC	Allocator type for memory management

Parameters

lhs	First JMap to swap
rhs	Second JMap to swap

Note: No-throw guarantee if JMap::swap is noexcept

Provides standard library integration for JMap by specializing std::swap. This enables probabilistic skip list containers to work seamlessly with standard C++ algorithms and generic programming patterns.

The implementation delegates to JMap::swap() to ensure proper handling of:

Skip list head node exchange (entire multi-level structure)
Size counter swapping
Comparison function transfer
Allocator propagation according to ALLOC traits

Iterator Invalidation: All iterators from both maps are invalidated Exception Safety: No-throw if JMap::swap is noexcept Probabilistic Structure: Both skip lists maintain their level distributions

See also: JMap::swap For the underlying swap implementation; skipList For the underlying probabilistic data structure; std::swap For the general swap algorithm

◆ swap() [11/14]

template<typename TYPE , typename COMPARE , typename ALLOC >

void std::swap	(	original::JSet< TYPE, COMPARE, ALLOC > &	lhs,
		original::JSet< TYPE, COMPARE, ALLOC > &	rhs
	)

noexcept

std::swap specialization for JSet

Template Parameters

TYPE	Element type
COMPARE	Comparison function type
ALLOC	Allocator type

Parameters

lhs	First JSet to swap
rhs	Second JSet to swap

Note: No-throw guarantee if JSet::swap is noexcept

Enables ADL-friendly swapping for use with standard algorithms and containers. Delegates to JSet::swap for actual implementation.

Example usage with standard algorithms:

JSet<int> set1, set2;
std::swap(set1, set2);  // Uses this specialization
std::sort(/* ... * /, [](auto& a, auto& b) {
    std::swap(a, b);    // Also uses this specialization
});

◆ swap() [12/14]

template<typename TYPE >

void std::swap	(	original::objPoolAllocator< TYPE > &	lhs,
		original::objPoolAllocator< TYPE > &	rhs
	)

noexcept

Specialization of std::swap for objPoolAllocator.

Template Parameters

TYPE	Type of objects allocated

Parameters

lhs	First allocator to swap
rhs	Second allocator to swap

Examples: /home/runner/work/original/original/src/core/tuple.h, and /home/runner/work/original/original/src/core/vector.h.

◆ swap() [13/14]

template<typename K_TYPE , typename V_TYPE , typename COMPARE , typename ALLOC >

void std::swap	(	original::treeMap< K_TYPE, V_TYPE, COMPARE, ALLOC > &	lhs,
		original::treeMap< K_TYPE, V_TYPE, COMPARE, ALLOC > &	rhs
	)

noexcept

std::swap specialization for treeMap

Template Parameters

K_TYPE	Key type (must be comparable and copyable)
V_TYPE	Value type (must be copyable and movable)
COMPARE	Comparison function type (default: increaseComparator<K_TYPE>)
ALLOC	Allocator type for memory management

Parameters

lhs	First treeMap to swap
rhs	Second treeMap to swap

Note: No-throw guarantee if treeMap::swap is noexcept

Provides standard library integration for treeMap by specializing std::swap. This enables consistent behavior with standard ordered containers like std::map and std::set.

The implementation delegates to treeMap::swap() to ensure proper handling of:

Red-Black tree root node exchange
Size counter swapping
Comparison function transfer
Allocator propagation according to ALLOC traits

Iterator Invalidation: All iterators from both maps are invalidated Exception Safety: No-throw if treeMap::swap is noexcept Order Preservation: Both maps maintain their key ordering after swap

See also: treeMap::swap For the underlying swap implementation; std::map For the standard ordered map comparison; std::swap For the general swap algorithm

◆ swap() [14/14]

template<typename TYPE , typename COMPARE , typename ALLOC >

void std::swap	(	original::treeSet< TYPE, COMPARE, ALLOC > &	lhs,
		original::treeSet< TYPE, COMPARE, ALLOC > &	rhs
	)

noexcept

std::swap specialization for treeSet

Template Parameters

TYPE	Element type
COMPARE	Comparison function type
ALLOC	Allocator type

Parameters

lhs	First treeSet to swap
rhs	Second treeSet to swap

Note: No-throw guarantee if treeSet::swap is noexcept

Enables ADL-friendly swapping for use with standard algorithms and containers. Delegates to treeSet::swap for actual implementation.

Example usage with standard algorithms:

treeSet<int> set1, set2;
std::swap(set1, set2);  // Uses this specialization
std::sort(/* ... * /, [](auto& a, auto& b) {
    std::swap(a, b);    // Also uses this specialization
});

◆ to_string()

template<typename T >
requires original::ExtendsOf<original::printable, T>

std::string std::to_string ( const T & t )

std::to_string overload for printable-derived types

Template Parameters

T	Type derived from printable

Parameters

t	Printable object to convert

Returns: String representation using printable::formatString

Provides integration with standard library functions that use std::to_string, enabling seamless use of printable types in standard contexts.

MyClass obj;

std::string s = std::to_string(obj); // Uses printable formatting

std::to_string

std::string to_string(const T &t)

std::to_string overload for printable-derived types

Definition printable.h:415

Examples: /home/runner/work/original/original/src/core/vector.h.

Classes

Functions

Detailed Description

Function Documentation

◆ get() [1/6]

◆ get() [2/6]

◆ get() [3/6]

◆ get() [4/6]

◆ get() [5/6]

◆ get() [6/6]

◆ swap() [1/14]

◆ swap() [2/14]

◆ swap() [3/14]

◆ swap() [4/14]

◆ swap() [5/14]

◆ swap() [6/14]

◆ swap() [7/14]

◆ swap() [8/14]

◆ swap() [9/14]

◆ swap() [10/14]

◆ swap() [11/14]

◆ swap() [12/14]

◆ swap() [13/14]

◆ swap() [14/14]

◆ to_string()