Inheritance diagram for python.AlgSequence.AlgSequenceIterator:

Collaboration diagram for python.AlgSequence.AlgSequenceIterator:

Public Member Functions
def	__init__ (self, sequence)

def	__iter__ (self)

def	__next__ (self)

Private Attributes
	_sequence

	_index

	_iterator

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 234 of file PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/AlgSequence.py.

Constructor & Destructor Documentation

◆ init()

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

Constructor for the algorithm sequence iterator

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

Definition at line 242 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()

def python.AlgSequence.AlgSequenceIterator.__iter__ ( self )

Function making this iterator iterable itself

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

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

◆ next()

def 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 261 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__()
                 pass
  
             # 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
  