Span.h

Go to the documentation of this file.

// (c) IMT - Information Management Technology AG, CH-9470 Buchs, www.imt.ch.
 
#ifndef IMT_BASE_CORE_UTIL_SPAN_H
#define IMT_BASE_CORE_UTIL_SPAN_H
 
// AXIVION FILE Style AutosarC++19_03-A2.11.1: allow volatile ElementType then e.g. DMA-buffers can be volatile
 
#include <algorithm>
#include <array>
#include <cstddef>
#include <type_traits>
 
namespace imt {
namespace base {
namespace core {
namespace util {
 
template<typename ElementType>
class Span final {
 
public:
 
    using SpanElementType = ElementType;
 
    constexpr Span() noexcept :
        Span {nullptr, 0U} {
    }
 
    constexpr Span(ElementType* const pFirstElement, size_t const elementCount) noexcept :
        m_pFirstElement {pFirstElement},
        m_elementCount {elementCount} {
    }
 
    constexpr Span(ElementType& firstElement, size_t const elementCount) noexcept :
        Span {&firstElement, elementCount} {
    }
 
    template<typename ArrayElementType, size_t ArraySize, typename = std::enable_if_t<std::is_convertible<ArrayElementType (*)[], ElementType (*)[]>::value>> // AXIVION Line AutosarC++19_03-A18.1.1: is not using C-style array but a conversion check
    constexpr Span(std::array<ArrayElementType, ArraySize>& array) noexcept :
        Span {array.data(), array.size()} {
    }
 
    template<typename ArrayElementType, size_t ArraySize, typename = std::enable_if_t<std::is_convertible<ArrayElementType const (*)[], ElementType (*)[]>::value>> // AXIVION Line AutosarC++19_03-A18.1.1: is not using C-style array but a conversion check
    constexpr Span(std::array<ArrayElementType, ArraySize> const& array) noexcept :
        Span {array.data(), array.size()} {
    }
 
    template<typename ArrayElementType, size_t ArraySize, typename = std::enable_if_t<std::is_convertible<ArrayElementType (*)[], ElementType (*)[]>::value>> // AXIVION Line AutosarC++19_03-A18.1.1: is not using C-style array but a conversion check
    constexpr Span(std::array<ArrayElementType, ArraySize>& array, size_t const elementCount) noexcept :
        Span {array.data(), std::min(elementCount, array.size())} {
    }
 
    template<typename ArrayElementType, size_t ArraySize, typename = std::enable_if_t<std::is_convertible<ArrayElementType const (*)[], ElementType (*)[]>::value>> // AXIVION Line AutosarC++19_03-A18.1.1: is not using C-style array but a conversion check
    constexpr Span(std::array<ArrayElementType, ArraySize> const& array, size_t const elementCount) noexcept :
        Span {array.data(), std::min(elementCount, array.size())} {
    }
 
    template<typename OtherElementType, typename = std::enable_if_t<std::is_convertible<OtherElementType (*)[], ElementType (*)[]>::value>> // AXIVION Line AutosarC++19_03-A18.1.1: is not using C-style array but a conversion check
    constexpr Span(Span<OtherElementType> const& other) noexcept :
        Span {other.data(), other.size()} {
    }
 
    constexpr ElementType* data() const noexcept {
        return m_pFirstElement; // AXIVION Line AutosarC++19_03-M9.3.1: (Returning non-const pointer to class data) see std::span and also UnitTest testSpan_validationAxivionSuppressionForMemberFuncData
    }
 
    ElementType* begin() noexcept {
        return m_pFirstElement;
    }
 
    ElementType* end() noexcept {
        return m_pFirstElement + m_elementCount; // AXIVION Line AutosarC++19_03-M5.0.15: Pointer arithmetic required
    }
 
    ElementType const* cbegin() const noexcept {
        return m_pFirstElement;
    }
 
    ElementType const* cend() const noexcept {
        return m_pFirstElement + m_elementCount; // AXIVION Line AutosarC++19_03-M5.0.15: Pointer arithmetic required
    }
 
    constexpr size_t size() const noexcept {
        return m_elementCount;
    }
 
    constexpr ElementType& operator[](size_t const idx) const noexcept {
        return *(m_pFirstElement + idx); // AXIVION Line AutosarC++19_03-M5.0.15: Pointer arithmetic required
    }
 
    constexpr bool empty() const noexcept {
        return m_elementCount == 0U;
    }
 
private:
 
    ElementType* m_pFirstElement; // AXIVION Line AutosarC++19_03-M0.1.4: false positive, is not only reference once
    size_t m_elementCount;        // AXIVION Line AutosarC++19_03-M0.1.4: false positive, is not only reference once
};
 
// AXIVION Next Line AutosarC++19_03-A16.0.1: required to support projects who want to use the C++17 feature template argument deduction
#if __cplusplus >= 201703L
// provide class template argument deduction guide
template<typename ElementType, size_t ArraySize>
Span(std::array<ElementType, ArraySize>&) -> Span<ElementType>;
 
template<typename ElementType, size_t ArraySize>
Span(std::array<ElementType, ArraySize> const&) -> Span<ElementType const>;
 
template<typename ArrayElementType, size_t ArraySize>
Span(std::array<ArrayElementType, ArraySize>& array, size_t const elementCount) -> Span<ArrayElementType>;
 
template<typename ArrayElementType, size_t ArraySize>
Span(std::array<ArrayElementType, ArraySize> const& array, size_t const elementCount) -> Span<ArrayElementType const>;
#endif
 
} // namespace util
} // namespace core
} // namespace base
} // namespace imt
 
#endif // IMT_BASE_CORE_UTIL_SPAN_H