DEV: update deque functionality
This commit is contained in:
+53
-15
@@ -33,8 +33,10 @@
|
||||
|
||||
#include <core/core.h>
|
||||
#include <core/ring_iterator.h>
|
||||
#include <cont/range.h>
|
||||
|
||||
#include <array>
|
||||
#include <atomic>
|
||||
|
||||
namespace tbx {
|
||||
|
||||
@@ -50,16 +52,21 @@ namespace tbx {
|
||||
* We use a ring buffer of size \c N+1. We start the front iterator at the last location of the buffer
|
||||
* and the rear on the first. This way when the queue is full the iterators are pointing to the same location.
|
||||
*
|
||||
* \tparam Data_t The char-like queued item type. Usually \c char
|
||||
* \tparam N The size of deque
|
||||
* \tparam Data_t The char-like queued item type. Usually \c char
|
||||
* \tparam N The size of deque
|
||||
* \tparam SemiAtomic True for semi-atomic operation. In that case the \c ring_iterator is also atomic.
|
||||
* \note
|
||||
* SemiAtomic means it is safe to access different ends from different threads. For example one thread can
|
||||
* push only from front and another can pop from back to implement a queue.
|
||||
*/
|
||||
template <typename Data_t, size_t N>
|
||||
template <typename Data_t, size_t N, bool SemiAtomic =false>
|
||||
class deque {
|
||||
public:
|
||||
// meta-identity type
|
||||
using type = deque<Data_t, N>;
|
||||
using buffer_t = std::array<Data_t, N+1>; // We need N+1 spaces ring buffer for N spaces deque
|
||||
using iterator_t = ring_iterator<Data_t*, N+1>;
|
||||
using iterator_t = ring_iterator<Data_t*, N+1, SemiAtomic>;
|
||||
using range_t = range<iterator_t>;
|
||||
|
||||
// STL
|
||||
using value_type = Data_t;
|
||||
@@ -103,9 +110,9 @@ class deque {
|
||||
//! \name Iterators
|
||||
//! @{
|
||||
public:
|
||||
constexpr iterator begin() noexcept { return f+1; }
|
||||
constexpr const_iterator begin() const noexcept { return f+1; }
|
||||
constexpr const_iterator cbegin() const noexcept { return f+1; }
|
||||
constexpr iterator begin() noexcept { iterator ret = f; return ++ret; }
|
||||
constexpr const_iterator begin() const noexcept { iterator ret = f; return ++ret; }
|
||||
constexpr const_iterator cbegin() const noexcept { iterator ret = f; return ++ret; }
|
||||
|
||||
constexpr iterator end() noexcept { return r; }
|
||||
constexpr const_iterator end() const noexcept { return r; }
|
||||
@@ -115,9 +122,9 @@ class deque {
|
||||
constexpr const_reverse_iterator rbegin() const noexcept { return r; }
|
||||
constexpr const_reverse_iterator crbegin() const noexcept { return r; }
|
||||
|
||||
constexpr reverse_iterator rend() noexcept { return f+1; }
|
||||
constexpr const_reverse_iterator rend() const noexcept { return f+1; }
|
||||
constexpr const_reverse_iterator crend() const noexcept { return f+1; }
|
||||
constexpr reverse_iterator rend() noexcept { reverse_iterator ret = f; return ++ret; }
|
||||
constexpr const_reverse_iterator rend() const noexcept { reverse_iterator ret = f; return ++ret; }
|
||||
constexpr const_reverse_iterator crend() const noexcept { reverse_iterator ret = f; return ++ret; }
|
||||
//! @}
|
||||
|
||||
//! \name Capacity
|
||||
@@ -127,6 +134,9 @@ class deque {
|
||||
constexpr size_t size() noexcept {
|
||||
return full() ? N: (r - f) -1;
|
||||
}
|
||||
constexpr size_t size() const noexcept {
|
||||
return full() ? N: (r - f) -1;
|
||||
}
|
||||
//! \return The maximum size of the deque. The items the queue can hold.
|
||||
constexpr size_t max_size() noexcept { return N; }
|
||||
//! \return The capacity of the deque. The items the queue can hold.
|
||||
@@ -134,7 +144,11 @@ class deque {
|
||||
//! \return True if the deque is empty
|
||||
constexpr bool empty() noexcept { return size() == 0 ? true : false; }
|
||||
//! \return True if the deque is full
|
||||
constexpr bool full() noexcept { return (r == f) ? true : false; }
|
||||
constexpr bool full() noexcept {
|
||||
if constexpr (SemiAtomic)
|
||||
std::atomic_thread_fence(std::memory_order_acquire);
|
||||
return (r == f) ? true : false;
|
||||
}
|
||||
//! @}
|
||||
|
||||
//! \name Member access
|
||||
@@ -145,41 +159,65 @@ class deque {
|
||||
constexpr void clear() noexcept {
|
||||
f = iterator_t(data_.data(), N);
|
||||
r = iterator_t(data_.data());
|
||||
if constexpr (SemiAtomic)
|
||||
std::atomic_thread_fence(std::memory_order_release);
|
||||
}
|
||||
//! \brief Push an item in the front of the deque
|
||||
//! \param it The item to push
|
||||
constexpr void push_front (const Data_t& it) {
|
||||
if (full()) return;
|
||||
if constexpr (SemiAtomic)
|
||||
std::atomic_thread_fence(std::memory_order_acquire);
|
||||
*f-- = it;
|
||||
if constexpr (SemiAtomic)
|
||||
std::atomic_thread_fence(std::memory_order_release);
|
||||
}
|
||||
//! \brief Extract an item from the front of the deque and remove it from the deque
|
||||
//! \param it The item to push
|
||||
constexpr Data_t pop_front () {
|
||||
if (empty()) return Data_t{};
|
||||
if constexpr (SemiAtomic)
|
||||
std::atomic_thread_fence(std::memory_order_acquire);
|
||||
return *++f;
|
||||
}
|
||||
//! \brief Push an item in the back of the deque
|
||||
//! \param it The item to push
|
||||
constexpr void push_back (const Data_t& it) {
|
||||
if (full()) return;
|
||||
if constexpr (SemiAtomic)
|
||||
std::atomic_thread_fence(std::memory_order_acquire);
|
||||
*r++ = it;
|
||||
if constexpr (SemiAtomic)
|
||||
std::atomic_thread_fence(std::memory_order_release);
|
||||
}
|
||||
//! \brief Extract an item from the back of the deque and remove it from the deque
|
||||
//! \param it The item to push
|
||||
constexpr Data_t pop_back () {
|
||||
if (empty()) return Data_t{};
|
||||
if constexpr (SemiAtomic)
|
||||
std::atomic_thread_fence(std::memory_order_acquire);
|
||||
return *--r;
|
||||
}
|
||||
|
||||
//! \brief Get a reference to the item in the front of the deque without extracting it.
|
||||
//! \return Reference to the item
|
||||
constexpr Data_t& front() noexcept { return *(f+1); }
|
||||
constexpr const Data_t& front() const noexcept { return *(f+1); }
|
||||
constexpr Data_t& front() noexcept { iterator_t it = f; return *++it; }
|
||||
constexpr const Data_t& front() const noexcept { iterator_t it = f; return *++it; }
|
||||
|
||||
//! \brief Get a reference to the item in the front of the deque without extracting it.
|
||||
//! \return Reference to the item
|
||||
constexpr Data_t& back() noexcept { return *(r-1); }
|
||||
constexpr const Data_t& back() const noexcept { return *(r-1); }
|
||||
constexpr Data_t& back() noexcept { iterator_t it = r; return *--it; }
|
||||
constexpr const Data_t& back() const noexcept { iterator_t it = r; return *--it; }
|
||||
|
||||
//! \brief Get a pointer to the begin of the items on the deque
|
||||
//! \return
|
||||
constexpr Data_t* data() noexcept { return &front(); }
|
||||
constexpr const Data_t* data() const noexcept { return &front(); }
|
||||
|
||||
//! \brief Get a range for the data in queue
|
||||
//! \return A begin-end iterator pair struct
|
||||
constexpr range_t contents () noexcept { iterator_t b = f; return {++b, r}; }
|
||||
constexpr const range_t contents () const noexcept { iterator_t b = f; return {++b, r}; }
|
||||
|
||||
//! @}
|
||||
private:
|
||||
|
||||
@@ -0,0 +1,64 @@
|
||||
/*!
|
||||
* \file cont/range.h
|
||||
* \brief
|
||||
* A plain definition of a range struct with agregate initialization
|
||||
* and begin-end pairs.
|
||||
*
|
||||
* \copyright Copyright (C) 2021 Christos Choutouridis <christos@choutouridis.net>
|
||||
*
|
||||
* <dl class=\"section copyright\"><dt>License</dt><dd>
|
||||
* The MIT License (MIT)
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
* SOFTWARE.
|
||||
* </dd></dl>
|
||||
*/
|
||||
|
||||
#ifndef TBX_CONT_RANGE_H_
|
||||
#define TBX_CONT_RANGE_H_
|
||||
|
||||
#include <core/core.h>
|
||||
|
||||
namespace tbx {
|
||||
|
||||
/*!
|
||||
* \brief
|
||||
* A plain definition of a range struct with begin-end pairs.
|
||||
*
|
||||
* \tparam Iter_t The iterator type of the range
|
||||
*/
|
||||
template <typename Iter_t>
|
||||
struct range {
|
||||
Iter_t b{}, e{};
|
||||
|
||||
// range () = default;
|
||||
// range (const Iter_t& first, const Iter_t& last) noexcept :
|
||||
// b(first), e(last) { }
|
||||
// range (Iter_t first, Iter_t last) noexcept :
|
||||
// b(first), e(last) { }
|
||||
|
||||
Iter_t begin() { return b; }
|
||||
const Iter_t begin() const { return b; }
|
||||
const Iter_t cbegin() const { return b; }
|
||||
Iter_t end() { return e; }
|
||||
const Iter_t end() const { return e; }
|
||||
const Iter_t cend() const { return e; }
|
||||
};
|
||||
|
||||
}
|
||||
#endif /* TBX_CONT_RANGE_H_ */
|
||||
@@ -0,0 +1,607 @@
|
||||
/*
|
||||
* This is an implementation of C++20's std::span
|
||||
* http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/n4820.pdf
|
||||
*/
|
||||
|
||||
// Copyright Tristan Brindle 2018.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// https://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
#ifndef TBX_CONT_SPAN_H_
|
||||
#define TBX_CONT_SPAN_H_
|
||||
|
||||
#include <array>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <type_traits>
|
||||
|
||||
#ifndef TBX_SPAN_NO_EXCEPTIONS
|
||||
// Attempt to discover whether we're being compiled with exception support
|
||||
#if !(defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND))
|
||||
#define TBX_SPAN_NO_EXCEPTIONS
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef TBX_SPAN_NO_EXCEPTIONS
|
||||
#include <cstdio>
|
||||
#include <stdexcept>
|
||||
#endif
|
||||
|
||||
// Various feature test macros
|
||||
|
||||
#if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
|
||||
#define TBX_SPAN_HAVE_CPP17
|
||||
#endif
|
||||
|
||||
#if __cplusplus >= 201402L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
|
||||
#define TBX_SPAN_HAVE_CPP14
|
||||
#endif
|
||||
|
||||
namespace tbx {
|
||||
|
||||
// Establish default contract checking behavior
|
||||
#if !defined(TBX_SPAN_THROW_ON_CONTRACT_VIOLATION) && \
|
||||
!defined(TBX_SPAN_TERMINATE_ON_CONTRACT_VIOLATION) && \
|
||||
!defined(TBX_SPAN_NO_CONTRACT_CHECKING)
|
||||
#if defined(NDEBUG) || !defined(TBX_SPAN_HAVE_CPP14)
|
||||
#define TBX_SPAN_NO_CONTRACT_CHECKING
|
||||
#else
|
||||
#define TBX_SPAN_TERMINATE_ON_CONTRACT_VIOLATION
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(TBX_SPAN_THROW_ON_CONTRACT_VIOLATION)
|
||||
struct contract_violation_error : std::logic_error {
|
||||
explicit contract_violation_error(const char* msg) : std::logic_error(msg)
|
||||
{}
|
||||
};
|
||||
|
||||
inline void contract_violation(const char* msg)
|
||||
{
|
||||
throw contract_violation_error(msg);
|
||||
}
|
||||
|
||||
#elif defined(TBX_SPAN_TERMINATE_ON_CONTRACT_VIOLATION)
|
||||
[[noreturn]] inline void contract_violation(const char* /*unused*/)
|
||||
{
|
||||
std::terminate();
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !defined(TBX_SPAN_NO_CONTRACT_CHECKING)
|
||||
#define TBX_SPAN_STRINGIFY(cond) #cond
|
||||
#define TBX_SPAN_EXPECT(cond) \
|
||||
cond ? (void) 0 : contract_violation("Expected " TBX_SPAN_STRINGIFY(cond))
|
||||
#else
|
||||
#define TBX_SPAN_EXPECT(cond)
|
||||
#endif
|
||||
|
||||
#if defined(TBX_SPAN_HAVE_CPP17) || defined(__cpp_inline_variables)
|
||||
#define TBX_SPAN_INLINE_VAR inline
|
||||
#else
|
||||
#define TBX_SPAN_INLINE_VAR
|
||||
#endif
|
||||
|
||||
#if defined(TBX_SPAN_HAVE_CPP14) || \
|
||||
(defined(__cpp_constexpr) && __cpp_constexpr >= 201304)
|
||||
#define TBX_SPAN_HAVE_CPP14_CONSTEXPR
|
||||
#endif
|
||||
|
||||
#if defined(TBX_SPAN_HAVE_CPP14_CONSTEXPR)
|
||||
#define TBX_SPAN_CONSTEXPR14 constexpr
|
||||
#else
|
||||
#define TBX_SPAN_CONSTEXPR14
|
||||
#endif
|
||||
|
||||
#if defined(TBX_SPAN_HAVE_CPP14_CONSTEXPR) && \
|
||||
(!defined(_MSC_VER) || _MSC_VER > 1900)
|
||||
#define TBX_SPAN_CONSTEXPR_ASSIGN constexpr
|
||||
#else
|
||||
#define TBX_SPAN_CONSTEXPR_ASSIGN
|
||||
#endif
|
||||
|
||||
#if defined(TBX_SPAN_NO_CONTRACT_CHECKING)
|
||||
#define TBX_SPAN_CONSTEXPR11 constexpr
|
||||
#else
|
||||
#define TBX_SPAN_CONSTEXPR11 TBX_SPAN_CONSTEXPR14
|
||||
#endif
|
||||
|
||||
#if defined(TBX_SPAN_HAVE_CPP17) || defined(__cpp_deduction_guides)
|
||||
#define TBX_SPAN_HAVE_DEDUCTION_GUIDES
|
||||
#endif
|
||||
|
||||
#if defined(TBX_SPAN_HAVE_CPP17) || defined(__cpp_lib_byte)
|
||||
#define TBX_SPAN_HAVE_STD_BYTE
|
||||
#endif
|
||||
|
||||
#if defined(TBX_SPAN_HAVE_CPP17) || defined(__cpp_lib_array_constexpr)
|
||||
#define TBX_SPAN_HAVE_CONSTEXPR_STD_ARRAY_ETC
|
||||
#endif
|
||||
|
||||
#if defined(TBX_SPAN_HAVE_CONSTEXPR_STD_ARRAY_ETC)
|
||||
#define TBX_SPAN_ARRAY_CONSTEXPR constexpr
|
||||
#else
|
||||
#define TBX_SPAN_ARRAY_CONSTEXPR
|
||||
#endif
|
||||
|
||||
#ifdef TBX_SPAN_HAVE_STD_BYTE
|
||||
using byte = std::byte;
|
||||
#else
|
||||
using byte = unsigned char;
|
||||
#endif
|
||||
|
||||
#if defined(TBX_SPAN_HAVE_CPP17)
|
||||
#define TBX_SPAN_NODISCARD [[nodiscard]]
|
||||
#else
|
||||
#define TBX_SPAN_NODISCARD
|
||||
#endif
|
||||
|
||||
TBX_SPAN_INLINE_VAR constexpr std::size_t dynamic_extent = SIZE_MAX;
|
||||
|
||||
template <typename ElementType, std::size_t Extent = dynamic_extent>
|
||||
class span;
|
||||
|
||||
namespace detail {
|
||||
|
||||
template <typename E, std::size_t S>
|
||||
struct span_storage {
|
||||
constexpr span_storage() noexcept = default;
|
||||
|
||||
constexpr span_storage(E* p_ptr, std::size_t /*unused*/) noexcept
|
||||
: ptr(p_ptr)
|
||||
{}
|
||||
|
||||
E* ptr = nullptr;
|
||||
static constexpr std::size_t size = S;
|
||||
};
|
||||
|
||||
template <typename E>
|
||||
struct span_storage<E, dynamic_extent> {
|
||||
constexpr span_storage() noexcept = default;
|
||||
|
||||
constexpr span_storage(E* p_ptr, std::size_t p_size) noexcept
|
||||
: ptr(p_ptr), size(p_size)
|
||||
{}
|
||||
|
||||
E* ptr = nullptr;
|
||||
std::size_t size = 0;
|
||||
};
|
||||
|
||||
// Reimplementation of C++17 std::size() and std::data()
|
||||
#if defined(TBX_SPAN_HAVE_CPP17) || \
|
||||
defined(__cpp_lib_nonmember_container_access)
|
||||
using std::data;
|
||||
using std::size;
|
||||
#else
|
||||
template <class C>
|
||||
constexpr auto size(const C& c) -> decltype(c.size())
|
||||
{
|
||||
return c.size();
|
||||
}
|
||||
|
||||
template <class T, std::size_t N>
|
||||
constexpr std::size_t size(const T (&)[N]) noexcept
|
||||
{
|
||||
return N;
|
||||
}
|
||||
|
||||
template <class C>
|
||||
constexpr auto data(C& c) -> decltype(c.data())
|
||||
{
|
||||
return c.data();
|
||||
}
|
||||
|
||||
template <class C>
|
||||
constexpr auto data(const C& c) -> decltype(c.data())
|
||||
{
|
||||
return c.data();
|
||||
}
|
||||
|
||||
template <class T, std::size_t N>
|
||||
constexpr T* data(T (&array)[N]) noexcept
|
||||
{
|
||||
return array;
|
||||
}
|
||||
|
||||
template <class E>
|
||||
constexpr const E* data(std::initializer_list<E> il) noexcept
|
||||
{
|
||||
return il.begin();
|
||||
}
|
||||
#endif // TBX_SPAN_HAVE_CPP17
|
||||
|
||||
#if defined(TBX_SPAN_HAVE_CPP17) || defined(__cpp_lib_void_t)
|
||||
using std::void_t;
|
||||
#else
|
||||
template <typename...>
|
||||
using void_t = void;
|
||||
#endif
|
||||
|
||||
template <typename T>
|
||||
using uncvref_t =
|
||||
typename std::remove_cv<typename std::remove_reference<T>::type>::type;
|
||||
|
||||
template <typename>
|
||||
struct is_span : std::false_type {};
|
||||
|
||||
template <typename T, std::size_t S>
|
||||
struct is_span<span<T, S>> : std::true_type {};
|
||||
|
||||
template <typename>
|
||||
struct is_std_array : std::false_type {};
|
||||
|
||||
template <typename T, std::size_t N>
|
||||
struct is_std_array<std::array<T, N>> : std::true_type {};
|
||||
|
||||
template <typename, typename = void>
|
||||
struct has_size_and_data : std::false_type {};
|
||||
|
||||
template <typename T>
|
||||
struct has_size_and_data<T, void_t<decltype(detail::size(std::declval<T>())),
|
||||
decltype(detail::data(std::declval<T>()))>>
|
||||
: std::true_type {};
|
||||
|
||||
template <typename C, typename U = uncvref_t<C>>
|
||||
struct is_container {
|
||||
static constexpr bool value =
|
||||
!is_span<U>::value && !is_std_array<U>::value &&
|
||||
!std::is_array<U>::value && has_size_and_data<C>::value;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
using remove_pointer_t = typename std::remove_pointer<T>::type;
|
||||
|
||||
template <typename, typename, typename = void>
|
||||
struct is_container_element_type_compatible : std::false_type {};
|
||||
|
||||
template <typename T, typename E>
|
||||
struct is_container_element_type_compatible<
|
||||
T, E,
|
||||
typename std::enable_if<
|
||||
!std::is_same<typename std::remove_cv<decltype(
|
||||
detail::data(std::declval<T>()))>::type,
|
||||
void>::value>::type>
|
||||
: std::is_convertible<
|
||||
remove_pointer_t<decltype(detail::data(std::declval<T>()))> (*)[],
|
||||
E (*)[]> {};
|
||||
|
||||
template <typename, typename = size_t>
|
||||
struct is_complete : std::false_type {};
|
||||
|
||||
template <typename T>
|
||||
struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template <typename ElementType, std::size_t Extent>
|
||||
class span {
|
||||
static_assert(std::is_object<ElementType>::value,
|
||||
"A span's ElementType must be an object type (not a "
|
||||
"reference type or void)");
|
||||
static_assert(detail::is_complete<ElementType>::value,
|
||||
"A span's ElementType must be a complete type (not a forward "
|
||||
"declaration)");
|
||||
static_assert(!std::is_abstract<ElementType>::value,
|
||||
"A span's ElementType cannot be an abstract class type");
|
||||
|
||||
using storage_type = detail::span_storage<ElementType, Extent>;
|
||||
|
||||
public:
|
||||
// constants and types
|
||||
using element_type = ElementType;
|
||||
using value_type = typename std::remove_cv<ElementType>::type;
|
||||
using size_type = std::size_t;
|
||||
using difference_type = std::ptrdiff_t;
|
||||
using pointer = element_type*;
|
||||
using const_pointer = const element_type*;
|
||||
using reference = element_type&;
|
||||
using const_reference = const element_type&;
|
||||
using iterator = pointer;
|
||||
using reverse_iterator = std::reverse_iterator<iterator>;
|
||||
|
||||
static constexpr size_type extent = Extent;
|
||||
|
||||
// [span.cons], span constructors, copy, assignment, and destructor
|
||||
template <
|
||||
std::size_t E = Extent,
|
||||
typename std::enable_if<(E == dynamic_extent || E <= 0), int>::type = 0>
|
||||
constexpr span() noexcept
|
||||
{}
|
||||
|
||||
TBX_SPAN_CONSTEXPR11 span(pointer ptr, size_type count)
|
||||
: storage_(ptr, count)
|
||||
{
|
||||
TBX_SPAN_EXPECT(extent == dynamic_extent || count == extent);
|
||||
}
|
||||
|
||||
TBX_SPAN_CONSTEXPR11 span(pointer first_elem, pointer last_elem)
|
||||
: storage_(first_elem, last_elem - first_elem)
|
||||
{
|
||||
TBX_SPAN_EXPECT(extent == dynamic_extent ||
|
||||
last_elem - first_elem ==
|
||||
static_cast<std::ptrdiff_t>(extent));
|
||||
}
|
||||
|
||||
template <std::size_t N, std::size_t E = Extent,
|
||||
typename std::enable_if<
|
||||
(E == dynamic_extent || N == E) &&
|
||||
detail::is_container_element_type_compatible<
|
||||
element_type (&)[N], ElementType>::value,
|
||||
int>::type = 0>
|
||||
constexpr span(element_type (&arr)[N]) noexcept : storage_(arr, N)
|
||||
{}
|
||||
|
||||
template <std::size_t N, std::size_t E = Extent,
|
||||
typename std::enable_if<
|
||||
(E == dynamic_extent || N == E) &&
|
||||
detail::is_container_element_type_compatible<
|
||||
std::array<value_type, N>&, ElementType>::value,
|
||||
int>::type = 0>
|
||||
TBX_SPAN_ARRAY_CONSTEXPR span(std::array<value_type, N>& arr) noexcept
|
||||
: storage_(arr.data(), N)
|
||||
{}
|
||||
|
||||
template <std::size_t N, std::size_t E = Extent,
|
||||
typename std::enable_if<
|
||||
(E == dynamic_extent || N == E) &&
|
||||
detail::is_container_element_type_compatible<
|
||||
const std::array<value_type, N>&, ElementType>::value,
|
||||
int>::type = 0>
|
||||
TBX_SPAN_ARRAY_CONSTEXPR span(const std::array<value_type, N>& arr) noexcept
|
||||
: storage_(arr.data(), N)
|
||||
{}
|
||||
|
||||
template <
|
||||
typename Container, std::size_t E = Extent,
|
||||
typename std::enable_if<
|
||||
E == dynamic_extent && detail::is_container<Container>::value &&
|
||||
detail::is_container_element_type_compatible<
|
||||
Container&, ElementType>::value,
|
||||
int>::type = 0>
|
||||
constexpr span(Container& cont)
|
||||
// : storage_(detail::data(cont), detail::size(cont))
|
||||
: storage_(cont.data(), cont.size())
|
||||
{}
|
||||
|
||||
template <
|
||||
typename Container, std::size_t E = Extent,
|
||||
typename std::enable_if<
|
||||
E == dynamic_extent && detail::is_container<Container>::value &&
|
||||
detail::is_container_element_type_compatible<
|
||||
const Container&, ElementType>::value,
|
||||
int>::type = 0>
|
||||
constexpr span(const Container& cont)
|
||||
: storage_(detail::data(cont), detail::size(cont))
|
||||
{}
|
||||
|
||||
constexpr span(const span& other) noexcept = default;
|
||||
|
||||
template <typename OtherElementType, std::size_t OtherExtent,
|
||||
typename std::enable_if<
|
||||
(Extent == OtherExtent || Extent == dynamic_extent) &&
|
||||
std::is_convertible<OtherElementType (*)[],
|
||||
ElementType (*)[]>::value,
|
||||
int>::type = 0>
|
||||
constexpr span(const span<OtherElementType, OtherExtent>& other) noexcept
|
||||
: storage_(other.data(), other.size())
|
||||
{}
|
||||
|
||||
~span() noexcept = default;
|
||||
|
||||
TBX_SPAN_CONSTEXPR_ASSIGN span&
|
||||
operator=(const span& other) noexcept = default;
|
||||
|
||||
// [span.sub], span subviews
|
||||
template <std::size_t Count>
|
||||
TBX_SPAN_CONSTEXPR11 span<element_type, Count> first() const
|
||||
{
|
||||
TBX_SPAN_EXPECT(Count <= size());
|
||||
return {data(), Count};
|
||||
}
|
||||
|
||||
template <std::size_t Count>
|
||||
TBX_SPAN_CONSTEXPR11 span<element_type, Count> last() const
|
||||
{
|
||||
TBX_SPAN_EXPECT(Count <= size());
|
||||
return {data() + (size() - Count), Count};
|
||||
}
|
||||
|
||||
template <std::size_t Offset, std::size_t Count = dynamic_extent>
|
||||
using subspan_return_t =
|
||||
span<ElementType, Count != dynamic_extent
|
||||
? Count
|
||||
: (Extent != dynamic_extent ? Extent - Offset
|
||||
: dynamic_extent)>;
|
||||
|
||||
template <std::size_t Offset, std::size_t Count = dynamic_extent>
|
||||
TBX_SPAN_CONSTEXPR11 subspan_return_t<Offset, Count> subspan() const
|
||||
{
|
||||
TBX_SPAN_EXPECT(Offset <= size() &&
|
||||
(Count == dynamic_extent || Offset + Count <= size()));
|
||||
return {data() + Offset,
|
||||
Count != dynamic_extent ? Count : size() - Offset};
|
||||
}
|
||||
|
||||
TBX_SPAN_CONSTEXPR11 span<element_type, dynamic_extent>
|
||||
first(size_type count) const
|
||||
{
|
||||
TBX_SPAN_EXPECT(count <= size());
|
||||
return {data(), count};
|
||||
}
|
||||
|
||||
TBX_SPAN_CONSTEXPR11 span<element_type, dynamic_extent>
|
||||
last(size_type count) const
|
||||
{
|
||||
TBX_SPAN_EXPECT(count <= size());
|
||||
return {data() + (size() - count), count};
|
||||
}
|
||||
|
||||
TBX_SPAN_CONSTEXPR11 span<element_type, dynamic_extent>
|
||||
subspan(size_type offset, size_type count = dynamic_extent) const
|
||||
{
|
||||
TBX_SPAN_EXPECT(offset <= size() &&
|
||||
(count == dynamic_extent || offset + count <= size()));
|
||||
return {data() + offset,
|
||||
count == dynamic_extent ? size() - offset : count};
|
||||
}
|
||||
|
||||
// [span.obs], span observers
|
||||
constexpr size_type size() const noexcept { return storage_.size; }
|
||||
|
||||
constexpr size_type size_bytes() const noexcept
|
||||
{
|
||||
return size() * sizeof(element_type);
|
||||
}
|
||||
|
||||
TBX_SPAN_NODISCARD constexpr bool empty() const noexcept
|
||||
{
|
||||
return size() == 0;
|
||||
}
|
||||
|
||||
// [span.elem], span element access
|
||||
TBX_SPAN_CONSTEXPR11 reference operator[](size_type idx) const
|
||||
{
|
||||
TBX_SPAN_EXPECT(idx < size());
|
||||
return *(data() + idx);
|
||||
}
|
||||
|
||||
TBX_SPAN_CONSTEXPR11 reference front() const
|
||||
{
|
||||
TBX_SPAN_EXPECT(!empty());
|
||||
return *data();
|
||||
}
|
||||
|
||||
TBX_SPAN_CONSTEXPR11 reference back() const
|
||||
{
|
||||
TBX_SPAN_EXPECT(!empty());
|
||||
return *(data() + (size() - 1));
|
||||
}
|
||||
|
||||
constexpr pointer data() const noexcept { return storage_.ptr; }
|
||||
|
||||
// [span.iterators], span iterator support
|
||||
constexpr iterator begin() const noexcept { return data(); }
|
||||
|
||||
constexpr iterator end() const noexcept { return data() + size(); }
|
||||
|
||||
TBX_SPAN_ARRAY_CONSTEXPR reverse_iterator rbegin() const noexcept
|
||||
{
|
||||
return reverse_iterator(end());
|
||||
}
|
||||
|
||||
TBX_SPAN_ARRAY_CONSTEXPR reverse_iterator rend() const noexcept
|
||||
{
|
||||
return reverse_iterator(begin());
|
||||
}
|
||||
|
||||
private:
|
||||
storage_type storage_{};
|
||||
};
|
||||
|
||||
#ifdef TBX_SPAN_HAVE_DEDUCTION_GUIDES
|
||||
|
||||
/* Deduction Guides */
|
||||
template <class T, size_t N>
|
||||
span(T (&)[N])->span<T, N>;
|
||||
|
||||
template <class T, size_t N>
|
||||
span(std::array<T, N>&)->span<T, N>;
|
||||
|
||||
template <class T, size_t N>
|
||||
span(const std::array<T, N>&)->span<const T, N>;
|
||||
|
||||
template <class Container>
|
||||
span(Container&)->span<typename Container::value_type>;
|
||||
|
||||
template <class Container>
|
||||
span(const Container&)->span<const typename Container::value_type>;
|
||||
|
||||
#endif // TCB_HAVE_DEDUCTION_GUIDES
|
||||
|
||||
template <typename ElementType, std::size_t Extent>
|
||||
constexpr span<ElementType, Extent>
|
||||
make_span(span<ElementType, Extent> s) noexcept
|
||||
{
|
||||
return s;
|
||||
}
|
||||
|
||||
template <typename T, std::size_t N>
|
||||
constexpr span<T, N> make_span(T (&arr)[N]) noexcept
|
||||
{
|
||||
return {arr};
|
||||
}
|
||||
|
||||
template <typename T, std::size_t N>
|
||||
TBX_SPAN_ARRAY_CONSTEXPR span<T, N> make_span(std::array<T, N>& arr) noexcept
|
||||
{
|
||||
return {arr};
|
||||
}
|
||||
|
||||
template <typename T, std::size_t N>
|
||||
TBX_SPAN_ARRAY_CONSTEXPR span<const T, N>
|
||||
make_span(const std::array<T, N>& arr) noexcept
|
||||
{
|
||||
return {arr};
|
||||
}
|
||||
|
||||
template <typename Container>
|
||||
constexpr span<typename Container::value_type> make_span(Container& cont)
|
||||
{
|
||||
return {cont};
|
||||
}
|
||||
|
||||
template <typename Container>
|
||||
constexpr span<const typename Container::value_type>
|
||||
make_span(const Container& cont)
|
||||
{
|
||||
return {cont};
|
||||
}
|
||||
|
||||
template <typename ElementType, std::size_t Extent>
|
||||
span<const byte, ((Extent == dynamic_extent) ? dynamic_extent
|
||||
: sizeof(ElementType) * Extent)>
|
||||
as_bytes(span<ElementType, Extent> s) noexcept
|
||||
{
|
||||
return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
|
||||
}
|
||||
|
||||
template <
|
||||
class ElementType, size_t Extent,
|
||||
typename std::enable_if<!std::is_const<ElementType>::value, int>::type = 0>
|
||||
span<byte, ((Extent == dynamic_extent) ? dynamic_extent
|
||||
: sizeof(ElementType) * Extent)>
|
||||
as_writable_bytes(span<ElementType, Extent> s) noexcept
|
||||
{
|
||||
return {reinterpret_cast<byte*>(s.data()), s.size_bytes()};
|
||||
}
|
||||
|
||||
template <std::size_t N, typename E, std::size_t S>
|
||||
constexpr auto get(span<E, S> s) -> decltype(s[N])
|
||||
{
|
||||
return s[N];
|
||||
}
|
||||
|
||||
} // namespace tbx
|
||||
|
||||
namespace std {
|
||||
|
||||
template <typename ElementType, size_t Extent>
|
||||
class tuple_size<tbx::span<ElementType, Extent>>
|
||||
: public integral_constant<size_t, Extent> {};
|
||||
|
||||
template <typename ElementType>
|
||||
class tuple_size<tbx::span<
|
||||
ElementType, tbx::dynamic_extent>>; // not defined
|
||||
|
||||
template <size_t I, typename ElementType, size_t Extent>
|
||||
class tuple_element<I, tbx::span<ElementType, Extent>> {
|
||||
public:
|
||||
static_assert(Extent != tbx::dynamic_extent &&
|
||||
I < Extent,
|
||||
"");
|
||||
using type = ElementType;
|
||||
};
|
||||
|
||||
} // end namespace std
|
||||
|
||||
#endif // TBX_CONT_SPAN_H_
|
||||
Reference in New Issue
Block a user