Collaboration diagram for python.D3PDObject.D3PDObject:

Public Member Functions
	__init__ (self, maker, default_prefix='', default_object_name='', default_name=None, allow_args=[], **kw)
	defineBlock (self, lod, name, func, prefix=None, **kw)
	removeBlock (self, name, allowMissing=False)
	defineHook (self, hook)
	allBlocknames (self)
	__call__ (self, level, name=None, prefix=None, name_prefix='', parent_prefix='', object_name=None, include=[], exclude=[], blockargs={}, parent_hookargs=None, args, *kw)
	blockFillers (self, level, parent_name, parent_prefix='', include=[], exclude=[], blockargs={}, hookargs={})
	copy (self, default_prefix=None, default_object_name=None, default_name=None, **kw_in)

Static Public Member Functions
	runHooks (c, flags, acc)

Protected Member Functions
	_add_blockname (self, n, warnonly=False)
	_remove_blockname (self, n)
	_makeBlockFillers (self, c, level, parent_prefix, include, exclude, blockargs, hookargs)

Protected Attributes
	_maker = maker
	_default_object_name = default_object_name
list	_blocks = []
list	_hooks = []
dict	_all_blocknames = {}
	_default_prefix = default_prefix
	_default_name = default_name
	_hookArgs = kw
	_parent = None
	_allow_args = allow_args

Static Protected Attributes
dict	_hookArgsStore = {}

Detailed Description

D3PD object creator class.

For each type of object written to the D3PD, create
an instance of this class.  The arguments to the constructor
are a function to create the Configurable for the object filler
tool and a default value for the variable name prefix
for this block.

After creating the instance, one calls defineBlock to define
the blocks of variables that can be written for this object.

Finally, one calls the object in order to create the
configurable.

So, a typical usage might look like this.

  def makeElectronD3PDObject (name, prefix,
                              getter = None,
                              sgkey = 'ElectronAODCollection')
      if not getter:
          getter = CompFactory.D3PD.SGDataVectorGetterTool \
                   (name + '_Getter',
                    TypeName = 'ElectronContainer',
                    SGKey = sgkey)

      return CompFactory.D3PD.VectorFillerTool (name,
                                                Prefix = prefix,
                                                Getter = getter)

  ElectronD3PDObject = D3PDObject (makeElectronD3PDObject, 'el_')

  ElectronD3PDObject.defineBlock (0, 'Kinematics',
                                  EventCommonD3PDMaker.FourMomFillerTool)

  alg = ...
  alg += ElectronD3PDObject (level)

Definition at line 99 of file D3PDObject.py.

Constructor & Destructor Documentation

◆ init()

python.D3PDObject.D3PDObject.__init__	(		self,
			maker,
			default_prefix = '',
			default_object_name = '',
			default_name = None,
			allow_args = [],
		**	kw )

Constructor.

Arguments:
  maker: A function to create the IObjFillerTool Configurable
         for this object.  It is called with two fixed arguments,
         the tool name and the variable name prefix.  Any other
         arguments provided to the call will be passed through.
  default_prefix: Default variable name prefix for objects
                  of this type.
  default_object_name: Default D3PDObject name, something like
                       'EventInfoD3PDObject'
  default_name: If specified, the default tool name to use
                for these objects.
  allow_args: Additional arguments that may be passed in when
              instantiating the D3PDObject, but which are not
              to be passed to the maker function.  This can be
              used to allow for additional arguments to hook
              or level-of-detail functions.

  Any additional arguments are passed into any hook functions.

Definition at line 141 of file D3PDObject.py.

                  default_name = None, allow_args = [], **kw):
        """Constructor.
 
        Arguments:
          maker: A function to create the IObjFillerTool Configurable
                 for this object.  It is called with two fixed arguments,
                 the tool name and the variable name prefix.  Any other
                 arguments provided to the call will be passed through.
          default_prefix: Default variable name prefix for objects
                          of this type.
          default_object_name: Default D3PDObject name, something like
                               'EventInfoD3PDObject'
          default_name: If specified, the default tool name to use
                        for these objects.
          allow_args: Additional arguments that may be passed in when
                      instantiating the D3PDObject, but which are not
                      to be passed to the maker function.  This can be
                      used to allow for additional arguments to hook
                      or level-of-detail functions.
 
          Any additional arguments are passed into any hook functions.
 
"""
        self._maker = maker
        self._default_object_name = default_object_name
        self._blocks = []
        self._hooks = []
        self._all_blocknames = {}
        self._default_prefix = default_prefix
        self._default_name   = default_name
        self._hookArgs = kw
        self._parent = None
        self._allow_args = allow_args
        return
 
 

