span.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstddef>
#include <span>
#include <type_traits>
#include <promeki/namespace.h>
 
PROMEKI_NAMESPACE_BEGIN
 
// Forward declarations
template <typename T> class List;
template <typename T, size_t N> class Array;
 
template <typename T> class Span {
        public:
                using Iterator = typename std::span<T>::iterator;
 
                using ConstIterator = typename std::span<const T>::iterator;
 
                using RevIterator = typename std::span<T>::reverse_iterator;
 
                using ConstRevIterator = typename std::span<const T>::reverse_iterator;
 
                Span() = default;
 
                Span(T *ptr, size_t count) : d(ptr, count) {}
 
                Span(List<T> &list) : d(list.data(), list.size()) {}
 
                template <size_t N> Span(T (&arr)[N]) : d(arr, N) {}
 
                template <size_t N> Span(Array<T, N> &arr) : d(arr.data(), N) {}
 
                Span(const Span &other) = default;
 
                Span &operator=(const Span &other) = default;
 
                template <typename U, typename = std::enable_if_t<std::is_convertible_v<U (*)[], T (*)[]>>>
                Span(const Span<U> &other) : d(other.data(), other.size()) {}
 
                // -- Iterators --
 
                Iterator begin() noexcept { return d.begin(); }
 
                ConstIterator begin() const noexcept { return std::span<const T>(d.data(), d.size()).begin(); }
 
                Iterator end() noexcept { return d.end(); }
 
                ConstIterator end() const noexcept { return std::span<const T>(d.data(), d.size()).end(); }
 
                ConstIterator constBegin() const noexcept { return begin(); }
 
                ConstIterator constEnd() const noexcept { return end(); }
 
                RevIterator rbegin() noexcept { return d.rbegin(); }
 
                RevIterator revBegin() noexcept { return d.rbegin(); }
 
                RevIterator rend() noexcept { return d.rend(); }
 
                RevIterator revEnd() noexcept { return d.rend(); }
 
                ConstRevIterator crbegin() const noexcept { return std::span<const T>(d.data(), d.size()).rbegin(); }
 
                ConstRevIterator constRevBegin() const noexcept { return crbegin(); }
 
                ConstRevIterator crend() const noexcept { return std::span<const T>(d.data(), d.size()).rend(); }
 
                ConstRevIterator constRevEnd() const noexcept { return crend(); }
 
                // -- Access --
 
                T &operator[](size_t index) { return d[index]; }
 
                const T &operator[](size_t index) const { return d[index]; }
 
                T &front() { return d.front(); }
 
                const T &front() const { return d.front(); }
 
                T &back() { return d.back(); }
 
                const T &back() const { return d.back(); }
 
                T *data() noexcept { return d.data(); }
 
                const T *data() const noexcept { return d.data(); }
 
                // -- Capacity --
 
                bool isEmpty() const noexcept { return d.empty(); }
 
                size_t size() const noexcept { return d.size(); }
 
                size_t sizeBytes() const noexcept { return d.size_bytes(); }
 
                // -- Sub-views --
 
                Span subspan(size_t offset, size_t count) const { return Span(d.data() + offset, count); }
 
                Span first(size_t count) const { return Span(d.data(), count); }
 
                Span last(size_t count) const { return Span(d.data() + d.size() - count, count); }
 
                // -- Convenience --
 
                template <typename Func> void forEach(Func &&func) const {
                        for (size_t i = 0; i < d.size(); ++i) func(d[i]);
                        return;
                }
 
        private:
                std::span<T> d;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE