callable.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_CALLABLE_HH
#define DUNE_FUFEM_PYTHON_CALLABLE_HH
 
// Only introduce the dune-python interface if python
// was found and enabled.
#if HAVE_PYTHON || DOXYGEN
 
#include <Python.h>
 
#include <string>
#include <sstream>
#include <vector>
#include <map>
 
#include <dune/common/exceptions.hh>
#include <dune/common/shared_ptr.hh>
#include <dune/common/fvector.hh>
#include <dune/common/parametertree.hh>
#include <dune/common/typetraits.hh>
#include <dune/common/indices.hh>
 
#include <dune/grid/common/gridfactory.hh>
 
#include <dune/fufem/python/reference.hh>
 
 
namespace Python
{
 
// forward declarations
void handlePythonError(const std::string& origin, const std::string& message);
Reference dict();
 
namespace Imp
{
    // forward declarations
    PyObject* inc(PyObject* p);
 
 
 
    // Helper for marking a keyword argument
    template<class Key, class Value>
    struct KeyWordArgument
    {
        Key key;
        Value value;
    };
 
 
 
    // Check for KeyWordArgument
    template<class T>
    struct IsKeyWordArgument : std::false_type {};
 
    template<class Key, class Value>
    struct IsKeyWordArgument<KeyWordArgument<Key, Value>> : std::true_type {};
 
    // Count positional (non-keyword) arguments up to pos-1.
    // The result is returned as compile time constant using index_constant.
    template<std::size_t pos, class... Args>
    auto positionalArgumentCount()
    {
        using ArgTuple = std::tuple<Args...>;
        return Dune::unpackIntegerSequence([] (auto... i) {
            return Dune::index_constant<(0 + ... + not(Imp::IsKeyWordArgument<std::decay_t<std::tuple_element_t<i, ArgTuple>>>::value))>();
        }, std::make_index_sequence<pos>{});
    }
 
    // Helper for tagging string as keyword
    template<class Char>
    struct KeyWord {
        std::string key;
        template <typename Value>
        KeyWordArgument<std::string, Value> operator=(Value&& value) const {
            return {key, std::forward<Value>(value)};
        }
    };
 
