callbacks.cpp

Go to the documentation of this file.

/* @authors 11/2023 :: ICON Community Interface  <comin@icon-model.org>
 
   SPDX-License-Identifier: BSD-3-Clause
 
   Please see the file LICENSE in the root of the source tree for this code.
   Where software is supplied by third parties, it is indicated in the
   headers of the routines. */
 
#define PY_SSIZE_T_CLEAN
#include <Python.h>
 
#include <map>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "comin.h"
#include "util.h"
 
#include "callbacks.h"
#include "exception.h"
 
namespace comin::python {
 
// stores a vector of callable python objects for each plugin id and entry
// point. In contrast to the fortran and c interface we explicitly allow to
// register multiple callbacks for every entrypoint. This makes it
// easy to combine multiple python 3rd party modules. However, we do not make
// any guarantees about the order in which the callbacks are called.
static std::map<int, std::map<int, std::vector<PyObject*>>> callbacks;
 
void generic_callback() {
  int ep        = 0;
  ep            = comin_current_get_ep();
  int plugin_id = comin_current_get_plugin_id();
  for (PyObject* fun : callbacks[plugin_id][ep]) {
    // call it (no arguments supplied)
    PyObject* rv = PyObject_CallObject(fun, 0);
    Py_CLEAR(rv);
    if (PyErr_Occurred()) {
      PyErr_Print();
      comin_plugin_finish("python_adapter", "Uncaught exception in callback");
    }
  }
}
 
static PyObject* callback_register(PyObject* /*self*/, PyObject* args) {
  int ientry_point;
  PyObject* callback;
  if (!PyArg_ParseTuple(args, "iO", &ientry_point, &callback)) {
    return NULL;
  }
  int entry_point = ientry_point;
  if (!PyCallable_Check(callback)) {
    return PyErr_Format(PyExc_TypeError, "A callable is required");
  }
 
  int plugin_id = comin_current_get_plugin_id();
  if (callbacks[plugin_id].find(entry_point) == callbacks[plugin_id].end() &&
      entry_point != EP_DESTRUCTOR) {
    comin_callback_register((t_comin_entry_point)ientry_point,
                            &generic_callback);
    check_error();
  }
  Py_INCREF(callback);
  callbacks[plugin_id][entry_point].push_back(callback);
  Py_RETURN_NONE;
}
 
static PyObject* EP_DESCTRUCTOR(PyObject* /*self*/, PyObject* /*args*/) {
  return PyLong_FromLong((long)EP_DESTRUCTOR);
}

static PyObject* callback_get_ep_name(PyObject* /*self*/, PyObject* args,
                                      PyObject* kwargs) {
  int iep;
  static char const* kwlist[] = {(char*)"iep", NULL};
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i", (char**)&kwlist, &iep)) {
    return NULL;
  }
  const char* out_ep_name =
      comin_callback_get_ep_name((t_comin_entry_point)iep);
  using namespace std::string_literals;
  check_error("ep = "s + std::to_string(iep));
  return Py_BuildValue("s", out_ep_name);
};
 
std::vector<PyMethodDef> callbacks_methods() {
  return {
      {"_callback_register", func_wrapper<callback_register>, METH_VARARGS,
       "Registers callback to ICON"},
      {"_EP_DESTRUCTOR", func_wrapper<EP_DESCTRUCTOR>, METH_NOARGS, ""},
      {"callback_get_ep_name", (PyCFunction)func_wrapper<callback_get_ep_name>,
       METH_VARARGS | METH_KEYWORDS,
       "C function signature: const char* "
       "comin_callback_get_ep_name(t_comin_entry_point iep)"},
  };
}
} // namespace comin::python