IComponentInstance (Jadex Active Component Platform 2.4 API.)

All Known Implementing Classes:

jadex.kernelbase.AbstractInterpreter, BDIInterpreter, BpmnInterpreter, BpmnPlanBodyInstance, MicroAgentInterpreter, jadex.kernelbase.StatelessAbstractInterpreter
```
public interface IComponentInstance
```
Component interface to be used (invoked) by platform (adapters). This interface is implemented by the different kernels. To create a kernel component instance use the kernel's component factory

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`afterBlock()` Called after unblocking the component thread.
`void`	`beforeBlock()` Called before blocking the component thread.
`IFuture<Void>`	`cleanupComponent()` Can be called concurrently (also during executeAction()).
`IFuture<Void>`	`componentCreated(IComponentDescription desc, IModelInfo model)` Called when a component has been created as a subcomponent of this component.
`IFuture<Void>`	`componentDestroyed(IComponentDescription desc)` Called when a subcomponent of this component has been destroyed.
`boolean`	`executeStep()` Can be called on the component thread only.
`ClassLoader`	`getClassLoader()` Get the class loader of the component.
`IExternalAccess`	`getExternalAccess()` Can be called concurrently (also during executeAction()).
`Object`	`getProperty(String name)` Get a property of the component.
`Map<String,Object>`	`getResults()` Get the results of the component (considering it as a functionality).
`IServiceContainer`	`getServiceContainer()` Create the service container.
`boolean`	`isAtBreakpoint(String[] breakpoints)` Test if the component's execution is currently at one of the given breakpoints.
`boolean`	`isExternalThread()` Check if the external thread is accessing.
`void`	`messageArrived(IMessageAdapter message)` Can be called concurrently (also during executeAction()).
`void`	`startBehavior()` Start the behavior of a component.
`void`	`streamArrived(IConnection con)` Can be called concurrently (also during executeAction()).

- Method Detail
  - executeStep
```
boolean executeStep()
```
    Can be called on the component thread only. Main method to perform component execution. Whenever this method is called, the component performs one of its scheduled actions. The platform can provide different execution models for components (e.g. thread based, or synchronous). To avoid idle waiting, the return value can be checked. The platform guarantees that executeAction() will not be called in parallel.
    
    Returns:
    True, when there are more actions waiting to be executed.
  - messageArrived
```
void messageArrived(IMessageAdapter message)
```
    Can be called concurrently (also during executeAction()). Inform the component that a message has arrived. Can be called concurrently (also during executeAction()).
    
    Parameters:
    message - The message that arrived.
  - streamArrived
```
void streamArrived(IConnection con)
```
    Can be called concurrently (also during executeAction()). Inform the component that a stream has arrived. Can be called concurrently (also during executeAction()).
    
    Parameters:
    con - The stream that arrived.
  - componentCreated
```
IFuture<Void> componentCreated(IComponentDescription desc,
                             IModelInfo model)
```
    Called when a component has been created as a subcomponent of this component. This event may be ignored, if no special reaction to new or destroyed components is required. The current subcomponents can be accessed by IComponentAdapter.getSubcomponents().
    
    Parameters:
    desc - The newly created component.
    model - The model of the newly created component.
    
    Returns:
    A future to indicate when the event has been processed.
  - componentDestroyed
```
IFuture<Void> componentDestroyed(IComponentDescription desc)
```
    Called when a subcomponent of this component has been destroyed. This event may be ignored, if no special reaction to new or destroyed components is required. The current subcomponents can be accessed by IComponentAdapter.getSubcomponents().
    
    Parameters:
    desc - The destroyed component.
    
    Returns:
    A future to indicate when the event has been processed.
  - cleanupComponent
```
IFuture<Void> cleanupComponent()
```
    Can be called concurrently (also during executeAction()). Request component to cleanup itself after kill. The component might perform arbitrary cleanup activities during which executeAction() will still be called as usual. Can be called concurrently (also during executeAction()).
    
    Returns:
    When cleanup of the component is finished, the future is notified.
  - getExternalAccess
```
IExternalAccess getExternalAccess()
```
    Can be called concurrently (also during executeAction()). Get the external access for this component. External access objects must implement the IExternalAccess interface. The specific external access interface is kernel specific and has to be casted to its corresponding incarnation.
    
    Returns:
    External access is delivered via future.
  - getClassLoader
```
ClassLoader getClassLoader()
```
    Get the class loader of the component. The component class loader is required to avoid incompatible class issues, when changing the platform class loader while components are running. This may occur e.g. when decoding messages and instantiating parameter values.
    
    Returns:
    The component class loader.
  - getResults
```
Map<String,Object> getResults()
```
    Get the results of the component (considering it as a functionality). Note: The method cannot make use of the asynchronous result listener mechanism, because the it is called when the component is already terminated (i.e. no invokerLater can be used).
    
    Returns:
    The results map (name -> value).
  - getProperty
```
Object getProperty(String name)
```
    Get a property of the component. May only be called after the component's init has finished.
    
    Parameters:
    name - The property name.
    
    Returns:
    The property value
  - isAtBreakpoint
```
boolean isAtBreakpoint(String[] breakpoints)
```
    Test if the component's execution is currently at one of the given breakpoints. If yes, the component will be suspended by the platform.
    
    Parameters:
    breakpoints - An array of breakpoints.
    
    Returns:
    True, when some breakpoint is triggered.
  - getServiceContainer
```
IServiceContainer getServiceContainer()
```
    Create the service container.
    
    Returns:
    The service container.
  - startBehavior
```
void startBehavior()
```
    Start the behavior of a component. Called from external thread that needs to be decoupled.
  - isExternalThread
```
boolean isExternalThread()
```
    Check if the external thread is accessing.
    
    Returns:
    True, if called from an external (i.e. non-synchronized) thread.
  - beforeBlock
```
void beforeBlock()
```
    Called before blocking the component thread.
  - afterBlock
```
void afterBlock()
```
    Called after unblocking the component thread.

Interface IComponentInstance

Method Summary

Method Detail

executeStep

messageArrived

streamArrived

componentCreated

componentDestroyed

cleanupComponent

getExternalAccess

getClassLoader

getResults

getProperty

isAtBreakpoint

getServiceContainer

startBehavior

isExternalThread

beforeBlock

afterBlock