span.hpp

Go to the documentation of this file.

#ifndef HPP_DTK_SPAN_INCLUDED
#   define HPP_DTK_SPAN_INCLUDED
 
#   include <array>
#    include <limits>
#
#    include <dtk/config.hpp>
 
namespace dtk
{
     struct DynamicExtent : std::integral_constant<std::size_t, static_cast< std::size_t >( -1 )>{};
 
     template <class T, std::size_t Extent = DynamicExtent::value> class Span;
 
     template <class T> class Span<T, DynamicExtent::value>
     {
     public:
          typedef T* Pointer;
          typedef T const* ConstPointer;
          typedef T Element;
     public:
          static auto const extent = DynamicExtent::value;
     public:
          Span() DTK_NOEXCEPT
               : m_data( nullptr ), m_size( 0u )
          {
          }
          Span( T * data, std::size_t n ) DTK_NOEXCEPT
               : m_data( data ), m_size( n )
          {
          }
          template <class Iterator> Span( Iterator begin, Iterator end )
               : m_data( &( *begin ) )
               , m_size( static_cast< std::size_t >( end - begin ) )
          {
          }
          template <class Range> Span( Range&& range )
               : m_data( std::forward<Range>( range ).data() )
               , m_size( std::forward<Range>( range ).size() )
          {
          }
     public:
          Pointer data() const DTK_NOEXCEPT
          {
               return m_data;
          }
          Pointer begin() const DTK_NOEXCEPT
          {
               return m_data;
          }
          Pointer end() const DTK_NOEXCEPT
          {
               return m_data + m_size;
          }
          ConstPointer cbegin() const DTK_NOEXCEPT
          {
               return m_data;
          }
          ConstPointer cend() const DTK_NOEXCEPT
          {
               return m_data + m_size;
          }
     public:
          Span subspan( std::size_t offset, std::size_t count = static_cast< std::size_t >( -1 ) ) const DTK_NOEXCEPT
          {
               auto const off = offset > m_size ? m_size : offset;
               return Span( m_data + off, ( count > m_size - off ? ( m_size - off ) : count ) );
          }
          Span& operator+=( std::size_t n ) DTK_NOEXCEPT
          {
               *this = subspan( n );
               return *this;
          }
     public:
          std::size_t size() const DTK_NOEXCEPT
          {
               return m_size;
          }
          bool empty() const DTK_NOEXCEPT
          {
               return !m_size;
          }
     public:
          friend Span operator+( Span const& s, std::size_t n ) DTK_NOEXCEPT
          {
               return s.subspan( n );
          }
     private:
          Pointer m_data;
          std::size_t m_size;
     };
 
     template <class Range> auto as_const_span( Range&& range ) -> Span<typename std::add_const<typename std::remove_pointer<decltype( std::forward<Range>( range ).data() )>::type>::type>
     {
          return Span<typename std::add_const<typename std::remove_pointer<decltype( std::forward<Range>( range ).data() )>::type>::type>( std::forward<Range>( range ) );
     }
     template <class T> auto as_const_span( T* data, std::size_t n ) DTK_NOEXCEPT -> Span<T const>
     {
          return Span<T const>( data, n );
     }
     template <class T> auto as_const_span( T const* data, std::size_t n ) DTK_NOEXCEPT -> Span<T const>
     {
          return Span<T const>( data, n );
     }
     template <class Range> auto as_span( Range&& range ) -> Span<typename std::remove_pointer<decltype( std::forward<Range>( range ).data() )>::type>
     {
          return Span<typename std::remove_pointer<decltype( std::forward<Range>( range ).data() )>::type>( std::forward<Range>( range ) );
     }
     template <class T> auto as_span( T* data, std::size_t n ) DTK_NOEXCEPT -> Span<T>
     {
          return Span<T>( data, n );
     }
     template <class T> auto as_span( T const* data, std::size_t n ) DTK_NOEXCEPT -> Span<T const>
     {
          return Span<T const>( data, n );
     }
 
     typedef Span<char> MutableBuffer;
     typedef Span<char const> ConstBuffer;
 
     template <class T> auto as_const_buffer( T * data, std::size_t n ) DTK_NOEXCEPT -> ConstBuffer
     {
          return ConstBuffer( reinterpret_cast< char const* >( data ), n * sizeof( T ) );
     }
     template <class T> auto as_const_buffer( T const* data, std::size_t n ) DTK_NOEXCEPT -> ConstBuffer
     {
          return ConstBuffer( reinterpret_cast< char const* >( data ), n * sizeof( T ) );
     }
     template <class Range> auto as_const_buffer( Range&& range ) -> ConstBuffer
     {
          typedef typename std::remove_pointer<decltype( std::forward<Range>( range ).data() )>::type Element;
          return ConstBuffer( reinterpret_cast< char const* >( std::forward<Range>( range ).data() ), std::forward<Range>( range ).size() * sizeof( Element ) );
     }
     template <class T> auto as_buffer( T* data, std::size_t n ) DTK_NOEXCEPT -> MutableBuffer
     {
          return MutableBuffer( reinterpret_cast<char*>( data ), n * sizeof( T ) );
     }
     template <class T> auto as_buffer( T const* data, std::size_t n ) DTK_NOEXCEPT -> ConstBuffer
     {
          return ConstBuffer( reinterpret_cast<char const*>( data ), n * sizeof( T ) );
     }
     template <class Range> auto as_buffer( Range&& range ) -> decltype( as_buffer( std::forward<Range>( range ).data(), std::forward<Range>( range ).size() ) )
     {
          return as_buffer( std::forward<Range>( range ).data(), std::forward<Range>( range ).size() );
     }
}
 
#endif