Botan 3.5.0
Crypto and TLS for C&
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 >
 

Namespaces

namespace  Botan
 
namespace  Botan::detail
 

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::unpack (T &t)
 

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.