Member Function Documentation

◆ call()

python.D3PDObject.D3PDObject.__call__	(		self,
			level,
			name = None,
			prefix = None,
			name_prefix = '',
			parent_prefix = '',
			object_name = None,
			include = [],
			exclude = [],
			blockargs = {},
			parent_hookargs = None,
		*	args,
		**	kw )

Create a Configurable to fill an object of this type.

Arguments:
  level: Requested level of detail for this object.  An integer.
  name: Tool name.  If omitted, one will be constructed.
  prefix: Variable name prefix for this object.
  name_prefix: If name wasn't specified, this is a prefix
               to add to the tool name.
  parent_prefix: Variable name prefix for any parent tool.
  object_name: Name of the D3PDObject, like 'EventInfoD3PDObject'
  include: List of block names to include, regardless
           of level of detail.
  exclude: List of block names to exclude, regardless
           of level of detail.
  blockargs: Extra arguments to pass to block filler tools.
             The keys are block names.
             Values are dictionaries of keyword arguments.
             These override anything specified in defineBlock.
  parent_hookargs: [Not to be used by user code.]
                   Dictionary of hook args from the parent,
                   to be merged into our hook arg dictionary.
  args, kw: Additional arguments to pass to the maker function.
            However, any entries in KW that have the form
            BLOCK_parm, where BLOCK is a known block name,
            will instead be interpreted as arguments to pass
            to a block filler tool.  These override entries
            in BLOCKARGS.

Definition at line 316 of file D3PDObject.py.

                  *args, **kw):
        """Create a Configurable to fill an object of this type.
 
        Arguments:
          level: Requested level of detail for this object.  An integer.
          name: Tool name.  If omitted, one will be constructed.
          prefix: Variable name prefix for this object.
          name_prefix: If name wasn't specified, this is a prefix
                       to add to the tool name.
          parent_prefix: Variable name prefix for any parent tool.
          object_name: Name of the D3PDObject, like 'EventInfoD3PDObject'
          include: List of block names to include, regardless
                   of level of detail.
          exclude: List of block names to exclude, regardless
                   of level of detail.
          blockargs: Extra arguments to pass to block filler tools.
                     The keys are block names.
                     Values are dictionaries of keyword arguments.
                     These override anything specified in defineBlock.
          parent_hookargs: [Not to be used by user code.]
                           Dictionary of hook args from the parent,
                           to be merged into our hook arg dictionary.
          args, kw: Additional arguments to pass to the maker function.
                    However, any entries in KW that have the form
                    BLOCK_parm, where BLOCK is a known block name,
                    will instead be interpreted as arguments to pass
                    to a block filler tool.  These override entries
                    in BLOCKARGS.
"""
 
        # Prefix defaults to that given to the constructor.
        if prefix is None:
            prefix = self._default_prefix
 
        # Object name defaults to that given in the constructor
        if object_name is None:
            object_name = self._default_object_name
 
        # The tool name.
        if name is None:
            name = self._default_name
        name = _make_name (name, prefix, name_prefix, parent_prefix,
                           self._default_prefix)
 
        # Copy blockargs and kw.
        blockargs = dict ([(k, v.copy()) for (k, v) in blockargs.items()])
        kw = kw.copy()
 
        # Move any block filler args from kw to blockargs.
        for k in list (kw.keys()):
            # It is possible for block names themselves to contain
            # underscores.  So in the case we have more than one underscore
            # in the name, try all prefixes we can make, stopping at
            # the first (shortest) match.
            kk = k.split('_')
            for i in range(1, len(kk)):
                this_key = '_'.join (kk[:i])
                if this_key in self._all_blocknames:
                    this_var = '_'.join (kk[i:])
                    blockargs.setdefault(this_key,{})[this_var] = kw[k]
                    del kw[k]
                    break
 
        # Don't pass extra args listed in allow_args to the maker function.
        kw2 = kw.copy()
        for k in self._allow_args:
            if k in kw2: del kw2[k]
 
        # Call the maker function.
        try:
            c = self._maker (name=name, prefix=prefix, object_name=object_name,
                             *args, **kw2)  # noqa: B026 (star-arg unpacking after keyword OK here
                                            #             because we are handling failures below)
        except TypeError as exc:
            if (len(exc.args) > 0 and
                exc.args[0].find ("unexpected keyword argument 'object_name'") >= 0):
                log = logging.getLogger ('D3PDObject')
                log.warn ("Maker function missing `object_name' formal arg: %s", self._maker)
                c = self._maker (name=name, prefix=prefix, *args, **kw2)  # noqa: B026 (see above)
            else:
                raise
 
        # Construct arguments to pass to hooks.
        # Use a StackedDict: that allows any additions that a LOD function
        # makes to hookargs to be visible in the rest of the D3PDObject.
        if parent_hookargs is None:
            parent_hookargs = {}
        local_hookargs = {}
        hookargs = StackedDict (local_hookargs, kw,
                                self._hookArgs, parent_hookargs)
        local_hookargs['level'] = level
        local_hookargs['name'] = name
        local_hookargs['prefix'] = prefix
        local_hookargs['name_prefix'] = name_prefix
        local_hookargs['parent_prefix'] = parent_prefix
        local_hookargs['include'] = include
        local_hookargs['exclude'] = exclude
        local_hookargs['blockargs'] = blockargs
        local_hookargs['d3pdo'] = self
 
        # Create block filler tools.
        self._makeBlockFillers (c, level, parent_prefix + prefix,
                                include, exclude, blockargs, hookargs)
 
        # We used to run the hooks from here.
        # But in that case, we don't have access to the containing
        # algorithm --- too early for that.
        # So we break out the running of the hooks to a separate method
        # that gets called after the tool gets added to the algorithm.
        # A catch, though, is that we have to remember the arguments
        # that we pass to the hook functions.  We can't attach it
        # to the configurable, since it doesn't have a dictionary.
        # Instead, we need to keep a dictionary here of the tools
        # and the corresponding hook args.
        D3PDObject._hookArgsStore[c.getName()] = (self._hooks, args, hookargs)
        return c
 
 

