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	array
	A fixed-size array container with random access. More...
class	assignOptTransform
	Transformation that assigns a specified value to an element. 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	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[]>
	Base class for array deleters. More...
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 interface for all exception types in Original. 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...
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	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	map
	Abstract base class for key-value mapping containers. More...
class	multiOptTransform
	Transformation that multiplies an element by a given value. More...
class	noElementError
	Exception for missing element requests. 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	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	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	skipList
	Skip List container implementation. More...
class	stack
	Last-In-First-Out (LIFO) container adapter. More...
class	staticError
	Compile-time error assertion 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::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
class	thread
	High-level thread wrapper. More...
class	threadBase
	Base class for thread implementations. 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	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 hashable types.
concept	NotNull
	Ensures the parameter pack is not empty.
concept	Comparable
	Requires type to support all comparison operators.
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.

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	floating = double
	Double-precision floating-point type.
using	l_floating = long double
	Extended precision floating-point type.

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)
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<typename T, typename... ARGS>
vector< T >	makeVector (u_integer size, ARGS &&... args)

Variables
template<typename TYPE>
const strongPtr< filter< TYPE > >	filterStream< TYPE >::nullFilter {}
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.

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

byte

using original::byte = std::uint8_t

Unsigned 8-bit integer type (byte)

Typically used for raw byte manipulation and binary data handling.

Note

Range: 0 to 255

floating

using original::floating = double

Double-precision floating-point type.

Standard floating-point type for most numerical calculations.

Note

Typically 64-bit IEEE 754 floating-point (15-17 decimal digits precision)

Use this for most floating-point operations requiring precision

integer

using original::integer = std::int64_t

64-bit signed integer type for arithmetic operations

Primary type for most arithmetic operations where large range is needed.

Note

Range: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

Use this for calculations that may require large numbers

Examples

D:/FrozenLemonTee/Arbeit/PracticeProject/original/src/core/tuple.h, and D:/FrozenLemonTee/Arbeit/PracticeProject/original/src/core/vector.h.

l_floating

using original::l_floating = long double

Extended precision floating-point type.

Highest precision floating-point type for critical numerical calculations.

Note

Typically 80-bit or 128-bit extended precision (18-21 decimal digits precision)

Use this when maximum floating-point precision is required

s_byte

using original::s_byte = std::int8_t

Signed 8-bit integer type.

Used for small signed numeric values.

Note

Range: -128 to 127

u_integer

using original::u_integer = std::uint32_t

32-bit unsigned integer type for sizes and indexes

Used for array indexing, sizes, and counts where negative values are not needed.

Note

Range: 0 to 4,294,967,295

Warning

Not suitable for very large containers (>4GB)

Examples

D:/FrozenLemonTee/Arbeit/PracticeProject/original/src/core/tuple.h, and D:/FrozenLemonTee/Arbeit/PracticeProject/original/src/core/vector.h.

Function Documentation

abs()

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);

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);

makeTuple()

template<typename F_TYPE, typename S_TYPE>

tuple< F_TYPE, S_TYPE > original::makeTuple

(

const couple< F_TYPE, S_TYPE > &

cp

)

Template Parameters

F_TYPE	Type of the first element
S_TYPE	Type of the second element

Parameters

cp	The couple to convert

Returns

A new tuple with the couple's elements

Examples

D:/FrozenLemonTee/Arbeit/PracticeProject/original/src/core/tuple.h.

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/4]

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/Arbeit/PracticeProject/original/src/core/tuple.h.

operator+() [2/4]

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+() [3/4]

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+() [4/4]

template<typename... L_TYPES, typename... R_TYPES>

tuple< L_TYPES..., R_TYPES... > original::operator+	(	const tuple< L_TYPES... > &	lt,
		const tuple< R_TYPES... > &	rt )

Template Parameters

L_TYPES	Types of the left tuple's elements
R_TYPES	Types of the right tuple's elements

Parameters

lt	The left tuple
rt	The right tuple

Returns

A new tuple combining elements from both tuples

operator-()

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<<()

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 : public printable{};
 
MyClass obj;
std::cout << obj; // Outputs "printable(@0x7ffd) \n"

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

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/Arbeit/PracticeProject/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.