LCOV - code coverage report
Current view: top level - src - span.h (source / functions) Hit Total Coverage
Test: total_coverage.info Lines: 29 29 100.0 %
Date: 2025-02-23 09:33:43 Functions: 2 2 100.0 %

          Line data    Source code
       1             : // Copyright (c) 2018 The Bitcoin Core developers
       2             : // Distributed under the MIT software license, see the accompanying
       3             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4             : 
       5             : #ifndef PIVX_SPAN_H
       6             : #define PIVX_SPAN_H
       7             : 
       8             : #include <type_traits>
       9             : #include <cstddef>
      10             : #include <algorithm>
      11             : #include <assert.h>
      12             : 
      13             : #ifdef DEBUG
      14             : #define CONSTEXPR_IF_NOT_DEBUG
      15             : #define ASSERT_IF_DEBUG(x) assert((x))
      16             : #else
      17             : #define CONSTEXPR_IF_NOT_DEBUG constexpr
      18             : #define ASSERT_IF_DEBUG(x)
      19             : #endif
      20             : 
      21             : #if defined(__clang__)
      22             : #if __has_attribute(lifetimebound)
      23             : #define SPAN_ATTR_LIFETIMEBOUND [[clang::lifetimebound]]
      24             : #else
      25             : #define SPAN_ATTR_LIFETIMEBOUND
      26             : #endif
      27             : #else
      28             : #define SPAN_ATTR_LIFETIMEBOUND
      29             : #endif
      30             : 
      31             : /** A Span is an object that can refer to a contiguous sequence of objects.
      32             :  *
      33             :  * It implements a subset of C++20's std::span.
      34             :  *
      35             :  * Things to be aware of when writing code that deals with Spans:
      36             :  *
      37             :  * - Similar to references themselves, Spans are subject to reference lifetime
      38             :  *   issues. The user is responsible for making sure the objects pointed to by
      39             :  *   a Span live as long as the Span is used. For example:
      40             :  *
      41             :  *       std::vector<int> vec{1,2,3,4};
      42             :  *       Span<int> sp(vec);
      43             :  *       vec.push_back(5);
      44             :  *       printf("%i\n", sp.front()); // UB!
      45             :  *
      46             :  *   may exhibit undefined behavior, as increasing the size of a vector may
      47             :  *   invalidate references.
      48             :  *
      49             :  * - One particular pitfall is that Spans can be constructed from temporaries,
      50             :  *   but this is unsafe when the Span is stored in a variable, outliving the
      51             :  *   temporary. For example, this will compile, but exhibits undefined behavior:
      52             :  *
      53             :  *       Span<const int> sp(std::vector<int>{1, 2, 3});
      54             :  *       printf("%i\n", sp.front()); // UB!
      55             :  *
      56             :  *   The lifetime of the vector ends when the statement it is created in ends.
      57             :  *   Thus the Span is left with a dangling reference, and using it is undefined.
      58             :  *
      59             :  * - Due to Span's automatic creation from range-like objects (arrays, and data
      60             :  *   types that expose a data() and size() member function), functions that
      61             :  *   accept a Span as input parameter can be called with any compatible
      62             :  *   range-like object. For example, this works:
      63             : *
      64             :  *       void Foo(Span<const int> arg);
      65             :  *
      66             :  *       Foo(std::vector<int>{1, 2, 3}); // Works
      67             :  *
      68             :  *   This is very useful in cases where a function truly does not care about the
      69             :  *   container, and only about having exactly a range of elements. However it
      70             :  *   may also be surprising to see automatic conversions in this case.
      71             :  *
      72             :  *   When a function accepts a Span with a mutable element type, it will not
      73             :  *   accept temporaries; only variables or other references. For example:
      74             :  *
      75             :  *       void FooMut(Span<int> arg);
      76             :  *
      77             :  *       FooMut(std::vector<int>{1, 2, 3}); // Does not compile
      78             :  *       std::vector<int> baz{1, 2, 3};
      79             :  *       FooMut(baz); // Works
      80             :  *
      81             :  *   This is similar to how functions that take (non-const) lvalue references
      82             :  *   as input cannot accept temporaries. This does not work either:
      83             :  *
      84             :  *       void FooVec(std::vector<int>& arg);
      85             :  *       FooVec(std::vector<int>{1, 2, 3}); // Does not compile
      86             :  *
      87             :  *   The idea is that if a function accepts a mutable reference, a meaningful
      88             :  *   result will be present in that variable after the call. Passing a temporary
      89             :  *   is useless in that context.
      90             :  */
      91             : template<typename C>
      92             : class Span
      93             : {
      94             :     C* m_data;
      95             :     std::size_t m_size;
      96             : 
      97             :     template <class T>
      98             :     struct is_Span_int : public std::false_type {};
      99             :     template <class T>
     100             :     struct is_Span_int<Span<T>> : public std::true_type {};
     101             :     template <class T>
     102             :     struct is_Span : public is_Span_int<typename std::remove_cv<T>::type>{};
     103             : 
     104             : 
     105             : public:
     106             :     constexpr Span() noexcept : m_data(nullptr), m_size(0) {}
     107             : 
     108             :     /** Construct a span from a begin pointer and a size.
     109             :      *
     110             :      * This implements a subset of the iterator-based std::span constructor in C++20,
     111             :      * which is hard to implement without std::address_of.
     112             :      */
     113             :     template <typename T, typename std::enable_if<std::is_convertible<T (*)[], C (*)[]>::value, int>::type = 0>
     114      152818 :     constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {}
     115             : 
     116             :     /** Construct a span from a begin and end pointer.
     117             :      *
     118             :      * This implements a subset of the iterator-based std::span constructor in C++20,
     119             :      * which is hard to implement without std::address_of.
     120             :      */
     121             :     template <typename T, typename std::enable_if<std::is_convertible<T (*)[], C (*)[]>::value, int>::type = 0>
     122         112 :     CONSTEXPR_IF_NOT_DEBUG Span(T* begin, T* end) noexcept : m_data(begin), m_size(end - begin)
     123             :     {
     124             :         ASSERT_IF_DEBUG(end >= begin);
     125             :     }
     126             : 
     127             :     /** Implicit conversion of spans between compatible types.
     128             :      *
     129             :      *  Specifically, if a pointer to an array of type O can be implicitly converted to a pointer to an array of type
     130             :      *  C, then permit implicit conversion of Span<O> to Span<C>. This matches the behavior of the corresponding
     131             :      *  C++20 std::span constructor.
     132             :      *
     133             :      *  For example this means that a Span<T> can be converted into a Span<const T>.
     134             :      */
     135             :     template <typename O, typename std::enable_if<std::is_convertible<O (*)[], C (*)[]>::value, int>::type = 0>
     136           1 :     constexpr Span(const Span<O>& other) noexcept : m_data(other.m_data), m_size(other.m_size) {}
     137             : 
     138             :     /** Default copy constructor. */
     139             :     constexpr Span(const Span&) noexcept = default;
     140             : 
     141             :     /** Default assignment operator. */
     142             :     Span& operator=(const Span& other) noexcept = default;
     143             : 
     144             :     /** Construct a Span from an array. This matches the corresponding C++20 std::span constructor. */
     145             :     template <int N>
     146     7343243 :     constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {}
     147             : 
     148             :     /** Construct a Span for objects with .data() and .size() (std::string, std::array, std::vector, ...).
     149             :      *
     150             :      * This implements a subset of the functionality provided by the C++20 std::span range-based constructor.
     151             :      *
     152             :      * To prevent surprises, only Spans for constant value types are supported when passing in temporaries.
     153             :      * Note that this restriction does not exist when converting arrays or other Spans (see above).
     154             :      */
     155             :     template <typename V>
     156     9605448 :     constexpr Span(V& other SPAN_ATTR_LIFETIMEBOUND,
     157             :         typename std::enable_if<!is_Span<V>::value &&
     158             :                                 std::is_convertible<typename std::remove_pointer<decltype(std::declval<V&>().data())>::type (*)[], C (*)[]>::value &&
     159             :                                 std::is_convertible<decltype(std::declval<V&>().size()), std::size_t>::value, std::nullptr_t>::type = nullptr)
     160     9713365 :         : m_data(other.data()), m_size(other.size()){}
     161             : 
     162             :     template <typename V>
     163      145780 :     constexpr Span(const V& other SPAN_ATTR_LIFETIMEBOUND,
     164             :         typename std::enable_if<!is_Span<V>::value &&
     165             :                                 std::is_convertible<typename std::remove_pointer<decltype(std::declval<const V&>().data())>::type (*)[], C (*)[]>::value &&
     166             :                                 std::is_convertible<decltype(std::declval<const V&>().size()), std::size_t>::value, std::nullptr_t>::type = nullptr)
     167     4030586 :         : m_data(other.data()), m_size(other.size()){}
     168             : 
     169     9873543 :     constexpr C* data() const noexcept { return m_data; }
     170     9459779 :     constexpr C* begin() const noexcept { return m_data; }
     171     9459903 :     constexpr C* end() const noexcept { return m_data + m_size; }
     172             :     CONSTEXPR_IF_NOT_DEBUG C& front() const noexcept
     173             :     {
     174             :         ASSERT_IF_DEBUG(size() > 0);
     175             :         return m_data[0];
     176             :     }
     177             :     CONSTEXPR_IF_NOT_DEBUG C& back() const noexcept
     178             :     {
     179             :         ASSERT_IF_DEBUG(size() > 0);
     180             :         return m_data[m_size - 1];
     181             :     }
     182    19333588 :     constexpr std::size_t size() const noexcept { return m_size; }
     183          52 :     CONSTEXPR_IF_NOT_DEBUG C& operator[](std::size_t pos) const noexcept
     184             :     {
     185             :         ASSERT_IF_DEBUG(size() > pos);
     186         189 :         return m_data[pos];
     187             :     }
     188        4501 :     CONSTEXPR_IF_NOT_DEBUG Span<C> subspan(std::size_t offset) const noexcept
     189             :     {
     190             :         ASSERT_IF_DEBUG(size() >= offset);
     191        4464 :         return Span<C>(m_data + offset, m_size - offset);
     192             :     }
     193          93 :     CONSTEXPR_IF_NOT_DEBUG Span<C> subspan(std::size_t offset, std::size_t count) const noexcept
     194             :     {
     195             :         ASSERT_IF_DEBUG(size() >= offset + count);
     196          93 :         return Span<C>(m_data + offset, count);
     197             :     }
     198         118 :     CONSTEXPR_IF_NOT_DEBUG Span<C> first(std::size_t count) const noexcept
     199             :     {
     200             :         ASSERT_IF_DEBUG(size() >= count);
     201          81 :         return Span<C>(m_data, count);
     202             :     }
     203          58 :     CONSTEXPR_IF_NOT_DEBUG Span<C> last(std::size_t count) const noexcept
     204             :     {
     205             :          ASSERT_IF_DEBUG(size() >= count);
     206          58 :          return Span<C>(m_data + m_size - count, count);
     207             :     }
     208             : 
     209          70 :     friend constexpr bool operator==(const Span& a, const Span& b) noexcept { return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin()); }
     210           5 :     friend constexpr bool operator!=(const Span& a, const Span& b) noexcept { return !(a == b); }
     211             :     friend constexpr bool operator<(const Span& a, const Span& b) noexcept { return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end()); }
     212             :     friend constexpr bool operator<=(const Span& a, const Span& b) noexcept { return !(b < a); }
     213             :     friend constexpr bool operator>(const Span& a, const Span& b) noexcept { return (b < a); }
     214             :     friend constexpr bool operator>=(const Span& a, const Span& b) noexcept { return !(a < b); }
     215             : 
     216             :     template <typename O> friend class Span;
     217             : };
     218             : 
     219             : // MakeSpan helps constructing a Span of the right type automatically.
     220             : /** MakeSpan for arrays: */
     221             : template <typename A, int N> Span<A> constexpr MakeSpan(A (&a)[N]) { return Span<A>(a, N); }
     222             : /** MakeSpan for temporaries / rvalue references, only supporting const output. */
     223          20 : template <typename V> constexpr auto MakeSpan(V&& v SPAN_ATTR_LIFETIMEBOUND) -> typename std::enable_if<!std::is_lvalue_reference<V>::value, Span<const typename std::remove_pointer<decltype(v.data())>::type>>::type { return std::forward<V>(v); }
     224             : /** MakeSpan for (lvalue) references, supporting mutable output. */
     225     9927061 : template <typename V> constexpr auto MakeSpan(V& v SPAN_ATTR_LIFETIMEBOUND) -> Span<typename std::remove_pointer<decltype(v.data())>::type> { return v; }
     226             : 
     227             : /** Pop the last element off a span, and return a reference to that element. */
     228             : template <typename T>
     229             : T& SpanPopBack(Span<T>& span)
     230             : {
     231             :     size_t size = span.size();
     232             :     ASSERT_IF_DEBUG(size > 0);
     233             :     T& back = span[size - 1];
     234             :     span = Span<T>(span.data(), size - 1);
     235             :     return back;
     236             : }
     237             : 
     238             : // Helper functions to safely cast to unsigned char pointers.
     239             : inline unsigned char* UCharCast(char* c) { return (unsigned char*)c; }
     240             : inline unsigned char* UCharCast(unsigned char* c) { return c; }
     241      126432 : inline const unsigned char* UCharCast(const char* c) { return (unsigned char*)c; }
     242             : inline const unsigned char* UCharCast(const unsigned char* c) { return c; }
     243             : 
     244             : // Helper function to safely convert a Span to a Span<[const] unsigned char>.
     245      126432 : template <typename T> constexpr auto UCharSpanCast(Span<T> s) -> Span<typename std::remove_pointer<decltype(UCharCast(s.data()))>::type> { return {UCharCast(s.data()), s.size()}; }
     246             : 
     247             : /** Like MakeSpan, but for (const) unsigned char member types only. Only works for (un)signed char containers. */
     248      126432 : template <typename V> constexpr auto MakeUCharSpan(V&& v) -> decltype(UCharSpanCast(MakeSpan(std::forward<V>(v)))) { return UCharSpanCast(MakeSpan(std::forward<V>(v))); }
     249             : 
     250             : #endif // PIVX_SPAN_H

Generated by: LCOV version 1.14