python.root_pickle.Pickler Class Reference

Inheritance diagram for python.root_pickle.Pickler:

Collaboration diagram for python.root_pickle.Pickler:

Public Member Functions
	__init__ (self, file, proto=0)
	dump (self, o, key=None)
	clear_memo (self)

Protected Member Functions
	_persistent_id (self, o)

Private Attributes
	__file = file
	__keys = file.GetListOfKeys()
	__io = Write_Wrapper()
	__pickle = pickle.Pickler (self.__io, proto)
dict	__pmap = {}

Detailed Description

Definition at line 200 of file root_pickle.py.

Constructor & Destructor Documentation

__init__()

python.root_pickle.Pickler.__init__	(		self,
			file,
			proto = 0 )

Create a root pickler.
FILE should be a Root TFile.  PROTO is the python pickle protocol
version to use.  The python part will be pickled to a Root
TObjString called _pickle; it will contain references to the
Root objects.

Definition at line 201 of file root_pickle.py.

    def __init__ (self, file, proto=0):
        """Create a root pickler.
FILE should be a Root TFile.  PROTO is the python pickle protocol
version to use.  The python part will be pickled to a Root
TObjString called _pickle; it will contain references to the
Root objects.
"""
        self.__file = file
        self.__keys = file.GetListOfKeys()
        self.__io = Write_Wrapper()
        self.__pickle = pickle.Pickler (self.__io, proto)
        self.__pickle.persistent_id = self._persistent_id
        self.__pmap = {}
        return
 
 

Member Function Documentation

_persistent_id()

python.root_pickle.Pickler._persistent_id ( self, o )

protected

Definition at line 242 of file root_pickle.py.

    def _persistent_id (self, o):
        if hasattr (o, '_Root_Proxy__obj'):
            o = o._Root_Proxy__obj()
        if (isinstance (o, ROOT.TObject)):
            # Write the object, and return the resulting NAME;CYCLE.
            # We used to to this like this:
            #o.Write()
            #k = self.__file.GetKey (o.GetName())
            #pid = "%s;%d" % (k.GetName(), k.GetCycle())
            # It turns out, though, that destroying the python objects
            # referencing the TKeys is quite expensive (O(logN) where
            # N is the total number of pyroot objects?).  Although
            # we want to allow for the case of saving multiple objects
            # with the same name, the most common case is that the name
            # has not already been written to the file.  So we optimize
            # for that case, doing the key lookup before we write the
            # object, not after.  (Note further: GetKey() is very slow
            # if the key does not actually exist, as it does a linear
            # search of the key list.  We use FindObject instead for the
            # initial lookup, which is a hashed lookup, but it is not
            # guaranteed to find the highest cycle.  So if we do
            # find an existing key, we need to look up again using GetKey.
            nm = o.GetName()
            k = self.__keys.FindObject(nm)
            o.Write()
            if k:
                k = self.__file.GetKey (nm)
                pid = "%s;%d" % (nm, k.GetCycle())
            else:
                pid = nm + ";1"
            return pid
        return
 
 
 

clear_memo()

python.root_pickle.Pickler.clear_memo

(

self

)

Clears the pickler's internal memo.

Definition at line 235 of file root_pickle.py.

    def clear_memo (self):
        """Clears the pickler's internal memo."""
        self.__pickle.memo.clear()
        return
    
 
 

dump()

python.root_pickle.Pickler.dump	(		self,
			o,
			key = None )

Write a pickled representation of o to the open TFile.

Definition at line 217 of file root_pickle.py.

    def dump (self, o, key=None):
        """Write a pickled representation of o to the open TFile."""
        if key is None:
            key = '_pickle'
        directory = _getdir()
        try:
            self.__file.cd()
            self.__pickle.dump (o)
            s = self.__io.getvalue()
            self.__io.reopen()
            s.Write (key)
            self.__file.Flush()
            self.__pmap.clear()
        finally:
            _setdir (directory)
        return
 
 

Member Data Documentation

__file

python.root_pickle.Pickler.__file = file

private

Definition at line 208 of file root_pickle.py.

__io

python.root_pickle.Pickler.__io = Write_Wrapper()

private

Definition at line 210 of file root_pickle.py.

__keys

python.root_pickle.Pickler.__keys = file.GetListOfKeys()

private

Definition at line 209 of file root_pickle.py.

__pickle

python.root_pickle.Pickler.__pickle = pickle.Pickler (self.__io, proto)

private

Definition at line 211 of file root_pickle.py.

__pmap

dict python.root_pickle.Pickler.__pmap = {}

private

Definition at line 213 of file root_pickle.py.

---

The documentation for this class was generated from the following file:

• root_pickle.py