span.hpp

// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <vitrio/byte.hpp>
 
#include <array>
#include <cstddef>
#include <type_traits>
#include <vector>
 
namespace vitrio
{
 
template <typename T>
class span
{
public:
    using element_type = T;
    using value_type = typename std::remove_cv<T>::type;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using pointer = T*;
    using reference = T&;
    using iterator = T*;
 
    constexpr span() noexcept;
 
    constexpr span(pointer data, size_type size) noexcept;
 
    template <
        typename U,
        typename = typename std::enable_if<
            std::is_convertible<U (*)[], T (*)[]>::value
        >::type
    >
    constexpr span(const span<U> &other) noexcept;
 
    span(const span &other) = default;
    ~span() = default;
 
    span& operator=(const span &other) = default;
 
    constexpr pointer data() const noexcept;
 
    constexpr size_type size() const noexcept;
 
    constexpr bool empty() const noexcept;
 
    constexpr reference operator[](size_type index) const noexcept;
 
    constexpr reference front() const noexcept;
 
    constexpr reference back() const noexcept;
 
    constexpr iterator begin() const noexcept;
 
    constexpr iterator end() const noexcept;
 
private:
    pointer m_data;
    size_type m_size;
};
 
template <typename T>
constexpr span<T> make_span(T *data, std::size_t size) noexcept;
 
template <typename T>
span<T> make_span(std::vector<T> &values) noexcept;
 
template <typename T>
span<const T> make_span(const std::vector<T> &values) noexcept;
 
template <typename T, std::size_t N>
span<T> make_span(std::array<T, N> &values) noexcept;
 
template <typename T, std::size_t N>
span<const T> make_span(const std::array<T, N> &values) noexcept;
 
template <typename T>
span<byte> as_bytes(span<T> values) noexcept;
 
template <typename T>
span<const byte> as_bytes(span<const T> values) noexcept;
 
} // namespace vitrio
 
#include "span.inl"