Classes
struct	AutoDetect
class	bitvector_iterator
class	Bounded_XOF
class	Container_Strong_Adapter_Base
struct	first_type
class	Strong_Adapter
class	Strong_Adapter< T >
class	Strong_Base
struct	wrapped_type_helper
struct	wrapped_type_helper< T >
struct	wrapped_type_helper_with_enum
struct	wrapped_type_helper_with_enum< T >

Concepts
concept	is_blockwise_processing_callback_return_type
concept	blockwise_processing_callback_without_mask
concept	blockwise_processing_callback_with_mask
concept	blockwise_processing_callback
concept	manipulating_blockwise_processing_callback
concept	predicate_blockwise_processing_callback
concept	custom_loadable
concept	custom_storable
concept	unsigned_integralish

Typedefs
template<typename OutT, typename>
using	as = OutT
template<typename FnT, std::unsigned_integral BlockT, typename... ParamTs>
using	blockwise_processing_callback_return_type = std::invoke_result_t<FnT, as<BlockT, ParamTs>...>
template<typename... Ts>
using	first_t = typename first_type<Ts...>::type
template<unsigned_integralish T>
using	wrapped_type = typename wrapped_type_helper_with_enum<T>::type

Functions
template<ranges::spanable_range OutR, ranges::spanable_range... Rs> requires (concepts::reservable_container<OutR> \|\| ranges::statically_spanable_range<OutR>)
constexpr OutR	concatenate (Rs &&... ranges)
template<bitvectorish T1, bitvectorish T2>
constexpr auto	copy_lhs_allocator_aware (const T1 &lhs, const T2 &)
template<std::endian endianness, unsigned_integralish T>
size_t	copy_out_any_word_aligned_portion (std::span< uint8_t > &out, std::span< const T > &in)
template<std::endian endianness, std::unsigned_integral OutT, ranges::contiguous_range< uint8_t > InR>
constexpr OutT	fallback_load_any (const InR &in_range)
template<std::endian endianness, std::unsigned_integral InT, ranges::contiguous_output_range< uint8_t > OutR>
constexpr void	fallback_store_any (InT in, OutR &&out_range)
template<std::endian 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 (const InR &in, Ts &... outs)
template<std::endian endianness, unsigned_integralish WrappedOutT, ranges::contiguous_range< uint8_t > InR> requires (custom_loadable<strong_type_wrapped_type<WrappedOutT>>)
constexpr WrappedOutT	load_any (const InR &in_range)
template<std::endian endianness, unsigned_integralish OutT>
constexpr OutT	load_any (const uint8_t in[], size_t off)
template<std::endian 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<std::endian endianness, unsigned_integralish WrappedOutT, ranges::contiguous_range< uint8_t > InR> requires (!custom_loadable<strong_type_wrapped_type<WrappedOutT>>)
constexpr WrappedOutT	load_any (InR &&in_range)
template<std::endian 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<std::endian 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, const InR &in)
template<std::endian 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)
consteval std::endian	opposite (std::endian endianness)
template<std::endian 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<std::endian 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, const InR &in)
template<std::endian 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<std::endian 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<std::endian 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<std::endian endianness, typename OutR, unsigned_integralish... Ts> requires all_same_v<Ts...>
constexpr auto	store_any (Ts... ins)
template<std::endian 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)
template<std::endian endianness, unsigned_integralish WrappedInT, ranges::contiguous_output_range< uint8_t > OutR> requires (custom_storable<strong_type_wrapped_type<WrappedInT>>)
constexpr void	store_any (WrappedInT wrapped_in, const OutR &out_range)
template<std::endian endianness, unsigned_integralish WrappedInT, ranges::contiguous_output_range< uint8_t > OutR> requires (!custom_storable<strong_type_wrapped_type<WrappedInT>>)
constexpr void	store_any (WrappedInT wrapped_in, OutR &&out_range)
template<unsigned_integralish InT>
constexpr auto	unwrap_strong_type_or_enum (InT t)
template<unsigned_integralish OutT, std::unsigned_integral T>
constexpr auto	wrap_strong_type_or_enum (T t)

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

Typedef Documentation

◆ as

template<typename OutT, typename>

using Botan::detail::as = OutT

Definition at line 74 of file bitvector.h.

◆ blockwise_processing_callback_return_type

template<typename FnT, std::unsigned_integral BlockT, typename... ParamTs>

using Botan::detail::blockwise_processing_callback_return_type = std::invoke_result_t<FnT, as<BlockT, ParamTs>...>

Definition at line 77 of file bitvector.h.

