StormByte 3.0.0
C++26 foundation of the StormByte suite
Loading...
Searching...
No Matches
StormByte::Type::Detail Namespace Reference

Private helpers for Safe classification. More...

Classes

struct  IsKnownNeverSafe
 Identifies standard-library ownership and view wrappers that Base will not admit. More...
struct  IsKnownNeverSafe< T * >
struct  IsKnownNeverSafe< T[]>
struct  IsKnownNeverSafe< T[N]>
struct  IsKnownNeverSafe< std::basic_string< T, Traits, Allocator > >
struct  IsKnownNeverSafe< std::basic_string_view< T, Traits > >
struct  IsKnownNeverSafe< std::array< T, N > >
struct  IsKnownNeverSafe< std::vector< T, Allocator > >
struct  IsKnownNeverSafe< std::deque< T, Allocator > >
struct  IsKnownNeverSafe< std::list< T, Allocator > >
struct  IsKnownNeverSafe< std::forward_list< T, Allocator > >
struct  IsKnownNeverSafe< std::map< K, V, Compare, Allocator > >
struct  IsKnownNeverSafe< std::multimap< K, V, Compare, Allocator > >
struct  IsKnownNeverSafe< std::set< K, Compare, Allocator > >
struct  IsKnownNeverSafe< std::multiset< K, Compare, Allocator > >
struct  IsKnownNeverSafe< std::unordered_map< K, V, Hash, Equal, Allocator > >
struct  IsKnownNeverSafe< std::unordered_multimap< K, V, Hash, Equal, Allocator > >
struct  IsKnownNeverSafe< std::unordered_set< K, Hash, Equal, Allocator > >
struct  IsKnownNeverSafe< std::unordered_multiset< K, Hash, Equal, Allocator > >
struct  IsKnownNeverSafe< std::queue< T, Container > >
struct  IsKnownNeverSafe< std::priority_queue< T, Container, Compare > >
struct  IsKnownNeverSafe< std::stack< T, Container > >
struct  IsKnownNeverSafe< std::initializer_list< T > >
struct  IsKnownNeverSafe< std::optional< T > >
struct  IsKnownNeverSafe< std::variant< T... > >
struct  IsKnownNeverSafe< std::tuple< T... > >
struct  IsKnownNeverSafe< std::pair< A, B > >
struct  IsKnownNeverSafe< std::span< T, Extent > >
struct  IsKnownNeverSafe< std::reference_wrapper< T > >
struct  IsKnownNeverSafe< std::function< Signature > >
struct  IsKnownNeverSafe< std::shared_ptr< T > >
struct  IsKnownNeverSafe< std::unique_ptr< T, Deleter > >
struct  IsKnownNeverSafe< std::weak_ptr< T > >
struct  is_std_queue
 Primary classification for standard FIFO wrappers. More...
struct  is_std_queue< std::queue< Value, Container > >
 Specialization for std::queue with any underlying container. More...

Functions

template<typename VariantT, typename U, std::size_t... I>
constexpr bool variant_has_type_impl (std::index_sequence< I... > seq) noexcept
 Fold: is stripped U one of VariantT's alternatives?
Endian
template<typename U>
requires TriviallyCopyable<U> && (sizeof(U) > 0)
constexpr U swap_endian (U val) noexcept
 Reverses the object-representation byte order of val.

Variables

template<typename T>
constexpr bool ArrayV = false
 Primary: T is not std::array.
template<typename U, std::size_t N>
constexpr bool ArrayV< std::array< U, N > > = true
 Partial: exact std::array<U, N>.
template<typename T>
constexpr bool is_variant_v = false
 true when T is exactly std::variant after stripping cv and references.
template<typename... Ts>
constexpr bool is_variant_v< std::variant< Ts... > > = true
 Specialization for every std::variant alternative list.
template<typename VariantT, typename U>
constexpr bool variant_has_type_v
 Convenience wrapper around StormByte::Type::Detail::variant_has_type_impl.

Detailed Description

Private helpers for Safe classification.

Function Documentation

◆ swap_endian()

template<typename U>
requires TriviallyCopyable<U> && (sizeof(U) > 0)
U StormByte::Type::Detail::swap_endian ( U val)
constexprnoexcept

Reverses the object-representation byte order of val.

Template Parameters
UTrivially copyable value type.
Parameters
[in]valValue whose bytes are reversed.
Returns
val with endianness swapped.

This always reverses bytes. Whether the caller should invoke it (host ≠ little-endian) is Serializable's job. Integrals go through std::byteswap; every other trivial type goes through std::bit_cast + reverse so float, enum and small POD structs stay defined.

Warning
Not a format detector. No BOM, no std::endian test.

◆ variant_has_type_impl()

template<typename VariantT, typename U, std::size_t... I>
bool StormByte::Type::Detail::variant_has_type_impl ( std::index_sequence< I... > seq)
constexprnoexcept

Fold: is stripped U one of VariantT's alternatives?

Template Parameters
VariantTA std::variant (already stripped by the caller).
UCandidate alternative.
IIndex pack over std::variant_size_v<VariantT>.
Parameters
[in]seqIndex sequence; unused except to expand I.
Returns
true if U matches any alternative.

Variable Documentation

◆ ArrayV

template<typename T>
bool StormByte::Type::Detail::ArrayV = false
inlineconstexpr

Primary: T is not std::array.

Template Parameters
TDecayed type.

◆ ArrayV< std::array< U, N > >

template<typename U, std::size_t N>
bool StormByte::Type::Detail::ArrayV< std::array< U, N > > = true
inlineconstexpr

Partial: exact std::array<U, N>.

Template Parameters
UElement type.
NExtent.

Specialisation only. Do not use tuple_size_v in the concept: any type with value_type (e.g. StormByte::Safe::Binary) would instantiate an incomplete std::tuple_size.

◆ is_variant_v

template<typename T>
bool StormByte::Type::Detail::is_variant_v = false
constexpr

true when T is exactly std::variant after stripping cv and references.

Template Parameters
TType to test.

Partial specialization of a variable template — not SFINAE. Needed because there is no standard std::is_variant.

◆ is_variant_v< std::variant< Ts... > >

template<typename... Ts>
bool StormByte::Type::Detail::is_variant_v< std::variant< Ts... > > = true
constexpr

Specialization for every std::variant alternative list.

Template Parameters
TsVariant alternatives.

◆ variant_has_type_v

template<typename VariantT, typename U>
bool StormByte::Type::Detail::variant_has_type_v
constexpr
Initial value:
=
std::make_index_sequence<std::variant_size_v<VariantT>>()
)
constexpr bool variant_has_type_impl(std::index_sequence< I... > seq) noexcept
Fold: is stripped U one of VariantT's alternatives?
Definition wrappers.hxx:108

Convenience wrapper around StormByte::Type::Detail::variant_has_type_impl.

Template Parameters
VariantTA std::variant.
UCandidate alternative.