python.AlgSequence.AlgSequenceIterator Class Reference

Collaboration diagram for python.AlgSequence.AlgSequenceIterator:

Public Member Functions
	__init__ (self, sequence)
	__iter__ (self)
	__next__ (self)

Protected Attributes
	_sequence = sequence
int	_index = 0
	_iterator = None

Detailed Description

Iterator over a standalone algorithm sequence

This custom class is needed to implement a "recursive iteration", which
would loop over all algorithms in a sequence that itself may have
sub-sequences inside of it.

Definition at line 216 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

Constructor & Destructor Documentation

__init__()

python.AlgSequence.AlgSequenceIterator.__init__	(		self,
			sequence )

Constructor for the algorithm sequence iterator

Keyword arguments:
  sequence -- The sequence to iterate over (recursively)

Definition at line 224 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

        def __init__( self, sequence ):
            """Constructor for the algorithm sequence iterator
 
            Keyword arguments:
              sequence -- The sequence to iterate over (recursively)
            """
 
            # Set up the internal variables:
            self._sequence = sequence
            self._index = 0
            self._iterator = None
 
            return
 

Member Function Documentation

__iter__()

python.AlgSequence.AlgSequenceIterator.__iter__

(

self

)

Function making this iterator iterable itself

Definition at line 238 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

        def __iter__( self ):
            """Function making this iterator iterable itself
            """
            return self
 

__next__()

python.AlgSequence.AlgSequenceIterator.__next__

(

self

)

Function implementing the recursive iteration over an AlgSequence

This is where most of the logic is. The iterator loops over the
elements of the AlgSequence that was given to it, one by one. When
it finds an element in the AlgSequence that itself is also an
AlgSequence, then it creates a helper iterator object that would
process that sub-sequence, and continue the iteration using that
helper.

The end result is that the iteration should loop over every
algorithm in the sequence and its sub-sequences.

Definition at line 243 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

        def __next__( self ):
            """Function implementing the recursive iteration over an AlgSequence
 
            This is where most of the logic is. The iterator loops over the
            elements of the AlgSequence that was given to it, one by one. When
            it finds an element in the AlgSequence that itself is also an
            AlgSequence, then it creates a helper iterator object that would
            process that sub-sequence, and continue the iteration using that
            helper.
 
            The end result is that the iteration should loop over every
            algorithm in the sequence and its sub-sequences.
            """
 
            # First off, check whether we reached the end of the sequence.
            if self._index >= len( self._sequence ):
                raise StopIteration()
 
            # If not, check whether we are currently iterating over a
            # sub-sequence.
            if self._iterator:
                try:
                    return self._iterator.__next__()
                except StopIteration:
                    # If the sub-sequence is exhaused, then switch to the
                    # next element in our sequence, and call this function
                    # recursively.
                    self._index += 1
                    self._iterator = None
                    return self.__next__()
 
            # If we are not iterating over a sub-sequence at the moment, let's
            # just take the next element of our sequence.
            element = self._sequence[ self._index ]
 
            # If this element is a sequence itself, then switch to "sub-sequence
            # iterating mode", and call this function recursively in that mode.
            if isinstance( element, AlgSequence ):
                self._iterator = AlgSequenceIterator( element )
                return self.__next__()
 
            # Apparently it's an algorithm we found. So update the internal
            # index, and simply return the algorithm.
            self._index += 1
            return element
 
    #

Member Data Documentation

_index

int python.AlgSequence.AlgSequenceIterator._index = 0

protected

Definition at line 233 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

_iterator

python.AlgSequence.AlgSequenceIterator._iterator = None

protected

Definition at line 234 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

_sequence

python.AlgSequence.AlgSequenceIterator._sequence = sequence

protected

Definition at line 232 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

---

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

• PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py