PyArrayOfArrays.hpp

Go to the documentation of this file.

/*
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Copyright (c) 2019, Lawrence Livermore National Security, LLC.
 *
 * Produced at the Lawrence Livermore National Laboratory
 *
 * LLNL-CODE-746361
 *
 * All rights reserved. See COPYRIGHT for details.
 *
 * This file is part of the GEOSX Simulation Framework.
 *
 * GEOSX is a free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License (as published by the
 * Free Software Foundation) version 2.1 dated February 1999.
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

#pragma once

// Source includes
#include "pythonForwardDeclarations.hpp"
#include "numpyHelpers.hpp"
#include "../ArrayOfArrays.hpp"
#include "../Macros.hpp"
#include "../limits.hpp"
#include "../output.hpp"

// System includes
#include <string>
#include <memory>
#include <typeindex>

namespace LvArray
{
namespace python
{
namespace internal
{

class PyArrayOfArraysWrapperBase
{
public:

  virtual ~PyArrayOfArraysWrapperBase() = default;

  virtual int getAccessLevel() const
  { return m_accessLevel; }

  virtual void setAccessLevel( int const accessLevel ) = 0;

  virtual std::string repr() const = 0;

  virtual long long size() const = 0;

  virtual long long sizeOfArray( long long arrayIndex ) const = 0;

  virtual PyObject * operator[]( long long arrayIndex ) = 0;

  virtual std::type_index valueType() const = 0;

  virtual void eraseArray( long long arrayIndex ) = 0;

  virtual void eraseFromArray( long long arrayIndex, long long valueIndex ) = 0;

  virtual void insertArray( long long arrayIndex, void const * values, long long numVals ) = 0;

  virtual void insertIntoArray( long long arrayIndex,
                                long long valueIndex,
                                void const * values,
                                long long numVals ) = 0;

protected:

  PyArrayOfArraysWrapperBase():
    m_accessLevel( static_cast< int >( LvArray::python::PyModify::READ_ONLY ) )
  {}

  int m_accessLevel;
};

template< typename T,
          typename INDEX_TYPE,
          template< typename > class BUFFER_TYPE >
class PyArrayOfArraysWrapper final : public PyArrayOfArraysWrapperBase
{
public:

  PyArrayOfArraysWrapper( ArrayOfArrays< T, INDEX_TYPE, BUFFER_TYPE > & arrayOfArrays ):
    PyArrayOfArraysWrapperBase( ),
    m_arrayOfArrays( arrayOfArrays )
  {}

  virtual ~PyArrayOfArraysWrapper() = default;

  virtual void setAccessLevel( int accessLevel ) final override
  {
    if( accessLevel >= static_cast< int >( LvArray::python::PyModify::RESIZEABLE ) )
    {
      // touch
    }
    m_accessLevel = accessLevel;
  }

  virtual std::string repr() const final override
  { return system::demangleType< ArrayOfArrays< T, INDEX_TYPE, BUFFER_TYPE > >(); }

  virtual long long size() const final override
  { return integerConversion< long long >( m_arrayOfArrays.size() ); }

  virtual long long sizeOfArray( long long arrayIndex ) const final override
  {
    INDEX_TYPE convertedIndex = integerConversion< INDEX_TYPE >( arrayIndex );
    return integerConversion< long long >( m_arrayOfArrays.sizeOfArray( convertedIndex ) );
  }

  virtual PyObject * operator[]( long long arrayIndex ) final override
  {
    INDEX_TYPE convertedIndex = integerConversion< INDEX_TYPE >( arrayIndex );
    ArraySlice< T, 1, 0, INDEX_TYPE > slice = m_arrayOfArrays[ convertedIndex ];
    T * data = slice;
    constexpr INDEX_TYPE strides = 1;
    INDEX_TYPE size = slice.size();
    return createNumPyArray( data, getAccessLevel() >= static_cast< int >( LvArray::python::PyModify::MODIFIABLE ), 1, &size, &strides );
  }

  virtual std::type_index valueType() const final override
  { return std::type_index( typeid( T ) ); }

  virtual void eraseArray( long long arrayIndex ) final override
  {
    INDEX_TYPE convertedIndex = integerConversion< INDEX_TYPE >( arrayIndex );
    m_arrayOfArrays.eraseArray( convertedIndex );
  }

  virtual void eraseFromArray( long long arrayIndex, long long valueIndex ) final override
  {
    INDEX_TYPE convertedIndex = integerConversion< INDEX_TYPE >( arrayIndex );
    INDEX_TYPE convertedBegin = integerConversion< INDEX_TYPE >( valueIndex );
    m_arrayOfArrays.eraseFromArray( convertedIndex, convertedBegin );
  }

  virtual void insertArray( long long arrayIndex, void const * values, long long numVals ) final override
  {
    INDEX_TYPE convertedIndex = integerConversion< INDEX_TYPE >( arrayIndex );
    T const * begin = static_cast< T const * >( values );
    T const * end = begin + numVals;
    m_arrayOfArrays.insertArray( convertedIndex, begin, end );
  }

  virtual void insertIntoArray( long long arrayIndex,
                                long long valueIndex,
                                void const * values,
                                long long numVals ) final override
  {
    INDEX_TYPE convertedArray = integerConversion< INDEX_TYPE >( arrayIndex );
    INDEX_TYPE convertedIndex = integerConversion< INDEX_TYPE >( valueIndex );
    T const * begin = static_cast< T const * >( values );
    T const * end = begin + numVals;
    m_arrayOfArrays.insertIntoArray( convertedArray, convertedIndex, begin, end );
  }

private:
  ArrayOfArrays< T, INDEX_TYPE, BUFFER_TYPE > & m_arrayOfArrays;
};

PyObject * create( std::unique_ptr< internal::PyArrayOfArraysWrapperBase > && arrayOfArrays );

} // namespace internal

template< typename T, typename INDEX_TYPE, template< typename > class BUFFER_TYPE >
std::enable_if_t< internal::canExportToNumpy< T >, PyObject * >
create( ArrayOfArrays< T, INDEX_TYPE, BUFFER_TYPE > & arrayOfArrays )
{
  auto tmp = std::make_unique< internal::PyArrayOfArraysWrapper< T, INDEX_TYPE, BUFFER_TYPE > >( arrayOfArrays );
  return internal::create( std::move( tmp ) );
}

PyTypeObject * getPyArrayOfArraysType();

} // namespace python
} // namespace LvArray