pythonHelpers.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 "../system.hpp"
#include "../Macros.hpp"
#include "../limits.hpp"

// system includes
#include <vector>
#include <stdexcept>

#if defined(PyObject_HEAD)
#define PYTHON_ERROR_IF( CONDITION, TYPE, MSG, RET ) \
  do \
  { \
    if( CONDITION ) \
    { \
      std::ostringstream __oss; \
      __oss << "***** ERROR\n"; \
      __oss << "***** LOCATION: " LOCATION "\n"; \
      __oss << "***** Controlling expression (should be false): " STRINGIZE( EXP ) "\n"; \
      __oss << MSG << "\n"; \
      __oss << LvArray::system::stackTrace( true ); \
      PyErr_SetString( TYPE, __oss.str().c_str() ); \
      return RET; \
    } \
  } while( false )
#else
#define PYTHON_ERROR_IF( CONDITION, TYPE, MSG, RET ) \
  static_assert( false, "You are attempting to use PYTHON_ERROR_IF but haven't yet included Python.hpp" )
#endif

// UNCRUSTIFY-OFF

#if defined( __clang_version__ )
  #if defined( __CUDACC__ )
    #define BEGIN_ALLOW_DESIGNATED_INITIALIZERS \
      _Pragma( "GCC diagnostic push" ) \
      _Pragma( "GCC diagnostic ignored \"-Wc99-extensions\"") \
      _Pragma( "GCC diagnostic ignored \"-Wgnu-designator\"")
    #if __has_warning( "-Wc99-designator" )
      _Pragma( "GCC diagnostic ignored \"-Wc99-designator\"")
    #endif
  #else
    #define BEGIN_ALLOW_DESIGNATED_INITIALIZERS \
      _Pragma( "GCC diagnostic push" ) \
      _Pragma( "GCC diagnostic ignored \"-Wc99-designator\"")
  #endif
#elif defined( __GNUC__ )
  #define BEGIN_ALLOW_DESIGNATED_INITIALIZERS \
    _Pragma( "GCC diagnostic push" ) \
    _Pragma( "GCC diagnostic ignored \"-Wpedantic\"" ) \
    _Pragma( "GCC diagnostic ignored \"-Wmissing-field-initializers\"" )
    #if __GNUC__ > 8 
      _Pragma( "GCC diagnostic ignored \"-Wc++20-extensions\"")
    #endif
#endif

#define END_ALLOW_DESIGNATED_INITIALIZERS \
  _Pragma( "GCC diagnostic pop" )

// UNCRUSTIFY-ON

namespace LvArray
{
namespace python
{
namespace internal
{

void xincref( PyObject * const obj );

void xdecref( PyObject * const obj );

bool isInstanceOf( PyObject * const obj, PyTypeObject * type );

} // namespace internal

enum class PyModify
{
  READ_ONLY = 0,
  MODIFIABLE = 1,
  RESIZEABLE = 2,
};

template< typename T = PyObject >
class PyObjectRef
{
public:

  PyObjectRef() = default;

  PyObjectRef( T * const src ):
    m_object( src )
  {}

  PyObjectRef( PyObjectRef const & src )
  { *this = src; }

  PyObjectRef( PyObjectRef && src )
  { *this = std::move( src ); }

  ~PyObjectRef()
  { internal::xdecref( reinterpret_cast< PyObject * >( m_object ) ); }

  PyObjectRef & operator=( PyObjectRef const & src )
  {
    m_object = src.m_object;
    internal::xincref( reinterpret_cast< PyObject * >( src.m_object ) );
    return *this;
  }

  PyObjectRef & operator=( PyObjectRef && src )
  {
    m_object = src.m_object;
    src.m_object = nullptr;
    return *this;
  }

  PyObjectRef & operator=( PyObject * src )
  {
    internal::xdecref( reinterpret_cast< PyObject * >( m_object ) );

    m_object = src;
    return *this;
  }

  operator T *()
  { return m_object; }

  T * get() const
  { return m_object; }

  T * * getAddress()
  { return &m_object; }

  T * release()
  {
    T * const ret = m_object;
    m_object = nullptr;
    return ret;
  }

private:
  T * m_object = nullptr;
};

template< typename T >
T * convert( PyObject * const obj, PyTypeObject * const type )
{
  if( internal::isInstanceOf( obj, type ) )
  {
    return reinterpret_cast< T * >( obj );
  }

  return nullptr;
}

bool addTypeToModule( PyObject * const module,
                      PyTypeObject * const type,
                      char const * const typeName );

PyObject * create( std::string const & value );

PyObject * createPyListOfStrings( std::string const * const strptr, long long const size );

inline PyObject * create( std::vector< std::string > const & vec )
{ return createPyListOfStrings( vec.data(), integerConversion< long long >( vec.size() ) ); }

class PythonError : public std::runtime_error
{
public:
  PythonError():
    std::runtime_error( LvArray::system::stackTrace( true ) )
  {}
};

} // namespace python
} // namespace LvArray