rootpyPickler.Pickler Class Reference

Inheritance diagram for rootpyPickler.Pickler:

Collaboration diagram for rootpyPickler.Pickler:

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

Private Attributes
	__file
	__keys
	__io
	__pmap

Detailed Description

Definition at line 145 of file rootpyPickler.py.

Constructor & Destructor Documentation

__init__()

rootpyPickler.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 146 of file rootpyPickler.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 = IO_Wrapper()
        self.__pmap = {}
        if sys.version_info[0] < 3:
            # 2.X old-style classobj
            pickle.Pickler.__init__(self, self.__io, proto)
        else:
            super(Pickler, self).__init__(self.__io, proto)
 

Member Function Documentation

clear_memo()

rootpyPickler.Pickler.clear_memo

(

self

)

Clears the pickler's internal memo.

Definition at line 179 of file rootpyPickler.py.

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

dump()

rootpyPickler.Pickler.dump	(		self,
			obj,
			key = None
	)

Write a pickled representation of obj to the open TFile.

Definition at line 163 of file rootpyPickler.py.

    def dump(self, obj, key=None):
        """Write a pickled representation of obj to the open TFile."""
        if key is None:
            key = '_pickle'
        if 1>0:
            self.__file.cd()
            if sys.version_info[0] < 3:
                pickle.Pickler.dump(self, obj)
            else:
                super(Pickler, self).dump(obj)
            s = ROOT.TObjString(self.__io.getvalue())
            self.__io.reopen()
            s.Write(key)
            self.__file.GetFile().Flush()
            self.__pmap.clear()
 

persistent_id()

rootpyPickler.Pickler.persistent_id	(		self,
			obj
	)

Definition at line 183 of file rootpyPickler.py.

    def persistent_id(self, obj):
        if hasattr(obj, '_ROOT_Proxy__obj'):
            obj = obj._ROOT_Proxy__obj()
        if isinstance(obj, ROOT.TObject):
            """
            Write the object, and return the resulting NAME;CYCLE.
            We used to do this::
 
               o.Write()
               k = self.__file.GetKey(o.GetName())
               pid = "{0};{1:d}".format(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 = obj.GetName()
            key = self.__keys.FindObject(nm)
            obj.Write()
            if key:
                key = self.__file.GetKey(nm)
                pid = '{0};{1:d}'.format(nm, key.GetCycle())
            else:
                pid = nm + ';1'
            return pid
 
 

Member Data Documentation

__file

rootpyPickler.Pickler.__file

private

Definition at line 153 of file rootpyPickler.py.

__io

rootpyPickler.Pickler.__io

private

Definition at line 155 of file rootpyPickler.py.

__keys

rootpyPickler.Pickler.__keys

private

Definition at line 154 of file rootpyPickler.py.

__pmap

rootpyPickler.Pickler.__pmap

private

Definition at line 156 of file rootpyPickler.py.

---

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

• python/rootpyPickler.py