Classes
struct	AutoDetect

class	Strong_Adapter

class	Strong_Adapter< T >

class	Strong_Base

Concepts
concept	unsigned_integralish

Enumerations
enum class	Endianness : bool { Big , Little }

Functions
template<Endianness endianness, unsigned_integralish T>
size_t	copy_out_any_word_aligned_portion (std::span< uint8_t > &out, std::span< const T > &in)

template<Endianness endianness, std::unsigned_integral OutT, ranges::contiguous_range< uint8_t > InR>
constexpr OutT	fallback_load_any (InR &&in_range)

template<Endianness endianness, std::unsigned_integral InT, ranges::contiguous_output_range< uint8_t > OutR>
constexpr void	fallback_store_any (InT in, OutR &&out_range)

constexpr bool	is_native (Endianness endianness)

constexpr bool	is_opposite (Endianness endianness)

template<Endianness endianness, unsigned_integralish OutT>
constexpr OutT	load_any (const uint8_t in[], size_t off)

template<Endianness endianness, typename OutT , unsigned_integralish... Ts> requires (sizeof...(Ts) > 0 && all_same_v<Ts...> && ((std::same_as<AutoDetect, OutT> && all_same_v<Ts...>) \|\| (unsigned_integralish<OutT> && all_same_v<OutT, Ts...>)))
constexpr void	load_any (const uint8_t in[], Ts &... outs)

template<Endianness endianness, typename OutT , ranges::contiguous_range< uint8_t > InR, unsigned_integralish... Ts> requires (sizeof...(Ts) > 0) && ((std::same_as<AutoDetect, OutT> && all_same_v<Ts...>) \|\| (unsigned_integralish<OutT> && all_same_v<OutT, Ts...>))
constexpr void	load_any (InR &&in, Ts &... outs)

template<Endianness endianness, std::unsigned_integral OutT, ranges::contiguous_range< uint8_t > InR>
constexpr OutT	load_any (InR &&in_range)

template<Endianness endianness, typename OutT , ranges::contiguous_range< uint8_t > InR> requires (std::is_enum_v<OutT> && std::unsigned_integral<std::underlying_type_t<OutT>>)
constexpr OutT	load_any (InR &&in_range)

template<Endianness endianness, typename OutT , ranges::contiguous_range< uint8_t > InR> requires (std::same_as<AutoDetect, OutT> \|\| ((ranges::statically_spanable_range<OutT> \|\| concepts::resizable_container<OutT>)&&unsigned_integralish<typename OutT::value_type>))
constexpr auto	load_any (InR &&in_range)

template<Endianness endianness, typename OutT , ranges::contiguous_output_range OutR, ranges::contiguous_range< uint8_t > InR> requires (unsigned_integralish<std::ranges::range_value_t<OutR>> && (std::same_as<AutoDetect, OutT> \|\| std::same_as<OutT, std::ranges::range_value_t<OutR>>))
constexpr void	load_any (OutR &&out, InR &&in)

template<Endianness endianness, typename OutT , unsigned_integralish T> requires (std::same_as<AutoDetect, OutT> \|\| std::same_as<T, OutT>)
constexpr void	load_any (T out[], const uint8_t in[], size_t count)

template<Endianness endianness>
constexpr bool	native_endianness_is_unknown ()

template<Endianness endianness, typename OutR , ranges::spanable_range InR> requires (std::same_as<AutoDetect, OutR> \|\| (ranges::statically_spanable_range<OutR> && std::default_initializable<OutR>) \|\| concepts::resizable_byte_buffer<OutR>)
constexpr auto	store_any (InR &&in_range)

template<Endianness endianness, std::unsigned_integral InT, ranges::contiguous_output_range< uint8_t > OutR>
constexpr void	store_any (InT in, OutR &&out_range)

