original Namespace Reference

Main namespace for the project Original. More...

Classes
class	absTransform
	Transformation that converts an element to its absolute value. More...
class	addOptTransform
	Transformation that adds a given value to an element. More...
class	algorithms
	Utility class containing generic container algorithms. More...
class	allocateError
	Exception for memory allocation failures. More...
class	allocator
	Default memory allocator using allocators utilities. More...
class	allocatorBase
	Interface for other memory allocator implementations. More...
class	allocators
	Utility class providing static memory allocation/de-allocation functions. More...
class	alternative
	A type-safe container that may or may not contain a value. More...
class	alternative< void >
class	array
	A fixed-size array container with random access. More...
class	assignOptTransform
	Transformation that assigns a specified value to an element. More...
class	async
	Asynchronous programming utilities with future/promise pattern. More...
class	autoPtr
	Base smart pointer with reference counting. More...
class	baseArray
	Base class for fixed-size serial containers. More...
class	baseCloneable
	Base class that defines a cloneable interface. More...
class	baseIterator
	A base class for basic iterators. More...
class	baseList
	Base class for variable-size serial containers. More...
class	bitSet
	A class representing a set of bits, offering functionality to manipulate and query individual bits. More...
class	blocksList
	A block-based list implementation. More...
class	callBackChecker
	Static utility for validating callback signatures. More...
class	callbackReturnTypeError
	Exception for callback return type mismatch. More...
class	callbackSignatureError
	Exception for callback argument mismatch. More...
class	chain
	Non-cyclic doubly linked list container. More...
class	cloneable
	Concrete cloneable class with custom cloning behavior. More...
class	comparable
	Base class for comparable objects. More...
class	comparator
	Base class for comparison. More...
class	conditionBase
	Abstract base class for condition variable implementations. More...
class	container
	Abstract base class for containers. More...
class	containerAdapter
	Adapter class that provides unified interface for various container types. More...
class	copyTransform
	Transformation that copies an element into a container. More...
class	couple
	Container for two heterogeneous elements. More...
class	decreaseComparator
	Comparator for decreasing comparison (greater than). More...
class	decreaseNotStrictComparator
	Comparator for non-strict decreasing comparison (greater than or equal to). More...
class	deleter
	Default deletion policy for single objects. More...
class	deleter< TYPE[]>
class	deleterBase
	Base class for deleters defining the deletion policy interface. More...
class	deleterBase< TYPE[], DERIVED >
class	deque
	Double-ended queue container adapter. More...
class	doubleDirectionIterator
	Abstract base class for double-direction iterators. More...
class	equalComparator
	Comparator for equality comparison. More...
class	equalFilter
	A filter that checks if an element is equal to a target value. More...
class	error
	Base class for all exceptions in the Original project. More...
class	filter
	Base class for filter operations. More...
class	filterStream
	Composite filter builder with logical operator chaining. More...
class	forwardChain
	A singly linked list implementation. More...
struct	functionTraits
	Primary template for general callable types. More...
struct	functionTraits< R(*)(Args...)>
	Specialization for function pointers. More...
struct	functionTraits< R(Args...)>
	Specialization for function types. More...
struct	functionTraits< R(C::*)(Args...) const >
	Specialization for const member function pointers. More...
struct	functionTraits< R(C::*)(Args...)>
	Specialization for non-const member function pointers. More...
class	greaterFilter
	A filter that checks if an element is greater than a target value. More...
class	hash
	Forward declaration of hash class template. More...
class	hashable
	Forward declaration of hashable interface template. More...
class	hashMap
	Hash table based implementation of the map interface. More...
class	hashSet
	Hash table based implementation of the set interface. More...
class	hashTable
	Hash table implementation with separate chaining. More...
class	increaseComparator
	Comparator for increasing comparison (less than). More...
class	increaseNotStrictComparator
	Comparator for non-strict increasing comparison (less than or equal to). More...
class	indexSequence
	Compile-time sequence of unsigned integers. More...
class	iterable
	A base class for iterable containers that support multiple iteration patterns. More...
class	iterationStream
	A stream class that allows iteration, comparison, and printing. More...
class	iterator
	Base iterator interface that supports common operations for iteration. More...
class	JMap
	Skip List based implementation of the map interface. More...
class	JSet
	Skip List based implementation of the set interface. More...
class	lessFilter
	A filter that checks if an element is less than a target value. More...
class	lockGuard
	Abstract base class for lock guard implementations. More...
class	makeIndexSequence
	Utility for generating index sequences. More...
class	map
	Abstract base class for key-value mapping containers. More...
class	multiLock
	RAII wrapper for multiple mutex locking. More...
class	multiOptTransform
	Transformation that multiplies an element by a given value. More...
class	mutexBase
	Abstract base class for mutex implementations. More...