◆ first_t

template<typename... Ts>

using Botan::detail::first_t = typename first_type<Ts...>::type

Definition at line 63 of file bitvector.h.

◆ wrapped_type

template<unsigned_integralish T>

using Botan::detail::wrapped_type = typename wrapped_type_helper_with_enum<T>::type

Definition at line 187 of file loadstor.h.

Function Documentation

◆ concatenate()

template<ranges::spanable_range OutR, ranges::spanable_range... Rs>
requires (concepts::reservable_container<OutR> || ranges::statically_spanable_range<OutR>)

OutR Botan::detail::concatenate ( Rs &&... ranges )

constexpr

Helper function that performs range size-checks as required given the selected output and input range types. If all lengths are known at compile time, this check will be performed at compile time as well. It will then instantiate an output range and concatenate the input ranges' contents.

Definition at line 196 of file stl_util.h.

{
   OutR result{};
 
   // Prepare and validate the output range and construct a lambda that does the
   // actual filling of the result buffer.
   // (if no input ranges are given, GCC claims that fill_fn is unused)
   [[maybe_unused]] auto fill_fn = [&] {
      if constexpr(concepts::reservable_container<OutR>) {
         // dynamically allocate the correct result byte length
         const size_t total_size = (ranges.size() + ... + 0);
         result.reserve(total_size);
 
         // fill the result buffer using a back-inserter
         return [&result](auto&& range) {
            std::copy(
               std::ranges::begin(range), std::ranges::end(range), std::back_inserter(unwrap_strong_type(result)));
         };
      } else {
         if constexpr((ranges::statically_spanable_range<Rs> && ... && true)) {
            // all input ranges have a static extent, so check the total size at compile time
            // (work around an issue in MSVC that warns `total_size` is unused)
            [[maybe_unused]] constexpr size_t total_size = (decltype(std::span{ranges})::extent + ... + 0);
            static_assert(result.size() == total_size, "size of result buffer does not match the sum of input buffers");
         } else {
            // at least one input range has a dynamic extent, so check the total size at runtime
            const size_t total_size = (ranges.size() + ... + 0);
            BOTAN_ARG_CHECK(result.size() == total_size,
                            "result buffer has static extent that does not match the sum of input buffers");
         }
 
         // fill the result buffer and hold the current output-iterator position
         return [itr = std::ranges::begin(result)](auto&& range) mutable {
            std::copy(std::ranges::begin(range), std::ranges::end(range), itr);
            std::advance(itr, std::ranges::size(range));
         };
      }
   }();
 
   // perform the actual concatenation
   (fill_fn(std::forward<Rs>(ranges)), ...);
 
   return result;
}

References BOTAN_ARG_CHECK, and Botan::unwrap_strong_type().

Referenced by Botan::concat().

◆ copy_lhs_allocator_aware()

template<bitvectorish T1, bitvectorish T2>

auto Botan::detail::copy_lhs_allocator_aware	(	const T1 &	lhs,
		const T2 &	)

constexpr

If one of the allocators is a Botan::secure_allocator, this will always prefer it. Otherwise, the allocator of lhs will be used as a default.

Definition at line 1313 of file bitvector.h.

                                                                    {
   constexpr bool needs_secure_allocator =
      strong_type_wrapped_type<T1>::uses_secure_allocator || strong_type_wrapped_type<T2>::uses_secure_allocator;
 
   if constexpr(needs_secure_allocator) {
      return lhs.template as<secure_bitvector>();
   } else {
      return lhs.template as<bitvector>();
   }
}

Referenced by Botan::operator&(), Botan::operator^(), and Botan::operator|().

◆ copy_out_any_word_aligned_portion()

template<std::endian endianness, unsigned_integralish T>

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

inline

Definition at line 752 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 store_any().

Referenced by Botan::copy_out_be(), and Botan::copy_out_le().

◆ fallback_load_any()

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

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

inlineconstexpr

Manually load a word from a range in either big or little endian byte order.

This is only used at compile time.

