Botan::ranges Namespace Reference

Concepts
concept	contiguous_range
concept	contiguous_output_range
concept	spanable_range
concept	statically_spanable_range

Functions
template<spanable_range R0, spanable_range... Rs> requires (sizeof...(Rs) > 0)
constexpr void	assert_equal_byte_lengths (R0 &&r0, Rs &&... rs)
template<size_t expected, spanable_range R>
constexpr void	assert_exact_byte_length (R &&r)
constexpr size_t	size_bytes (spanable_range auto &&r)

Function Documentation

assert_equal_byte_lengths()

template<spanable_range R0, spanable_range... Rs>
requires (sizeof...(Rs) > 0)

void Botan::ranges::assert_equal_byte_lengths ( R0 && r0, Rs &&... rs )

inlineconstexpr

Check that a list of ranges (in r0 and rs) all have the same byte lengths. If the first range's extent is known at compile time, this will be a static check for all other ranges whose extents are known at compile time, otherwise a runtime argument check will be added.

Exceptions

Invalid_Argument

if any range has a dynamic extent and not all ranges feature the same byte length.

Definition at line 129 of file concepts.h.

{
   const std::span s0{r0};
 
   if constexpr(statically_spanable_range<R0>) {
      constexpr size_t expected_size = s0.size_bytes();
      (assert_exact_byte_length<expected_size>(rs), ...);
   } else {
      const size_t expected_size = s0.size_bytes();
      const bool correct_size =
         ((std::span<const std::ranges::range_value_t<Rs>>{rs}.size_bytes() == expected_size) && ...);
 
      if(!correct_size) {
         throw Invalid_Argument("Memory regions did not have equal lengths");
      }
   }
}

References assert_exact_byte_length().

Referenced by Botan::copy_mem(), Botan::detail::load_any(), Botan::detail::store_any(), Botan::typecast_copy(), Botan::xor_buf(), and Botan::xor_buf().

assert_exact_byte_length()

template<size_t expected, spanable_range R>

void Botan::ranges::assert_exact_byte_length ( R && r )

inlineconstexpr

Check that a given range r has a certain statically-known byte length. If the range's extent is known at compile time, this is a static check, otherwise a runtime argument check will be added.

Exceptions

Invalid_Argument

if range r has a dynamic extent and does not feature the expected byte length.

Definition at line 108 of file concepts.h.

                                                      {
   const std::span s{r};
   if constexpr(statically_spanable_range<R>) {
      static_assert(s.size_bytes() == expected, "memory region does not have expected byte lengths");
   } else {
      if(s.size_bytes() != expected) {
         throw Invalid_Argument("Memory regions did not have expected byte lengths");
      }
   }
}

Referenced by assert_equal_byte_lengths(), Botan::detail::load_any(), Botan::detail::load_any(), Botan::detail::store_any(), and Botan::detail::store_any().

size_bytes()

size_t Botan::ranges::size_bytes ( spanable_range auto && r )

inlineconstexpr

Find the length in bytes of a given contiguous range r.

Definition at line 95 of file concepts.h.

                                                            {
   return std::span{r}.size_bytes();
}

Referenced by Botan::clear_mem(), Botan::copy_mem(), Botan::secure_scrub_memory(), and Botan::typecast_copy().