class	noElementError
	Exception for missing element requests. More...
class	none
	A placeholder type representing the absence of a value. More...
class	notEqualComparator
	Comparator for inequality comparison. More...
class	notEqualFilter
	A filter that checks if an element is not equal to a target value. More...
class	notGreaterFilter
	A filter that checks if an element is less than or equal to a target value. More...
class	notLessFilter
	A filter that checks if an element is greater than or equal to a target value. More...
class	nullPointerError
	Exception for null pointer dereference attempts. More...
class	objPoolAllocator
	Object pool allocator for efficient fixed-size memory management. More...
class	outOfBoundError
	Exception for container index out-of-range errors. More...
class	ownerPtr
	Unique ownership smart pointer with move semantics. More...
class	pCondition
	POSIX condition variable implementation. More...
class	pMutex
	POSIX thread mutex implementation. More...
class	printable
	Base class providing polymorphic string conversion capabilities. More...
class	prique
	Heap-based priority queue container. More...
class	pThread
	POSIX thread implementation. More...
class	queue
	First-In-First-Out (FIFO) container adapter. More...
class	randomAccessIterator
	Abstract base class for random-access iterators. More...
class	rangeFilter
	A filter that checks if an element lies within a specified range. More...
class	RBTree
	Red-Black Tree container implementation. More...
class	refCntPtr
	Base class for reference-counted pointers. More...
class	refCount
	Reference counting metadata container. More...
class	refCountBase
	Base class for reference counting metadata. More...
class	serial
	Abstract base class for sequential containers with index-based access. More...
class	set
	Abstract base class for unique element containers. More...
class	singleDirectionIterator
	Abstract base class for single-direction iterators. More...
class	singleton
	Thread-safe singleton pattern implementation with ownership management. More...
class	skipList
	Skip List container implementation. More...
class	stack
	Last-In-First-Out (LIFO) container adapter. More...
class	staticError
	Compile-time error triggering utility. More...
class	staticError< original::allocateError, TRIGGERING_CONDITION >
class	staticError< original::callbackReturnTypeError, TRIGGERING_CONDITION >
class	staticError< original::callbackSignatureError, TRIGGERING_CONDITION >
class	staticError< original::error, TRIGGERING_CONDITION >
class	staticError< original::noElementError, TRIGGERING_CONDITION >
class	staticError< original::nullPointerError, TRIGGERING_CONDITION >
class	staticError< original::outOfBoundError, TRIGGERING_CONDITION >
class	staticError< original::sysError, TRIGGERING_CONDITION >
class	staticError< original::unSupportedMethodError, TRIGGERING_CONDITION >
class	staticError< original::valueError, TRIGGERING_CONDITION >
class	stepIterator
	Abstract base class for step iterators. More...
class	strongPtr
	Shared ownership smart pointer with strong references. More...
class	sysError
	Exception for generic system failure. More...
class	task
	Concrete task implementation with result type. More...
class	taskBase
	Abstract base class for all task types. More...
class	taskDelegator
	Thread pool for managing and executing tasks with priority. More...
class	thread
	High-level thread wrapper. More...
class	threadBase
	Base class for thread implementations. More...
class	time
	Namespace-like class containing time-related utilities. More...
class	transform
	Base class for transformation operations. More...
class	transformStream
	Ordered sequence of transformation operations. More...
class	treeMap
	Red-Black Tree based implementation of the map interface. More...
class	treeSet
	Red-Black Tree based implementation of the set interface. More...
class	tuple
	Container for multiple heterogeneous elements. More...
class	uniqueLock
	RAII wrapper for single mutex locking. More...
class	unSupportedMethodError
	Exception for unimplemented method calls. More...
class	valueError
	Exception for invalid parameter values. More...
class	vector
	Dynamic array container with amortized constant time operations. More...
class	weakPtr
	Non-owning reference to shared resource. More...
class	wrapper
	Base class for linked value containers with formatted output. More...

Concepts
concept	isHashable
	Concept checking for types that can be hashed.
concept	NotNull
	Ensures the parameter pack is not empty.
concept	EnumType
	Requires type to be an enumeration.
concept	Comparable
	Requires type to support all comparison operators.
concept	Printable
	Requires type to support output stream insertion.
concept	CallbackOf
	Validates callback signature compatibility.
concept	Compare
	Combines Comparable and CallbackOf for comparison callbacks.
concept	Condition
	Constraint for predicate callbacks.
concept	Operation
	Constraint for mutating operations.
concept	SuperOf
	Checks inheritance or type equality.
concept	ExtendsOf
	Checks derivation or type identity using std::derived_from.

Typedefs
using	byte = std::uint8_t
	Unsigned 8-bit integer type (byte)
using	s_byte = std::int8_t
	Signed 8-bit integer type.
using	integer = std::int64_t
	64-bit signed integer type for arithmetic operations
