Span.h

Go to the documentation of this file.

//-
//*****************************************************************************
// Copyright (c) 2025 Autodesk, Inc. All rights reserved.
//
// These coded instructions, statements, and computer programs contain
// unpublished proprietary information written by Autodesk, Inc. and are
// protected by Federal copyright law. They may not be disclosed to third
// parties or copied or duplicated in any form, in whole or in part, without
// the prior written consent of Autodesk, Inc.
//*****************************************************************************
//+
 
 
#ifndef AMINO_CORE_SPAN_H
#define AMINO_CORE_SPAN_H
 
#include <cassert>
#include <cstddef>
#include <type_traits>
 
namespace Amino {
 
//==============================================================================
// CLASS Span
//==============================================================================
 
// LCOV_EXCL_BR_START
template <typename T>
class Span {
private:
    template <typename R>
    static inline constexpr bool is_span =
        std::is_same_v<std::remove_cv_t<std::remove_reference_t<R>>, Span<T>>;
 
public:
    /*----- types -----*/
 
    using element_type    = T;
    using value_type      = std::remove_cv_t<T>;
    using iterator        = T*;
    using const_iterator  = T const*;
    using size_type       = size_t;
    using difference_type = ptrdiff_t;
 
    /*----- member functions -----*/
 
    constexpr Span() noexcept = default;
 
    constexpr Span(T* data, size_type size)
        : m_begin{data}, m_end{internal_get_end(data, size)} {
        assert(data || size == 0);
    }
 
    constexpr Span(T* begin, T* end) : m_begin{begin}, m_end{end} {
        assert(begin <= end);
    }
 
    template <typename R, typename = std::enable_if_t<!is_span<R>>>
    constexpr explicit Span(R&& r)
        : m_begin{r.data()}, m_end{m_begin + r.size()} {}
 
    constexpr Span(std::nullptr_t, size_type) = delete;
    constexpr Span(T*, std::nullptr_t)        = delete;
    constexpr Span(std::nullptr_t, T*)        = delete;
 
    constexpr bool empty() const { return m_begin == m_end; }
 
    constexpr T const& operator[](size_type i) const {
        assert(i < size());
        return m_begin[i];
    }
    constexpr T& operator[](size_type i) {
        assert(i < size());
        return m_begin[i];
    }
 
    constexpr T const& front() const {
        assert(!empty());
        return *m_begin;
    }
    constexpr T& front() {
        assert(!empty());
        return *m_begin;
    }
 
    constexpr T const& back() const {
        assert(!empty());
        return *(m_end - 1);
    }
    constexpr T& back() {
        assert(!empty());
        return *(m_end - 1);
    }
 
    constexpr const_iterator cbegin() const { return m_begin; }
    constexpr const_iterator begin() const { return m_begin; }
    constexpr iterator       begin() { return m_begin; }
 
    constexpr const_iterator cend() const { return m_end; }
    constexpr const_iterator end() const { return m_end; }
    constexpr iterator       end() { return m_end; }
 
    constexpr T* data() const { return m_begin; }
 
    constexpr size_type size() const {
        return static_cast<size_type>(m_end - m_begin);
    }
 
private:
    constexpr static T* internal_get_end(T* data, size_type size) {
        if (data) // separate line for coverage
            return data + size;
        return nullptr;
    }
 
    /*----- data members -----*/
 
    T* m_begin{nullptr};
    T* m_end{nullptr};
};
// LCOV_EXCL_BR_STOP
 
template <typename T>
Span(T*, size_t) -> Span<T>;
template <typename T>
Span(T*, T*) -> Span<T>;
template <typename R>
Span(R&&) -> Span<std::remove_pointer_t<decltype(std::declval<R>().data())>>;
 
//==============================================================================
// CLASS SpanParam
//==============================================================================
 
template <typename T>
class SpanParam : public Span<T> {
private:
    template <typename R>
    static inline constexpr bool is_span_param =
        std::is_same_v<std::remove_cv_t<std::remove_reference_t<R>>, Span<T>>;
 
public:
    using Span<T>::Span;
 
    template <typename R, typename = std::enable_if_t<!is_span_param<R>>>
    // NOLINTNEXTLINE(google-explicit-constructor)
    /*implicit*/ constexpr SpanParam(R&& r) : Span<T>{r} {}
 
    // NOLINTNEXTLINE(google-explicit-constructor)
    /*implicit*/ constexpr SpanParam(Span<T> const& other) : Span<T>{other} {}
};
 
template <typename T>
SpanParam(T*, size_t) -> SpanParam<T>;
template <typename T>
SpanParam(T*, T*) -> SpanParam<T>;
template <typename R>
SpanParam(R&&)
    -> SpanParam<std::remove_pointer_t<decltype(std::declval<R>().data())>>;
 
} // namespace Amino
 
#endif