StormByte::Type Namespace Reference

Named concepts and small type utilities used across the suite. More...

Namespaces
namespace	Detail
	Private helpers.

Concepts
concept	Reference
	Lvalue or rvalue reference type.
concept	LvalueReference
	Lvalue reference type (std::is_lvalue_reference).
concept	RvalueReference
	Rvalue reference type (std::is_rvalue_reference).
concept	Pointer
	Raw (possibly cv-qualified) pointer type.
concept	SmartPointer
	Smart pointer-like type: dereferenceable and exposes get().
concept	NullablePointer
	Smart pointer-like type that can test whether it contains an object.
concept	Integral
	Integral type (bool, char, int, long, …), including cv.
concept	FloatingPoint
	Floating-point type (float, double, long double).
concept	Arithmetic
	Integral or floating-point type.
concept	Signed
	Signed arithmetic type (std::is_signed).
concept	Unsigned
	Unsigned arithmetic type (std::is_unsigned).
concept	Const
	Top-level const qualifier (std::is_const_v).
concept	Class
	Class or struct type (not union, not enum).
concept	EqualityComparable
	Type whose == and != both yield something convertible to bool.
concept	ThreeWayComparable
	Type whose <=> operator is well-formed.
concept	Hashable
	Type with a valid std::hash specialization.
concept	String
	Text string types that are not generic containers.
concept	Container
	Has begin(), end() and value_type, and is not a String.
concept	HasKeyType
	Container that publishes a nested key_type.
concept	HasMappedType
	Container that publishes a nested mapped_type.
concept	HasPushBack
	Container that accepts push_back of a value_type.
concept	HasPushFront
	Container that accepts push_front of a value_type.
concept	HasInsert
	Associative Container that accepts insert of a value_type.
concept	HasSubscript
	Container that supports operator[] with key/index U.
concept	Sized
	Container that publishes size() convertible to std::size_t.
concept	ConvertibleTo
	From is implicitly convertible to To (std::is_convertible).
concept	ExplicitlyConvertibleTo
	From may be explicitly converted to To with static_cast.
concept	Enum
	Unscoped or scoped enumeration (enum / enum class).
concept	UnsignedEnum
	Enum whose underlying type is unsigned.
concept	ScopedEnum
	Scoped enumeration (enum class / enum struct).
concept	TriviallyCopyable
	Type that may be copied with memcpy / as-if memcpy.
concept	TriviallyDestructible
	Type with a trivial destructor.
concept	DefaultConstructible
	Type constructible from an empty initializer (T{} / T()).
concept	TriviallyDefaultConstructible
	DefaultConstructible with a trivial default constructor.
concept	CopyConstructible
	Type that can actually be copy-constructed.
concept	TriviallyCopyConstructible
	CopyConstructible with a trivial copy constructor.
concept	CopyAssignable
	Type that can actually be copy-assigned.
concept	TriviallyCopyAssignable
	CopyAssignable with a trivial copy-assignment operator.
concept	MoveConstructible
	Type that can be move-constructed.
concept	TriviallyMoveConstructible
	MoveConstructible with a trivial move constructor.
concept	MoveAssignable
	Type that can be move-assigned (operator=(T&&)).
concept	TriviallyMoveAssignable
	MoveAssignable with a trivial move-assignment operator.
concept	Copyable
	Both CopyConstructible and CopyAssignable.
concept	Movable
	Both MoveConstructible and MoveAssignable.
concept	Swappable
	Type that can be swapped with std::swap (std::is_swappable).
concept	Range
	Valid range (std::ranges::range).
concept	InputRange
	Input range (std::ranges::input_range).
concept	OutputRange
	Output range for values of type T (std::ranges::output_range).
concept	ForwardRange
	Forward range (std::ranges::forward_range).
concept	BidirectionalRange
	Bidirectional range (std::ranges::bidirectional_range).
concept	RandomAccessRange
	Random-access range (std::ranges::random_access_range).
concept	ContiguousRange
	Contiguous range (std::ranges::contiguous_range).
concept	SizedRange
	Sized range (std::ranges::sized_range).
concept	CommonRange
	Common range (std::ranges::common_range).
concept	View
	Range view (std::ranges::view).
concept	BorrowedRange
	Borrowed range (std::ranges::borrowed_range).
concept	InputIterator
	Input iterator (std::input_iterator).
concept	OutputIterator
	Output iterator for values of type T (std::output_iterator).
concept	ForwardIterator
	Forward iterator (std::forward_iterator).
concept	BidirectionalIterator
	Bidirectional iterator (std::bidirectional_iterator).
concept	RandomAccessIterator
	Random-access iterator (std::random_access_iterator).
concept	ContiguousIterator
	Contiguous iterator (std::contiguous_iterator).
concept	SentinelFor
	Valid sentinel for an iterator (std::sentinel_for).
concept	SizedSentinelFor
	Sized sentinel for an iterator (std::sized_sentinel_for).
concept	ByteInputRange
	Input range whose scalar values can be explicitly converted to std::byte.
concept	ByteInputIterator
	Input iterator whose scalar values can be explicitly converted to std::byte.
concept	Callable
	Invocable with argument types Args (std::is_invocable).
concept	SameAs
	Same type after stripping cv and references from both sides.
concept	DerivedFrom
	Derived derives from Base (std::is_base_of).
concept	Optional
	Exactly std::optional<U> for some U.
concept	Pair
	Type with accessible first and second members.
concept	Variant
	Instantiation of std::variant, after stripping cv/ref.
concept	VariantHasType
	Variant T that lists U among its alternatives.

Typedefs
template<typename E >
using	UnderlyingType = std::underlying_type_t< std::remove_cv_t< E > >
	Underlying integer type of enumeration E.
template<Range R>
using	RangeValue = std::ranges::range_value_t< R >
	Value type of a valid range.
template<Range R>
using	RangeReference = std::ranges::range_reference_t< R >
	Reference type produced by a valid range.
template<Range R>
using	RangeDifference = std::ranges::range_difference_t< R >
	Difference type associated with a valid range.
template<typename I >
using	IteratorValue = std::iter_value_t< I >
	Value type associated with an iterator.

Functions
template<typename E > requires Enum<E>
constexpr UnderlyingType< E >	ToUnderlying (E e) noexcept
	Converts an enumeration value to its underlying integer.

Detailed Description

Named concepts and small type utilities used across the suite.

Prefer these names in public templates. Do not reintroduce std::enable_if / void_t traits next to them.

Split by