◆ _add_blockname()

python.D3PDObject.D3PDObject._add_blockname	(	self,
		n,
		warnonly = False )

protected

Add a new block name N to the list of all names.
Raises an exception if a block name is duplicated.

Definition at line 276 of file D3PDObject.py.

    def _add_blockname (self, n, warnonly = False):
        """Add a new block name N to the list of all names.
        Raises an exception if a block name is duplicated.
"""
        if n in self._all_blocknames:
            if warnonly:
                log = logging.getLogger ('D3PDObject')
                log.warn ('Duplicate block name: %s (%s %s %s)',
                           n,
                           self._default_prefix,
                           self._default_name,
                           self._default_object_name)
            else:
                raise ValueError ('Duplicate block name: %s (%s %s %s)' %
                                  (n,
                                   self._default_prefix,
                                   self._default_name,
                                   self._default_object_name))
        self._all_blocknames[n] = 1
        if self._parent:
            self._parent._add_blockname (n, True)
        return
 
 

◆ _makeBlockFillers()

python.D3PDObject.D3PDObject._makeBlockFillers	(	self,
		c,
		level,
		parent_prefix,
		include,
		exclude,
		blockargs,
		hookargs )

protected

Create block filler tools for object C, for the specified
level of detail.

Arguments:
  c: Object for which to create the block fillers.
  level: Requested level of detail for this object.  An integer.
  parent_prefix: Variable name prefix for any parent tool.
  include: List of block names to include, regardless
           of level of detail.
  exclude: List of block names to exclude, regardless
           of level of detail.
  blockargs: Extra arguments to pass to block filler tools.
             The keys are block names.
             Values are dictionaries of keyword arguments.
             These override anything specified in defineBlock.
  hookargs: Arguments passed to the D3PD object, to be passed
            on to LOD functions.

Definition at line 540 of file D3PDObject.py.

                           hookargs):
        """Create block filler tools for object C, for the specified
        level of detail.
 
        Arguments:
          c: Object for which to create the block fillers.
          level: Requested level of detail for this object.  An integer.
          parent_prefix: Variable name prefix for any parent tool.
          include: List of block names to include, regardless
                   of level of detail.
          exclude: List of block names to exclude, regardless
                   of level of detail.
          blockargs: Extra arguments to pass to block filler tools.
                     The keys are block names.
                     Values are dictionaries of keyword arguments.
                     These override anything specified in defineBlock.
          hookargs: Arguments passed to the D3PD object, to be passed
                    on to LOD functions.
"""
        for bf in self.blockFillers (level, c.getName(), parent_prefix,
                                     include, exclude, blockargs,
                                     hookargs):
            c.BlockFillers += [bf]
        return
 
 
 

