span.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
 * Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration.
 */
#ifndef CXXUTILS_SPAN_H
#define CXXUTILS_SPAN_H
 
 
#include "CxxUtils/concepts.h"
#include <cstdlib>
#include <type_traits>
#include <iterator>
#include <cassert>
#include <ranges>
 
 
namespace CxxUtils {
 
 
inline constexpr size_t dynamic_extent = static_cast<size_t>(-1);
 
 
template <class T, class U>
inline constexpr bool valid_span_type_v = std::is_convertible_v<U(*)[], T(*)[]>;
 
 
template <class T>
class span
  : public std::ranges::view_base
{
public:
  using element_type           = T;
  using value_type             = std::remove_cv_t<T>;
  using size_type              = std::size_t;
  using difference_type        = std::ptrdiff_t;
  using pointer                = T*;
  using const_pointer          = const T*;
  using reference              = element_type&;
  using const_reference        = const element_type&;
  using iterator               = pointer;
  using const_iterator         = const_pointer;
  using reverse_iterator       = std::reverse_iterator<iterator>;
  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
 
  /*
   * @brief Default constructor.
   * Makes an empty span.
   */
  span();
 
 
  template <class U>
  requires (valid_span_type_v<T, U>)
  span (U* ptr, size_type sz);
 
 
  template <class U>
  requires (valid_span_type_v<T, U>)
  span (U* beg, U* end);
 
 
  // Default copy / assignment.
  span (const span&) = default;
  span& operator= (const span&) = default;
 
 
  template <class U>
  requires (valid_span_type_v<T, U>)
  span (const span<U>& other);
 
 
  constexpr size_type size() const noexcept;
 
  
  constexpr size_type size_bytes() const noexcept;
 
  
  [[nodiscard]] constexpr bool empty() const noexcept;
 
  
  constexpr reference front() noexcept;
 
   
  constexpr const_reference front() const noexcept;
 
  
  constexpr reference back() noexcept;
 
  
  constexpr const_reference back() const noexcept;
 
  
  constexpr reference operator[] (size_type i) noexcept;
 
  
  constexpr const_reference operator[] (size_type i) const noexcept;
 
  
  constexpr reference at (size_type i);
 
 
  constexpr const_reference at (size_type i) const;
 
 
  constexpr pointer data() noexcept;
 
  
  constexpr const_pointer data() const noexcept;
 
  
  constexpr iterator begin() noexcept;
 
  
  constexpr const_iterator begin() const noexcept;
 
  
  constexpr iterator end() noexcept;
 
  
  constexpr const_iterator end() const noexcept;
 
  
  constexpr reverse_iterator rbegin() noexcept;
 
  
  constexpr const_reverse_iterator rbegin() const noexcept;
 
  
  constexpr reverse_iterator rend() noexcept;
 
 
  constexpr const_reverse_iterator rend() const noexcept;
 
 
  constexpr span first (size_type n) noexcept;
 
  
  constexpr span<const T> first (size_type n) const noexcept;
 
  
  constexpr span last (size_type n) noexcept;
 
  
  constexpr span<const T> last (size_type n) const noexcept;
 
  
  constexpr span
  subspan (size_type offs, size_type n = dynamic_extent) noexcept;
 
 
  constexpr span<const T>
  subspan (size_type offs, size_type n = dynamic_extent) const noexcept;
 
 
private:
  T* m_ptr;
 
  size_t m_size;
};
 
 
template <class T>
span (T* ptr, std::size_t sz) -> span<T>;
template <class T>
span (T* beg, T* end) -> span<T>;
 
 
template <detail::IsContiguousContainer CONTAINER>
auto make_span (CONTAINER& c)
{
  return CxxUtils::span (c.data(), c.size());
}
 
 
// Stand-alone begin/end functions, findable by ADL.
// Needed to work around issues seen when root 6.30.04 is used with gcc14.
template <class T>
auto begin (span<T>& s) { return s.begin(); }
template <class T>
auto begin (const span<T>& s) { return s.begin(); }
template <class T>
auto end (span<T>& s) { return s.end(); }
template <class T>
auto end (const span<T>& s) { return s.end(); }
 
 
} // namespace CxxUtils
 
 
#include "CxxUtils/span.icc"
 
 
#endif // not CXXUTILS_SPAN_H