span.h

Go to the documentation of this file.

// === span.h ==========================================================================================================
//                                               Sen Infrastructure
//                   Released under the Apache License v2.0 (SPDX-License-Identifier Apache-2.0).
//                                    See the LICENSE.txt file for more information.
//                   © Airbus SAS, Airbus Helicopters, and Airbus Defence and Space SAU/GmbH/SAS.
// =====================================================================================================================
 
#ifndef SEN_CORE_BASE_SPAN_H
#define SEN_CORE_BASE_SPAN_H
 
// sen
#include "sen/core/base/assert.h"
#include "sen/core/base/compiler_macros.h"
 
// std
#include <array>
#include <iterator>
#include <vector>
 
namespace sen
{


template <class T>
class Span
{
public:
  SEN_COPY_MOVE(Span)
 
public:
  using element_type = T;                                                // NOLINT
  using value_type = std::remove_cv_t<T>;                                // NOLINT
  using index_type = std::size_t;                                        // NOLINT
  using difference_type = ptrdiff_t;                                     // NOLINT
  using pointer = T*;                                                    // NOLINT
  using reference = T&;                                                  // NOLINT
  using iterator = T*;                                                   // NOLINT
  using const_iterator = const T*;                                       // NOLINT
  using reverse_iterator = std::reverse_iterator<iterator>;              // NOLINT
  using const_reverse_iterator = std::reverse_iterator<const_iterator>;  // NOLINT
 
public:  // defaulted members
  Span() noexcept = default;
  ~Span() noexcept = default;
 
public:  // constructors
  template <typename U, std::enable_if_t<std::is_convertible_v<U*, T*>, int> = 0>
  constexpr Span(const Span<U>& other) noexcept  // NOLINT(hicpp-explicit-conversions)
    : data_(other.data_), size_(other.size_)
  {
  }

  constexpr Span(pointer ptr, index_type count) noexcept: data_(ptr), size_(count) {}

  template <std::size_t n>  // NOLINTNEXTLINE(hicpp-explicit-conversions)
  constexpr Span(std::array<value_type, n>& array) noexcept: data_(array.data()), size_(array.size())
  {
  }

  template <std::size_t n>  // NOLINTNEXTLINE(hicpp-explicit-conversions)
  constexpr Span(const std::array<value_type, n>& array) noexcept: data_(array.data()), size_(array.size())
  {
  }

  template <typename U, std::size_t n, std::enable_if_t<std::is_convertible_v<U*, T*>, int> = 0>
  constexpr Span(std::array<U, n>& array) noexcept  // NOLINT(hicpp-explicit-conversions)
    : data_(array.data()), size_(array.size())
  {
  }

  template <typename U, std::size_t n, std::enable_if_t<std::is_convertible_v<U*, T*>, int> = 0>
  constexpr Span(const std::array<U, n>& array) noexcept  // NOLINT(hicpp-explicit-conversions)
    : data_(array.data()), size_(array.size())
  {
  }

  constexpr Span(std::vector<value_type>& vector) noexcept: data_(vector.data()), size_(vector.size()) {}

  constexpr Span(const std::vector<value_type>& vector) noexcept: data_(vector.data()), size_(vector.size()) {}

  template <typename U, std::enable_if_t<std::is_convertible_v<U*, T*>, int> = 0>
  constexpr Span(std::vector<U>& vector) noexcept  // NOLINT(hicpp-explicit-conversions)
    : data_(vector.data()), size_(vector.size())
  {
  }

  template <typename U, std::enable_if_t<std::is_convertible_v<U*, T*>, int> = 0>
  constexpr Span(const std::vector<U>& vector) noexcept  // NOLINT(hicpp-explicit-conversions)
    : data_(vector.data()), size_(vector.size())
  {
  }
 
public:  // subviews
  [[nodiscard]] Span first(index_type count) const noexcept;

  [[nodiscard]] Span last(index_type count) const noexcept;

  [[nodiscard]] Span subspan(index_type offset = 0) const noexcept;

  [[nodiscard]] Span subspan(index_type offset, index_type count) const noexcept;
 
public:  // observers
  [[nodiscard]] constexpr std::size_t size() const noexcept { return size_; }

  [[nodiscard]] constexpr bool empty() const noexcept { return size_ == 0; }
 
public:  // element access
  [[nodiscard]] reference operator[](index_type i) const noexcept;

  [[nodiscard]] constexpr pointer data() const noexcept { return data_; }
 
public:  // iterator support
  [[nodiscard]] constexpr iterator begin() const noexcept { return {data()}; }