◆ _remove_blockname()

python.D3PDObject.D3PDObject._remove_blockname	(		self,
			n )

protected

Remove block name N.

Definition at line 300 of file D3PDObject.py.

    def _remove_blockname (self, n):
        """Remove block name N."""
        del self._all_blocknames[n]
        if self._parent:
            self._parent._remove_blockname (n)
        return
 
 

◆ allBlocknames()

python.D3PDObject.D3PDObject.allBlocknames ( self )

Return a dictionary the keys of which are the names of all blocks
defined for this object.  This list will include any blocks defined
recursively.

Definition at line 308 of file D3PDObject.py.

    def allBlocknames (self):
        """Return a dictionary the keys of which are the names of all blocks
        defined for this object.  This list will include any blocks defined
        recursively.
"""
        return self._all_blocknames
 
 

◆ blockFillers()

python.D3PDObject.D3PDObject.blockFillers	(	self,
		level,
		parent_name,
		parent_prefix = '',
		include = [],
		exclude = [],
		blockargs = {},
		hookargs = {} )

Return a list of block filler tool configurables.

Arguments:
  level: Requested level of detail for this object.  An integer.
  parent_name: Name of the parent component.
  parent_prefix: Variable name prefix for any parent tool.
  include: List of block names to include, regardless
           of level of detail.
  exclude: List of block names to exclude, regardless
           of level of detail.
  blockargs: Extra arguments to pass to block filler tools.
             The keys are block names.
             Values are dictionaries of keyword arguments.
             These override anything specified in defineBlock.
  hookargs: Arguments passed to the D3PD object, to be passed
            on to LOD functions.

Definition at line 464 of file D3PDObject.py.

                      hookargs = {}):
        """Return a list of block filler tool configurables.
        
        Arguments:
          level: Requested level of detail for this object.  An integer.
          parent_name: Name of the parent component.
          parent_prefix: Variable name prefix for any parent tool.
          include: List of block names to include, regardless
                   of level of detail.
          exclude: List of block names to exclude, regardless
                   of level of detail.
          blockargs: Extra arguments to pass to block filler tools.
                     The keys are block names.
                     Values are dictionaries of keyword arguments.
                     These override anything specified in defineBlock.
          hookargs: Arguments passed to the D3PD object, to be passed
                    on to LOD functions.
          """
        out = []
        for b in self._blocks:
            # Find the requested level.
            if b.name in include:
                # Always request inclusion.
                reqlev = 999
            elif b.name in exclude:
                # Always request exclusion.
                reqlev = -999
            else:
                # Request level passed in.
                reqlev = level
 
            # Block filler arguments.
            args = b.kw.copy()
            args.update (blockargs.get (b.name, {}))
 
            # Need to copy lists in arguments; otherwise, += operations
            # can modify the saved value.
            # Also evaluate deferred arguments here: need to do it before
            # calling the LOD function, as that should have the final
            # say about any changes in the argument list.
            for k, v in args.items():
                if isinstance(v, list):
                    args[k] = v[:]
                if isinstance(v, DeferArg):
                    args[k] = v(hookargs)
 
            if _testLOD (b.lod, reqlev, args, hookargs):
                fillername = parent_name + '_' + b.name
                if isinstance (b.func, D3PDObject): # ugly!
                    for k in self._allow_args:
                        if k in hookargs:
                            args[k] = hookargs[k]
                    bf = b.func (level, fillername,
                                 parent_prefix = parent_prefix,
                                 include = include,
                                 exclude = exclude,
                                 blockargs = blockargs,
                                 parent_hookargs = hookargs,
                                 **args)
                else:
                    bf = b.func (fillername, **args)
 
                out += [bf]
                if b._hooks:
                    D3PDObject._hookArgsStore[bf.getName()] = (b._hooks, args, hookargs)
 
        return out
 
 

◆ copy()

python.D3PDObject.D3PDObject.copy	(		self,
			default_prefix = None,
			default_object_name = None,
			default_name = None,
		**	kw_in )

