ObjectPtr.h

Go to the documentation of this file.

/*
 *  CepGen: a central exclusive processes event generator
 *  Copyright (C) 2018-2024  Laurent Forthomme
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef CepGenAddOns_PythonWrapper_ObjectPtr_h
#define CepGenAddOns_PythonWrapper_ObjectPtr_h
 
#include <Python.h>
 
#if PY_MAJOR_VERSION < 3
#define PYTHON2
#endif
 
#include <memory>
#include <string>
#include <vector>
 
namespace cepgen {
  namespace python {
    typedef std::unique_ptr<PyObject, void (*)(PyObject*)> PyObjectPtr;
    class ObjectPtr : public PyObjectPtr {
    public:
      explicit ObjectPtr(PyObject*, bool wrap_only = false);
 
      static ObjectPtr wrap(PyObject*);
      static ObjectPtr importModule(const std::string&);
      static ObjectPtr defineModule(const std::string&, const std::string&);
 
      template <typename T>
      static ObjectPtr make(const T&);
      template <typename T>
      static inline ObjectPtr make(const std::vector<T>& vec) {
        ObjectPtr list(PyList_New(vec.size()));
        for (size_t i = 0; i < vec.size(); ++i)
          PyList_SetItem(list.get(), i, make(vec.at(i)).release());
        return list;
      }
 
      template <typename T>
      bool is() const;
      template <typename T>
      T value() const;
      template <typename T>
      bool isVector() const;
      template <typename T>
      std::vector<T> vector() const;
 
      template <typename T>
      static ObjectPtr tupleFromVector(const std::vector<T>&);
      template <typename... Args>
      static inline ObjectPtr tuple(const std::tuple<Args...>& c_tuple) {
        const auto tuple_size = sizeof...(Args);
        ObjectPtr tuple(PyTuple_New(tuple_size));
        Py_ssize_t i = 0;
        std::apply(
            [&tuple, &i](auto... vals) {
              ((PyTuple_SetItem(tuple.get(), i++, make<decltype(vals)>(vals).release())), ...);
            },
            c_tuple);
        return tuple;
      }
 
      friend std::ostream& operator<<(std::ostream&, const ObjectPtr&);
 
      template <typename... Args>
      inline ObjectPtr operator()(Args&&... args) {
        return call(tuple(std::make_tuple(std::forward<Args>(args)...)));  // new
      }
      ObjectPtr call(const ObjectPtr&) const;
      ObjectPtr attribute(const std::string&) const;
    };
  }  // namespace python
}  // namespace cepgen
 
#endif