  [[nodiscard]] constexpr iterator end() const noexcept { return {data() + size()}; }

  [[nodiscard]] constexpr const_iterator cbegin() const noexcept { return {data()}; }

  [[nodiscard]] constexpr const_iterator cend() const noexcept { return {data() + size()}; }
 
private:
  pointer data_ = nullptr;
  index_type size_ = 0U;
};
 
//--------------------------------------------------------------------------------------------------------------
// Comparison operators
//--------------------------------------------------------------------------------------------------------------
 
template <typename T>
[[nodiscard]] constexpr bool operator==(const Span<T>& lhs, const Span<T>& rhs) noexcept
{
  return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin());
}
 
template <typename T>
[[nodiscard]] constexpr bool operator!=(const Span<T>& lhs, const Span<T>& rhs) noexcept
{
  return !(lhs == rhs);
}
 
//--------------------------------------------------------------------------------------------------------------
// makeSpan
//--------------------------------------------------------------------------------------------------------------

template <typename T>
[[nodiscard]] constexpr Span<T> makeSpan(T* ptr, std::size_t size) noexcept
{
  return Span<T>(ptr, size);
}

template <typename T, std::size_t n>
[[nodiscard]] constexpr Span<T> makeSpan(T (&arr)[n]) noexcept
{
  return makeSpan(arr, n);
}

template <typename T>
[[nodiscard]] constexpr Span<T> makeSpan(T& val) noexcept
{
  return makeSpan(&val, 1UL);
}

template <typename Iterator, typename T = typename std::iterator_traits<Iterator>::value_type>
[[nodiscard]] constexpr Span<T> makeSpan(Iterator first, Iterator last) noexcept
{
  return makeSpan(&*first, static_cast<std::size_t>(std::distance(first, last)));
}

template <typename T>
[[nodiscard]] constexpr Span<T> makeSpan(std::vector<T>& vector) noexcept
{
  return Span<T>(vector);
}

template <typename T, std::size_t s>
[[nodiscard]] constexpr Span<T> makeSpan(std::array<T, s>& array) noexcept
{
  return Span<T>(array);
}
 
//--------------------------------------------------------------------------------------------------------------
// makeConstSpan
//--------------------------------------------------------------------------------------------------------------

template <typename T>
[[nodiscard]] constexpr Span<const T> makeConstSpan(const T* ptr, std::size_t size) noexcept
{
  return Span<const T>(ptr, size);
}

template <typename T, std::size_t n>
[[nodiscard]] constexpr Span<const T> makeConstSpan(const T (&arr)[n]) noexcept
{
  return makeConstSpan(arr, n);
}

template <typename Iterator, typename T = typename std::iterator_traits<Iterator>::value_type>
[[nodiscard]] constexpr Span<const T> makeConstSpan(Iterator first, Iterator last) noexcept
{
  return makeConstSpan(&*first, static_cast<std::size_t>(std::distance(first, last)));
}

template <typename T>
[[nodiscard]] constexpr Span<const T> makeConstSpan(const std::vector<T>& vector) noexcept
{
  return Span<const T>(vector);
}

template <typename T, std::size_t s>
[[nodiscard]] constexpr Span<const T> makeConstSpan(const std::array<T, s>& array) noexcept
{
  return Span<const T>(array);
}

 
//----------------------------------------------------------------------------------------------------------------------
// Inline implementation
//----------------------------------------------------------------------------------------------------------------------
 
template <typename T>
Span<T> Span<T>::first(index_type count) const noexcept
{
  SEN_EXPECT(count <= size());
  return {data(), count};
}
 
template <typename T>
Span<T> Span<T>::last(index_type count) const noexcept
{
  SEN_EXPECT(count <= size());
  return {data() + (size() - count), count};  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
}
 
template <typename T>
Span<T> Span<T>::subspan(index_type offset) const noexcept
{
  SEN_EXPECT(offset <= size());
  return {data() + offset, size() - offset};  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
}
 
template <typename T>
Span<T> Span<T>::subspan(index_type offset, std::size_t count) const noexcept
{
  SEN_EXPECT(offset <= size());
  SEN_EXPECT(count <= (size() - offset));
  return {data() + offset, count};  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
}
 
template <typename T>
typename Span<T>::reference Span<T>::operator[](index_type i) const noexcept
{
  SEN_EXPECT(i < size());
  return *(data() + i);  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
}
 
}  // namespace sen
 
#endif  // SEN_CORE_BASE_SPAN_H