strong_type.h File Reference

Public Header. More...

#include <ostream>
#include <span>
#include <botan/concepts.h>

Go to the source code of this file.

Classes
struct	Botan::EnableArithmeticWithPlainNumber
struct	Botan::is_strong_span< typename >
struct	Botan::is_strong_span< StrongSpan< T > >
class	Botan::Strong< T, TagTypeT, Capabilities >
class	Botan::detail::Strong_Adapter< T >
class	Botan::detail::Strong_Adapter< T >
class	Botan::detail::Strong_Base< T >
class	Botan::StrongSpan< T >
struct	Botan::detail::wrapped_type_helper< T >
struct	Botan::detail::wrapped_type_helper< T >

Namespaces
namespace	Botan
namespace	Botan::detail

Typedefs
template<typename T >
using	Botan::strong_type_wrapped_type = typename detail::wrapped_type_helper<std::remove_cvref_t<T>>::type
	Extracts the wrapped type from a strong type.

Functions
template<std::integral T, typename... Tags>
constexpr decltype(auto)	Botan::operator& (Strong< T, Tags... > a, Strong< T, Tags... > b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr decltype(auto)	Botan::operator& (Strong< T1, Tags... > a, T2 b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr decltype(auto)	Botan::operator& (T1 a, Strong< T2, Tags... > b)
template<std::integral T, typename... Tags>
constexpr auto	Botan::operator&= (Strong< T, Tags... > &a, Strong< T, Tags... > b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr auto	Botan::operator&= (Strong< T1, Tags... > &a, T2 b)
template<std::integral T, typename... Tags>
constexpr decltype(auto)	Botan::operator* (Strong< T, Tags... > a, Strong< T, Tags... > b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr decltype(auto)	Botan::operator* (Strong< T1, Tags... > a, T2 b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr decltype(auto)	Botan::operator* (T1 a, Strong< T2, Tags... > b)
template<std::integral T, typename... Tags>
constexpr auto	Botan::operator*= (Strong< T, Tags... > &a, Strong< T, Tags... > b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr auto	Botan::operator*= (Strong< T1, Tags... > &a, T2 b)
template<std::integral T, typename... Tags>
constexpr decltype(auto)	Botan::operator+ (Strong< T, Tags... > a, Strong< T, Tags... > b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr decltype(auto)	Botan::operator+ (Strong< T1, Tags... > a, T2 b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr decltype(auto)	Botan::operator+ (T1 a, Strong< T2, Tags... > b)
template<std::integral T, typename... Tags>
constexpr auto	Botan::operator++ (Strong< T, Tags... > &a)
template<std::integral T, typename... Tags>
constexpr auto	Botan::operator++ (Strong< T, Tags... > &a, int)
template<std::integral T, typename... Tags>
constexpr auto	Botan::operator+= (Strong< T, Tags... > &a, Strong< T, Tags... > b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr auto	Botan::operator+= (Strong< T1, Tags... > &a, T2 b)
template<std::integral T, typename... Tags>
constexpr decltype(auto)	Botan::operator- (Strong< T, Tags... > a, Strong< T, Tags... > b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr decltype(auto)	Botan::operator- (Strong< T1, Tags... > a, T2 b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr decltype(auto)	Botan::operator- (T1 a, Strong< T2, Tags... > b)
template<std::integral T, typename... Tags>
constexpr auto	Botan::operator-- (Strong< T, Tags... > &a)
template<std::integral T, typename... Tags>
constexpr auto	Botan::operator-- (Strong< T, Tags... > &a, int)
template<std::integral T, typename... Tags>
constexpr auto	Botan::operator-= (Strong< T, Tags... > &a, Strong< T, Tags... > b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr auto	Botan::operator-= (Strong< T1, Tags... > &a, T2 b)
template<std::integral T, typename... Tags>
constexpr decltype(auto)	Botan::operator/ (Strong< T, Tags... > a, Strong< T, Tags... > b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr decltype(auto)	Botan::operator/ (Strong< T1, Tags... > a, T2 b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr decltype(auto)	Botan::operator/ (T1 a, Strong< T2, Tags... > b)
template<std::integral T, typename... Tags>
constexpr auto	Botan::operator/= (Strong< T, Tags... > &a, Strong< T, Tags... > b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr auto	Botan::operator/= (Strong< T1, Tags... > &a, T2 b)
template<typename T , typename... Tags> requires (concepts::streamable<T>)
decltype(auto)	Botan::operator<< (std::ostream &os, const Strong< T, Tags... > &v)
template<std::integral T, typename... Tags>
constexpr decltype(auto)	Botan::operator<< (Strong< T, Tags... > a, Strong< T, Tags... > b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr decltype(auto)	Botan::operator<< (Strong< T1, Tags... > a, T2 b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr decltype(auto)	Botan::operator<< (T1 a, Strong< T2, Tags... > b)
template<std::integral T, typename... Tags>
constexpr auto	Botan::operator<<= (Strong< T, Tags... > &a, Strong< T, Tags... > b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr auto	Botan::operator<<= (Strong< T1, Tags... > &a, T2 b)
template<typename T , typename... Tags> requires (std::three_way_comparable<T>)
auto	Botan::operator<=> (const Strong< T, Tags... > &lhs, const Strong< T, Tags... > &rhs)
template<std::integral T1, std::integral T2, typename... Tags>
auto	Botan::operator<=> (Strong< T1, Tags... > a, T2 b)
template<std::integral T1, std::integral T2, typename... Tags>
auto	Botan::operator<=> (T1 a, Strong< T2, Tags... > b)
template<typename T , typename... Tags> requires (std::equality_comparable<T>)
bool	Botan::operator== (const Strong< T, Tags... > &lhs, const Strong< T, Tags... > &rhs)
template<std::integral T1, std::integral T2, typename... Tags>
auto	Botan::operator== (Strong< T1, Tags... > a, T2 b)
template<std::integral T1, std::integral T2, typename... Tags>
auto	Botan::operator== (T1 a, Strong< T2, Tags... > b)
template<std::integral T, typename... Tags>
constexpr decltype(auto)	Botan::operator>> (Strong< T, Tags... > a, Strong< T, Tags... > b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr decltype(auto)	Botan::operator>> (Strong< T1, Tags... > a, T2 b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr decltype(auto)	Botan::operator>> (T1 a, Strong< T2, Tags... > b)
template<std::integral T, typename... Tags>
constexpr auto	Botan::operator>>= (Strong< T, Tags... > &a, Strong< T, Tags... > b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr auto	Botan::operator>>= (Strong< T1, Tags... > &a, T2 b)
template<std::integral T, typename... Tags>
constexpr decltype(auto)	Botan::operator^ (Strong< T, Tags... > a, Strong< T, Tags... > b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr decltype(auto)	Botan::operator^ (Strong< T1, Tags... > a, T2 b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr decltype(auto)	Botan::operator^ (T1 a, Strong< T2, Tags... > b)
template<std::integral T, typename... Tags>
constexpr auto	Botan::operator^= (Strong< T, Tags... > &a, Strong< T, Tags... > b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr auto	Botan::operator^= (Strong< T1, Tags... > &a, T2 b)
template<std::integral T, typename... Tags>
constexpr decltype(auto)	Botan::operator| (Strong< T, Tags... > a, Strong< T, Tags... > b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr decltype(auto)	Botan::operator| (Strong< T1, Tags... > a, T2 b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr decltype(auto)	Botan::operator| (T1 a, Strong< T2, Tags... > b)
template<std::integral T, typename... Tags>
constexpr auto	Botan::operator|= (Strong< T, Tags... > &a, Strong< T, Tags... > b)
template<std::integral T1, std::integral T2, typename... Tags> requires (detail::has_capability<EnableArithmeticWithPlainNumber, Tags...>)
constexpr auto	Botan::operator|= (Strong< T1, Tags... > &a, T2 b)
template<typename T >
constexpr decltype(auto)	Botan::unwrap_strong_type (T &&t)
	Generically unwraps a strong type to its underlying type.
template<typename T , typename ParamT > requires std::constructible_from<T, ParamT> || (concepts::strong_type<T> && std::constructible_from<typename T::wrapped_type, ParamT>)
constexpr decltype(auto)	Botan::wrap_strong_type (ParamT &&t)
	Wraps a value into a caller-defined (strong) type.

Variables
template<typename CapabilityT , typename... Tags>
constexpr bool	Botan::detail::has_capability = (std::is_same_v<CapabilityT, Tags> || ...)
template<typename T >
constexpr bool	Botan::is_strong_span_v = is_strong_span<T>::value

Detailed Description

Public Header.

Definition in file strong_type.h.