using	u_integer = std::uint32_t
	32-bit unsigned integer type for sizes and indexes
using	ul_integer = std::uint64_t
	64-bit unsigned integer type
using	floating = double
	Double-precision floating-point type.
using	l_floating = long double
	Extended precision floating-point type.
template<u_integer N>
using	makeReverseSequence
	Creates a reversed index sequence.

Functions
template<typename T , typename DER , typename DEL >
bool	operator== (const autoPtr< T, DER, DEL > &ptr, const std::nullptr_t &null)
	Equality comparison with nullptr.
template<typename T , typename DER , typename DEL >
bool	operator!= (const autoPtr< T, DER, DEL > &ptr, const std::nullptr_t &null)
	Inequality comparison with nullptr.
template<typename T , typename DER , typename DEL >
bool	operator== (const std::nullptr_t &null, const autoPtr< T, DER, DEL > &ptr)
	Equality comparison with nullptr (reversed operands)
template<typename T , typename DER , typename DEL >
bool	operator!= (const std::nullptr_t &null, const autoPtr< T, DER, DEL > &ptr)
	Inequality comparison with nullptr (reversed operands)
template<typename ALLOC_ >
bitSet< ALLOC_ >	operator& (const bitSet< ALLOC_ > &lbs, const bitSet< ALLOC_ > &rbs)
template<typename ALLOC_ >
bitSet< ALLOC_ >	operator| (const bitSet< ALLOC_ > &lbs, const bitSet< ALLOC_ > &rbs)
template<typename ALLOC_ >
bitSet< ALLOC_ >	operator^ (const bitSet< ALLOC_ > &lbs, const bitSet< ALLOC_ > &rbs)
template<typename ALLOC_ >
bitSet< ALLOC_ >	operator~ (const bitSet< ALLOC_ > &bs)
template<typename EXTENDED >
std::strong_ordering	operator<=> (const EXTENDED &lc, const EXTENDED &rc)
consteval bool	ON_WINDOWS ()
	Checks if compiling for Windows platform.
consteval bool	ON_WIN32 ()
	Checks if compiling for 32-bit Windows.
consteval bool	ON_WIN64 ()
	Checks if compiling for 64-bit Windows.
consteval bool	ON_LINUX ()
	Checks if compiling for Linux platform.
consteval bool	ON_MACOS ()
	Checks if compiling for macOS platform.
consteval bool	ON_UNIX ()
	Checks if compiling for Unix-like platform (excluding Linux/macOS)
consteval bool	ON_UNKNOWN_PLATFORM ()
	Checks if compiling for unknown platform.
consteval bool	USING_CLANG ()
	Checks if compiling with Clang.
consteval bool	USING_GCC ()
	Checks if compiling with GCC.
consteval bool	USING_MSVC ()
	Checks if compiling with MSVC.
consteval bool	USING_UNKNOWN_COMPLIER ()
	Checks if compiling with unknown compiler.
template<typename T >
filterStream< T >	operator&& (const filter< T > &f1, const filter< T > &f2)
	Create AND filterStream from two filters.
template<typename T >
filterStream< T >	operator&& (const filter< T > &f, const filterStream< T > &ofs)
	AND operator between filter and filterStream.
template<typename T >
filterStream< T >	operator&& (const filterStream< T > &ofs, const filter< T > &f)
	AND operator between filterStream and filter.
template<typename T >
filterStream< T >	operator|| (const filter< T > &f1, const filter< T > &f2)
	Create OR filterStream from two filters.
template<typename T >
filterStream< T >	operator|| (const filter< T > &f, const filterStream< T > &ofs)
	OR operator between filter and filterStream.
template<typename T >
filterStream< T >	operator|| (const filterStream< T > &ofs, const filter< T > &f)
	OR operator between filterStream and filter.
template<typename T >
filterStream< T >	operator! (const filter< T > &f)
	Create negated filterStream from filter.
template<typename T >
filterStream< T >	operator! (const filterStream< T > &ofs)
	Create negated filterStream from existing stream.
template<typename T >
filterStream< T >	group (const filterStream< T > &ofs)
	Create grouped filterStream from existing stream.
template<typename T >
filterStream< T >	group (const filter< T > &f)
	Create grouped filterStream from single filter.
template<typename T >
auto	operator+ (const iterator< T > &it, integer steps) -> iterator< T > *
	Adds a number of steps to the iterator's current position and returns a new iterator.
template<typename T >
auto	operator- (const iterator< T > &it, integer steps) -> iterator< T > *
	Subtracts a number of steps from the iterator's current position and returns a new iterator.
template<typename T >
bool	operator== (const iterator< T > &l_it, const iterator< T > &r_it)
	Equality comparison operator for iterators.
template<typename T >
bool	operator!= (const iterator< T > &l_it, const iterator< T > &r_it)
	Inequality comparison operator for iterators.
