ArrayOfArrays.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 "ArrayOfArraysView.hpp"

namespace LvArray
{

// Forward declaration of the ArrayOfSets class so that we can define the assimilate method.
template< typename T, typename INDEX_TYPE, template< typename > class BUFFER_TYPE >
class ArrayOfSets;

template< typename T,
          typename INDEX_TYPE,
          template< typename > class BUFFER_TYPE >
class ArrayOfArrays : protected ArrayOfArraysView< T, INDEX_TYPE, false, BUFFER_TYPE >
{
  using ParentClass = ArrayOfArraysView< T, INDEX_TYPE, false, BUFFER_TYPE >;

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


  inline
  ArrayOfArrays( INDEX_TYPE const numArrays=0, INDEX_TYPE const defaultArrayCapacity=0 ):
    ParentClass( true )
  {
    resize( numArrays, defaultArrayCapacity );
    setName( "" );
  }

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

  inline
  ArrayOfArrays( ArrayOfArrays && ) = default;

  ~ArrayOfArrays()
  { ParentClass::free(); }



  constexpr inline
  ArrayOfArraysView< T, INDEX_TYPE const, false, BUFFER_TYPE >
  toView() const &
  { return ParentClass::toView(); }

  constexpr inline
  ArrayOfArraysView< T, INDEX_TYPE const, false, BUFFER_TYPE >
  toView() const && = delete;

  constexpr inline
  ArrayOfArraysView< T, INDEX_TYPE const, true, BUFFER_TYPE >
  toViewConstSizes() const &
  { return ParentClass::toViewConstSizes(); }

  constexpr inline
  ArrayOfArraysView< T, INDEX_TYPE const, true, BUFFER_TYPE >
  toViewConstSizes() const && = delete;

  constexpr inline
  ArrayOfArraysView< T const, INDEX_TYPE const, true, BUFFER_TYPE >
  toViewConst() const &
  { return ParentClass::toViewConst(); }

  constexpr inline
  ArrayOfArraysView< T const, INDEX_TYPE const, true, BUFFER_TYPE >
  toViewConst() const && = delete;



  inline
  ArrayOfArrays & operator=( ArrayOfArrays const & src )
  {
    ParentClass::setEqualTo( src.m_numArrays,
                             src.m_offsets[ src.m_numArrays ],
                             src.m_offsets,
                             src.m_sizes,
                             src.m_values );
    return *this;
  }

  inline
  ArrayOfArrays & operator=( ArrayOfArrays && src )
  {
    ParentClass::free();
    ParentClass::operator=( std::move( src ) );
    return *this;
  }

  inline
  void assimilate( ArrayOfSets< T, INDEX_TYPE, BUFFER_TYPE > && src )
  {
    ParentClass::free();
    ParentClass::assimilate( reinterpret_cast< ParentClass && >( src ) );
  }

  using ParentClass::resizeFromCapacities;
  using ParentClass::resizeFromOffsets;



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

  using ParentClass::sizeOfArray;
  using ParentClass::capacity;
  using ParentClass::capacityOfArray;
  using ParentClass::valueCapacity;



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



  using ParentClass::reserve;
  using ParentClass::reserveValues;

  void resize( INDEX_TYPE const newSize, INDEX_TYPE const defaultArrayCapacity=0 )
  { return ParentClass::resize( newSize, defaultArrayCapacity ); }

  using ParentClass::compress;



  void appendArray( INDEX_TYPE const n )
  {
    LVARRAY_ASSERT( arrayManipulation::isPositive( n ) );

    INDEX_TYPE const maxOffset = this->m_offsets[ this->m_numArrays ];
    bufferManipulation::emplaceBack( this->m_offsets, this->m_numArrays + 1, maxOffset );
    bufferManipulation::emplaceBack( this->m_sizes, this->m_numArrays, 0 );
    ++this->m_numArrays;

    resizeArray( this->m_numArrays - 1, n );
  }

