Span.h

#pragma once

#include <type_traits>
#include <cassert>

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_;
        }
    };
}