TPython

class TPython

    private:

      static Bool_t Initialize()

    public:

                             TPython()
                             TPython(const TPython&)
                     virtual ~TPython()
               static Bool_t Bind(TObject* object, const char* label)
              static TClass* Class()
      static const TPyReturn Eval(const char* expr) const
                 static void Exec(const char* cmd)
             virtual TClass* IsA() const
                 static void LoadMacro(const char* name)
                    TPython& operator=(const TPython&)
                 static void Prompt()
                virtual void ShowMembers(TMemberInspector& insp, char* parent)
                virtual void Streamer(TBuffer& b)
                        void StreamerNVirtual(TBuffer& b)

Data Members

Class Description

                          Python interpreter access
                          =========================

 The TPython class allows for access to python objects from CINT. The current
 functionality is only basic: ROOT objects and builtin types can freely cross
 the boundary between the two interpreters, python objects can be instantiated
 and their methods can be called. All other cross-coding is based on strings
 that are run on the python interpreter.

 Examples:

  $ cat MyPyClass.py
  print 'creating class MyPyClass ... '

  class MyPyClass:
     def __init__( self ):
        print 'in MyPyClass.__init__'

     def gime( self, what ):
        return what

  $ root -l
  // Execute a string of python code.
  root [0] TPython::Exec( "print \'Hello World!\'" );
  Hello World!

  // Create a TBrowser on the python side, and transfer it back and forth.
  // Note the required explicit (void*) cast!
  root [1] TBrowser* b = (void*)TPython::Eval( "ROOT.TBrowser()" );
  root [2] TPython::Bind( b, "b" );
  root [3] b == (void*) TPython::Eval( "b" )
  (int)1

  // Builtin variables can cross-over by using implicit casts.
  root [4] int i = TPython::Eval( "1 + 1" );
  root [5] i
  (int)2

  // Load a python module with a class definition, and use it.
  root [6] TPython::LoadMacro( "MyPyClass.py" );
  creating class MyPyClass ...
  root [7] MyPyClass m;
  in MyPyClass.__init__
  root [8] char* s = m.gime( "aap" );
  root [9] s
  (char* 0x41ee7754)"aap"

 It is possible to switch between interpreters by calling "TPython::Prompt()"
 on the CINT side, while returning with ^D (EOF). State is preserved between
 successive switches.

 Private initialization method: setup the python interpreter and load the
 ROOT module.

 Execute the give python script as if it were a macro (effectively an
 execfile in __main__), and create CINT equivalents for any newly available
 python classes.

 Execute a python statement (e.g. "import ROOT").

 Evaluate a python expression (e.g. "ROOT.TBrowser()").

 Caution: do not hold on to the return value: either store it in a builtin
 type (implicit casting will work), or in a pointer to a ROOT object (explicit
 casting to a void* is required).

 Bind a ROOT object with, at the python side, the name "label".

 Enter an interactive python session (exit with ^D). State is preserved
 between successive calls.

Inline Functions

               void ~TPython()
            TClass* Class()
            TClass* IsA() const
               void ShowMembers(TMemberInspector& insp, char* parent)
               void Streamer(TBuffer& b)
               void StreamerNVirtual(TBuffer& b)
            TPython TPython()
            TPython TPython(const TPython&)
           TPython& operator=(const TPython&)