ArrayOfSetsView.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 "ArrayOfArraysView.hpp"
#include "arrayManipulation.hpp"
#include "sortedArrayManipulation.hpp"
#include "ArraySlice.hpp"
#include "typeManipulation.hpp"

namespace LvArray
{

template< typename T,
          typename INDEX_TYPE,
          template< typename > class BUFFER_TYPE >
class ArrayOfSetsView : protected ArrayOfArraysView< T, INDEX_TYPE, std::is_const< T >::value, BUFFER_TYPE >
{
protected:
  using ParentClass = ArrayOfArraysView< T, INDEX_TYPE, std::is_const< T >::value, BUFFER_TYPE >;

  using INDEX_TYPE_NC = typename ParentClass::INDEX_TYPE_NC;

  using typename ParentClass::SIZE_TYPE;

public:
  using typename ParentClass::ValueType;
  using typename ParentClass::IndexType;
  using typename ParentClass::value_type;
  using typename ParentClass::size_type;



  ArrayOfSetsView() = default;

  inline
  ArrayOfSetsView( ArrayOfSetsView const & ) = default;

  inline
  ArrayOfSetsView( ArrayOfSetsView && ) = default;

  LVARRAY_HOST_DEVICE constexpr inline
  ArrayOfSetsView( INDEX_TYPE const numArrays,
                   BUFFER_TYPE< INDEX_TYPE > const & offsets,
                   BUFFER_TYPE< SIZE_TYPE > const & sizes,
                   BUFFER_TYPE< T > const & values ):
    ParentClass( numArrays, offsets, sizes, values )
  {}

  inline
  ArrayOfSetsView & operator=( ArrayOfSetsView const & ) = default;

  inline
  ArrayOfSetsView & operator=( ArrayOfSetsView && ) = default;



  LVARRAY_HOST_DEVICE constexpr inline
  ArrayOfSetsView< T, INDEX_TYPE const, BUFFER_TYPE >
  toView() const
  {
    return ArrayOfSetsView< T, INDEX_TYPE const, BUFFER_TYPE >( size(),
                                                                this->m_offsets,
                                                                this->m_sizes,
                                                                this->m_values );
  }

  LVARRAY_HOST_DEVICE constexpr inline
  ArrayOfSetsView< T const, INDEX_TYPE const, BUFFER_TYPE >
  toViewConst() const
  {
    return ArrayOfSetsView< T const, INDEX_TYPE const, BUFFER_TYPE >( size(),
                                                                      this->m_offsets,
                                                                      this->m_sizes,
                                                                      this->m_values );
  }

  LVARRAY_HOST_DEVICE constexpr inline
  ArrayOfArraysView< T const, INDEX_TYPE const, true, BUFFER_TYPE >
  toArrayOfArraysView() const
  {
    return ArrayOfArraysView< T const, INDEX_TYPE const, true, BUFFER_TYPE >( size(),
                                                                              this->m_offsets,
                                                                              this->m_sizes,
                                                                              this->m_values );
  }



  using ParentClass::size;

  LVARRAY_HOST_DEVICE constexpr inline
  INDEX_TYPE_NC sizeOfSet( INDEX_TYPE const i ) const
  { return ParentClass::sizeOfArray( i ); }

  using ParentClass::capacity;

  LVARRAY_HOST_DEVICE constexpr inline
  INDEX_TYPE_NC capacityOfSet( INDEX_TYPE const i ) const
  { return ParentClass::capacityOfArray( i ); }

  using ParentClass::valueCapacity;

  LVARRAY_HOST_DEVICE inline
  bool contains( INDEX_TYPE const i, T const & value ) const
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( i );

    INDEX_TYPE const setSize = sizeOfSet( i );
    T const * const setValues = (*this)[ i ];

    return sortedArrayManipulation::contains( setValues, setSize, value );
  }

  void consistencyCheck() const
  {
    INDEX_TYPE const numSets = size();
    for( INDEX_TYPE_NC i = 0; i < numSets; ++i )
    {
      LVARRAY_ERROR_IF_GT( sizeOfSet( i ), capacityOfSet( i ) );

      T * const setValues = getSetValues( i );
      INDEX_TYPE const numValues = sizeOfSet( i );
      LVARRAY_ERROR_IF( !sortedArrayManipulation::isSortedUnique( setValues, setValues + numValues ),
                        "Values should be sorted and unique!" );
    }
  }



  LVARRAY_HOST_DEVICE constexpr inline
  ArraySlice< T const, 1, 0, INDEX_TYPE_NC > operator[]( INDEX_TYPE const i ) const
  { return ParentClass::operator[]( i ); }

  LVARRAY_HOST_DEVICE constexpr inline
  T const & operator()( INDEX_TYPE const i, INDEX_TYPE const j ) const
  { return ParentClass::operator()( i, j ); }



  LVARRAY_HOST_DEVICE inline
  bool insertIntoSet( INDEX_TYPE const i, T const & value ) const
  { return insertIntoSetImpl( i, value, CallBacks( *this, i ) ); }