  template< typename ITER >
  void appendArray( ITER const first, ITER const last )
  {
    INDEX_TYPE const maxOffset = this->m_offsets[ this->m_numArrays ];
    bufferManipulation::emplaceBack( this->m_offsets, this->m_numArrays + 1, maxOffset );
    bufferManipulation::emplaceBack( this->m_sizes, this->m_numArrays, 0 );
    ++this->m_numArrays;

    appendToArray( this->m_numArrays - 1, first, last );
  }

  template< typename ITER >
  void insertArray( INDEX_TYPE const i, ITER const first, ITER const last )
  {
    ARRAYOFARRAYS_CHECK_INSERT_BOUNDS( i );

    // Insert an array of capacity zero at the given location
    INDEX_TYPE const offset = this->m_offsets[ i ];
    bufferManipulation::emplace( this->m_offsets, this->m_numArrays + 1, i + 1, offset );
    bufferManipulation::emplace( this->m_sizes, this->m_numArrays, i, 0 );
    ++this->m_numArrays;

    // Append to the new array
    appendToArray( i, first, last );
  }

  void eraseArray( INDEX_TYPE const i )
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( i );

    setCapacityOfArray( i, 0 );
    bufferManipulation::erase( this->m_offsets, this->m_numArrays + 1, i + 1 );
    bufferManipulation::erase( this->m_sizes, this->m_numArrays, i );
    --this->m_numArrays;
  }



  template< typename ... ARGS >
  void emplaceBack( INDEX_TYPE const i, ARGS && ... args )
  {
    dynamicallyGrowArray( i, 1 );
    ParentClass::emplaceBack( i, std::forward< ARGS >( args )... );
  }

  template< typename ITER >
  void appendToArray( INDEX_TYPE const i, ITER const first, ITER const last )
  {
    INDEX_TYPE const n = arrayManipulation::iterDistance( first, last );
    dynamicallyGrowArray( i, n );
    ParentClass::appendToArray( i, first, last );
  }

  using ParentClass::emplaceBackAtomic;

  template< typename ... ARGS >
  void emplace( INDEX_TYPE const i, INDEX_TYPE const j, ARGS && ... args )
  {
    dynamicallyGrowArray( i, 1 );
    ParentClass::emplace( i, j, std::forward< ARGS >( args )... );
  }

  template< typename ITER >
  void insertIntoArray( INDEX_TYPE const i, INDEX_TYPE const j, ITER const first, ITER const last )
  {
    INDEX_TYPE const n = arrayManipulation::iterDistance( first, last );
    dynamicallyGrowArray( i, n );
    ParentClass::insertIntoArray( i, j, first, last );
  }

  using ParentClass::eraseFromArray;

  template< class ... ARGS >
  void resizeArray( INDEX_TYPE const i, INDEX_TYPE const newSize, ARGS && ... args )
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( i );
    LVARRAY_ASSERT( arrayManipulation::isPositive( newSize ) );

    if( newSize > capacityOfArray( i ) )
    {
      setCapacityOfArray( i, newSize );
    }

    INDEX_TYPE const prevSize = sizeOfArray( i );
    T * const values = (*this)[i];
    arrayManipulation::resize( values, prevSize, newSize, std::forward< ARGS >( args )... );
    this->m_sizes[ i ] = newSize;
  }

  void clearArray( INDEX_TYPE const i )
  { resizeArray( i, 0 ); }

  void setCapacityOfArray( INDEX_TYPE const i, INDEX_TYPE const newCapacity )
  { ParentClass::setCapacityOfArray( i, newCapacity ); }



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


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

private:

  void dynamicallyGrowArray( INDEX_TYPE const i, INDEX_TYPE const increase )
  {
    LVARRAY_ASSERT( arrayManipulation::isPositive( increase ) );

    INDEX_TYPE const newArraySize = sizeOfArray( i ) + increase;
    if( newArraySize > capacityOfArray( i ))
    {
      setCapacityOfArray( i, 2 * newArraySize );
    }
  }
};

} /* namespace LvArray */