Span.h

Go to the documentation of this file.

#ifndef ZSERIO_SPAN_H_INC
#define ZSERIO_SPAN_H_INC
 
#include <array>
#include <cstddef>
#include <iterator>
#include <limits>
#include <type_traits>
#include <vector>
 
#include "zserio/Types.h"
 
namespace zserio
{
 
constexpr size_t dynamic_extent = std::numeric_limits<size_t>::max();
 
namespace detail
{
 
template <typename T, size_t Extent>
struct SpanStorage
{
    SpanStorage() = default;
 
    SpanStorage(T* data, size_t) :
            m_data(data)
    {}
 
    T* m_data = nullptr;
    static constexpr size_t m_size = Extent;
};
 
template <typename T>
struct SpanStorage<T, dynamic_extent>
{
    SpanStorage() = default;
 
    SpanStorage(T* data, size_t size) :
            m_data(data),
            m_size(size)
    {}
 
    T* m_data = nullptr;
    size_t m_size = 0;
};
 
} // namespace detail
 
template <typename T, size_t Extent = dynamic_extent>
class Span
{
public:
    using element_type = T;
    using value_type = typename std::remove_cv<T>::type;
    using size_type = size_t;
    using difference_type = std::ptrdiff_t;
    using pointer = T*;
    using const_pointer = const T*;
    using reference = T&;
    using iterator = pointer;
    using const_iterator = const_pointer;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
    static constexpr size_type extent = Extent;
 
    template <size_type ext = Extent,
            typename std::enable_if<(ext == 0 || ext == dynamic_extent), int>::type = 0>
    constexpr Span() noexcept
    {}
 
    constexpr Span(pointer first_, size_type count) :
            m_storage(first_, count)
    {}
 
    constexpr Span(pointer first_, pointer last_) :
            m_storage(first_, static_cast<size_t>(last_ - first_))
    {}
 
    template <size_type N, size_type ext = Extent,
            typename std::enable_if<(ext == dynamic_extent || ext == N), int>::type = 0>
    constexpr Span(element_type (&arr)[N]) noexcept :
            m_storage(arr, N)
    {}
 
    template <typename U, size_type N, size_type ext = Extent,
            typename std::enable_if<(ext == dynamic_extent || ext == N) &&
                            std::is_convertible<U (*)[], T (*)[]>::value,
                    int>::type = 0>
    constexpr Span(std::array<U, N>& arr) noexcept :
            m_storage(arr.data(), arr.size())
    {}
 
    template <typename U, size_type N, size_type ext = Extent,
            typename std::enable_if<(ext == dynamic_extent || ext == N) &&
                            std::is_convertible<const U (*)[], T (*)[]>::value,
                    int>::type = 0>
    constexpr Span(const std::array<U, N>& arr) noexcept :
            m_storage(arr.data(), arr.size())
    {}
 
    template <typename U, typename ALLOC, size_type ext = Extent,
            typename std::enable_if<(ext == dynamic_extent) && std::is_convertible<U (*)[], T (*)[]>::value,
                    int>::type = 0>
    constexpr Span(std::vector<U, ALLOC>& vec) :
            m_storage(vec.data(), vec.size())
    {}
 
    template <typename U, typename ALLOC, size_type ext = Extent,
            typename std::enable_if<
                    (ext == dynamic_extent) && std::is_convertible<const U (*)[], T (*)[]>::value, int>::type =
                    0>
    constexpr Span(const std::vector<U, ALLOC>& vec) :
            m_storage(vec.data(), vec.size())
    {}
 
    template <typename U, size_type N,
            typename std::enable_if<(Extent == N || Extent == dynamic_extent) &&
                            std::is_convertible<U (*)[], T (*)[]>::value,
                    int>::type = 0>
    constexpr Span(const Span<U, N>& span) noexcept :
            m_storage(span.data(), span.size())
    {}
 
    ~Span() = default;
 
    Span(const Span& other) noexcept = default;
    Span& operator=(const Span& other) noexcept = default;
 
    Span(Span&& other) noexcept = default;
    Span& operator=(Span&& other) noexcept = default;
    constexpr iterator begin() const noexcept
    {
        return data();
    }
 
    constexpr iterator end() const noexcept
    {
        return data() + size();
    }
 
    constexpr reverse_iterator rbegin() const noexcept
    {
        return reverse_iterator(end());
    }
 
    constexpr reverse_iterator rend() const noexcept
    {
        return reverse_iterator(begin());
    }
 
    constexpr reference front() const
    {
        return data()[0];
    }
 
    constexpr reference back() const
    {
        return data()[size() - 1];
    }
 
    constexpr reference operator[](size_type idx) const
    {
        return data()[idx];
    }
 
    constexpr pointer data() const noexcept
    {
        return m_storage.m_data;
    }
 
    constexpr size_type size() const noexcept
    {
        return m_storage.m_size;
    }
 
    constexpr size_type size_bytes() const noexcept
    {
        return size() * sizeof(element_type);
    }
 
    constexpr bool empty() const noexcept
    {
        return size() == 0;
    }
 
    template <size_type Count>
    constexpr Span<element_type, Count> first() const
    {
        static_assert(Count <= Extent, "Requested number of characters out of range.");
        return Span<element_type, Count>(data(), Count);
    }
 
    constexpr Span<element_type, dynamic_extent> first(size_type Count) const
    {
        return Span<element_type, dynamic_extent>(data(), Count);
    }
 
    template <size_type Count>
    constexpr Span<element_type, Count> last() const
    {
        static_assert(Count <= Extent, "Requested number of characters out of range.");
        return Span<element_type, Count>(data() + (size() - Count), Count);
    }
 
    constexpr Span<element_type, dynamic_extent> last(size_type Count) const
    {
        return Span<element_type, dynamic_extent>(data() + (size() - Count), Count);
    }
 
    template <size_type Offset, size_type Count>
    using SubspanReturnType = Span<T,
            Count != dynamic_extent ? Count : (Extent != dynamic_extent ? Extent - Offset : dynamic_extent)>;
 
    template <size_type Offset, size_type Count = dynamic_extent,
            typename std::enable_if<Count == dynamic_extent, int>::type = 0>
    constexpr SubspanReturnType<Offset, Count> subspan() const
    {
        static_assert((Extent == dynamic_extent) || (Offset <= Extent),
                "Requested number of characters out of range.");
        return SubspanReturnType<Offset, Count>(data() + Offset, size() - Offset);
    }
 
    template <size_type Offset, size_type Count,
            typename std::enable_if<Count != dynamic_extent, int>::type = 0>
    constexpr SubspanReturnType<Offset, Count> subspan() const
    {
        static_assert((Extent == dynamic_extent) || (Offset <= Extent && Offset + Count <= Extent),
                "Requested number of characters out of range.");
        return SubspanReturnType<Offset, Count>(data() + Offset, Count);
    }
    constexpr Span<element_type, dynamic_extent> subspan(
            size_type Offset, size_type Count = dynamic_extent) const
    {
        return Span<element_type, dynamic_extent>(
                data() + Offset, Count == dynamic_extent ? size() - Offset : Count);
    }
 
private:
    detail::SpanStorage<T, Extent> m_storage;
};
 
} // namespace zserio
 
#endif // ZSERIO_SPAN_H_INC