original::alternative< TYPE > Class Template Reference

A type-safe container that may or may not contain a value. More...

#include <optional.h>

Collaboration diagram for original::alternative< TYPE >:

Public Member Functions
	alternative ()
	Constructs an empty alternative.
template<typename... Args>
	alternative (Args &&... args)
	Constructs an alternative containing a value.
	alternative (const alternative &other)
	Copy constructor.
alternative &	operator= (const alternative &other)
	Copy assignment.
	alternative (alternative &&other) noexcept
	Move constructor.
alternative &	operator= (alternative &&other) noexcept
	Move assignment.
void	swap (alternative &other) noexcept
	Swaps contents with another alternative.
const TYPE &	operator* () const
	Const value access.
TYPE &	operator* ()
	Mutable value access.
const TYPE *	operator-> () const
	Const member access.
TYPE *	operator-> ()
	Mutable member access.
const TYPE *	get () const
	Gets const pointer to value.
TYPE *	get ()
	Gets mutable pointer to value.
void	reset () noexcept
	Resets to empty state.
template<typename... Args>
void	emplace (Args &&... args)
	Constructs value in-place.
void	set (const TYPE &t)
	Sets value by copy.
alternative &	operator= (const TYPE &t)
	Copy assignment from value type.
	operator bool () const
	Checks if contains a value.
bool	hasValue () const
	Checks if contains a value.
	~alternative ()
	Destructor.

Detailed Description

template<typename TYPE>
class original::alternative< TYPE >

A type-safe container that may or may not contain a value.

Specialization for void type alternative.

Template Parameters

TYPE	The type of value to store

This class provides a way to represent optional values without using pointers. It can either contain a value of type TYPE or be empty. The empty state is represented using original::none from types.h.

The implementation uses a union for storage to avoid dynamic allocation and ensure optimal performance. All operations provide strong exception safety guarantee when TYPE operations are exception-safe.

Example usage:

alternative<int> opt;          // Empty state
alternative<int> opt2(42);     // Contains value 42
if (opt2) {                    // Check if has value
    int val = *opt2;           // Access the value
}
 
// In-place construction
alternative<std::string> str(std::in_place, "hello", 5);
 
// Safe access with error checking
try {
    auto value = *opt;  // Throws valueError if empty
} catch (const valueError& e) {
    // Handle empty case
}

Represents a simple boolean flag indicating presence or absence of a value without storing actual data. Useful for signaling states without associated data, similar to std::optional<std::monostate>.

This specialization is more memory efficient than alternative<bool> and provides a clean interface for presence/absence signaling.

Example usage:

alternative<void> flag;                    // Empty state
alternative<void> present(std::in_place); // Present state
if (present) {
    // Do something when value is present
}

Constructor & Destructor Documentation

alternative() [1/4]

template<typename TYPE >

original::alternative< TYPE >::alternative ( )

explicit

Constructs an empty alternative.

Postcondition

hasValue() == false

alternative() [2/4]

template<typename TYPE >

template<typename... Args>

original::alternative< TYPE >::alternative ( Args &&...  args )

explicit

Constructs an alternative containing a value.

Template Parameters

Args	Argument types for TYPE construction

Parameters

args	Arguments to forward to TYPE constructor

Postcondition

hasValue() == true

alternative() [3/4]

template<typename TYPE >

original::alternative< TYPE >::alternative

(

const alternative< TYPE > &

other

)

Copy constructor.

Parameters

other

Alternative to copy from

Postcondition

hasValue() == other.hasValue()

alternative() [4/4]

template<typename TYPE >

original::alternative< TYPE >::alternative ( alternative< TYPE > &&  other )

noexcept

Move constructor.

Parameters

other

Alternative to move from

Postcondition

other is left in valid but unspecified state

~alternative()

template<typename TYPE >

original::alternative< TYPE >::~alternative

(

)

Destructor.

Note

Properly destroys contained value if present