template<typename TYPE >
TYPE	abs (TYPE a)
	Returns the absolute value of a given number.
template<typename TYPE >
TYPE	max (TYPE a, TYPE b)
	Returns the larger of two given values.
template<typename TYPE >
TYPE	min (TYPE a, TYPE b)
	Returns the smaller of two given values.
double	pow (double base, int exp)
	Returns the result of raising a base to an exponent.
template<typename T , typename DEL = deleter<T>, typename... Args>
ownerPtr< T, DEL >	makeOwnerPtr (Args &&... args)
	Creates a new ownerPtr managing a dynamically allocated object.
template<typename T , typename DEL = deleter<T[]>, typename... Args>
ownerPtr< T, DEL >	makeOwnerPtrArray (u_integer size, Args &&... args)
	Creates a new ownerPtr managing a dynamically allocated array.
std::ostream &	operator<< (std::ostream &os, const printable &p)
	Stream insertion operator for printable objects.
template<typename T , typename DEL = deleter<T>, typename... Args>
strongPtr< T, DEL >	makeStrongPtr (Args &&... args)
	Creates a new strongPtr managing a shared object.
template<typename T , typename DEL = deleter<T[]>, typename... Args>
strongPtr< T, DEL >	makeStrongPtrArray (u_integer size, Args &&... args)
	Creates a new strongPtr managing a shared array.
template<typename T >
transformStream< T >	operator+ (const transform< T > &t1, const transform< T > &t2)
	Creates new transformation stream from two transforms.
template<typename T >
transformStream< T >	operator+ (const transform< T > &t, const transformStream< T > &ots)
	Creates new stream by prefixing existing stream.
template<typename F_TYPE , typename S_TYPE >
tuple< F_TYPE, S_TYPE >	makeTuple (const couple< F_TYPE, S_TYPE > &cp)
template<typename... L_TYPES, typename... R_TYPES>
tuple< L_TYPES..., R_TYPES... >	operator+ (const tuple< L_TYPES... > &lt, const tuple< R_TYPES... > &rt)
template<u_integer NUM>
consteval auto	makeSequence ()
	Creates an index sequence of given length.
template<u_integer... Indices>
consteval auto	reverseIndexSequenceImpl (indexSequence< Indices... > seq)
	Implementation detail for reversing an index sequence.
template<typename T , typename... ARGS>
vector< T >	makeVector (u_integer size, ARGS &&... args)
time::duration	nanoseconds (time::time_val_type val=1)
time::duration	microseconds (time::time_val_type val=1)
time::duration	milliseconds (time::time_val_type val=1)
time::duration	seconds (time::time_val_type val=1)
time::duration	minutes (time::time_val_type val=1)
time::duration	hours (time::time_val_type val=1)
time::duration	days (time::time_val_type val=1)
time::duration	operator- (const time::duration &d)
time::duration	operator+ (const time::duration &lhs, const time::duration &rhs)
time::duration	operator- (const time::duration &lhs, const time::duration &rhs)
time::duration	operator* (const time::duration &d, time::time_val_type factor)
time::duration	operator* (time::time_val_type factor, const time::duration &d)
time::duration	operator/ (const time::duration &d, time::time_val_type factor)
time::duration	operator/ (const time::duration &lhs, const time::duration &rhs)
time::duration	abs (const time::duration &d)
time::point	operator+ (const time::point &p, const time::duration &d)
time::point	operator+ (const time::duration &d, const time::point &p)
time::point	operator- (const time::point &p, const time::duration &d)
time::duration	operator- (const time::point &lhs, const time::point &rhs)
time::UTCTime	operator+ (const time::UTCTime &t, const time::duration &d)
time::UTCTime	operator+ (const time::duration &d, const time::UTCTime &t)
time::UTCTime	operator- (const time::UTCTime &t, const time::duration &d)
time::duration	operator- (const time::UTCTime &lhs, const time::UTCTime &rhs)

