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