Member Function Documentation

emplace()

template<typename TYPE >

template<typename... Args>

void original::alternative< TYPE >::emplace

(

Args &&...

args

)

Constructs value in-place.

Template Parameters

Args	Argument types for TYPE construction

Parameters

args	Arguments to forward to TYPE constructor

Postcondition

hasValue() == true

get() [1/2]

template<typename TYPE >

TYPE * original::alternative< TYPE >::get

(

)

Gets mutable pointer to value.

Returns

Pointer to value or nullptr if empty

get() [2/2]

template<typename TYPE >

const TYPE * original::alternative< TYPE >::get

(

)

const

Gets const pointer to value.

Returns

Pointer to value or nullptr if empty

hasValue()

template<typename TYPE >

bool original::alternative< TYPE >::hasValue

(

)

const

Checks if contains a value.

Returns

true if contains value, false if empty

operator bool()

template<typename TYPE >

original::alternative< TYPE >::operator bool ( ) const

explicit

Checks if contains a value.

Returns

true if contains value, false if empty

operator*() [1/2]

template<typename TYPE >

TYPE & original::alternative< TYPE >::operator*

(

)

Mutable value access.

Returns

Reference to contained value

Exceptions

valueError

if empty

operator*() [2/2]

template<typename TYPE >

const TYPE & original::alternative< TYPE >::operator*

(

)

const

Const value access.

Returns

Const reference to contained value

Exceptions

valueError

if empty

operator->() [1/2]

template<typename TYPE >

TYPE * original::alternative< TYPE >::operator->

(

)

Mutable member access.

Returns

Pointer to contained value

Exceptions

valueError

if empty

operator->() [2/2]

template<typename TYPE >

const TYPE * original::alternative< TYPE >::operator->

(

)

const

Const member access.

Returns

Const pointer to contained value

Exceptions

valueError

if empty

operator=() [1/3]

template<typename TYPE >

original::alternative< TYPE > & original::alternative< TYPE >::operator= ( alternative< TYPE > &&  other )

noexcept

Move assignment.

Parameters

other

Alternative to move from

Returns

Reference to this alternative

Postcondition

other is left in valid but unspecified state

operator=() [2/3]

template<typename TYPE >

original::alternative< TYPE > & original::alternative< TYPE >::operator=

(

const alternative< TYPE > &

other

)

Copy assignment.

Parameters

other

Alternative to copy from

Returns

Reference to this alternative

Postcondition

hasValue() == other.hasValue()

operator=() [3/3]

template<typename TYPE >

original::alternative< TYPE > & original::alternative< TYPE >::operator=

(

const TYPE &

t

)

Copy assignment from value type.

Parameters

t	Value to copy into the alternative

Returns

Reference to this alternative

Postcondition

hasValue() == true

Replaces the current contents (if any) with a copy of the given value. If the alternative was previously empty, constructs a new value. If it already contained a value, assigns the new value using TYPE's copy assignment operator. Provides strong exception safety guarantee if TYPE's copy constructor/assignment is exception-safe.

Example usage:

alternative<std::string> opt;
opt = "hello";  // Now contains "hello"
 
alternative<int> opt2(42);
opt2 = 100;     // Replaces 42 with 100

reset()

template<typename TYPE >

void original::alternative< TYPE >::reset ( )

noexcept

Resets to empty state.

Postcondition

hasValue() == false

set()

template<typename TYPE >

void original::alternative< TYPE >::set

(

const TYPE &

t

)

Sets value by copy.

Parameters

t	Value to copy

Postcondition

hasValue() == true

swap()

template<typename TYPE >

void original::alternative< TYPE >::swap ( alternative< TYPE > &  other )

noexcept

Swaps contents with another alternative.

Parameters

other

Alternative to swap with

Note

No-throw guarantee if TYPE's swap is noexcept

Efficiently exchanges contents without copying

---

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

• src/core/optional.h