template<Endianness endianness, typename InT , ranges::contiguous_output_range< uint8_t > OutR> requires (std::is_enum_v<InT> && std::unsigned_integral<std::underlying_type_t<InT>>)
constexpr void	store_any (InT in, OutR &&out_range)

template<Endianness endianness, typename InT , ranges::contiguous_output_range< uint8_t > OutR, ranges::spanable_range InR> requires (std::same_as<AutoDetect, InT> \|\| std::same_as<InT, std::ranges::range_value_t<InR>>)
constexpr void	store_any (OutR &&out, InR &&in)

template<Endianness endianness, typename InT , ranges::contiguous_output_range< uint8_t > OutR, unsigned_integralish... Ts> requires (sizeof...(Ts) > 0) && ((std::same_as<AutoDetect, InT> && all_same_v<Ts...>) \|\| (unsigned_integralish<InT> && all_same_v<InT, Ts...>))
constexpr void	store_any (OutR &&out, Ts... ins)

template<Endianness endianness, typename InT , unsigned_integralish T, ranges::contiguous_output_range< uint8_t > OutR> requires std::same_as<AutoDetect, InT>
constexpr void	store_any (T in, OutR &&out_range)

template<Endianness endianness, typename InT , unsigned_integralish T> requires (std::same_as<AutoDetect, InT> \|\| std::same_as<T, InT>)
constexpr void	store_any (T in, uint8_t out[])

template<Endianness endianness, typename OutR , unsigned_integralish... Ts> requires all_same_v<Ts...>
constexpr auto	store_any (Ts... ins)

template<Endianness endianness, typename InT , unsigned_integralish T0, unsigned_integralish... Ts> requires (std::same_as<AutoDetect, InT> \|\| std::same_as<T0, InT>) && all_same_v<T0, Ts...>
constexpr void	store_any (uint8_t out[], T0 in0, Ts... ins)

Variables
template<typename CapabilityT , typename... Tags>
constexpr bool	has_capability = (std::is_same_v<CapabilityT, Tags> \|\| ...)

Enumeration Type Documentation

◆ Endianness

enum class Botan::detail::Endianness : bool

strong

Enumerator
Big
Little

Definition at line 126 of file loadstor.h.

                      : bool {
   Big,
   Little,
};

Function Documentation

◆ copy_out_any_word_aligned_portion()

template<Endianness endianness, unsigned_integralish T>

size_t Botan::detail::copy_out_any_word_aligned_portion	(	std::span< uint8_t > &	out,
		std::span< const T > &	in )

Definition at line 718 of file loadstor.h.

                                                                                      {
   const size_t full_words = out.size() / sizeof(T);
   const size_t full_word_bytes = full_words * sizeof(T);
   const size_t remaining_bytes = out.size() - full_word_bytes;
   BOTAN_ASSERT_NOMSG(in.size_bytes() >= full_word_bytes + remaining_bytes);
 
   // copy full words
   store_any<endianness, T>(out.first(full_word_bytes), in.first(full_words));
   out = out.subspan(full_word_bytes);
   in = in.subspan(full_words);
 
   return remaining_bytes;
}

References BOTAN_ASSERT_NOMSG, and T.

◆ fallback_load_any()

template<Endianness endianness, std::unsigned_integral OutT, ranges::contiguous_range< uint8_t > InR>

constexpr OutT Botan::detail::fallback_load_any ( InR && in_range )

inlineconstexpr

Manually load a word from a range in either big or little endian byte order. This will be used only if the endianness of the target platform is unknown at compile time.

Definition at line 185 of file loadstor.h.

                                                        {
   std::span in{in_range};
   // clang-format off
   if constexpr(endianness == Endianness::Big) {
      return [&]<size_t... i>(std::index_sequence<i...>) {
         return static_cast<OutT>(((static_cast<OutT>(in[i]) << ((sizeof(OutT) - i - 1) * 8)) | ...));
      } (std::make_index_sequence<sizeof(OutT)>());
   } else {
      static_assert(endianness == Endianness::Little);
      return [&]<size_t... i>(std::index_sequence<i...>) {
         return static_cast<OutT>(((static_cast<OutT>(in[i]) << (i * 8)) | ...));
      } (std::make_index_sequence<sizeof(OutT)>());
   }
   // clang-format on
}

