Collaboration diagram for python.D3PDObject.D3PDObject:

Public Member Functions
def	__init__ (self, maker, default_prefix='', default_object_name='', default_name=None, allow_args=[], **kw)

def	defineBlock (self, lod, name, func, prefix=None, **kw)

def	removeBlock (self, name, allowMissing=False)

def	defineHook (self, hook)

def	allBlocknames (self)

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

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

def	copy (self, default_prefix=None, default_object_name=None, default_name=None, **kw_in)

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

Private Member Functions
def	_add_blockname (self, n, warnonly=False)

def	_remove_blockname (self, n)

def	_makeBlockFillers (self, c, level, parent_prefix, include, exclude, blockargs, hookargs)

Private Attributes
	_maker

	_default_object_name

	_blocks

	_hooks

	_all_blocknames

	_default_prefix

	_default_name

	_hookArgs

	_parent

	_allow_args

Static Private Attributes
dictionary	_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()

def 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.

     def __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.
  
 """
         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()

def 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.

     def __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.
 """
  
         # 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()

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

private

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()

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

private

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.

     def _makeBlockFillers (self,
                            c,
                            level,
                            parent_prefix,
                            include,
                            exclude,
                            blockargs,
                            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()

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

private

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()

def 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()

def 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.

     def 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.
           """
         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()

def 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.

     def copy (self,
               default_prefix = None,
               default_object_name = None,
               default_name = None,
               **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()

def 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()

def 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()

def 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()

def 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

python.D3PDObject.D3PDObject._all_blocknames

private

Definition at line 168 of file D3PDObject.py.

◆ _allow_args

python.D3PDObject.D3PDObject._allow_args

private

Definition at line 173 of file D3PDObject.py.

◆ _blocks

python.D3PDObject.D3PDObject._blocks

private

Definition at line 166 of file D3PDObject.py.

◆ _default_name

python.D3PDObject.D3PDObject._default_name

private

Definition at line 170 of file D3PDObject.py.

◆ _default_object_name

python.D3PDObject.D3PDObject._default_object_name

private

Definition at line 165 of file D3PDObject.py.

◆ _default_prefix

python.D3PDObject.D3PDObject._default_prefix

private

Definition at line 169 of file D3PDObject.py.

◆ _hookArgs

python.D3PDObject.D3PDObject._hookArgs

private

Definition at line 171 of file D3PDObject.py.

◆ _hookArgsStore

dictionary python.D3PDObject.D3PDObject._hookArgsStore = {}

staticprivate

Definition at line 138 of file D3PDObject.py.

◆ _hooks

python.D3PDObject.D3PDObject._hooks

private

Definition at line 167 of file D3PDObject.py.

◆ _maker

python.D3PDObject.D3PDObject._maker

private

Definition at line 164 of file D3PDObject.py.

◆ _parent

python.D3PDObject.D3PDObject._parent

private

Definition at line 172 of file D3PDObject.py.

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

D3PDObject.py

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private 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()