From a409439a08b42b2c5e79832437bd735584741f41 Mon Sep 17 00:00:00 2001
From: Phil Miller <philip.miller@noaa.gov>
Date: Mon, 22 Jan 2024 14:00:49 -0800
Subject: [PATCH] Drop private copies of Boost span.hpp and data.hpp

---
 include/utilities/boostcore_data.hpp |  48 ----
 include/utilities/span.hpp           | 412 ---------------------------
 2 files changed, 460 deletions(-)
 delete mode 100644 include/utilities/boostcore_data.hpp
 delete mode 100644 include/utilities/span.hpp

diff --git a/include/utilities/boostcore_data.hpp b/include/utilities/boostcore_data.hpp
deleted file mode 100644
index 61177a738d..0000000000
--- a/include/utilities/boostcore_data.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
-Copyright 2023 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-
-
-#ifndef BOOST_CORE_DATA_HPP
-#define BOOST_CORE_DATA_HPP
-
-#include <initializer_list>
-#include <cstddef>
-
-namespace boost {
-
-template<class C>
-inline constexpr auto
-data(C& c) noexcept(noexcept(c.data())) -> decltype(c.data())
-{
-    return c.data();
-}
-
-template<class C>
-inline constexpr auto
-data(const C& c) noexcept(noexcept(c.data())) -> decltype(c.data())
-{
-    return c.data();
-}
-
-template<class T, std::size_t N>
-inline constexpr T*
-data(T(&a)[N]) noexcept
-{
-    return a;
-}
-
-template<class T>
-inline constexpr const T*
-data(std::initializer_list<T> l) noexcept
-{
-    return l.begin();
-}
-
-} /* boost */
-
-#endif // define BOOST_CORE_DATA_HPP
diff --git a/include/utilities/span.hpp b/include/utilities/span.hpp
deleted file mode 100644
index 98dc4de425..0000000000
--- a/include/utilities/span.hpp
+++ /dev/null
@@ -1,412 +0,0 @@
-/*
-Copyright 2019-2023 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-
-#if __has_include(<boost/core/span.hpp>)
-#include <boost/core/span.hpp>
-#else
-
-#ifndef BOOST_CORE_SPAN_HPP
-#define BOOST_CORE_SPAN_HPP
-
-#if __has_include(<boost/core/data.hpp>)
-#include <boost/core/data.hpp>
-#else
-#include "boostcore_data.hpp"
-#endif
-
-#include <array>
-#include <iterator>
-#include <type_traits>
-
-namespace boost {
-
-constexpr std::size_t dynamic_extent = static_cast<std::size_t>(-1);
-
-template<class T, std::size_t E = dynamic_extent>
-class span;
-
-namespace detail {
-
-template<class U, class T>
-struct span_convertible {
-    static constexpr bool value = std::is_convertible<U(*)[], T(*)[]>::value;
-};
-
-template<std::size_t E, std::size_t N>
-struct span_capacity {
-    static constexpr bool value = E == boost::dynamic_extent || E == N;
-};
-
-template<class T, std::size_t E, class U, std::size_t N>
-struct span_compatible {
-    static constexpr bool value = span_capacity<E, N>::value &&
-        span_convertible<U, T>::value;
-};
-
-template<class T>
-using span_uncvref = typename std::remove_cv<typename
-    std::remove_reference<T>::type>::type;
-
-template<class>
-struct span_is_span {
-    static constexpr bool value = false;
-};
-
-template<class T, std::size_t E>
-struct span_is_span<boost::span<T, E> > {
-    static constexpr bool value = true;
-};
-
-template<class T>
-struct span_is_array {
-    static constexpr bool value = false;
-};
-
-template<class T, std::size_t N>
-struct span_is_array<std::array<T, N> > {
-    static constexpr bool value = true;
-};
-
-template<class T>
-using span_ptr = decltype(boost::data(std::declval<T&>()));
-
-template<class, class = void>
-struct span_data { };
-
-template<class T>
-struct span_data<T,
-    typename std::enable_if<std::is_pointer<span_ptr<T> >::value>::type> {
-    typedef typename std::remove_pointer<span_ptr<T> >::type type;
-};
-
-template<class, class, class = void>
-struct span_has_data {
-    static constexpr bool value = false;
-};
-
-template<class R, class T>
-struct span_has_data<R, T, typename std::enable_if<span_convertible<typename
-    span_data<R>::type, T>::value>::type> {
-    static constexpr bool value = true;
-};
-
-template<class, class = void>
-struct span_has_size {
-    static constexpr bool value = false;
-};
-
-template<class R>
-struct span_has_size<R, typename
-    std::enable_if<std::is_convertible<decltype(std::declval<R&>().size()),
-        std::size_t>::value>::type> {
-    static constexpr bool value = true;
-};
-
-template<class R, class T>
-struct span_is_range {
-    static constexpr bool value = (std::is_const<T>::value ||
-        std::is_lvalue_reference<R>::value) &&
-        !span_is_span<span_uncvref<R> >::value &&
-        !span_is_array<span_uncvref<R> >::value &&
-        !std::is_array<span_uncvref<R> >::value &&
-        span_has_data<R, T>::value &&
-        span_has_size<R>::value;
-};
-
-template<std::size_t E, std::size_t N>
-struct span_implicit {
-    static constexpr bool value = E == boost::dynamic_extent ||
-        N != boost::dynamic_extent;
-};
-
-template<class T, std::size_t E, class U, std::size_t N>
-struct span_copyable {
-    static constexpr bool value = (N == boost::dynamic_extent ||
-        span_capacity<E, N>::value) && span_convertible<U, T>::value;
-};
-
-template<std::size_t E, std::size_t O>
-struct span_sub {
-    static constexpr std::size_t value = E == boost::dynamic_extent ?
-        boost::dynamic_extent : E - O;
-};
-
-template<class T, std::size_t E>
-struct span_store {
-    constexpr span_store(T* p_, std::size_t) noexcept
-        : p(p_) { }
-    static constexpr std::size_t n = E;
-    T* p;
-};
-
-template<class T>
-struct span_store<T, boost::dynamic_extent> {
-    constexpr span_store(T* p_, std::size_t n_) noexcept
-        : p(p_)
-        , n(n_) { }
-    T* p;
-    std::size_t n;
-};
-
-template<class T, std::size_t E>
-struct span_bytes {
-    static constexpr std::size_t value = sizeof(T) * E;
-};
-
-template<class T>
-struct span_bytes<T, boost::dynamic_extent> {
-    static constexpr std::size_t value = boost::dynamic_extent;
-};
-
-} /* detail */
-
-template<class T, std::size_t E>
-class span {
-public:
-    typedef T element_type;
-    typedef typename std::remove_cv<T>::type value_type;
-    typedef std::size_t size_type;
-    typedef std::ptrdiff_t difference_type;
-    typedef T* pointer;
-    typedef const T* const_pointer;
-    typedef T& reference;
-    typedef const T& const_reference;
-    typedef T* iterator;
-    typedef const T* const_iterator;
-    typedef std::reverse_iterator<T*> reverse_iterator;
-    typedef std::reverse_iterator<const T*> const_reverse_iterator;
-
-    static constexpr std::size_t extent = E;
-
-    template<std::size_t N = E,
-        typename std::enable_if<N == dynamic_extent || N == 0, int>::type = 0>
-    constexpr span() noexcept
-        : s_(0, 0) { }
-
-    template<class I,
-        typename std::enable_if<E == dynamic_extent &&
-            detail::span_convertible<I, T>::value, int>::type = 0>
-    constexpr span(I* f, size_type c)
-        : s_(f, c) { }
-
-    template<class I,
-        typename std::enable_if<E != dynamic_extent &&
-            detail::span_convertible<I, T>::value, int>::type = 0>
-    explicit constexpr span(I* f, size_type c)
-        : s_(f, c) { }
-
-    template<class I, class L,
-        typename std::enable_if<E == dynamic_extent &&
-            detail::span_convertible<I, T>::value, int>::type = 0>
-    constexpr span(I* f, L* l)
-        : s_(f, l - f) { }
-
-    template<class I, class L,
-        typename std::enable_if<E != dynamic_extent &&
-            detail::span_convertible<I, T>::value, int>::type = 0>
-    explicit constexpr span(I* f, L* l)
-        : s_(f, l - f) { }
-
-    template<std::size_t N,
-        typename std::enable_if<detail::span_capacity<E, N>::value,
-            int>::type = 0>
-    constexpr span(typename std::enable_if<true, T>::type (&a)[N]) noexcept
-        : s_(a, N) { }
-
-    template<class U, std::size_t N,
-        typename std::enable_if<detail::span_compatible<T, E, U, N>::value,
-            int>::type = 0>
-    constexpr span(std::array<U, N>& a) noexcept
-        : s_(a.data(), N) { }
-
-    template<class U, std::size_t N,
-        typename std::enable_if<detail::span_compatible<T, E, const U,
-            N>::value, int>::type = 0>
-    constexpr span(const std::array<U, N>& a) noexcept
-        : s_(a.data(), N) { }
-
-    template<class R,
-        typename std::enable_if<E == dynamic_extent &&
-            detail::span_is_range<R, T>::value, int>::type = 0>
-    constexpr span(R&& r) noexcept(noexcept(boost::data(r)) &&
-        noexcept(r.size()))
-        : s_(boost::data(r), r.size()) { }
-
-    template<class R,
-        typename std::enable_if<E != dynamic_extent &&
-            detail::span_is_range<R, T>::value, int>::type = 0>
-    explicit constexpr span(R&& r) noexcept(noexcept(boost::data(r)) &&
-        noexcept(r.size()))
-        : s_(boost::data(r), r.size()) { }
-
-    template<class U, std::size_t N,
-        typename std::enable_if<detail::span_implicit<E, N>::value &&
-            detail::span_copyable<T, E, U, N>::value, int>::type = 0>
-    constexpr span(const span<U, N>& s) noexcept
-        : s_(s.data(), s.size()) { }
-
-    template<class U, std::size_t N,
-        typename std::enable_if<!detail::span_implicit<E, N>::value &&
-            detail::span_copyable<T, E, U, N>::value, int>::type = 0>
-    explicit constexpr span(const span<U, N>& s) noexcept
-        : s_(s.data(), s.size()) { }
-
-    template<std::size_t C>
-    constexpr span<T, C> first() const {
-        static_assert(C <= E, "Count <= Extent");
-        return span<T, C>(s_.p, C);
-    }
-
-    template<std::size_t C>
-    constexpr span<T, C> last() const {
-        static_assert(C <= E, "Count <= Extent");
-        return span<T, C>(s_.p + (s_.n - C), C);
-    }
-
-    template<std::size_t O, std::size_t C = dynamic_extent>
-    constexpr typename std::enable_if<C == dynamic_extent,
-        span<T, detail::span_sub<E, O>::value> >::type subspan() const {
-        static_assert(O <= E, "Offset <= Extent");
-        return span<T, detail::span_sub<E, O>::value>(s_.p + O, s_.n - O);
-    }
-
-    template<std::size_t O, std::size_t C = dynamic_extent>
-    constexpr typename std::enable_if<C != dynamic_extent,
-        span<T, C> >::type subspan() const {
-        static_assert(O <= E && C <= E - O,
-            "Offset <= Extent && Count <= Extent - Offset");
-        return span<T, C>(s_.p + O, C);
-    }
-
-    constexpr span<T, dynamic_extent> first(size_type c) const {
-        return span<T, dynamic_extent>(s_.p, c);
-    }
-
-    constexpr span<T, dynamic_extent> last(size_type c) const {
-        return span<T, dynamic_extent>(s_.p + (s_.n - c), c);
-    }
-
-    constexpr span<T, dynamic_extent> subspan(size_type o,
-        size_type c = dynamic_extent) const {
-        return span<T, dynamic_extent>(s_.p + o,
-            c == dynamic_extent ? s_.n - o : c);
-    }
-
-    constexpr size_type size() const noexcept {
-        return s_.n;
-    }
-
-    constexpr size_type size_bytes() const noexcept {
-        return s_.n * sizeof(T);
-    }
-
-    constexpr bool empty() const noexcept {
-        return s_.n == 0;
-    }
-
-    constexpr reference operator[](size_type i) const {
-        return s_.p[i];
-    }
-
-    constexpr reference front() const {
-        return *s_.p;
-    }
-
-    constexpr reference back() const {
-        return s_.p[s_.n - 1];
-    }
-
-    constexpr pointer data() const noexcept {
-        return s_.p;
-    }
-
-    constexpr iterator begin() const noexcept {
-        return s_.p;
-    }
-
-    constexpr iterator end() const noexcept {
-        return s_.p + s_.n;
-    }
-
-    constexpr reverse_iterator rbegin() const noexcept {
-        return reverse_iterator(s_.p + s_.n);
-    }
-
-    constexpr reverse_iterator rend() const noexcept {
-        return reverse_iterator(s_.p);
-    }
-
-    constexpr const_iterator cbegin() const noexcept {
-        return s_.p;
-    }
-
-    constexpr const_iterator cend() const noexcept {
-        return s_.p + s_.n;
-    }
-
-    constexpr const_reverse_iterator crbegin() const noexcept {
-        return const_reverse_iterator(s_.p + s_.n);
-    }
-
-    constexpr const_reverse_iterator crend() const noexcept {
-        return const_reverse_iterator(s_.p);
-    }
-
-private:
-    detail::span_store<T, E> s_;
-};
-
-template<class T, std::size_t E>
-constexpr std::size_t span<T, E>::extent;
-
-#ifdef __cpp_deduction_guides
-template<class I, class L>
-span(I*, L) -> span<I>;
-
-template<class T, std::size_t N>
-span(T(&)[N]) -> span<T, N>;
-
-template<class T, std::size_t N>
-span(std::array<T, N>&) -> span<T, N>;
-
-template<class T, std::size_t N>
-span(const std::array<T, N>&) -> span<const T, N>;
-
-template<class R>
-span(R&&) -> span<typename detail::span_data<R>::type>;
-
-template<class T, std::size_t E>
-span(span<T, E>) -> span<T, E>;
-#endif
-
-#ifdef __cpp_lib_byte
-template<class T, std::size_t E>
-inline span<const std::byte, detail::span_bytes<T, E>::value>
-as_bytes(span<T, E> s) noexcept
-{
-    return span<const std::byte, detail::span_bytes<T,
-        E>::value>(reinterpret_cast<const std::byte*>(s.data()),
-            s.size_bytes());
-}
-
-template<class T, std::size_t E>
-inline typename std::enable_if<!std::is_const<T>::value,
-    span<std::byte, detail::span_bytes<T, E>::value> >::type
-as_writable_bytes(span<T, E> s) noexcept
-{
-    return span<std::byte, detail::span_bytes<T,
-        E>::value>(reinterpret_cast<std::byte*>(s.data()), s.size_bytes());
-}
-#endif
-
-} /* boost */
-
-#endif
-
-
-#endif // __has_include(<boost/core/span.hpp>)