java.lang.Object
- org.processmining.specpp.componenting.system.link.AbstractBaseClass

All Implemented Interfaces:

FullComponentSystemUser, HasComponentCollection, IsGlobalProvider, UsesGlobalComponentSystem, UsesLocalComponentSystem, Initializable

Direct Known Subclasses:

AbstractComposer, AbstractComposition, AbstractEfficientTreeBasedProposer, AbstractSupervisor, ConstrainablePlaceProposer, ConstrainingPlaceCollection, EnumeratingTree, ExternalInitializer, HeuristicTreeExpansion, PlaceGenerationLogic, RecursiveComposer, SPECpp, VariableExpansion, WrappedPostProcessor
```
public abstract class AbstractBaseClass
extends java.lang.Object
implements FullComponentSystemUser
```
An abstract base class for any object that may want to make use of the component system. It contains the component system connection objects (ComponentRepositorys). Additionally, it structures an initialization sequence for registered subcomponents, e.g. nested objects. A main aspect of that is transitive local component system requirement resolution, i.e. if a nested subcomponent provides something that this class requires, it will be matched.

Constructor Summary

Constructors
Constructor Description

AbstractBaseClass()

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`java.util.List<FullComponentSystemUser>`	`collectTransitiveSubcomponents()`
`ComponentCollection`	`getComponentCollection()`
`protected java.util.List<FullComponentSystemUser>`	`getSubComponents()`
`ComponentCollection`	`globalComponentSystem()`
`void`	`init()`	Structures the initialization of subcomponents and calls the hook for self initialization `initSelf()`.
`protected abstract void`	`initSelf()`	Hook for subclasses to initialize themselves after the initial constructor call.
`ComponentCollection`	`localComponentSystem()`
`protected void`	`postSubComponentInit()`
`protected void`	`preSubComponentInit()`
`void`	`registerSubComponent(FullComponentSystemUser subComponent)`
`void`	`unregisterSubComponent(FullComponentSystemUser subComponent)`	This may have some unintended consequences.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.processmining.specpp.componenting.system.FullComponentSystemUser
connectLocalComponentSystem

Methods inherited from interface org.processmining.specpp.componenting.traits.UsesLocalComponentSystem
bridgeToChildren

- Constructor Detail
  - AbstractBaseClass
```
public AbstractBaseClass()
```
- Method Detail
  - getSubComponents
```
protected java.util.List<FullComponentSystemUser> getSubComponents()
```
  - registerSubComponent
```
public void registerSubComponent(FullComponentSystemUser subComponent)
```
    Specified by:
    
    registerSubComponent in interface FullComponentSystemUser
  - unregisterSubComponent
```
public void unregisterSubComponent(FullComponentSystemUser subComponent)
```
    This may have some unintended consequences. Same thing for late registrations, i.e. after initial SPECpp component initialization. If this class fulfils any requirements, e.g. data, evaluators, or provides observables or observes another component they will dangle. Currently, all requirement containers are refillable, i.e. do not report isFull() == true ever. In effect, the unregistered component's provisions will still be used until they are re-fulfilled. Consuming containers may forever retain a reference to the component. At the very least, a localComponentSystem update should be performed through the SPECpp provided handle. It may fix some things.
    
    Specified by:
    
    unregisterSubComponent in interface FullComponentSystemUser
  - collectTransitiveSubcomponents
```
public java.util.List<FullComponentSystemUser> collectTransitiveSubcomponents()
```
    Specified by:
    
    collectTransitiveSubcomponents in interface FullComponentSystemUser
  - init
```
public final void init()
```
    Structures the initialization of subcomponents and calls the hook for self initialization initSelf().
    
    Specified by:
    
    init in interface Initializable
  - postSubComponentInit
```
protected void postSubComponentInit()
```
  - preSubComponentInit
```
protected void preSubComponentInit()
```
  - initSelf
```
protected abstract void initSelf()
```
    Hook for subclasses to initialize themselves after the initial constructor call. At the time this is called, all fulfillable local & global component system requests will be fulfilled. Unless advanced interaction with the underlying systems is required, this is the only relevant hook for user-defined subclasses.
  - localComponentSystem
```
public ComponentCollection localComponentSystem()
```
    Specified by:
    
    localComponentSystem in interface UsesLocalComponentSystem
  - globalComponentSystem
```
public ComponentCollection globalComponentSystem()
```
    Specified by:
    
    globalComponentSystem in interface UsesGlobalComponentSystem
  - getComponentCollection
```
public ComponentCollection getComponentCollection()
```
    Specified by:
    
    getComponentCollection in interface FullComponentSystemUser
    
    Specified by:
    
    getComponentCollection in interface HasComponentCollection
    
    Specified by:
    
    getComponentCollection in interface UsesGlobalComponentSystem
    
    Specified by:
    
    getComponentCollection in interface UsesLocalComponentSystem

Class AbstractBaseClass

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.processmining.specpp.componenting.system.FullComponentSystemUser

Methods inherited from interface org.processmining.specpp.componenting.traits.UsesLocalComponentSystem

Constructor Detail

AbstractBaseClass

Method Detail

getSubComponents

registerSubComponent

unregisterSubComponent

collectTransitiveSubcomponents

init

postSubComponentInit

preSubComponentInit

initSelf

localComponentSystem

globalComponentSystem

getComponentCollection