gnunet-android

span.h (7855B)

---

 // Copyright 2017 The BoringSSL Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     https://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #ifndef OPENSSL_HEADER_SSL_SPAN_H
 #define OPENSSL_HEADER_SSL_SPAN_H
 
 #include <openssl/base.h>   // IWYU pragma: export
 
 #if !defined(BORINGSSL_NO_CXX)
 
 extern "C++" {
 
 #include <stdlib.h>
 
 #include <algorithm>
 #include <string_view>
 #include <type_traits>
 
 #if __has_include(<version>)
 #include <version>
 #endif
 
 #if defined(__cpp_lib_ranges) && __cpp_lib_ranges >= 201911L
 #include <ranges>
 BSSL_NAMESPACE_BEGIN
 template <typename T>
 class Span;
 BSSL_NAMESPACE_END
 
 // Mark `Span` as satisfying the `view` and `borrowed_range` concepts. This
 // should be done before the definition of `Span`, so that any inlined calls to
 // range functionality use the correct specializations.
 template <typename T>
 inline constexpr bool std::ranges::enable_view<bssl::Span<T>> = true;
 template <typename T>
 inline constexpr bool std::ranges::enable_borrowed_range<bssl::Span<T>> = true;
 #endif
 
 BSSL_NAMESPACE_BEGIN
 
 template <typename T>
 class Span;
 
 namespace internal {
 template <typename T>
 class SpanBase {
   // Put comparison operator implementations into a base class with const T, so
   // they can be used with any type that implicitly converts into a Span.
   static_assert(std::is_const<T>::value,
                 "Span<T> must be derived from SpanBase<const T>");
 
   friend bool operator==(Span<T> lhs, Span<T> rhs) {
     return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
   }
 
   friend bool operator!=(Span<T> lhs, Span<T> rhs) { return !(lhs == rhs); }
 };
 
 // Heuristically test whether C is a container type that can be converted into
 // a Span<T> by checking for data() and size() member functions.
 template <typename C, typename T>
 using EnableIfContainer = std::enable_if_t<
     std::is_convertible_v<decltype(std::declval<C>().data()), T *> &&
     std::is_integral_v<decltype(std::declval<C>().size())>>;
 
 }  // namespace internal
 
 // A Span<T> is a non-owning reference to a contiguous array of objects of type
 // |T|. Conceptually, a Span is a simple a pointer to |T| and a count of
 // elements accessible via that pointer. The elements referenced by the Span can
 // be mutated if |T| is mutable.
 //
 // A Span can be constructed from container types implementing |data()| and
 // |size()| methods. If |T| is constant, construction from a container type is
 // implicit. This allows writing methods that accept data from some unspecified
 // container type:
 //
 // // Foo views data referenced by v.
 // void Foo(bssl::Span<const uint8_t> v) { ... }
 //
 // std::vector<uint8_t> vec;
 // Foo(vec);
 //
 // For mutable Spans, conversion is explicit:
 //
 // // FooMutate mutates data referenced by v.
 // void FooMutate(bssl::Span<uint8_t> v) { ... }
 //
 // FooMutate(bssl::Span<uint8_t>(vec));
 //
 // You can also use C++17 class template argument deduction to construct Spans
 // in order to deduce the type of the Span automatically.
 //
 // FooMutate(bssl::Span(vec));
 //
 // Note that Spans have value type sematics. They are cheap to construct and
 // copy, and should be passed by value whenever a method would otherwise accept
 // a reference or pointer to a container or array.
 template <typename T>
 class Span : private internal::SpanBase<const T> {
  public:
   static const size_t npos = static_cast<size_t>(-1);
 
   using element_type = T;
   using value_type = std::remove_cv_t<T>;
   using size_type = size_t;
   using difference_type = ptrdiff_t;
   using pointer = T *;
   using const_pointer = const T *;
   using reference = T &;
   using const_reference = const T &;
   using iterator = T *;
   using const_iterator = const T *;
 
   constexpr Span() : Span(nullptr, 0) {}
   constexpr Span(T *ptr, size_t len) : data_(ptr), size_(len) {}
 
   template <size_t N>
   constexpr Span(T (&array)[N]) : Span(array, N) {}
 
   template <typename C, typename = internal::EnableIfContainer<C, T>,
             typename = std::enable_if_t<std::is_const<T>::value, C>>
   constexpr Span(const C &container)
       : data_(container.data()), size_(container.size()) {}
 
   template <typename C, typename = internal::EnableIfContainer<C, T>,
             typename = std::enable_if_t<!std::is_const<T>::value, C>>
   constexpr explicit Span(C &container)
       : data_(container.data()), size_(container.size()) {}
 
   constexpr T *data() const { return data_; }
   constexpr size_t size() const { return size_; }
   constexpr bool empty() const { return size_ == 0; }
 
   constexpr iterator begin() const { return data_; }
   constexpr const_iterator cbegin() const { return data_; }
   constexpr iterator end() const { return data_ + size_; }
   constexpr const_iterator cend() const { return end(); }
 
   constexpr T &front() const {
     if (size_ == 0) {
       abort();
     }
     return data_[0];
   }
   constexpr T &back() const {
     if (size_ == 0) {
       abort();
     }
     return data_[size_ - 1];
   }
 
   constexpr T &operator[](size_t i) const {
     if (i >= size_) {
       abort();
     }
     return data_[i];
   }
   T &at(size_t i) const { return (*this)[i]; }
 
   constexpr Span subspan(size_t pos = 0, size_t len = npos) const {
     if (pos > size_) {
       // absl::Span throws an exception here. Note std::span and Chromium
       // base::span additionally forbid pos + len being out of range, with a
       // special case at npos/dynamic_extent, while absl::Span::subspan clips
       // the span. For now, we align with absl::Span in case we switch to it in
       // the future.
       abort();
     }
     return Span(data_ + pos, std::min(size_ - pos, len));
   }
 
   constexpr Span first(size_t len) const {
     if (len > size_) {
       abort();
     }
     return Span(data_, len);
   }
 
   constexpr Span last(size_t len) const {
     if (len > size_) {
       abort();
     }
     return Span(data_ + size_ - len, len);
   }
 
  private:
   T *data_;
   size_t size_;
 };
 
 template <typename T>
 const size_t Span<T>::npos;
 
 template <typename T>
 Span(T *, size_t) -> Span<T>;
 template <typename T, size_t size>
 Span(T (&array)[size]) -> Span<T>;
 template <
     typename C,
     typename T = std::remove_pointer_t<decltype(std::declval<C>().data())>,
     typename = internal::EnableIfContainer<C, T>>
 Span(C &) -> Span<T>;
 
 template <typename T>
 constexpr Span<T> MakeSpan(T *ptr, size_t size) {
   return Span<T>(ptr, size);
 }
 
 template <typename C>
 constexpr auto MakeSpan(C &c) -> decltype(MakeSpan(c.data(), c.size())) {
   return MakeSpan(c.data(), c.size());
 }
 
 template <typename T, size_t N>
 constexpr Span<T> MakeSpan(T (&array)[N]) {
   return Span<T>(array, N);
 }
 
 template <typename T>
 constexpr Span<const T> MakeConstSpan(T *ptr, size_t size) {
   return Span<const T>(ptr, size);
 }
 
 template <typename C>
 constexpr auto MakeConstSpan(const C &c)
     -> decltype(MakeConstSpan(c.data(), c.size())) {
   return MakeConstSpan(c.data(), c.size());
 }
 
 template <typename T, size_t size>
 constexpr Span<const T> MakeConstSpan(T (&array)[size]) {
   return array;
 }
 
 inline Span<const uint8_t> StringAsBytes(std::string_view s) {
   return MakeConstSpan(reinterpret_cast<const uint8_t *>(s.data()), s.size());
 }
 
 inline std::string_view BytesAsStringView(bssl::Span<const uint8_t> b) {
   return std::string_view(reinterpret_cast<const char *>(b.data()), b.size());
 }
 
 BSSL_NAMESPACE_END
 
 }  // extern C++
 
 #endif  // !defined(BORINGSSL_NO_CXX)
 
 #endif  // OPENSSL_HEADER_SSL_SPAN_H