Variables
constexpr long double	E = 2.7182818284590452353602874713526624977572470937000L
	The mathematical constant E (Euler's number).
constexpr long double	PI = 3.1415926535897932384626433832795028841971693993751L
	The mathematical constant PI (π).

Detailed Description

Main namespace for the project Original.

The main namespace containing all core type system components.

Main namespace containing all hashing utilities.

This namespace serves as the main container for all modules and functionality within the Original project. It includes various classes, functions, and data structures that form the backbone of the system.

Typedef Documentation

makeReverseSequence

template<u_integer N>

using original::makeReverseSequence

Initial value:

 decltype(
        reverseIndexSequenceImpl(makeSequence<N>())
    )

Creates a reversed index sequence.

Template Parameters

N	Length of the sequence to create

Returns

indexSequence instance with values N-1..0

Function Documentation

abs() [1/2]

original::time::duration original::abs ( const time::duration & d )

inline

Parameters

d	Duration to get absolute value of

Returns

Absolute duration

abs() [2/2]

template<typename TYPE >

TYPE original::abs

(

TYPE

a

)

Returns the absolute value of a given number.

Template Parameters

TYPE	The type of the input value.

Parameters

a	The input value.

Returns

The absolute value of the input value.

This function returns the absolute value of the input argument a, which is the distance of a from zero. It works for both positive and negative values.

// Example usage:
int a = -5;
int result = original::abs(a); // result will be 5

group() [1/2]

template<typename T >

filterStream< T > original::group

(

const filter< T > &

f

)

Create grouped filterStream from single filter.

Template Parameters

T	Element type

Parameters

f	Filter to group

Returns

New grouped filterStream

Enables future operator precedence modifications

group() [2/2]

template<typename T >

filterStream< T > original::group

(

const filterStream< T > &

ofs

)

Create grouped filterStream from existing stream.

Template Parameters

T	Element type

Parameters

ofs	filterStream to group

Returns

New grouped filterStream

Use instead of parentheses for explicit precedence control

makeOwnerPtr()

template<typename T , typename DEL = deleter<T>, typename... Args>

ownerPtr< T, DEL > original::makeOwnerPtr

(

Args &&...

args

)

Creates a new ownerPtr managing a dynamically allocated object.

Template Parameters

T	Type of object to create and manage
DEL	Deleter policy type (default: deleter<T>)
Args	Argument types for object construction

Parameters

args	Arguments to forward to T's constructor

Returns

ownerPtr<T, DEL> owning the newly created object

Note

Provides exception-safe object creation

Warning

The returned ownerPtr has exclusive ownership of the object

// Create an ownerPtr managing a new MyClass constructed with args
auto ptr = makeOwnerPtr<MyClass>(arg1, arg2);

makeOwnerPtrArray()

template<typename T , typename DEL = deleter<T[]>, typename... Args>

ownerPtr< T, DEL > original::makeOwnerPtrArray	(	u_integer	size,
		Args &&...	args )

Creates a new ownerPtr managing a dynamically allocated array.

Template Parameters

T	Type of array elements to create
DEL	Deleter policy type (default: deleter<T[]>)
Args	Argument types for array element initialization

Parameters

size	Number of elements in the array
args	Arguments to forward to each element's constructor

Returns

ownerPtr<T, DEL> owning the newly created array

Note

Provides exception-safe array creation

Warning

The returned ownerPtr has exclusive ownership of the array

// Create an ownerPtr managing a new MyClass[10] array
auto arr = makeOwnerPtrArray<MyClass>(10);

makeSequence()

template<u_integer NUM>

auto original::makeSequence ( )

constevalnoexcept

Creates an index sequence of given length.

Template Parameters

NUM	Length of the sequence to create

Returns

indexSequence instance with values 0..NUM-1

makeStrongPtr()

template<typename T , typename DEL = deleter<T>, typename... Args>

strongPtr< T, DEL > original::makeStrongPtr

(

Args &&...

args

)

Creates a new strongPtr managing a shared object.

Template Parameters

T	Type of object to create and manage
DEL	Deleter policy type (default: deleter<T>)
Args	Argument types for object construction

Parameters

args	Arguments to forward to T's constructor

Returns

strongPtr<T, DEL> sharing ownership of the new object

Note

Provides exception-safe object creation with shared ownership

The object will be destroyed when all strong references are released

// Create a strongPtr managing a new MyClass constructed with args
auto ptr = makeStrongPtr<MyClass>(arg1, arg2);

makeStrongPtrArray()

template<typename T , typename DEL = deleter<T[]>, typename... Args>

strongPtr< T, DEL > original::makeStrongPtrArray	(	u_integer	size,
		Args &&...	args )

Creates a new strongPtr managing a shared array.

Template Parameters

T	Type of array elements to create
DEL	Deleter policy type (default: deleter<T[]>)
Args	Argument types for array element initialization

Parameters

size	Number of elements in the array
args	Arguments to forward to each element's constructor

Returns

strongPtr<T, DEL> sharing ownership of the new array

Note

Provides exception-safe array creation with shared ownership

The array will be destroyed when all strong references are released

// Create a strongPtr managing a new MyClass[10] array
auto arr = makeStrongPtrArray<MyClass>(10);

max()

template<typename TYPE >

TYPE original::max	(	TYPE	a,
		TYPE	b )

Returns the larger of two given values.

Template Parameters

TYPE	The type of the input values.

Parameters

a	The first input value.
b	The second input value.

Returns

The larger of a and b.

This function compares the two values a and b, and returns the value that is greater.

// Example usage:
double a = 3.5, b = 7.2;
double result = original::max(a, b); // result will be 7.2

min()

template<typename TYPE >

TYPE original::min	(	TYPE	a,
		TYPE	b )

Returns the smaller of two given values.

Template Parameters

TYPE	The type of the input values.

Parameters

a	The first input value.
b	The second input value.

Returns

The smaller of a and b.

This function compares the two values a and b, and returns the value that is smaller.

// Example usage:
double a = 3.5, b = 7.2;
double result = original::min(a, b); // result will be 3.5

operator!() [1/2]

template<typename T >

filterStream< T > original::operator!

(

const filter< T > &

f

)

Create negated filterStream from filter.

Template Parameters

T	Element type

Parameters

f	Filter to negate

Returns

New filterStream with NOT operation

Note

Automatically adds grouping parentheses

operator!() [2/2]

template<typename T >

filterStream< T > original::operator!

(

const filterStream< T > &

ofs

)

Create negated filterStream from existing stream.

Template Parameters

T	Element type

Parameters

ofs	filterStream to negate

Returns

New negated filterStream

Note

Automatically adds grouping parentheses

operator!=() [1/3]

template<typename T , typename DER , typename DEL >

bool original::operator!=	(	const autoPtr< T, DER, DEL > &	ptr,
		const std::nullptr_t &	null )

Inequality comparison with nullptr.

Template Parameters

T	Managed object type
DER	CRTP derived class type
DEL	Deleter policy type

Parameters

ptr	autoPtr to compare
null	nullptr_t to compare against

Returns

true if the autoPtr is not empty (has a managed object)

Note

Equivalent to checking operator bool() of ptr

operator!=() [2/3]

template<typename T >

bool original::operator!=	(	const iterator< T > &	l_it,
		const iterator< T > &	r_it )

Inequality comparison operator for iterators.

Template Parameters

T	The type of elements the iterator traverses.

Parameters

l_it	Left-hand side iterator.
r_it	Right-hand side iterator.

Returns

True if the iterators point to different elements, false otherwise.

Note

This operation uses equalPtr for optimal constant-time comparison.

operator!=() [3/3]

template<typename T , typename DER , typename DEL >

bool original::operator!=	(	const std::nullptr_t &	null,
		const autoPtr< T, DER, DEL > &	ptr )

Inequality comparison with nullptr (reversed operands)

Template Parameters

T	Managed object type
DER	CRTP derived class type
DEL	Deleter policy type

Parameters

ptr	autoPtr to compare
null	nullptr_t to compare against

Returns

true if the autoPtr is not empty (has a managed object)

Note

Equivalent to checking operator bool() of ptr

operator&()

template<typename ALLOC_ >

bitSet< ALLOC_ > original::operator&	(	const bitSet< ALLOC_ > &	lbs,
		const bitSet< ALLOC_ > &	rbs )

Parameters

lbs	The left bitSet.
rbs	The right bitSet.

Returns

The result of the AND operation.

operator&&() [1/3]

template<typename T >

filterStream< T > original::operator&&	(	const filter< T > &	f,
		const filterStream< T > &	ofs )

AND operator between filter and filterStream.

Template Parameters

T	Element type

Parameters

f	Filter operand
ofs	filterStream operand

Returns

New combined filterStream

operator&&() [2/3]

template<typename T >

filterStream< T > original::operator&&	(	const filter< T > &	f1,
		const filter< T > &	f2 )

Create AND filterStream from two filters.

Template Parameters

T	Element type

Parameters

f1	First filter operand
f2	Second filter operand

Returns

New filterStream with AND operation

operator&&() [3/3]

template<typename T >

filterStream< T > original::operator&&	(	const filterStream< T > &	ofs,
		const filter< T > &	f )

AND operator between filterStream and filter.

Template Parameters

T	Element type

Parameters

ofs	filterStream operand
f	Filter operand

Returns

New combined filterStream

operator*() [1/2]

original::time::duration original::operator* ( const time::duration & d, time::time_val_type factor )

inline

Parameters

d	Duration to multiply
factor	Multiplication factor

Returns

Product of duration and factor

operator*() [2/2]

original::time::duration original::operator* ( time::time_val_type factor, const time::duration & d )

inline

Parameters

factor	Multiplication factor
d	Duration to multiply

Returns

Product of factor and duration

operator+() [1/7]

template<typename T >

auto original::operator+	(	const iterator< T > &	it,
		integer	steps ) -> iterator<T>*

Adds a number of steps to the iterator's current position and returns a new iterator.

Template Parameters

T	The type of the elements the iterator will traverse.

Parameters

it	The iterator to move.
steps	The number of steps to move forward.

Returns

A new iterator that is moved forward by the specified steps from the original iterator.

This operator does not modify the original iterator, but creates a new one that is advanced by steps positions.

Examples

D:/FrozenlemonTee/original/src/core/tuple.h.

operator+() [2/7]

original::time::UTCTime original::operator+ ( const time::duration & d, const time::UTCTime & t )

inline

Parameters

d	Duration to add
t	UTCTime

Returns

New UTCTime after addition

operator+() [3/7]

original::time::duration original::operator+ ( const time::duration & lhs, const time::duration & rhs )

inline

Parameters

lhs	Left operand
rhs	Right operand

Returns

Sum of durations

operator+() [4/7]

original::time::point original::operator+ ( const time::point & p, const time::duration & d )

inline

Parameters

p	Time point
d	Duration to add

Returns

New time point after addition

operator+() [5/7]

original::time::UTCTime original::operator+ ( const time::UTCTime & t, const time::duration & d )

inline

Parameters

t	UTCTime
d	Duration to add

Returns

New UTCTime after addition

operator+() [6/7]

template<typename T >

transformStream< T > original::operator+ ( const transform< T > & t, const transformStream< T > & ots )

related

Creates new stream by prefixing existing stream.

Creates new stream from transformation and existing stream.

Template Parameters

T

Data type

Parameters

t	Transformation to prepend
ots	Original stream

Returns

New stream applying t then ots's transformations

operator+() [7/7]

template<typename T >

transformStream< T > original::operator+ ( const transform< T > & t1, const transform< T > & t2 )

related

Creates new transformation stream from two transforms.

Creates new stream from two transformations.

Template Parameters

T

Data type

Parameters

t1	First transformation
t2	Second transformation

Returns

New stream applying t1 then t2

operator-() [1/7]

template<typename T >

auto original::operator-	(	const iterator< T > &	it,
		integer	steps ) -> iterator<T>*

Subtracts a number of steps from the iterator's current position and returns a new iterator.

Template Parameters

T	The type of the elements the iterator will traverse.

Parameters

it	The iterator to move.
steps	The number of steps to move backward.

Returns

A new iterator that is moved backward by the specified steps from the original iterator.

This operator does not modify the original iterator, but creates a new one that is moved backward by steps positions.

operator-() [2/7]

original::time::duration original::operator- ( const time::duration & d )

inline

Parameters

d	Duration to negate

Returns

Negated duration

operator-() [3/7]

original::time::duration original::operator- ( const time::duration & lhs, const time::duration & rhs )

inline

Parameters

lhs	Left operand
rhs	Right operand

Returns

Difference of durations

operator-() [4/7]

original::time::duration original::operator- ( const time::point & lhs, const time::point & rhs )

inline

Parameters

lhs	Left operand
rhs	Right operand

Returns

Duration between points

operator-() [5/7]

original::time::point original::operator- ( const time::point & p, const time::duration & d )

inline

Parameters

p	Time point
d	Duration to subtract

Returns

New time point after subtraction

operator-() [6/7]

original::time::duration original::operator- ( const time::UTCTime & lhs, const time::UTCTime & rhs )

inline

Parameters

lhs	Left operand
rhs	Right operand

Returns

Duration between UTCTimes

operator-() [7/7]

original::time::UTCTime original::operator- ( const time::UTCTime & t, const time::duration & d )

inline

Parameters

t	UTCTime
d	Duration to subtract

Returns

New UTCTime after subtraction

operator/() [1/2]

original::time::duration original::operator/ ( const time::duration & d, time::time_val_type factor )

inline

Parameters

d	Duration to divide
factor	Division factor

Returns

Quotient of duration and factor

operator/() [2/2]

original::time::duration original::operator/ ( const time::duration & lhs, const time::duration & rhs )

inline

Parameters

lhs	Left operand
rhs	Right operand

Returns

Quotient of durations

operator<<()

std::ostream & original::operator<< ( std::ostream & os, const printable & p )

inline

Stream insertion operator for printable objects.

Parameters

os	Output stream
p	Printable object

Returns

Modified output stream

MyClass obj;
std::cout << obj; // Outputs "printable(@0x7ffd)"

operator<=>()

template<typename EXTENDED >

std::strong_ordering original::operator<=>	(	const EXTENDED &	lc,
		const EXTENDED &	rc )

This operator is implemented by invoking the compareTo() method of the comparable object. The result type is std::strong_ordering, indicating strong ordering semantics. Defined as a friend function to enable symmetric argument handling.

Template Parameters

EXTENDED

The actual derived type using CRTP pattern.

Parameters

lc	Left-hand side comparable object
rc	Right-hand side comparable object

Returns

std::strong_ordering

• std::strong_ordering::less if lhs < rhs
• std::strong_ordering::equal if lhs == rhs
• std::strong_ordering::greater if lhs > rhs

operator==() [1/3]

template<typename T , typename DER , typename DEL >

bool original::operator==	(	const autoPtr< T, DER, DEL > &	ptr,
		const std::nullptr_t &	null )

Equality comparison with nullptr.

Template Parameters

T	Managed object type
DER	CRTP derived class type
DEL	Deleter policy type

Parameters

ptr	autoPtr to compare
null	nullptr_t to compare against

Returns

true if the autoPtr is empty (no managed object)

Note

Equivalent to checking !operator bool() of ptr

operator==() [2/3]

template<typename T >

bool original::operator==	(	const iterator< T > &	l_it,
		const iterator< T > &	r_it )

Equality comparison operator for iterators.

Template Parameters

T	The type of elements the iterator traverses.

Parameters

l_it	Left-hand side iterator.
r_it	Right-hand side iterator.

Returns

True if the iterators point to the same element, false otherwise.

Note

This operation uses equalPtr for optimal constant-time comparison.

operator==() [3/3]

template<typename T , typename DER , typename DEL >

bool original::operator==	(	const std::nullptr_t &	null,
		const autoPtr< T, DER, DEL > &	ptr )

Equality comparison with nullptr (reversed operands)

Template Parameters

T	Managed object type
DER	CRTP derived class type
DEL	Deleter policy type

Parameters

ptr	autoPtr to compare
null	nullptr_t to compare against

Returns

true if the autoPtr is empty (no managed object)

Note

Equivalent to checking !operator bool() of ptr

operator^()

template<typename ALLOC_ >

bitSet< ALLOC_ > original::operator^	(	const bitSet< ALLOC_ > &	lbs,
		const bitSet< ALLOC_ > &	rbs )

Parameters

lbs	The left bitSet.
rbs	The right bitSet.

Returns

The result of the XOR operation.

operator|()

template<typename ALLOC_ >

bitSet< ALLOC_ > original::operator|	(	const bitSet< ALLOC_ > &	lbs,
		const bitSet< ALLOC_ > &	rbs )

Parameters

lbs	The left bitSet.
rbs	The right bitSet.

Returns

The result of the OR operation.

operator||() [1/3]

template<typename T >

filterStream< T > original::operator||	(	const filter< T > &	f,
		const filterStream< T > &	ofs )

OR operator between filter and filterStream.

Template Parameters

T	Element type

Parameters

f	Filter operand
ofs	filterStream operand

Returns

New combined filterStream

operator||() [2/3]

template<typename T >

filterStream< T > original::operator||	(	const filter< T > &	f1,
		const filter< T > &	f2 )

Create OR filterStream from two filters.

Template Parameters

T	Element type

Parameters

f1	First filter operand
f2	Second filter operand

Returns

New filterStream with OR operation

operator||() [3/3]

template<typename T >

filterStream< T > original::operator||	(	const filterStream< T > &	ofs,
		const filter< T > &	f )

OR operator between filterStream and filter.

Template Parameters

T	Element type

Parameters

ofs	filterStream operand
f	Filter operand

Returns

New combined filterStream

operator~()

template<typename ALLOC_ >

bitSet< ALLOC_ > original::operator~

(

const bitSet< ALLOC_ > &

bs

)

Parameters

bs	The bitSet to negate.

Returns

The result of the NOT operation.

pow()

auto original::pow ( double base, int exp )

inline

Returns the result of raising a base to an exponent.

Parameters

base	The base value.
exp	The exponent value.

Returns

The result of base raised to the power of exp.

Exceptions

valueError

If base is 0 and exp is less than or equal to 0.

This function performs exponentiation by iterating exp times and multiplying the base. If exp is negative, it computes the reciprocal of the result. An exception is thrown if base is 0 and exp is non-positive.

// Example usage:
double base = 2.0;
int exp = 3;
double result = original::pow(base, exp); // result will be 8.0
 
// For negative exponent:
exp = -2;
result = original::pow(base, exp); // result will be 0.25

reverseIndexSequenceImpl()

template<u_integer... Indices>

auto original::reverseIndexSequenceImpl ( indexSequence< Indices... > seq )

consteval

Implementation detail for reversing an index sequence.

Template Parameters

Indices

Sequence indices to reverse

Parameters

seq	The index sequence to reverse

Returns

Reversed index sequence

Variable Documentation

E

long double original::E = 2.7182818284590452353602874713526624977572470937000L

constexpr

The mathematical constant E (Euler's number).

This is the base of the natural logarithm, approximately equal to 2.71828. It is used in various mathematical, scientific, and engineering applications, particularly in exponential growth and decay models, as well as in complex analysis.

Examples

D:/FrozenlemonTee/original/src/core/tuple.h.

PI

long double original::PI = 3.1415926535897932384626433832795028841971693993751L

constexpr

The mathematical constant PI (π).

This is the ratio of a circle's circumference to its diameter, approximately equal to 3.14159. It is used in geometry, trigonometry, and many other mathematical fields, especially when dealing with circular or spherical shapes.