Definition at line 214 of file loadstor.h.

                                                             {
   std::span in{in_range};
   // clang-format off
   if constexpr(endianness == std::endian::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 == std::endian::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
}

Referenced by load_any().

◆ fallback_store_any()

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

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 at compile time.

Definition at line 236 of file loadstor.h.

                                                                     {
   std::span out{out_range};
   // clang-format off
   if constexpr(endianness == std::endian::big) {
      [&]<size_t... i>(std::index_sequence<i...>) {
         ((out[i] = get_byte<i>(in)), ...);
      } (std::make_index_sequence<sizeof(InT)>());
   } else {
      static_assert(endianness == std::endian::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 Botan::get_byte().

Referenced by store_any().

◆ load_any() [1/8]

template<std::endian 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...>))

void Botan::detail::load_any	(	const 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 332 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 load_any().

◆ load_any() [2/8]

template<std::endian endianness, unsigned_integralish WrappedOutT, ranges::contiguous_range< uint8_t > InR>
requires (custom_loadable<strong_type_wrapped_type<WrappedOutT>>)

WrappedOutT Botan::detail::load_any ( const InR & in_range )

inlineconstexpr

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

This is the base implementation for custom objects (e.g. SIMD type wrappres), all other overloads are just convenience overloads.

Parameters

in_range a fixed-length byte range

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

Definition at line 313 of file loadstor.h.

                                                           {
   using OutT = detail::wrapped_type<WrappedOutT>;
   ranges::assert_exact_byte_length<sizeof(OutT)>(in_range);
   std::span<const uint8_t, sizeof(OutT)> ins{in_range};
   if constexpr(endianness == std::endian::big) {
      return wrap_strong_type<WrappedOutT>(OutT::load_be(ins));
   } else {
      return wrap_strong_type<WrappedOutT>(OutT::load_le(ins));
   }
}

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

◆ load_any() [3/8]

template<std::endian endianness, unsigned_integralish OutT>

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 454 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));
}

References load_any().

◆ load_any() [4/8]

template<std::endian 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...>)))

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 469 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...);
}

References load_any().

◆ load_any() [5/8]

template<std::endian endianness, unsigned_integralish WrappedOutT, ranges::contiguous_range< uint8_t > InR>
requires (!custom_loadable<strong_type_wrapped_type<WrappedOutT>>)

WrappedOutT 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:

std::endian Either std::endian::big or std::endian::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

Definition at line 278 of file loadstor.h.

                                                      {
   using OutT = detail::wrapped_type<WrappedOutT>;
   ranges::assert_exact_byte_length<sizeof(OutT)>(in_range);
 
   return detail::wrap_strong_type_or_enum<WrappedOutT>([&]() -> OutT {
      // 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 {
         std::span in{in_range};
         if constexpr(sizeof(OutT) == 1) {
            return static_cast<OutT>(in[0]);
         } else if constexpr(endianness == std::endian::native) {
            return typecast_copy<OutT>(in);
         } else {
            static_assert(opposite(endianness) == std::endian::native);
            return reverse_bytes(typecast_copy<OutT>(in));
         }
      }
   }());
}

References Botan::ranges::assert_exact_byte_length(), fallback_load_any(), opposite(), Botan::reverse_bytes(), Botan::typecast_copy(), and wrap_strong_type_or_enum().

Referenced by load_any(), load_any(), load_any(), load_any(), load_any(), load_any(), Botan::load_be(), and Botan::load_le().

◆ load_any() [6/8]

template<std::endian 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>))

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 397 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, and load_any().

◆ load_any() [7/8]

template<std::endian 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>>))

void Botan::detail::load_any	(	OutR &&	out,
		const 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 355 of file loadstor.h.

                                                            {
   ranges::assert_equal_byte_lengths(out, in);
   using element_type = std::ranges::range_value_t<OutR>;
 
   auto load_elementwise = [&] {
      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(endianness == std::endian::native && !custom_loadable<element_type>) {
         typecast_copy(out, in);
      } else {
         load_elementwise();
      }
   }
}

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

◆ load_any() [8/8]

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

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 483 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 load_any().

◆ opposite()

std::endian Botan::detail::opposite ( std::endian endianness )

consteval

Returns: the opposite endianness of the specified endianness

Note this assumes that there are only two endian orderings; we do not supported mixed endian systems

Definition at line 136 of file loadstor.h.

                                                   {
   if(endianness == std::endian::big) {
      return std::endian::little;
   } else {
      // We already verified via static assert earlier in this file that we are
      // running on either a big endian or little endian system
      return std::endian::big;
   }
}

Referenced by load_any(), and store_any().

◆ store_any() [1/9]

template<std::endian 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>)

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 663 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;
}

References store_any().

◆ store_any() [2/9]

template<std::endian 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>>)

void Botan::detail::store_any	(	OutR &&	out,
		const 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 603 of file loadstor.h.

                                                             {
   ranges::assert_equal_byte_lengths(out, in);
   using element_type = std::ranges::range_value_t<InR>;
 
   auto store_elementwise = [&] {
      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(endianness == std::endian::native && !custom_storable<element_type>) {
         typecast_copy(out, in);
      } else {
         store_elementwise();
      }
   }
}

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

◆ store_any() [3/9]

template<std::endian 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...>))

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 582 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 store_any().