References Big, and Little.

◆ fallback_store_any()

template<Endianness endianness, std::unsigned_integral InT, ranges::contiguous_output_range< uint8_t > OutR>

constexpr void Botan::detail::fallback_store_any	(	InT	in,
		OutR &&	out_range )

inlineconstexpr

Manually store a word into a range in either big or little endian byte order. This will be used only if the endianness of the target platform is unknown at compile time.

Definition at line 207 of file loadstor.h.

                                                                   {
   std::span out{out_range};
   // clang-format off
   if constexpr(endianness == Endianness::Big) {
      [&]<size_t... i>(std::index_sequence<i...>) {
         ((out[i] = get_byte<i>(in)), ...);
      } (std::make_index_sequence<sizeof(InT)>());
   } else {
      static_assert(endianness == Endianness::Little);
      [&]<size_t... i>(std::index_sequence<i...>) {
         ((out[i] = get_byte<sizeof(InT) - i - 1>(in)), ...);
      } (std::make_index_sequence<sizeof(InT)>());
   }
   // clang-format on
}

References Big, Botan::get_byte(), and Little.

◆ is_native()

constexpr bool Botan::detail::is_native ( Endianness endianness )

constexpr

Warning: This function may return false if the native endianness is unknown

Returns: true iff the native endianness matches the given endianness

Definition at line 139 of file loadstor.h.

                                                {
#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
   return endianness == Endianness::Big;
#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
   return endianness == Endianness::Little;
#else
   return false;
#endif
}

References Big, and Little.

Referenced by load_any(), load_any(), store_any(), and store_any().

◆ is_opposite()

constexpr bool Botan::detail::is_opposite ( Endianness endianness )

constexpr

Warning: This function may return false if the native endianness is unknown

Returns: true iff the native endianness does not match the given endianness

Definition at line 153 of file loadstor.h.

                                                  {
#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN)
   return endianness == Endianness::Little;
#elif defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
   return endianness == Endianness::Big;
#else
   return false;
#endif
}

References Big, and Little.

Referenced by load_any(), and store_any().

◆ load_any() [1/8]

template<Endianness endianness, unsigned_integralish OutT>

constexpr OutT Botan::detail::load_any	(	const uint8_t	in[],
		size_t	off )

inlineconstexpr

Load a word from in at some offset off

Parameters

in	a pointer to some bytes
off	an offset into the array

Returns: off'th T of in, as a big-endian value

Definition at line 421 of file loadstor.h.

                                                               {
   // asserts that *in points to enough bytes to read at offset off
   constexpr size_t out_size = sizeof(OutT);
   return load_any<endianness, OutT>(std::span<const uint8_t, out_size>(in + off * out_size, out_size));
}

◆ load_any() [2/8]

template<Endianness endianness, typename OutT , unsigned_integralish... Ts>
requires (sizeof...(Ts) > 0 && all_same_v<Ts...> && ((std::same_as<AutoDetect, OutT> && all_same_v<Ts...>) || (unsigned_integralish<OutT> && all_same_v<OutT, Ts...>)))

constexpr void Botan::detail::load_any	(	const uint8_t	in[],
		Ts &...	outs )

inlineconstexpr

Load many words from in

Parameters

in	a pointer to some bytes
outs	a arbitrary-length parameter list of unsigned integers to be loaded

Definition at line 436 of file loadstor.h.

                                                                {
   constexpr auto bytes = (sizeof(outs) + ...);
   // asserts that *in points to the correct amount of memory
   load_any<endianness, OutT>(std::span<const uint8_t, bytes>(in, bytes), outs...);
}

