Simplified the implementation and features of span

1 files changed, 0 insertions, 174 deletions

diff --git a/contrib/epee/include/span_view.h b/contrib/epee/include/span_view.h
deleted file mode 100644
index 33c538d37..000000000
--- a/contrib/epee/include/span_view.h
+++ /dev/null
@@ -1,174 +0,0 @@
-// Copyright (c) 2017, The Monero Project
-//
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without modification, are
-// permitted provided that the following conditions are met:
-//
-// 1. Redistributions of source code must retain the above copyright notice, this list of
-//    conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright notice, this list
-//    of conditions and the following disclaimer in the documentation and/or other
-//    materials provided with the distribution.
-//
-// 3. Neither the name of the copyright holder nor the names of its contributors may be
-//    used to endorse or promote products derived from this software without specific
-//    prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
-// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
-// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#pragma once
-
-#include <cstddef>
-#include <memory>
-#include <type_traits>
-#include <utility>
-
-namespace epee
-{
-  /*!
-    \brief Non-owning sequence of data. Does not deep copy
-
-    Inspired by `gsl::span`. This class is intended to be used as a parameter
-    type for functions that need to take a writable or read-only sequence of
-    data. Most common cases are `span<char>` and `span<std::uint8_t>`. Using as
-    a class member is only recommended if clearly documented as not doing a
-    deep-copy. `std::vector`, `std::string`, `std::array`, and C-arrays are all
-    easily convertible to this type.
-
-    \note Conversion from C string literal to `view<char>` will include the
-      NULL-terminator.
-    \note `view<T>` is an alias for `span<const T>` which is read-only.
-    \note Never allows derived-to-base pointer conversion; an array of derived
-      types is not an array of base types.
-   */
-  template<typename T>
-  class span
-  {
-    /* Supporting class types is tricky - the {ptr,len} and {container}
-       constructors will allow derived-to-base conversions. This is NOT
-       desireable because an array of derived types is not an array of base
-       types. It is possible to handle this case, implement when/if needed. */
-    static_assert(std::is_integral<T>::value, "only integral values currently for span");
-
-    // Disables ADL for these calls.
-    struct get {
-      // we only accept pointer and size_t return types, so use noexcept aggressively
-      template<std::size_t N>
-      static constexpr T* data(T (&src)[N]) noexcept { return src; }
-
-      template<typename C>
-      static constexpr auto
-      data(C& src) noexcept(noexcept(src.data())) -> decltype(src.data()) {
-        return src.data();
-      }
-
-
-      template<std::size_t N>
-      static constexpr std::size_t size(T (&)[N]) noexcept { return N; }
-
-      template<typename C>
-      static constexpr auto
-      size(const C& src) noexcept(noexcept(src.size())) -> decltype(src.size()) {
-        return src.size();
-      }
-    };
-
-  public:
-    using value_type = T;
-    using pointer = T*;
-    using reference = T&;
-    using iterator = pointer;
-    using const_iterator = typename std::add_const<value_type>::type *;
-
-    constexpr span() noexcept : ptr(nullptr), len(0) {}
-    constexpr span(std::nullptr_t) noexcept : span() {}
-
-    constexpr span(T* const src_ptr, const std::size_t src_len) noexcept
-      : ptr(src_ptr), len(src_len) {
-    }
-
-    /*!
-       A `span` is implicitly convertible from any type where `get::data(src)`
-       returns a pointer convertible to T* and `get::size(src)` returns a
-       `std::size_t`. This constructor is disabled for all other types.
-     */
-    template<
-      typename C,
-      typename U = decltype(get::data(std::declval<C&>())),
-      typename S = decltype(get::size(std::declval<C&>())),
-      typename = typename std::enable_if<
-        // Do not allow proxy iterators, but allow valid cv conversions
-        std::is_pointer<U>::value && std::is_convertible<U, pointer>::value &&
-        // Prevent underflow/overflow on size storage
-        std::is_same<S, std::size_t>::value
-      >::type
-    >
-    constexpr span(C&& src) noexcept(noexcept(get::data(src), get::size(src)))
-      : span(get::data(src), get::size(src)) {
-    }
-
-    constexpr span(span&&) noexcept = default;
-    constexpr span(span&) noexcept = default;
-    constexpr span(const span&) noexcept = default;
-    span& operator=(const span&) noexcept = default;
-
-    constexpr iterator begin() const noexcept { return ptr; }
-    constexpr const_iterator cbegin() const noexcept { return ptr; }
-
-    constexpr iterator end() const noexcept { return begin() + size(); }
-    constexpr const_iterator cend() const noexcept { return cbegin() + size(); }
-
-    constexpr bool empty() const noexcept { return size() == 0; }
-    constexpr pointer data() const noexcept { return ptr; }
-    constexpr std::size_t size() const noexcept { return len; }
-    constexpr std::size_t size_bytes() const noexcept { return size() * sizeof(value_type); }
-
-  private:
-    T* ptr;
-    std::size_t len;
-  };
-
-  //! A `view` is a `span` over immutable data. See `span` for more info.
-  template<typename T>
-  using view = span<typename std::add_const<T>::type>;
-
-  //! \return `src` aliased as a view of type `T`.
-  template<typename T, typename U>
-  view<T> view_cast(const span<U>& src) noexcept
-  {
-    using normalized = typename std::remove_cv<T>::type;
-    static_assert(
-      std::is_same<normalized, char>::value || std::is_same<normalized, std::uint8_t>::value,
-      "only valid aliasing allowed - char or unsigned char target types"
-    );
-
-    static_assert(std::is_integral<U>::value, "only integral source types");
-    return {reinterpret_cast<typename std::add_const<T>::type *>(src.data()), src.size_bytes()};
-  }
-
-  //! \return `src` aliased as a span of type `T`.
-  template<typename T, typename U>
-  span<T> pod_cast(U&& src) noexcept
-  {
-    using normalized = typename std::remove_cv<T>::type;
-    static_assert(
-      std::is_same<normalized, char>::value || std::is_same<normalized, std::uint8_t>::value,
-      "only valid aliasing allowed - char or unsigned char target types"
-    );
-
-    using decayed = typename std::decay<U>::type;
-    static_assert(std::is_pod<decayed>::value, "only POD types allowed for conversion");
-    static_assert(alignof(decayed) == 1, "only types with 1 byte alignment allowed for conversion");
-    return {reinterpret_cast<T*>(std::addressof(src)), sizeof(decayed)};
-  }
-}