reference.hh

Go to the documentation of this file.

// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set ts=8 sw=4 et sts=4:
 
// SPDX-FileCopyrightText: Copyright © DUNE-FUFEM Project contributors, see file AUTHORS.md
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception OR LGPL-3.0-or-later
 
#ifndef DUNE_FUFEM_PYTHON_REFERENCE_HH
#define DUNE_FUFEM_PYTHON_REFERENCE_HH
 
// Only introduce the dune-python interface if python
// was found and enabled.
#if HAVE_PYTHON || DOXYGEN
 
#include <Python.h>
 
#include <string>
#include <type_traits>
 
#include <dune/common/exceptions.hh>
#include <dune/common/typetraits.hh>
#include <dune/common/stringutility.hh>
 
 
 
namespace Python
{
 
 
 
// forward declaration needed by Python::Reference
class Reference;
template<class T> struct Conversion;
template<class T> Reference makeObject(const T& t);
template<typename... Ts> Reference makeTuple(const Ts&...);
void handlePythonError(const std::string& origin, const std::string& message);
 
 
 
class Reference
{
    public:
 
        Reference() :
            p_(0)
        {}
 
        Reference(PyObject* p) :
            p_(p)
        {}
 
        Reference(const Reference& other) :
            p_(other.p_)
        {
            Py_XINCREF(p_);
        }
 
        virtual ~Reference()
        {
            if (Py_IsInitialized())
                Py_XDECREF(p_);
        }
 
        virtual Reference& operator= (const Reference& other)
        {
            Py_XINCREF(other.p_);
            Py_XDECREF(p_);
            p_ = other.p_;
            return *this;
        }
 
        operator PyObject* () const
        {
            return p_;
        }
 
        template<class T>
        void toC(T& t) const
        {
            assertPyObject("toC()");
            Conversion<T>::toC(p_, t);
        }
 
        template<class T>
        typename std::enable_if< Conversion<T>::useDefaultConstructorConversion, T>::type toC() const
        {
            assertPyObject("toC()");
            T t;
            Conversion<T>::toC(p_, t);
            return t;
        }
 
        template<class T>
        typename std::enable_if< Conversion<T>::useCustomConstructorConversion, T>::type toC() const
        {
            assertPyObject("toC()");
            return Conversion<T>::toC(p_);
        }
 
        bool hasAttr(const std::string& name) const
        {
            assertPyObject("hasAttr()");
            return PyObject_HasAttrString(p_, name.c_str());
        }
 
        Reference get(const std::string& name) const
        {
            assertPyObject("get()");
            // This returns a new reference, i.e., it increments the reference count.
            PyObject* value = PyObject_GetAttrString(p_, name.c_str());
            if (not value)
                handlePythonError("get()", Dune::formatString("failed to get attribute '%s'", name.c_str()));
            return value;
        }
 
        template<class V>
        void set(const std::string& name, const V& value)
        {
            assertPyObject("set()");
            if (PyObject_SetAttrString(p_, name.c_str(), makeObject(value))==-1)
                handlePythonError("set()", Dune::formatString("failed to set attribute '%s'", name.c_str()));
        }
 
        std::string str() const
        {
            assertPyObject("str()");
#if PY_MAJOR_VERSION >= 3
            const char* s = PyUnicode_AsUTF8(PyObject_Str(p_));
#else
            char* s = PyString_AsString(PyObject_Str(p_));
#endif
            if (not s)
                handlePythonError("str()", "cannot obtain string representation");
            return s;
        }
 
    protected:
 
        void assertPyObject(const std::string& origin) const
        {
            if (not p_)
                DUNE_THROW(Dune::Exception,
                    "Python error occurred." << std::endl <<
                    "  Origin:  " << origin << std::endl <<
                    "  Error:   Python::Reference points to NULL object");
        }
 
        // We must store a mutable pointer since all methods of the
        // python api use nonsonst PyObject* pointers.
        mutable PyObject* p_;
};
 
 
} // end of namespace Python
 
 
 
#else
    #warning dunepython.hh was included but python was not found or enabled!
#endif // DUNE_FUFEM_PYTHON_REFERENCE_HH
 
 
#endif