◆ load_any() [3/8]

template<Endianness endianness, typename OutT , ranges::contiguous_range< uint8_t > InR, unsigned_integralish... Ts>
requires (sizeof...(Ts) > 0) && ((std::same_as<AutoDetect, OutT> && all_same_v<Ts...>) || (unsigned_integralish<OutT> && all_same_v<OutT, Ts...>))

constexpr void Botan::detail::load_any	(	InR &&	in,
		Ts &...	outs )

inlineconstexpr

Load many unsigned integers

Parameters

in	a fixed-length span to some bytes
outs	a arbitrary-length parameter list of unsigned integers to be loaded

Definition at line 299 of file loadstor.h.

                                                      {
   ranges::assert_exact_byte_length<(sizeof(Ts) + ...)>(in);
   auto load_one = [off = 0]<typename T>(auto i, T& o) mutable {
      o = load_any<endianness, T>(i.subspan(off).template first<sizeof(T)>());
      off += sizeof(T);
   };
 
   (load_one(std::span{in}, outs), ...);
}

References Botan::ranges::assert_exact_byte_length(), and T.

◆ load_any() [4/8]

template<Endianness endianness, std::unsigned_integral OutT, ranges::contiguous_range< uint8_t > InR>

constexpr OutT Botan::detail::load_any ( InR && in_range )

inlineconstexpr

Load a word from a range in either big or little endian byte order

This is the base implementation, all other overloads are just convenience wrappers. It is assumed that the range has the correct size for the word.

Template arguments of all overloads of load_any() share the same semantics:

Endianness Either Endianness::Big or Endianness::Little, that will eventually select the byte order translation mode implemented in this base function.
Output type Either AutoDetect, an unsigned integer or a container holding an unsigned integer type. AutoDetect means that the caller did not explicitly specify the type and expects the type to be inferred from the input.

3+. Argument types Typically, those are input and output ranges of bytes or unsigned integers. Or one or more unsigned integers acting as output parameters.

Parameters

in_range a fixed-length byte range

Returns: T loaded from in_range, as a big-endian value

Overload for loading into a strong type holding an unsigned integer

Definition at line 248 of file loadstor.h.

                                               {
   ranges::assert_exact_byte_length<sizeof(OutT)>(in_range);
   std::span in{in_range};
 
   // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
   // internally to copy ranges on a byte-by-byte basis, which is not allowed
   // in a `constexpr` context.
   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
      return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
   } else {
      if constexpr(sizeof(OutT) == 1) {
         return static_cast<OutT>(in[0]);
      } else if constexpr(is_native(endianness)) {
         return typecast_copy<OutT>(in);
      } else if constexpr(is_opposite(endianness)) {
         return reverse_bytes(typecast_copy<OutT>(in));
      } else {
         static_assert(native_endianness_is_unknown<endianness>());
         return fallback_load_any<endianness, OutT>(std::forward<InR>(in_range));
      }
   }
}

References is_native(), is_opposite(), and Botan::reverse_bytes().

◆ load_any() [5/8]

template<Endianness endianness, typename OutT , ranges::contiguous_range< uint8_t > InR>
requires (std::is_enum_v<OutT> && std::unsigned_integral<std::underlying_type_t<OutT>>)

constexpr OutT Botan::detail::load_any ( InR && in_range )

inlineconstexpr

Overload for loading into an enum type that uses an unsigned integer as its underlying type.

Definition at line 286 of file loadstor.h.

                                               {
   using underlying_type = std::underlying_type_t<OutT>;
   return static_cast<OutT>(load_any<endianness, underlying_type>(std::forward<InR>(in_range)));
}

◆ load_any() [6/8]

template<Endianness endianness, typename OutT , ranges::contiguous_range< uint8_t > InR>
requires (std::same_as<AutoDetect, OutT> || ((ranges::statically_spanable_range<OutT> || concepts::resizable_container<OutT>)&&unsigned_integralish<typename OutT::value_type>))