  template< typename ITER >
  LVARRAY_HOST_DEVICE inline
  INDEX_TYPE_NC insertIntoSet( INDEX_TYPE const i, ITER const first, ITER const last ) const
  { return insertIntoSetImpl( i, first, last, CallBacks( *this, i ) ); }

  LVARRAY_HOST_DEVICE inline
  bool removeFromSet( INDEX_TYPE const i, T const & value ) const
  { return removeFromSetImpl( i, value, CallBacks( *this, i ) ); }

  template< typename ITER >
  LVARRAY_HOST_DEVICE inline
  INDEX_TYPE_NC removeFromSet( INDEX_TYPE const i, ITER const first, ITER const last ) const
  { return removeFromSetImpl( i, first, last, CallBacks( *this, i ) ); }



  void move( MemorySpace const space, bool const touch=true ) const
  { return ParentClass::move( space, touch ); }



  using ParentClass::getSizes;
  using ParentClass::getOffsets;
  using ParentClass::getValues;

protected:

  ArrayOfSetsView( bool ):
    ParentClass( true )
  {}

  LVARRAY_HOST_DEVICE constexpr inline
  ArraySlice< T, 1, 0, INDEX_TYPE_NC > getSetValues( INDEX_TYPE const i ) const
  { return ParentClass::operator[]( i ); }


  template< typename CALLBACKS >
  LVARRAY_HOST_DEVICE inline
  bool insertIntoSetImpl( INDEX_TYPE const i, T const & value, CALLBACKS && cbacks ) const
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( i );

    INDEX_TYPE const setSize = sizeOfSet( i );
    T * const setValues = getSetValues( i );

    bool const success = sortedArrayManipulation::insert( setValues, setSize, value, std::move( cbacks ) );
    this->m_sizes[i] += success;
    return success;
  }

  template< typename ITER, typename CALLBACKS >
  LVARRAY_HOST_DEVICE inline
  INDEX_TYPE_NC insertIntoSetImpl( INDEX_TYPE const i,
                                   ITER const first,
                                   ITER const last,
                                   CALLBACKS && cbacks ) const
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( i );

    INDEX_TYPE const setSize = sizeOfSet( i );
    T * const setValues = getSetValues( i );

    INDEX_TYPE const nInserted = sortedArrayManipulation::insert( setValues,
                                                                  setSize,
                                                                  first,
                                                                  last,
                                                                  std::forward< CALLBACKS >( cbacks ) );
    this->m_sizes[i] += nInserted;
    return nInserted;
  }

  template< typename CALLBACKS >
  LVARRAY_HOST_DEVICE inline
  bool removeFromSetImpl( INDEX_TYPE const i, T const & value, CALLBACKS && cbacks ) const
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( i );

    INDEX_TYPE const setSize = sizeOfSet( i );
    T * const setValues = getSetValues( i );

    bool const success = sortedArrayManipulation::remove( setValues, setSize, value, std::move( cbacks ) );
    this->m_sizes[i] -= success;
    return success;
  }

  template< typename ITER, typename CALLBACKS >
  LVARRAY_HOST_DEVICE inline
  INDEX_TYPE_NC removeFromSetImpl( INDEX_TYPE const i,
                                   ITER const first,
                                   ITER const last,
                                   CALLBACKS && cbacks ) const
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( i );

    INDEX_TYPE const setSize = sizeOfSet( i );
    T * const setValues = getSetValues( i );

    INDEX_TYPE const nRemoved = sortedArrayManipulation::remove( setValues,
                                                                 setSize,
                                                                 first,
                                                                 last,
                                                                 std::forward< CALLBACKS >( cbacks ) );
    this->m_sizes[i] -= nRemoved;
    return nRemoved;
  }


private:

  class CallBacks : public sortedArrayManipulation::CallBacks< T >
  {
public:

    LVARRAY_HOST_DEVICE inline
    CallBacks( ArrayOfSetsView const & aos, INDEX_TYPE const i ):
      m_aos( aos ),
      m_indexOfSet( i )
    {}

    LVARRAY_HOST_DEVICE inline
    T * incrementSize( T * const curPtr, INDEX_TYPE const nToAdd ) const
    {
      LVARRAY_UNUSED_VARIABLE( curPtr );
#ifdef LVARRAY_BOUNDS_CHECK
      LVARRAY_ERROR_IF_GT_MSG( m_aos.sizeOfSet( m_indexOfSet ) + nToAdd, m_aos.capacityOfSet( m_indexOfSet ),
                               "ArrayOfSetsView cannot do reallocation." );
#else
      LVARRAY_DEBUG_VAR( nToAdd );
#endif
      return m_aos.getSetValues( m_indexOfSet );
    }

private:
    ArrayOfSetsView const & m_aos;

    INDEX_TYPE const m_indexOfSet;
  };
};

} // namespace LvArray