SortedArray.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

#include "SortedArrayView.hpp"

namespace LvArray
{

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

  using ParentClass = SortedArrayView< T, INDEX_TYPE, BUFFER_TYPE >;

  // Alias public typedefs of SortedArrayView.
  using typename ParentClass::ValueType;
  using typename ParentClass::IndexType;
  using typename ParentClass::value_type;
  using typename ParentClass::size_type;

  using ViewType = SortedArrayView< T const, INDEX_TYPE, BUFFER_TYPE > const;

  using ViewTypeConst = SortedArrayView< T const, INDEX_TYPE, BUFFER_TYPE > const;

  // Alias public methods of SortedArrayView.


  inline
  SortedArray():
    ParentClass()
  { setName( "" ); }

  inline
  SortedArray( SortedArray const & src ):
    ParentClass()
  { *this = src; }

  inline
  SortedArray( SortedArray && src ) = default;

  inline
  ~SortedArray()
  { bufferManipulation::free( this->m_values, size() ); }

  inline
  SortedArray & operator=( SortedArray const & src )
  {
    bufferManipulation::copyInto( this->m_values, size(), src.m_values, src.size() );
    this->m_size = src.size();
    return *this;
  }

  inline
  SortedArray & operator=( SortedArray && src )
  {
    bufferManipulation::free( this->m_values, size() );
    ParentClass::operator=( std::move( src ) );
    return *this;
  }



  LVARRAY_HOST_DEVICE inline
  SortedArrayView< T const, INDEX_TYPE, BUFFER_TYPE > toView() const &
  { return ParentClass::toView(); }

  LVARRAY_HOST_DEVICE inline
  SortedArrayView< T const, INDEX_TYPE, BUFFER_TYPE > toView() const && = delete;

  LVARRAY_HOST_DEVICE inline
  SortedArrayView< T const, INDEX_TYPE, BUFFER_TYPE > toViewConst() const &
  { return ParentClass::toViewConst(); }

  LVARRAY_HOST_DEVICE inline
  SortedArrayView< T const, INDEX_TYPE, BUFFER_TYPE > toViewConst() const && = delete;

  using ParentClass::toSlice;



  using ParentClass::empty;

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

  using ParentClass::contains;
  using ParentClass::count;



  using ParentClass::operator[];
  using ParentClass::operator();

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

  using ParentClass::begin;
  using ParentClass::end;



  inline
  bool insert( T const & value )
  {
    bool const success = sortedArrayManipulation::insert( this->m_values.data(),
                                                          size(),
                                                          value,
                                                          CallBacks( this->m_values, size() ) );
    this->m_size += success;
    return success;
  }

  template< typename ITER >
  INDEX_TYPE insert( ITER const first, ITER const last )
  {
    INDEX_TYPE const nInserted = sortedArrayManipulation::insert( this->m_values.data(),
                                                                  size(),
                                                                  first,
                                                                  last,
                                                                  CallBacks( this->m_values, size() ) );
    this->m_size += nInserted;
    return nInserted;
  }

  inline
  bool remove( T const & value )
  {
    bool const success = sortedArrayManipulation::remove( this->m_values.data(),
                                                          size(),
                                                          value,
                                                          CallBacks( this->m_values, size() ) );
    this->m_size -= success;
    return success;
  }

  template< typename ITER >
  INDEX_TYPE remove( ITER const first, ITER const last )
  {
    INDEX_TYPE const nRemoved = sortedArrayManipulation::remove( this->m_values.data(),
                                                                 size(),
                                                                 first,
                                                                 last,
                                                                 CallBacks( this->m_values, size() ) );
    this->m_size -= nRemoved;
    return nRemoved;
  }



  inline
  void clear()
  {
    bufferManipulation::resize( this->m_values, size(), 0 );
    this->m_size = 0;
  }

  inline
  void reserve( INDEX_TYPE const nVals )
  { bufferManipulation::reserve( this->m_values, size(), MemorySpace::host, nVals ); }



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


  void setName( std::string const & name )
  { this->m_values.template setName< decltype( *this ) >( name ); }

private:

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

    inline
    CallBacks( BUFFER_TYPE< T > & buffer, INDEX_TYPE const size ):
      m_buffer( buffer ),
      m_size( size )
    {}

    inline
    T * incrementSize( T * const curPtr,
                       INDEX_TYPE const nToAdd ) const
    {
      LVARRAY_UNUSED_VARIABLE( curPtr );
      bufferManipulation::dynamicReserve( m_buffer, m_size, m_size + nToAdd );
      return m_buffer.data();
    }

private:
    BUFFER_TYPE< T > & m_buffer;

    INDEX_TYPE const m_size;
  };
};

template< class >
constexpr bool isSortedArray = false;

template< class T,
          class INDEX_TYPE,
          template< typename > class BUFFER_TYPE >
constexpr bool isSortedArray< SortedArray< T, INDEX_TYPE, BUFFER_TYPE > > = true;


} // namespace LvArray