constexpr auto Botan::detail::load_any ( InR && in_range )

inlineconstexpr

Load one or more unsigned integers, auto-detect the output type if possible. Otherwise, use the specified integer or integer container type.

Parameters

in_range a statically-sized range with some bytes

Returns: T loaded from in

Definition at line 364 of file loadstor.h.

                                               {
   auto out = []([[maybe_unused]] const auto& in) {
      if constexpr(std::same_as<AutoDetect, OutT>) {
         if constexpr(ranges::statically_spanable_range<InR>) {
            constexpr size_t extent = decltype(std::span{in})::extent;
 
            // clang-format off
            using type =
               std::conditional_t<extent == 1, uint8_t,
               std::conditional_t<extent == 2, uint16_t,
               std::conditional_t<extent == 4, uint32_t,
               std::conditional_t<extent == 8, uint64_t, void>>>>;
            // clang-format on
 
            static_assert(
               !std::is_void_v<type>,
               "Cannot determine the output type based on a statically sized bytearray with length other than those: 1, 2, 4, 8");
 
            return type{};
         } else {
            static_assert(
               !std::same_as<AutoDetect, OutT>,
               "cannot infer return type from a dynamic range at compile time, please specify it explicitly");
         }
      } else if constexpr(concepts::resizable_container<OutT>) {
         const size_t in_bytes = std::span{in}.size_bytes();
         constexpr size_t out_elem_bytes = sizeof(typename OutT::value_type);
         BOTAN_ARG_CHECK(in_bytes % out_elem_bytes == 0,
                         "Input range is not word-aligned with the requested output range");
         return OutT(in_bytes / out_elem_bytes);
      } else {
         return OutT{};
      }
   }(in_range);
 
   using out_type = decltype(out);
   if constexpr(unsigned_integralish<out_type>) {
      out = load_any<endianness, out_type>(std::forward<InR>(in_range));
   } else {
      static_assert(ranges::contiguous_range<out_type>);
      using out_range_type = std::ranges::range_value_t<out_type>;
      load_any<endianness, out_range_type>(out, std::forward<InR>(in_range));
   }
   return out;
}

References BOTAN_ARG_CHECK.

◆ load_any() [7/8]

template<Endianness endianness, typename OutT , ranges::contiguous_output_range OutR, ranges::contiguous_range< uint8_t > InR>
requires (unsigned_integralish<std::ranges::range_value_t<OutR>> && (std::same_as<AutoDetect, OutT> || std::same_as<OutT, std::ranges::range_value_t<OutR>>))

constexpr void Botan::detail::load_any	(	OutR &&	out,
		InR &&	in )

inlineconstexpr

Load a variable number of words from in into out. The byte length of the out and in ranges must match.

Parameters

out	the output range of words
in	the input range of bytes

Definition at line 322 of file loadstor.h.

                                                     {
   ranges::assert_equal_byte_lengths(out, in);
 
   auto load_elementwise = [&] {
      using element_type = std::ranges::range_value_t<OutR>;
      constexpr size_t bytes_per_element = sizeof(element_type);
      std::span<const uint8_t> in_s(in);
      for(auto& out_elem : out) {
         out_elem = load_any<endianness, element_type>(in_s.template first<bytes_per_element>());
         in_s = in_s.subspan(bytes_per_element);
      }
   };
 
   // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
   // internally to copy ranges on a byte-by-byte basis, which is not allowed
   // in a `constexpr` context.
   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
      load_elementwise();
   } else {
      if constexpr(is_native(endianness)) {
         typecast_copy(out, in);
      } else {
         load_elementwise();
      }
   }
}

References Botan::ranges::assert_equal_byte_lengths(), is_native(), and Botan::typecast_copy().

◆ load_any() [8/8]

template<Endianness endianness, typename OutT , unsigned_integralish T>
requires (std::same_as<AutoDetect, OutT> || std::same_as<T, OutT>)

