import quincy beta 17.1.0

[ceph.git] / ceph / src / boost / boost / histogram / detail / span.hpp

diff --git a/ceph/src/boost/boost/histogram/detail/span.hpp b/ceph/src/boost/boost/histogram/detail/span.hpp
index c0e70c806626f38b0b7005c63ca4e9bc85075b4d..663b457562d7f74666c6c3eae28961ee15c3e9d7 100644 (file)
--- a/ceph/src/boost/boost/histogram/detail/span.hpp
+++ b/ceph/src/boost/boost/histogram/detail/span.hpp
@@ -35,8 +35,8 @@ using std::span;
 // to be replaced by boost::span
 
 #include <array>
-#include <boost/assert.hpp>
-#include <boost/histogram/detail/non_member_container_access.hpp>
+#include <boost/histogram/detail/nonmember_container_access.hpp>
+#include <cassert>
 #include <initializer_list>
 #include <iterator>
 #include <type_traits>
@@ -57,10 +57,14 @@ public:
   constexpr std::size_t size() const noexcept { return N; }
 
 protected:
-  constexpr span_base(T* b, std::size_t s) noexcept : begin_(b) { BOOST_ASSERT(N == s); }
+  constexpr span_base(T* b, std::size_t s) noexcept : begin_(b) {
+    (void)s;
+    assert(N == s);
+  }
   constexpr void set(T* b, std::size_t s) noexcept {
+    (void)s;
     begin_ = b;
-    BOOST_ASSERT(N == s);
+    assert(N == s);
   }
 
 private:
@@ -70,13 +74,14 @@ private:
 template <class T>
 class span_base<T, dynamic_extent> {
 public:
+  constexpr span_base() noexcept : begin_(nullptr), size_(0) {}
+
   constexpr T* data() noexcept { return begin_; }
   constexpr const T* data() const noexcept { return begin_; }
   constexpr std::size_t size() const noexcept { return size_; }
 
 protected:
   constexpr span_base(T* b, std::size_t s) noexcept : begin_(b), size_(s) {}
-
   constexpr void set(T* b, std::size_t s) noexcept {
     begin_ = b;
     size_ = s;
@@ -107,14 +112,12 @@ public:
 
   static constexpr std::size_t extent = Extent;
 
-  template <std::size_t _ = extent,
-            class = std::enable_if_t<(_ == 0 || _ == dynamic_extent)> >
-  constexpr span() noexcept : base(nullptr, 0) {}
+  using base::base;
 
   constexpr span(pointer first, pointer last)
       : span(first, static_cast<std::size_t>(last - first)) {
-    BOOST_ASSERT(extent == dynamic_extent ||
-                 static_cast<difference_type>(extent) == (last - first));
+    assert(extent == dynamic_extent ||
+           static_cast<difference_type>(extent) == (last - first));
   }
 
   constexpr span(pointer ptr, index_type count) : base(ptr, count) {}
@@ -134,14 +137,14 @@ public:
       : span(dtl::data(arr), N) {}
 
   template <class Container, class = std::enable_if_t<std::is_convertible<
-                                 decltype(dtl::size(std::declval<Container>()),
-                                          dtl::data(std::declval<Container>())),
+                                 decltype(dtl::size(std::declval<const Container&>()),
+                                          dtl::data(std::declval<const Container&>())),
                                  pointer>::value> >
   constexpr span(const Container& cont) : span(dtl::data(cont), dtl::size(cont)) {}
 
   template <class Container, class = std::enable_if_t<std::is_convertible<
-                                 decltype(dtl::size(std::declval<Container>()),
-                                          dtl::data(std::declval<Container>())),
+                                 decltype(dtl::size(std::declval<Container&>()),
+                                          dtl::data(std::declval<Container&>())),
                                  pointer>::value> >
   constexpr span(Container& cont) : span(dtl::data(cont), dtl::size(cont)) {}
 
@@ -173,8 +176,8 @@ public:
   const_reverse_iterator rend() const { return reverse_iterator(begin()); }
   const_reverse_iterator crend() { return reverse_iterator(begin()); }
 
-  constexpr reference front() { *base::data(); }
-  constexpr reference back() { *(base::data() + base::size() - 1); }
+  constexpr reference front() { return *base::data(); }
+  constexpr reference back() { return *(base::data() + base::size() - 1); }
 
   constexpr reference operator[](index_type idx) const { return base::data()[idx]; }
 
@@ -186,23 +189,23 @@ public:
 
   template <std::size_t Count>
   constexpr span<element_type, Count> first() const {
-    BOOST_ASSERT(Count <= base::size());
+    assert(Count <= base::size());
     return span<element_type, Count>(base::data(), Count);
   }
 
   constexpr span<element_type, dynamic_extent> first(std::size_t count) const {
-    BOOST_ASSERT(count <= base::size());
+    assert(count <= base::size());
     return span<element_type, dynamic_extent>(base::data(), count);
   }
 
   template <std::size_t Count>
   constexpr span<element_type, Count> last() const {
-    BOOST_ASSERT(Count <= base::size());
+    assert(Count <= base::size());
     return span<element_type, Count>(base::data() + base::size() - Count, Count);
   }
 
   constexpr span<element_type, dynamic_extent> last(std::size_t count) const {
-    BOOST_ASSERT(count <= base::size());
+    assert(count <= base::size());
     return span<element_type, dynamic_extent>(base::data() + base::size() - count, count);
   }
 
@@ -212,21 +215,21 @@ public:
                       ? Count
                       : (extent != dynamic_extent ? extent - Offset : dynamic_extent))>
   subspan() const {
-    BOOST_ASSERT(Offset <= base::size());
+    assert(Offset <= base::size());
     constexpr std::size_t E =
         (Count != dynamic_extent
              ? Count
              : (extent != dynamic_extent ? extent - Offset : dynamic_extent));
-    BOOST_ASSERT(E == dynamic_extent || E <= base::size());
+    assert(E == dynamic_extent || E <= base::size());
     return span<element_type, E>(base::data() + Offset,
                                  Count == dynamic_extent ? base::size() - Offset : Count);
   }
 
   constexpr span<element_type, dynamic_extent> subspan(
       std::size_t offset, std::size_t count = dynamic_extent) const {
-    BOOST_ASSERT(offset <= base::size());
+    assert(offset <= base::size());
     const std::size_t s = count == dynamic_extent ? base::size() - offset : count;
-    BOOST_ASSERT(s <= base::size());
+    assert(s <= base::size());
     return span<element_type, dynamic_extent>(base::data() + offset, s);
   }
 };
@@ -237,7 +240,7 @@ public:
 
 #endif
 
-#include <boost/histogram/detail/non_member_container_access.hpp>
+#include <boost/histogram/detail/nonmember_container_access.hpp>
 #include <utility>
 
 namespace boost {