TPyArg.cxx

Go to the documentation of this file.

// Author: Enric Tejedor CERN  08/2019
// Original PyROOT code by Wim Lavrijsen, LBL
//
// /*************************************************************************
//  * Copyright (C) 1995-2019, Rene Brun and Fons Rademakers.               *
//  * All rights reserved.                                                  *
//  *                                                                       *
//  * For the licensing terms see $ROOTSYS/LICENSE.                         *
//  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
//  *************************************************************************/
 
// Bindings
#include "CPyCppyy.h"
#include "TPyArg.h"
 
//______________________________________________________________________________
//                        Generic wrapper for arguments
//                        =============================
//
// Transport class for bringing C++ values and objects from Cling to Python. It
// provides, from the selected constructor, the proper conversion to a PyObject.
// In principle, there should be no need to use this class directly: it relies
// on implicit conversions.
 
//- data ---------------------------------------------------------------------
ClassImp(TPyArg);
 
//- constructor dispatcher ---------------------------------------------------
void TPyArg::CallConstructor(PyObject *&pyself, PyObject *pyclass, const std::vector<TPyArg> &args)
{
   int nArgs = args.size();
   PyObject *pyargs = PyTuple_New(nArgs);
   for (int i = 0; i < nArgs; ++i)
      PyTuple_SET_ITEM(pyargs, i, (PyObject *)args[i]);
   pyself = PyObject_Call(pyclass, pyargs, NULL);
   Py_DECREF(pyargs);
}
 
////////////////////////////////////////////////////////////////////////////////
void CallConstructor(PyObject *&pyself, PyObject *pyclass)
{
   PyObject *pyargs = PyTuple_New(0);
   pyself = PyObject_Call(pyclass, pyargs, NULL);
   Py_DECREF(pyargs);
}
 
//- generic dispatcher -------------------------------------------------------
PyObject *TPyArg::CallMethod(PyObject *pymeth, const std::vector<TPyArg> &args)
{
   int nArgs = args.size();
   PyObject *pyargs = PyTuple_New(nArgs);
   for (int i = 0; i < nArgs; ++i)
      PyTuple_SET_ITEM(pyargs, i, (PyObject *)args[i]);
   PyObject *result = PyObject_Call(pymeth, pyargs, NULL);
   Py_DECREF(pyargs);
   return result;
}
 
//- denstructor dispatcher ----------------------------------------------------
void TPyArg::CallDestructor(PyObject *&pyself, PyObject *, const std::vector<TPyArg> &)
{
   Py_XDECREF(pyself); // calls actual dtor if ref-count down to 0
}
 
////////////////////////////////////////////////////////////////////////////////
void TPyArg::CallDestructor(PyObject *&pyself)
{
   Py_XDECREF(pyself);
}
 
//- constructors/destructor --------------------------------------------------
TPyArg::TPyArg(PyObject *pyobject)
{
   // Construct a TPyArg from a python object.
   Py_XINCREF(pyobject);
   fPyObject = pyobject;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Construct a TPyArg from an integer value.
 
TPyArg::TPyArg(Int_t value)
{
   fPyObject = PyInt_FromLong(value);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Construct a TPyArg from an integer value.
 
TPyArg::TPyArg(Long_t value)
{
   fPyObject = PyLong_FromLong(value);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Construct a TPyArg from a double value.
 
TPyArg::TPyArg(Double_t value)
{
   fPyObject = PyFloat_FromDouble(value);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Construct a TPyArg from a C-string.
 
TPyArg::TPyArg(const char *value)
{
   fPyObject = CPyCppyy_PyText_FromString(value);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Copy constructor.
 
TPyArg::TPyArg(const TPyArg &s)
{
   Py_XINCREF(s.fPyObject);
   fPyObject = s.fPyObject;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Assignment operator.
 
TPyArg &TPyArg::operator=(const TPyArg &s)
{
   if (&s != this) {
      Py_XINCREF(s.fPyObject);
      fPyObject = s.fPyObject;
   }
   return *this;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Done with held PyObject.
 
TPyArg::~TPyArg()
{
   Py_XDECREF(fPyObject);
   fPyObject = NULL;
}
 
//- public members -----------------------------------------------------------
TPyArg::operator PyObject *() const
{
   // Extract the python object.
   Py_XINCREF(fPyObject);
   return fPyObject;
}