constexpr void Botan::detail::load_any	(	T	out[],
		const uint8_t	in[],
		size_t	count )

inlineconstexpr

Load a variable number of words from in into out.

Parameters

out	the output array of words
in	the input array of bytes
count	how many words are in in

Definition at line 450 of file loadstor.h.

                                                                          {
   // asserts that *in and *out point to the correct amount of memory
   load_any<endianness, OutT>(std::span<T>(out, count), std::span<const uint8_t>(in, count * sizeof(T)));
}

References T.

◆ native_endianness_is_unknown()

template<Endianness endianness>

constexpr bool Botan::detail::native_endianness_is_unknown ( )

constexpr

Definition at line 164 of file loadstor.h.

                                              {
#if defined(BOTAN_TARGET_CPU_IS_BIG_ENDIAN) || defined(BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN)
   return false;
#else
   return true;
#endif
}

◆ store_any() [1/9]

template<Endianness endianness, typename OutR , ranges::spanable_range InR>
requires (std::same_as<AutoDetect, OutR> || (ranges::statically_spanable_range<OutR> && std::default_initializable<OutR>) || concepts::resizable_byte_buffer<OutR>)

constexpr auto Botan::detail::store_any ( InR && in_range )

inlineconstexpr

The caller provided some integer values in a collection but did not provide the output container. Let's create one for them, fill it with one of the overloads above and return it. This will default to a std::array if the caller did not specify the desired output container type.

Parameters

in_range a range of words that should be stored

Returns: a container of bytes that contains the stored words

Definition at line 629 of file loadstor.h.

                                                {
   auto out = []([[maybe_unused]] const auto& in) {
      if constexpr(std::same_as<AutoDetect, OutR>) {
         if constexpr(ranges::statically_spanable_range<InR>) {
            constexpr size_t bytes = decltype(std::span{in})::extent * sizeof(std::ranges::range_value_t<InR>);
            return std::array<uint8_t, bytes>();
         } else {
            static_assert(
               !std::same_as<AutoDetect, OutR>,
               "cannot infer a suitable result container type from the given parameters at compile time, please specify it explicitly");
         }
      } else if constexpr(concepts::resizable_byte_buffer<OutR>) {
         return OutR(std::span{in}.size_bytes());
      } else {
         return OutR{};
      }
   }(in_range);
 
   store_any<endianness, std::ranges::range_value_t<InR>>(out, std::forward<InR>(in_range));
   return out;
}

◆ store_any() [2/9]

template<Endianness endianness, std::unsigned_integral InT, ranges::contiguous_output_range< uint8_t > OutR>

constexpr void Botan::detail::store_any	(	InT	in,
		OutR &&	out_range )

inlineconstexpr

Store a word in either big or little endian byte order into a range

This is the base implementation, all other overloads are just convenience wrappers. It is assumed that the range has the correct size for the word.

Template arguments of all overloads of store_any() share the same semantics as those of load_any(). See the documentation of this function for more details.

Parameters

in	an unsigned integral to be stored
out_range	a byte range to store the word into

Overload for loading into a strong type holding an unsigned integer

Definition at line 491 of file loadstor.h.

                                                          {
   ranges::assert_exact_byte_length<sizeof(InT)>(out_range);
   std::span out{out_range};
 
   // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
   // internally to copy ranges on a byte-by-byte basis, which is not allowed
   // in a `constexpr` context.
   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
      return fallback_store_any<endianness, InT>(in, std::forward<OutR>(out_range));
   } else {
      if constexpr(sizeof(InT) == 1) {
         out[0] = static_cast<uint8_t>(in);
      } else if constexpr(is_native(endianness)) {
         typecast_copy(out, in);
      } else if constexpr(is_opposite(endianness)) {
         typecast_copy(out, reverse_bytes(in));
      } else {
         static_assert(native_endianness_is_unknown<endianness>());
         return fallback_store_any<endianness, InT>(in, std::forward<OutR>(out_range));
      }
   }
}

