Span.h

#pragma once

#include <cassert>
#include <type_traits>

namespace fsdk {

    template <class T>
    class Span {
        T* data_ = nullptr;
        std::size_t size_ = 0;

    public:
        /* @brief The type of value, including cv qualifiers
         */
        using element_type = T;

        /* @brief The type of value of each span element
         */
        using value_type = typename std::remove_const<T>::type;

        /* @brief The type of integer used to index the span
         */
        using index_type = std::ptrdiff_t;

        /* @brief A pointer to a span element
         */
        using pointer = T*;

        /* @brief A reference to a span element
         */
        using reference = T&;

        /* @brief The iterator used by the container
         */
        using iterator = pointer;

        /* @brief The const pointer used by the container
         */
        using const_pointer = T const*;

        /* @brief The const reference used by the container
         */
        using const_reference = T const&;

        /* @brief The const iterator used by the container
         */
        using const_iterator = const_pointer;

        /* @brief Initializes the empty Span.
         */
        Span() = default;

        /* @brief Default copy constructor
         */
        Span(Span const&) = default;

        /* @brief Default assignment
         */
        Span& operator=(Span const&) = default;

        Span(T* data, std::size_t size)
            : data_(data)
            , size_(size) {
        }

        template <class ContiguousContainer>
        Span(ContiguousContainer&& container)
            : data_(container.data())
            , size_(container.size()) {
        }

        template <class ContiguousContainer>
        Span& operator=(ContiguousContainer&& container) {
            data_ = container.data();
            size_ = container.size();
            return *this;
        }

        reference operator[](std::size_t index) {
            assert(index < size_);
            return data_[index];
        }

        const_reference operator[](std::size_t index) const {
            assert(index < size_);
            return data_[index];
        }

        bool empty() const {
            return size_ == 0;
        }

        pointer data() const {
            return data_;
        }

        std::size_t size() const {
            return getSize();
        }

        std::size_t getSize() const {
            return size_;
        }

        void setSize(std::size_t size) {
            size_ = size;
        }

        iterator begin() {
            return data_;
        }

        const_iterator begin() const {
            return data_;
        }

        const_iterator cbegin() const {
            return data_;
        }

        iterator end() {
            return data_ + size_;
        }

        const_iterator end() const {
            return data_ + size_;
        }

        const_iterator cend() const {
            return data_ + size_;
        }
    };
} // namespace fsdk