boost/histogram/detail/span.hpp

   1 // Copyright 2019 Hans Dembinski
   2 //
   3 // Distributed under the Boost Software License, Version 1.0.
   4 // (See accompanying file LICENSE_1_0.txt
   5 // or copy at http://www.boost.org/LICENSE_1_0.txt)
   6
   7 #ifndef BOOST_HISTOGRAM_DETAIL_SPAN_HPP
   8 #define BOOST_HISTOGRAM_DETAIL_SPAN_HPP
   9
  10 #if __cpp_constexpr >= 201603 && __cpp_deduction_guides >= 201703 && \
  11     __cpp_lib_nonmember_container_access >= 201411 && __has_include(<span>)
  12 #include <span>
  13
  14 namespace boost {
  15 namespace histogram {
  16 namespace detail {
  17 using std::span;
  18 } // namespace detail
  19 } // namespace histogram
  20 } // namespace boost
  21
  22 #else // C++17 span not available, so we use our implementation
  23
  24 // to be replaced by boost::span
  25
  26 #include <array>
  27 #include <boost/assert.hpp>
  28 #include <boost/histogram/detail/non_member_container_access.hpp>
  29 #include <initializer_list>
  30 #include <iterator>
  31 #include <type_traits>
  32
  33 namespace boost {
  34 namespace histogram {
  35 namespace detail {
  36
  37 namespace dtl = ::boost::histogram::detail;
  38
  39 static constexpr std::size_t dynamic_extent = ~static_cast<std::size_t>(0);
  40
  41 template <class T, std::size_t N>
  42 class span_base {
  43 public:
  44   constexpr T* data() noexcept { return begin_; }
  45   constexpr const T* data() const noexcept { return begin_; }
  46   constexpr std::size_t size() const noexcept { return N; }
  47
  48 protected:
  49   constexpr span_base(T* b, std::size_t s) noexcept : begin_(b) { BOOST_ASSERT(N == s); }
  50   constexpr void set(T* b, std::size_t s) noexcept {
  51     begin_ = b;
  52     BOOST_ASSERT(N == s);
  53   }
  54
  55 private:
  56   T* begin_;
  57 };
  58
  59 template <class T>
  60 class span_base<T, dynamic_extent> {
  61 public:
  62   constexpr T* data() noexcept { return begin_; }
  63   constexpr const T* data() const noexcept { return begin_; }
  64   constexpr std::size_t size() const noexcept { return size_; }
  65
  66 protected:
  67   constexpr span_base(T* b, std::size_t s) noexcept : begin_(b), size_(s) {}
  68
  69   constexpr void set(T* b, std::size_t s) noexcept {
  70     begin_ = b;
  71     size_ = s;
  72   }
  73
  74 private:
  75   T* begin_;
  76   std::size_t size_;
  77 };
  78
  79 template <class T, std::size_t Extent = dynamic_extent>
  80 class span : public span_base<T, Extent> {
  81   using base = span_base<T, Extent>;
  82
  83 public:
  84   using element_type = T;
  85   using value_type = std::remove_cv_t<T>;
  86   using index_type = std::size_t;
  87   using difference_type = std::ptrdiff_t;
  88   using pointer = T*;
  89   using const_pointer = const T*;
  90   using reference = T&;
  91   using const_reference = const T&;
  92   using iterator = pointer;
  93   using const_iterator = const_pointer;
  94   using reverse_iterator = std::reverse_iterator<iterator>;
  95   using const_reverse_iterator = std::reverse_iterator<const_iterator>;
  96
  97   static constexpr std::size_t extent = Extent;
  98
  99   template <std::size_t _ = extent,
 100             class = std::enable_if_t<(_ == 0 || _ == dynamic_extent)> >
 101   constexpr span() noexcept : base(nullptr, 0) {}
 102
 103   constexpr span(pointer first, pointer last)
 104       : span(first, static_cast<std::size_t>(last - first)) {
 105     BOOST_ASSERT(extent == dynamic_extent ||
 106                  static_cast<difference_type>(extent) == (last - first));
 107   }
 108
 109   constexpr span(pointer ptr, index_type count) : base(ptr, count) {}
 110
 111   template <std::size_t N>
 112   constexpr span(element_type (&arr)[N]) noexcept : span(dtl::data(arr), N) {
 113     static_assert(extent == dynamic_extent || extent == N, "static sizes do not match");
 114   }
 115
 116   template <std::size_t N,
 117             class = std::enable_if_t<(extent == dynamic_extent || extent == N)> >
 118   constexpr span(std::array<value_type, N>& arr) noexcept : span(dtl::data(arr), N) {}
 119
 120   template <std::size_t N,
 121             class = std::enable_if_t<(extent == dynamic_extent || extent == N)> >
 122   constexpr span(const std::array<value_type, N>& arr) noexcept
 123       : span(dtl::data(arr), N) {}
 124
 125   template <class Container, class = std::enable_if_t<std::is_convertible<
 126                                  decltype(dtl::size(std::declval<Container>()),
 127                                           dtl::data(std::declval<Container>())),
 128                                  pointer>::value> >
 129   constexpr span(const Container& cont) : span(dtl::data(cont), dtl::size(cont)) {}
 130
 131   template <class Container, class = std::enable_if_t<std::is_convertible<
 132                                  decltype(dtl::size(std::declval<Container>()),
 133                                           dtl::data(std::declval<Container>())),
 134                                  pointer>::value> >
 135   constexpr span(Container& cont) : span(dtl::data(cont), dtl::size(cont)) {}
 136
 137   template <class U, std::size_t N,
 138             class = std::enable_if_t<((extent == dynamic_extent || extent == N) &&
 139                                       std::is_convertible<U, element_type>::value)> >
 140   constexpr span(const span<U, N>& s) noexcept : span(s.data(), s.size()) {}
 141
 142   template <class U, std::size_t N,
 143             class = std::enable_if_t<((extent == dynamic_extent || extent == N) &&
 144                                       std::is_convertible<U, element_type>::value)> >
 145   constexpr span(span<U, N>& s) noexcept : span(s.data(), s.size()) {}
 146
 147   constexpr span(const span& other) noexcept = default;
 148
 149   constexpr iterator begin() { return base::data(); }
 150   constexpr const_iterator begin() const { return base::data(); }
 151   constexpr const_iterator cbegin() const { return base::data(); }
 152
 153   constexpr iterator end() { return base::data() + base::size(); }
 154   constexpr const_iterator end() const { return base::data() + base::size(); }
 155   constexpr const_iterator cend() const { return base::data() + base::size(); }
 156
 157   reverse_iterator rbegin() { return reverse_iterator(end()); }
 158   const_reverse_iterator rbegin() const { return reverse_iterator(end()); }
 159   const_reverse_iterator crbegin() { return reverse_iterator(end()); }
 160
 161   reverse_iterator rend() { return reverse_iterator(begin()); }
 162   const_reverse_iterator rend() const { return reverse_iterator(begin()); }
 163   const_reverse_iterator crend() { return reverse_iterator(begin()); }
 164
 165   constexpr reference front() { *base::data(); }
 166   constexpr reference back() { *(base::data() + base::size() - 1); }
 167
 168   constexpr reference operator[](index_type idx) const { return base::data()[idx]; }
 169
 170   constexpr std::size_t size_bytes() const noexcept {
 171     return base::size() * sizeof(element_type);
 172   }
 173
 174   constexpr bool empty() const noexcept { return base::size() == 0; }
 175
 176   template <std::size_t Count>
 177   constexpr span<element_type, Count> first() const {
 178     BOOST_ASSERT(Count <= base::size());
 179     return span<element_type, Count>(base::data(), Count);
 180   }
 181
 182   constexpr span<element_type, dynamic_extent> first(std::size_t count) const {
 183     BOOST_ASSERT(count <= base::size());
 184     return span<element_type, dynamic_extent>(base::data(), count);
 185   }
 186
 187   template <std::size_t Count>
 188   constexpr span<element_type, Count> last() const {
 189     BOOST_ASSERT(Count <= base::size());
 190     return span<element_type, Count>(base::data() + base::size() - Count, Count);
 191   }
 192
 193   constexpr span<element_type, dynamic_extent> last(std::size_t count) const {
 194     BOOST_ASSERT(count <= base::size());
 195     return span<element_type, dynamic_extent>(base::data() + base::size() - count, count);
 196   }
 197
 198   template <std::size_t Offset, std::size_t Count = dynamic_extent>
 199   constexpr span<element_type,
 200                  (Count != dynamic_extent
 201                       ? Count
 202                       : (extent != dynamic_extent ? extent - Offset : dynamic_extent))>
 203   subspan() const {
 204     BOOST_ASSERT(Offset <= base::size());
 205     constexpr std::size_t E =
 206         (Count != dynamic_extent
 207              ? Count
 208              : (extent != dynamic_extent ? extent - Offset : dynamic_extent));
 209     BOOST_ASSERT(E == dynamic_extent || E <= base::size());
 210     return span<element_type, E>(base::data() + Offset,
 211                                  Count == dynamic_extent ? base::size() - Offset : Count);
 212   }
 213
 214   constexpr span<element_type, dynamic_extent> subspan(
 215       std::size_t offset, std::size_t count = dynamic_extent) const {
 216     BOOST_ASSERT(offset <= base::size());
 217     const std::size_t s = count == dynamic_extent ? base::size() - offset : count;
 218     BOOST_ASSERT(s <= base::size());
 219     return span<element_type, dynamic_extent>(base::data() + offset, s);
 220   }
 221 };
 222
 223 } // namespace detail
 224 } // namespace histogram
 225 } // namespace boost
 226
 227 #endif
 228
 229 #include <boost/histogram/detail/non_member_container_access.hpp>
 230 #include <utility>
 231
 232 namespace boost {
 233 namespace histogram {
 234 namespace detail {
 235
 236 namespace dtl = ::boost::histogram::detail;
 237
 238 template <class T>
 239 auto make_span(T* begin, T* end) {
 240   return dtl::span<T>{begin, end};
 241 }
 242
 243 template <class T>
 244 auto make_span(T* begin, std::size_t size) {
 245   return dtl::span<T>{begin, size};
 246 }
 247
 248 template <class Container, class = decltype(dtl::size(std::declval<Container>()),
 249                                             dtl::data(std::declval<Container>()))>
 250 auto make_span(const Container& cont) {
 251   return make_span(dtl::data(cont), dtl::size(cont));
 252 }
 253
 254 template <class T, std::size_t N>
 255 auto make_span(T (&arr)[N]) {
 256   return dtl::span<T, N>(arr, N);
 257 }
 258
 259 } // namespace detail
 260 } // namespace histogram
 261 } // namespace boost
 262
 263 #endif