References is_native(), is_opposite(), Botan::reverse_bytes(), and Botan::typecast_copy().

◆ store_any() [3/9]

template<Endianness endianness, typename InT , ranges::contiguous_output_range< uint8_t > OutR>
requires (std::is_enum_v<InT> && std::unsigned_integral<std::underlying_type_t<InT>>)

constexpr void Botan::detail::store_any	(	InT	in,
		OutR &&	out_range )

inlineconstexpr

Overload for storing an enum type that uses an unsigned integer as its underlying type.

Definition at line 531 of file loadstor.h.

                                                          {
   using underlying_type = std::underlying_type_t<InT>;
   // TODO: C++23: use std::to_underlying(in) instead
   store_any<endianness, underlying_type>(static_cast<underlying_type>(in), std::forward<OutR>(out_range));
}

◆ store_any() [4/9]

template<Endianness endianness, typename InT , ranges::contiguous_output_range< uint8_t > OutR, ranges::spanable_range InR>
requires (std::same_as<AutoDetect, InT> || std::same_as<InT, std::ranges::range_value_t<InR>>)

constexpr void Botan::detail::store_any	(	OutR &&	out,
		InR &&	in )

inlineconstexpr

Store a variable number of words given in in into out. The byte lengths of in and out must be consistent.

Parameters

out	the output range of bytes
in	the input range of words

Definition at line 569 of file loadstor.h.

                                                      {
   ranges::assert_equal_byte_lengths(out, in);
 
   auto store_elementwise = [&] {
      using element_type = std::ranges::range_value_t<InR>;
      constexpr size_t bytes_per_element = sizeof(element_type);
      std::span<uint8_t> out_s(out);
      for(auto in_elem : in) {
         store_any<endianness, element_type>(out_s.template first<bytes_per_element>(), in_elem);
         out_s = out_s.subspan(bytes_per_element);
      }
   };
 
   // At compile time we cannot use `typecast_copy` as it uses `std::memcpy`
   // internally to copy ranges on a byte-by-byte basis, which is not allowed
   // in a `constexpr` context.
   if(std::is_constant_evaluated()) /* TODO: C++23: if consteval {} */ {
      store_elementwise();
   } else {
      if constexpr(is_native(endianness)) {
         typecast_copy(out, in);
      } else {
         store_elementwise();
      }
   }
}

References Botan::ranges::assert_equal_byte_lengths(), is_native(), and Botan::typecast_copy().

◆ store_any() [5/9]

template<Endianness endianness, typename InT , ranges::contiguous_output_range< uint8_t > OutR, unsigned_integralish... Ts>
requires (sizeof...(Ts) > 0) && ((std::same_as<AutoDetect, InT> && all_same_v<Ts...>) || (unsigned_integralish<InT> && all_same_v<InT, Ts...>))

constexpr void Botan::detail::store_any	(	OutR &&	out,
		Ts...	ins )

inlineconstexpr

Store many unsigned integers words into a byte range

Parameters

out	a sized range of some bytes
ins	a arbitrary-length parameter list of unsigned integers to be stored

Definition at line 548 of file loadstor.h.

                                                       {
   ranges::assert_exact_byte_length<(sizeof(Ts) + ...)>(out);
   auto store_one = [off = 0]<typename T>(auto o, T i) mutable {
      store_any<endianness, T>(i, o.subspan(off).template first<sizeof(T)>());
      off += sizeof(T);
   };
 
   (store_one(std::span{out}, ins), ...);
}

References Botan::ranges::assert_exact_byte_length(), and T.

◆ store_any() [6/9]

template<Endianness endianness, typename InT , unsigned_integralish T, ranges::contiguous_output_range< uint8_t > OutR>
requires std::same_as<AutoDetect, InT>

constexpr void Botan::detail::store_any	(	T	in,
		OutR &&	out_range )

inlineconstexpr

Infer InT from a single unsigned integer input parameter.

TODO: we might consider dropping this overload (i.e. out-range as second parameter) and make this a "special case" of the overload below, that takes a variadic number of input parameters.

Parameters

in	an unsigned integer to be stored
out_range	a range of bytes to store the word into

Definition at line 612 of file loadstor.h.

                                                        {
   store_any<endianness, T>(in, std::forward<OutR>(out_range));
}

◆ store_any() [7/9]

template<Endianness endianness, typename InT , unsigned_integralish T>
requires (std::same_as<AutoDetect, InT> || std::same_as<T, InT>)

constexpr void Botan::detail::store_any	(	T	in,
		uint8_t	out[] )

inlineconstexpr

Store a single unsigned integer into a raw pointer

Parameters

in	the input unsigned integer
out	the byte array to write to

Definition at line 677 of file loadstor.h.

                                                     {
   // asserts that *out points to enough bytes to write into
   store_any<endianness, InT>(in, std::span<uint8_t, sizeof(T)>(out, sizeof(T)));
}

References T.

◆ store_any() [8/9]

template<Endianness endianness, typename OutR , unsigned_integralish... Ts>
requires all_same_v<Ts...>

constexpr auto Botan::detail::store_any ( Ts... ins )

inlineconstexpr

The caller provided some integer values but did not provide the output container. Let's create one for them, fill it with one of the overloads above and return it. This will default to a std::array if the caller did not specify the desired output container type.

Parameters

ins	some words that should be stored

Returns: a container of bytes that contains the stored words

Definition at line 662 of file loadstor.h.

                                           {
   return store_any<endianness, OutR>(std::array{ins...});
}

◆ store_any() [9/9]

template<Endianness endianness, typename InT , unsigned_integralish T0, unsigned_integralish... Ts>
requires (std::same_as<AutoDetect, InT> || std::same_as<T0, InT>) && all_same_v<T0, Ts...>

constexpr void Botan::detail::store_any	(	uint8_t	out[],
		T0	in0,
		Ts...	ins )

inlineconstexpr

Store many unsigned integers words into a raw pointer

Parameters

ins	a arbitrary-length parameter list of unsigned integers to be stored
out	the byte array to write to

Definition at line 689 of file loadstor.h.

                                                                  {
   constexpr auto bytes = sizeof(in0) + (sizeof(ins) + ... + 0);
   // asserts that *out points to the correct amount of memory
   store_any<endianness, T0>(std::span<uint8_t, bytes>(out, bytes), in0, ins...);
}

Variable Documentation

◆ has_capability

template<typename CapabilityT , typename... Tags>

constexpr bool Botan::detail::has_capability = (std::is_same_v<CapabilityT, Tags> || ...)

constexpr

Checks whether the CapabilityT is included in the Tags type pack.

Definition at line 31 of file strong_type.h.

Classes

Concepts

Enumerations

Functions

Variables

Enumeration Type Documentation

◆ Endianness

Function Documentation

◆ copy_out_any_word_aligned_portion()

◆ fallback_load_any()

◆ fallback_store_any()

◆ is_native()

◆ is_opposite()

◆ load_any() [1/8]

◆ load_any() [2/8]

◆ load_any() [3/8]

◆ load_any() [4/8]

◆ load_any() [5/8]

◆ load_any() [6/8]

◆ load_any() [7/8]

◆ load_any() [8/8]

◆ native_endianness_is_unknown()

◆ store_any() [1/9]

◆ store_any() [2/9]

◆ store_any() [3/9]

◆ store_any() [4/9]

◆ store_any() [5/9]

◆ store_any() [6/9]

◆ store_any() [7/9]

◆ store_any() [8/9]

◆ store_any() [9/9]

Variable Documentation

◆ has_capability