Return a copy of this D3PD object, possibly changing parameters.

Definition at line 574 of file D3PDObject.py.

              **kw_in):
        """Return a copy of this D3PD object, possibly changing parameters."""
        if default_prefix is None:
            default_prefix = self._default_prefix
        if default_object_name is None:
            default_object_name = self._default_object_name
        if default_name is None:
            default_name = self._default_name
        kw = self._hookArgs.copy()
        kw.update (kw_in)
 
        c = D3PDObject (self._maker,
                        default_prefix,
                        default_object_name,
                        default_name,
                        **kw)
 
        #def defineBlock (self, lod, name, func, prefix = None, **kw):
        for b in self._blocks:
            func = b.func
            if isinstance (func, D3PDObject):
                func = func.copy()
            c.defineBlock (b.lod, b.name, func, **b.kw)
 
        for h in self._hooks:
            c.defineHook (h)
 
        return c
 
 

◆ defineBlock()

python.D3PDObject.D3PDObject.defineBlock	(		self,
			lod,
			name,
			func,
			prefix = None,
		**	kw )

Define a new block of variables for this object type.

Arguments:
lod: Level of detail of this block.  See below.
name: Name of this block.
func:   Function to create the block Configurable.
prefix: Variable name prefix for this block.
kw: Arguments to pass to the creation function.

The creation function will be called like this:

b.func (name, BlockName = blockname, **b.kw)

where name is the name for the tool.

However, if b.func is a class deriving from D3PDObject, then the creation
function will instead be called like this:

b.func (level, name, parent_prefix, **b.kw)

LOD is used to control whether this block should be included.

In the simple case, this is an integer, and the block is included
if the block's level of detail is less than or equal to the
requested level of detail (unless the block was explicitly
included or excluded).

In the general case, LOD may be a function.  The first two arguments
passed to the function will be the requested level of detail
and the block filler
arguments.  The requested level of detail will be an integer;
it will be 999 if the block was explicitly included, and -999
if the block was explicitly excluded.  The block filler arguments
is a dictionary of keyword arguments.  The LOD function should
return a boolean value saying whether or not the block should
be included.  It may also alter the dictionary of arguments
(this overrides all other argument settings).
The LOD function may optionally take a third argument; if present,
this is a dictionary of the arguments passed to the D3PDObject
(the same arguments that are passed to hook functions).

Definition at line 178 of file D3PDObject.py.

    def defineBlock (self, lod, name, func, prefix = None, **kw):
        """Define a new block of variables for this object type.
 
    Arguments:
      lod: Level of detail of this block.  See below.
      name: Name of this block.
      func:   Function to create the block Configurable.
      prefix: Variable name prefix for this block.
      kw: Arguments to pass to the creation function.
 
    The creation function will be called like this:
 
       b.func (name, BlockName = blockname, **b.kw)
 
    where name is the name for the tool.
 
    However, if b.func is a class deriving from D3PDObject, then the creation
    function will instead be called like this:
 
       b.func (level, name, parent_prefix, **b.kw)
 
    LOD is used to control whether this block should be included.
 
    In the simple case, this is an integer, and the block is included
    if the block's level of detail is less than or equal to the
    requested level of detail (unless the block was explicitly
    included or excluded).
 
    In the general case, LOD may be a function.  The first two arguments
    passed to the function will be the requested level of detail
    and the block filler
    arguments.  The requested level of detail will be an integer;
    it will be 999 if the block was explicitly included, and -999
    if the block was explicitly excluded.  The block filler arguments
    is a dictionary of keyword arguments.  The LOD function should
    return a boolean value saying whether or not the block should
    be included.  It may also alter the dictionary of arguments
    (this overrides all other argument settings).
    The LOD function may optionally take a third argument; if present,
    this is a dictionary of the arguments passed to the D3PDObject
    (the same arguments that are passed to hook functions).
"""
        if prefix is not None:
            kw = kw.copy()
            kw['Prefix'] = prefix
 
        # Record this block name.
        # Also recursively record any blocks that it contains.
        # This will check that the names are unique.
        self._add_blockname (name)
        if isinstance (func, D3PDObject):
            for n in func.allBlocknames():
                self._add_blockname (n)
            func._parent = self
            func._allow_args = self._allow_args
 
        self._blocks.append (Block (name, lod, func, kw))
        return self._blocks[-1]
 
 

◆ defineHook()

