Span.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 Total, S.A
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_COMMON_SPAN_HPP
#define GEOS_COMMON_SPAN_HPP
 
#include "codingUtilities/traits.hpp"
#include "common/logger/Logger.hpp"
 
#include <memory>
#include <iterator>
#include <type_traits>
 
namespace geos
{
 
template< typename T >
class Span
{
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;
 
  constexpr Span() noexcept = default;
 
  Span( T * const ptr, size_type const size ) noexcept
    : m_data( ptr ),
    m_size( size )
  {}
 
  template< typename ITER >
  constexpr Span( ITER const begin, ITER const end ) noexcept
    : Span( std::addressof( *begin ), std::distance( begin, end ) )
  {}
 
  template< int N >
  constexpr Span( T (& arr)[N] ) noexcept
    : Span( std::addressof( arr[0] ), N )
  {}
 
  template< typename R, typename std::enable_if_t< traits::is_range_like< R > > * = nullptr >
  constexpr Span( R const & range )
    : Span( range.begin(), range.end() )
  {}
 
  constexpr size_type size() const noexcept
  {
    return m_size;
  }
 
  constexpr size_type size_bytes() const noexcept
  {
    return size() * sizeof( element_type );
  }
 
  constexpr bool empty() const noexcept
  {
    return m_size == 0;
  }
 
  constexpr T * data() const noexcept
  {
    return m_data;
  }
 
  constexpr T * begin() const noexcept
  {
    return m_data;
  }
 
  constexpr T * end() const noexcept
  {
    return m_data + m_size;
  }
 
  constexpr std::reverse_iterator< T * > rbegin() const noexcept
  {
    return std::reverse_iterator< T * >( m_data + m_size - 1 );
  }
 
  constexpr std::reverse_iterator< T * > rend() const noexcept
  {
    return std::reverse_iterator< T * >( m_data - 1 );
  }
 
  T & front() const
  {
    GEOS_ASSERT_GT( m_size, 0 );
    return m_data[0];
  }
 
  T & back() const
  {
    GEOS_ASSERT_GT( m_size, 0 );
    return m_data[m_size-1];
  }
 
  T & operator[]( size_type const i ) const
  {
    GEOS_ASSERT_GT( m_size, i );
    return m_data[i];
  }
 
  Span< element_type > first( size_type const count ) const
  {
    GEOS_ASSERT_GE( m_size, count );
    return { m_data, count };
  }
 
  Span< element_type > last( size_type const count ) const
  {
    GEOS_ASSERT_GE( m_size, count );
    return { m_data + (m_size - count), count };
  }
 
  Span< element_type > subspan( size_type const offset, size_type const count ) const
  {
    GEOS_ASSERT_GE( m_size, offset + count );
    return { m_data + offset, count };
  }
 
private:
 
  T * m_data{};
 
  size_type m_size{};
 
};
 
}
 
#endif //GEOS_COMMON_SPAN_HPP