    // Parse argument list. The list may contain positional and keyword arguments.
    // The parameters to this function are two callback functions, followed by
    // the arguments to be parsed. Positional and keyword arguments may be interleaved.
    // In any case only positional arguments are counted when determining the position
    // of a positional argument.
    //
    // The first callback will be called with (pos,arg) for each positional argument arg
    // with its position pos (as compile time value using Dune::index_constant).
    // The second callback will be called with (keyword, value) for each
    // keyword argument.
    template<class PositionalCallback, class KeyWordCallBack, class... Args>
    void parseKeywordArguments(PositionalCallback&& posCallback, KeyWordCallBack&& kwCallBack, Args&&... args)
    {
        auto processArgument = [&](auto i, auto&& arg)
        {
            if constexpr (IsKeyWordArgument<std::decay_t<decltype(arg)>>::value)
                kwCallBack(arg.key, arg.value);
            else
                posCallback(positionalArgumentCount<i, Args...>(), std::forward<decltype(arg)>(arg));
        };
        // Unfold argument pack to process arguments. Doing this via
        // std::initializer_list guarantees the proper evaluation order.
        // To additionally pass the argument indices as variadic argument pack,
        // we use unpackIntegerSequence.
        //
        // Here one would like to simply unpack args like this:
        // std::initializer_list<int>{ (processArgument(i, args), 0)...};
        // But capturing parameter packs does not work in C++17
        // (in fact gcc allows it). Hence we have to artificially
        // wrap in this in a tuple and access entries using std::get.
        //
        // Create a tuple preserving value categories.
        // This will store appropriate l- and r-value references
        // to the individual arguments.
        auto argTuple = std::forward_as_tuple(std::forward<Args>(args)...);
        Dune::unpackIntegerSequence([&](auto... i) {
            // Extract tuple entries restoring the value category.
            // Notice that due to reference collapsing this also returns
            // l-value references properly. Furthermore doing multiple
            // move's on the same tuple is OK here, because each move
            // only changes the value category of the returned entry
            // but does not modify the tuple itself.
            [[maybe_unused]] auto dummy = std::initializer_list<int>{ (processArgument(i, std::get<i>(std::move(argTuple))), 0)...};
        }, std::index_sequence_for<Args...>());
    }
 
} // namespace Imp
 
 
template<class Key, class Value>
auto arg(Key key, Value&& value)
{
    using StoredKey = std::conditional_t<std::is_same_v<Key, const char*>, std::string, Key>;
    return Imp::KeyWordArgument<StoredKey, Value>{key, std::forward<Value>(value)};
}
 
namespace Literals {
    Imp::KeyWord<char> operator ""_a(const char* keyword, std::size_t) {
        return {keyword};
    }
}
 
 
 
class Callable :
    public Reference
{
    public:
 
        Callable() :
            Reference()
        {}
 
        Callable(PyObject* p) :
            Reference(p)
        {
            assertCallable(p_, "Callable(PyObject*)");
        }
 
        Callable(const Reference& other) :
            Reference(other)
        {
            assertCallable(p_, "Callable(Reference&)");
        }
 
        virtual ~Callable()
        {}
 
        virtual Callable& operator= (const Reference& other)
        {
            assertCallable(other, "Callable::operator=(Reference&)");
            Reference::operator=(other);
            return *this;
        }
 
        Reference callWithArgumentTuple(const Reference& args) const
        {
            assertPyObject("Callable::callWithArgumentTuple()");
            PyObject* result = PyObject_CallObject(p_, args);
            if (not result)
                handlePythonError("Callable::callWithArgumentTuple()", "failed to call object");
            return result;
        }
 
        Reference callWithArgumentTupleAndKeywordArgs(const Reference& args, const Reference& keywordArgs) const
        {
            assertPyObject("Callable::callWithArgumentTupleAndKeywordArgs()");
            PyObject* result = PyObject_Call(p_, args, keywordArgs);
            if (not result)
                handlePythonError("Callable::callWithArgumentTupleAndKeywordArgs()", "failed to call object");
            return result;
        }
 
        template<class... Args>
        Reference operator() (const Args&... args) const
        {
            static constexpr std::size_t kwArgCount = (0 + ... + Imp::IsKeyWordArgument<Args>::value);
            if constexpr (kwArgCount == 0)
                return callWithArgumentTuple(makeTuple(args...));
            else
            {
                Reference kwArgDict = dict();
                Reference argTuple = PyTuple_New(sizeof...(Args)-kwArgCount);
                Imp::parseKeywordArguments(
                    [&](auto position, auto&& arg) {
                        PyTuple_SetItem(argTuple, position, Imp::inc(makeObject(arg)));
                    }, [&](auto keyword, auto&& value) {
                        PyDict_SetItem(kwArgDict, makeObject(keyword), makeObject(value));
                        // We have to use inc() since PyTuple_SetItem STEALS a reference!
                    }, args...);
                return callWithArgumentTupleAndKeywordArgs(argTuple, kwArgDict);
            }
        }
 
    protected:
 
        static void assertCallable(PyObject* p, const std::string& origin)
        {
            if (p and (not PyCallable_Check(p)))
                DUNE_THROW(Dune::Exception,
                    "Python error occurred." << std::endl <<
                    "  Origin:  " << origin << std::endl <<
                    "  Error:   Trying to use a non-callable as callable");
        }
};
 
 
template<class ResultType>
auto make_function(Callable pyCallable)
{
    return [pyCallable](auto&&... args) {
        return pyCallable(std::forward<decltype(args)>(args)...).template toC<ResultType>();
    };
}
 
} // end of namespace Python
 
 
 
#else
    #warning dunepython.hh was included but python was not found or enabled!
#endif // DUNE_FUFEM_PYTHON_CALLABLE_HH
 
 
#endif