python.D3PDObject.D3PDObject.defineHook	(		self,
			hook )

Define a new hook function for this D3PD object.

HOOK is a function that will be called for each instance
of this D3PD object after all block filler tools have been
added.

The arguments to the hook function are the object filler tool,
followed by the arguments that were passed to __call__.

Definition at line 263 of file D3PDObject.py.

    def defineHook (self, hook):
        """Define a new hook function for this D3PD object.
 
        HOOK is a function that will be called for each instance
        of this D3PD object after all block filler tools have been
        added.
 
        The arguments to the hook function are the object filler tool,
        followed by the arguments that were passed to __call__.
"""
        self._hooks.append (hook)
 
 

◆ removeBlock()

python.D3PDObject.D3PDObject.removeBlock	(	self,
		name,
		allowMissing = False )

Remove the block NAME from this object.

Definition at line 238 of file D3PDObject.py.

    def removeBlock (self, name, allowMissing = False):
        """Remove the block NAME from this object."""
        bb = None
        for b in self._blocks:
            if isinstance (b.func, D3PDObject):
                if b.func.removeBlock (name, True):
                    return True
            if b.name == name:
                bb = b
                break
 
        if not bb:
            if allowMissing:
                return False
            raise ValueError ('Unknown block name: ', name)
 
        self._blocks.remove (bb)
        self._remove_blockname (name)
        if isinstance (bb.func, D3PDObject):
            for n in bb.func.allBlocknames():
                self._remove_blockname (n)
 
        return True
 
 

◆ runHooks()

python.D3PDObject.D3PDObject.runHooks	(	c,
		flags,
		acc )

static

Run creation hooks for configurable C.

Should be run by the D3PD maker algorithm; not for general use.

Definition at line 446 of file D3PDObject.py.

    def runHooks (c, flags, acc):
        """Run creation hooks for configurable C.
 
Should be run by the D3PD maker algorithm; not for general use.
"""
        info = D3PDObject._hookArgsStore.get (c.getName())
        if info:
            (hooks, args, hookargs) = info
            for h in hooks:
                h (c,
                   flags,
                   acc,
                   *args,
                   **dict(hookargs)
                   )
        return
 
 

Member Data Documentation

◆ _all_blocknames

dict python.D3PDObject.D3PDObject._all_blocknames = {}

protected

Definition at line 169 of file D3PDObject.py.

◆ _allow_args

python.D3PDObject.D3PDObject._allow_args = allow_args

protected

Definition at line 174 of file D3PDObject.py.

◆ _blocks

list python.D3PDObject.D3PDObject._blocks = []

protected

Definition at line 167 of file D3PDObject.py.

◆ _default_name

python.D3PDObject.D3PDObject._default_name = default_name

protected

Definition at line 171 of file D3PDObject.py.

◆ _default_object_name

python.D3PDObject.D3PDObject._default_object_name = default_object_name

protected

Definition at line 166 of file D3PDObject.py.

◆ _default_prefix

python.D3PDObject.D3PDObject._default_prefix = default_prefix

protected

Definition at line 170 of file D3PDObject.py.

◆ _hookArgs

python.D3PDObject.D3PDObject._hookArgs = kw

protected

Definition at line 172 of file D3PDObject.py.

◆ _hookArgsStore

dict python.D3PDObject.D3PDObject._hookArgsStore = {}

staticprotected

Definition at line 138 of file D3PDObject.py.

◆ _hooks

list python.D3PDObject.D3PDObject._hooks = []

protected

Definition at line 168 of file D3PDObject.py.

◆ _maker

python.D3PDObject.D3PDObject._maker = maker

protected

Definition at line 165 of file D3PDObject.py.

◆ _parent

python.D3PDObject.D3PDObject._parent = None

protected

Definition at line 173 of file D3PDObject.py.

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

D3PDObject.py

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __call__()

◆ _add_blockname()

◆ _makeBlockFillers()

◆ _remove_blockname()

◆ allBlocknames()

◆ blockFillers()

◆ copy()

◆ defineBlock()

◆ defineHook()

◆ removeBlock()

◆ runHooks()

Member Data Documentation

◆ _all_blocknames

◆ _allow_args

◆ _blocks

◆ _default_name

◆ _default_object_name

◆ _default_prefix

◆ _hookArgs

◆ _hookArgsStore

◆ _hooks

◆ _maker

◆ _parent

◆ init()

◆ call()