◆ store_any() [4/9]

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

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 646 of file loadstor.h.

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

References store_any().

◆ store_any() [5/9]

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

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 711 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 store_any().

◆ store_any() [6/9]

template<std::endian endianness, typename OutR, unsigned_integralish... Ts>
requires all_same_v<Ts...>

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 696 of file loadstor.h.

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

References store_any().

◆ store_any() [7/9]

template<std::endian 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...>

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 723 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...);
}

References store_any().

◆ store_any() [8/9]

template<std::endian endianness, unsigned_integralish WrappedInT, ranges::contiguous_output_range< uint8_t > OutR>
requires (custom_storable<strong_type_wrapped_type<WrappedInT>>)

void Botan::detail::store_any	(	WrappedInT	wrapped_in,
		const OutR &	out_range )

inlineconstexpr

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

This is the base implementation for storing custom objects, all other overloads are just convenience overloads.

Parameters

wrapped_in	a custom object to be stored
out_range	a byte range to store the word into

Definition at line 559 of file loadstor.h.

                                                                              {
   const auto in = detail::unwrap_strong_type_or_enum(wrapped_in);
   using InT = decltype(in);
   ranges::assert_exact_byte_length<sizeof(in)>(out_range);
   std::span<uint8_t, sizeof(InT)> outs{out_range};
   if constexpr(endianness == std::endian::big) {
      in.store_be(outs);
   } else {
      in.store_le(outs);
   }
}

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

◆ store_any() [9/9]

template<std::endian endianness, unsigned_integralish WrappedInT, ranges::contiguous_output_range< uint8_t > OutR>
requires (!custom_storable<strong_type_wrapped_type<WrappedInT>>)

void Botan::detail::store_any	(	WrappedInT	wrapped_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

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

Definition at line 525 of file loadstor.h.

                                                                         {
   const auto in = detail::unwrap_strong_type_or_enum(wrapped_in);
   using InT = decltype(in);
   ranges::assert_exact_byte_length<sizeof(in)>(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(endianness == std::endian::native) {
         typecast_copy(out, in);
      } else {
         static_assert(opposite(endianness) == std::endian::native);
         typecast_copy(out, reverse_bytes(in));
      }
   }
}

References Botan::ranges::assert_exact_byte_length(), fallback_store_any(), opposite(), Botan::reverse_bytes(), Botan::typecast_copy(), and unwrap_strong_type_or_enum().

Referenced by copy_out_any_word_aligned_portion(), store_any(), store_any(), store_any(), store_any(), store_any(), store_any(), store_any(), Botan::store_be(), and Botan::store_le().

◆ unwrap_strong_type_or_enum()

template<unsigned_integralish InT>

auto Botan::detail::unwrap_strong_type_or_enum ( InT t )

constexpr

Definition at line 190 of file loadstor.h.

                                                 {
   if constexpr(std::is_enum_v<InT>) {
      // TODO: C++23: use std::to_underlying(in) instead
      return static_cast<std::underlying_type_t<InT>>(t);
   } else {
      return Botan::unwrap_strong_type(t);
   }
}

References Botan::unwrap_strong_type().

Referenced by store_any(), and store_any().

◆ wrap_strong_type_or_enum()

template<unsigned_integralish OutT, std::unsigned_integral T>

auto Botan::detail::wrap_strong_type_or_enum ( T t )

constexpr

Definition at line 200 of file loadstor.h.

                                             {
   if constexpr(std::is_enum_v<OutT>) {
      return static_cast<OutT>(t);
   } else {
      return Botan::wrap_strong_type<OutT>(t);
   }
}

References Botan::wrap_strong_type().

Referenced by load_any().

Variable Documentation

◆ has_capability

template<typename CapabilityT, typename... Tags>

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 32 of file strong_type.h.

Classes

Concepts

Typedefs

Functions

Variables

Typedef Documentation

◆ as

◆ blockwise_processing_callback_return_type

◆ first_t

◆ wrapped_type

Function Documentation

◆ concatenate()

◆ copy_lhs_allocator_aware()

◆ copy_out_any_word_aligned_portion()

◆ fallback_load_any()

◆ fallback_store_any()

◆ 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]

◆ opposite()

◆ 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]

◆ unwrap_strong_type_or_enum()

◆ wrap_strong_type_or_enum()

Variable Documentation

◆ has_capability