SortedArrayView.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2021, Lawrence Livermore National Security, LLC and LvArray contributors.
 * All rights reserved.
 * See the LICENSE file for details.
 * SPDX-License-Identifier: (BSD-3-Clause)
 */

#pragma once

// Source includes
#include "ArraySlice.hpp"
#include "bufferManipulation.hpp"
#include "sortedArrayManipulation.hpp"

#ifdef LVARRAY_BOUNDS_CHECK

#define SORTEDARRAY_CHECK_BOUNDS( index ) \
  LVARRAY_ERROR_IF( index < 0 || index >= size(), \
                    "Array Bounds Check Failed: index=" << index << " size()=" << size())

#else // LVARRAY_BOUNDS_CHECK

#define SORTEDARRAY_CHECK_BOUNDS( index )

#endif // LVARRAY_BOUNDS_CHECK

namespace LvArray
{

template< typename T,
          typename INDEX_TYPE,
          template< typename > class BUFFER_TYPE >
class SortedArrayView
{
public:

  using ValueType = T;

  using IndexType = INDEX_TYPE;

  using value_type = T;

  using size_type = INDEX_TYPE;


  SortedArrayView( SortedArrayView const & src ) = default;

  LVARRAY_HOST_DEVICE constexpr inline
  SortedArrayView( SortedArrayView && src ):
    m_values( std::move( src.m_values ) ),
    m_size( src.m_size )
  {
    src.m_size = 0;
  }

  LVARRAY_HOST_DEVICE constexpr inline
  SortedArrayView( INDEX_TYPE const size, BUFFER_TYPE< T > const & buffer ):
    m_values( buffer ),
    m_size( size )
  {}

  SortedArrayView & operator=( SortedArrayView const & src ) = default;

  LVARRAY_HOST_DEVICE constexpr inline
  SortedArrayView & operator=( SortedArrayView && src )
  {
    m_values = std::move( src.m_values );
    m_size = src.m_size;
    src.m_size = 0;
    return *this;
  }



  LVARRAY_HOST_DEVICE constexpr inline
  SortedArrayView< T const, INDEX_TYPE, BUFFER_TYPE >
  toView() const
  { return SortedArrayView< T const, INDEX_TYPE, BUFFER_TYPE >( size(), m_values ); }

  LVARRAY_HOST_DEVICE constexpr inline
  SortedArrayView< T const, INDEX_TYPE, BUFFER_TYPE >
  toViewConst() const
  { return toView(); }

  LVARRAY_HOST_DEVICE constexpr inline
  ArraySlice< T const, 1, 0, INDEX_TYPE > toSlice() const &
  { return ArraySlice< T const, 1, 0, INDEX_TYPE >( data(), &m_size, nullptr ); }

  LVARRAY_HOST_DEVICE constexpr inline
  ArraySlice< T const, 1, 0, INDEX_TYPE > toSlice() const && = delete;



  LVARRAY_HOST_DEVICE constexpr inline
  bool empty() const
  { return size() == 0; }

  LVARRAY_HOST_DEVICE constexpr inline
  INDEX_TYPE size() const
  { return m_size; }

  LVARRAY_HOST_DEVICE inline
  bool contains( T const & value ) const
  { return sortedArrayManipulation::contains( data(), size(), value ); }

  LVARRAY_HOST_DEVICE inline
  bool count( T const & value ) const
  { return contains( value ); }



  LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
  T const & operator[]( INDEX_TYPE const i ) const
  {
    SORTEDARRAY_CHECK_BOUNDS( i );
    return data()[ i ];
  }

  LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
  T const & operator()( INDEX_TYPE const i ) const
  {
    SORTEDARRAY_CHECK_BOUNDS( i );
    return data()[ i ];
  }

  LVARRAY_HOST_DEVICE constexpr inline
  T const * data() const
  { return m_values.data(); }

  LVARRAY_HOST_DEVICE constexpr inline
  T const * begin() const
  { return data(); }

  LVARRAY_HOST_DEVICE constexpr inline
  T const * end() const
  { return data() + size(); }



  inline
  void move( MemorySpace const space, bool touch=true ) const
  {
  #if defined(LVARRAY_USE_CUDA)
    if( space == MemorySpace::cuda ) touch = false;
  #endif
  #if defined(LVARRAY_USE_HIP)
    if( space == MemorySpace::hip ) touch = false;
  #endif
    m_values.move( space, touch );
  }


protected:

  SortedArrayView():
    m_values( true )
  {}

  BUFFER_TYPE< T > m_values;

  INDEX_TYPE m_size = 0;
};

template< class >
constexpr bool isSortedArrayView = false;

template< class T,
          class INDEX_TYPE,
          template< typename > class BUFFER_TYPE >
constexpr bool isSortedArrayView< SortedArrayView< T, INDEX_TYPE, BUFFER_TYPE > > = true;

} // namespace LvArray