ISharedComponentControlHelper (pogamut-base 3.3.1 API)

All Superinterfaces:

IComponentControlHelper

All Known Implementing Classes:

SharedComponentControlHelper
```
public interface ISharedComponentControlHelper
extends IComponentControlHelper
```
Provides a way to control the shared component.
We have purposefully created specific helper interface for the control of the IComponent. That's because the designer of the component might want to hide its start/stop/kill method (e.g. they should not be accessible by anyone). This is typical when using ISharedComponentController to automatically start/stop the component based on its dependencies.
So if you want to hide these methods from the public interface of your component, than create private inner class inside your component and implement how the component is starting/stopping/killing itself possibly by recalling private methods of the component.
This helper is similar but quite different from the simpler IComponentControlHelper as it covers more lifecycle cases which ISharedComponent has over simple IComponent.

Author:

Jimmy

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`kill()` Kills the component in ruthless way.
`void`	`localKill(IAgentId agentId)` Kills the component for the agent identified by 'agentId'.
`void`	`localPause(IAgentId agentId)` Pauses the component for agent identified by 'agentId'.
`void`	`localPrePause(IAgentId agentId)` Called before the `IPausingEvent` of the component is broadcast into `ILifecycleBus` of the agent identified by 'agentId'.
`void`	`localPreResume(IAgentId agentId)` Called before the `IResumingEvent` of the component is broadcast into `ILifecycleBus` of the agent identified by 'agentId'.
`void`	`localPreStart(IAgentId agentId)` Called before the `IStartingEvent` of the component is broadcast into `ILifecycleBus` of the agent identified by 'agentId'.
`void`	`localPreStartPaused(IAgentId agentId)` Called before `IStartingPausedEvent` of the component is broadcast into `ILifecycleBus` of the agent identified by 'agentId'.
`void`	`localPreStop(IAgentId agentId)` Called before the `IStoppingEvent` of the component is broadcast into `ILifecycleBus` of the agent identified by 'agentId'.
`void`	`localReset(IAgentId agentId)` Called whenever `IResetEvent` is caught at the `ILifecycleBus` of the agent identified by 'agentId'.
`void`	`localResume(IAgentId agentId)` Resumes the component for the agent identified by 'agentId'.
`void`	`localStart(IAgentId agentId)` The component is being started inside the `ILifecycleBus` of the agent identified by 'agentId'.
`void`	`localStartPaused(IAgentId agentId)` Starts the component for the agent identified by 'agentId' but it assumes that the component just prepares whatever data structures it needs / make connections / handshake whatever it needs with the environment / etc.
`void`	`localStop(IAgentId agentId)` Stops the component for the agent identified by 'agentId'.
`void`	`pause()` Pauses the component.
`void`	`prePause()` Called whenever there is no running dependencies and the rest is going to be paused or is paused.
`void`	`preResume()` Called whenever some of paused dependencies is starting / is started.
`void`	`preStart()` Called whenever starting dependencies of some (first) agent becomes satisfied.
`void`	`preStartPaused()` Called whenever starting dependencies of some (first) agent becomes satisfied, should start the component into paused state.
`void`	`preStop()` Called whenever there is no running dependencies and the rest is going to be stopped.
`void`	`reset()` Called whenever `IResetEvent` is caught in any of stopped bus.
`void`	`resume()` Resumes the component.
`void`	`start()` Called to start the component whenever starting dependencies of some (first) agent becomes satisfied.
`void`	`startPaused()` Starts the component whenever starting dependencies of some (first) agent becomes satisfied.
`void`	`stop()` Stops the component.

- Method Detail
  - preStart
```
void preStart()
              throws cz.cuni.amis.utils.exception.PogamutException
```
    Called whenever starting dependencies of some (first) agent becomes satisfied.
    Similar to IComponentControlHelper.preStart() (sort of a global version).
    This method or preStartPaused() method is called prior to any localXXX() methods are called. Which means that you are always informed that your component should start before it "accepts" starts from respective agents.
    NOTE: this method does not have much meaning for ISharedComponent as method start() is called right after ... nothing is taking place between these two calls.
    
    Specified by:
    
    preStart in interface IComponentControlHelper
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - start
```
void start()
           throws cz.cuni.amis.utils.exception.PogamutException
```
    Called to start the component whenever starting dependencies of some (first) agent becomes satisfied.
    Similar to IComponentControlHelper.start() (sort of a global version).
    
    This method or startPaused() method is called prior to any localXXX() methods are called. Which means that you are always informed that your component should start before it "accepts" starts from respective agents.
    
    Specified by:
    
    start in interface IComponentControlHelper
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - preStartPaused
```
void preStartPaused()
                    throws cz.cuni.amis.utils.exception.PogamutException
```
    Called whenever starting dependencies of some (first) agent becomes satisfied, should start the component into paused state.
    You may need to prepare some stuff before starting event is generated.
    Similar to IComponentControlHelper.preStartPaused() (sort of a global version).
    NOTE: this method does not have much meaning for ISharedComponent as method startPaused() is called right after ... nothing is taking place between these two calls.
    
    Specified by:
    
    preStartPaused in interface IComponentControlHelper
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - startPaused
```
void startPaused()
                 throws cz.cuni.amis.utils.exception.PogamutException
```
    Starts the component whenever starting dependencies of some (first) agent becomes satisfied. But it assumes that the component just prepares whatever data structures it needs / make connections / handshake whatever it needs with the environment / etc.
    Similar to IComponentControlHelper.startPaused() (sort of a global version).
    
    Specified by:
    
    startPaused in interface IComponentControlHelper
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - prePause
```
void prePause()
              throws cz.cuni.amis.utils.exception.PogamutException
```
    Called whenever there is no running dependencies and the rest is going to be paused or is paused.
    Similar to IComponentControlHelper.prePause() (sort of a global version).
    NOTE: this method does not have much meaning for ISharedComponent as method pause() is called right after ... nothing is taking place between these two calls.
    
    Specified by:
    
    prePause in interface IComponentControlHelper
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - pause
```
void pause()
           throws cz.cuni.amis.utils.exception.PogamutException
```
    Pauses the component. Called whenever there is no running dependencies and the rest is going to be paused or is paused.
    Called whenever IPausingEvent is caught from one of the dependencies.
    Similar to IComponentControlHelper.pause() (sort of a global version).
    
    Specified by:
    
    pause in interface IComponentControlHelper
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - preResume
```
void preResume()
               throws cz.cuni.amis.utils.exception.PogamutException
```
    Called whenever some of paused dependencies is starting / is started.
    Similar to IComponentControlHelper.preResume() (sort of a global version).
    NOTE: this method does not have much meaning for ISharedComponent as method resume() is called right after ... nothing is taking place between these two calls.
    
    Specified by:
    
    preResume in interface IComponentControlHelper
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - resume
```
void resume()
            throws cz.cuni.amis.utils.exception.PogamutException
```
    Resumes the component. Called whenever some of paused dependencies is starting / is started.
    Similar to IComponentControlHelper.resume() (sort of a global version).
    
    Specified by:
    
    resume in interface IComponentControlHelper
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - preStop
```
void preStop()
             throws cz.cuni.amis.utils.exception.PogamutException
```
    Called whenever there is no running dependencies and the rest is going to be stopped.
    Similar to IComponentControlHelper.preStop() (sort of a global version).
    
    Specified by:
    
    preStop in interface IComponentControlHelper
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - stop
```
void stop()
          throws cz.cuni.amis.utils.exception.PogamutException
```
    Stops the component. Called whenever there is no running dependencies and the rest is going to be stopped.
    Similar to IComponentControlHelper.stop() (sort of a global version).
    NOTE: this method does not have much meaning for ISharedComponent as method stop() is called right after ... nothing is taking place between these two calls.
    
    Specified by:
    
    stop in interface IComponentControlHelper
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - kill
```
void kill()
```
    Kills the component in ruthless way. It must be non-blocking method.
    Called whenever IFatalErrorEvent is caught in any agent's bus.
    Must not throw any exception whatsoever.
    Similar to IComponentControlHelper.kill() (sort of a global version).
    
    Specified by:
    
    kill in interface IComponentControlHelper
  - reset
```
void reset()
           throws cz.cuni.amis.utils.exception.PogamutException
```
    Called whenever IResetEvent is caught in any of stopped bus. It should reinitialize data structures of the component so it can be started again.
    Should throw an exception in case that the component can't be reseted.
    Similar to IComponentControlHelper.reset() (sort of a global version).
    
    Specified by:
    
    reset in interface IComponentControlHelper
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - localPreStart
```
void localPreStart(IAgentId agentId)
                   throws cz.cuni.amis.utils.exception.PogamutException
```
    Called before the IStartingEvent of the component is broadcast into ILifecycleBus of the agent identified by 'agentId'.
    You may need to prepare some stuff before starting event is generated
    
    Parameters:
    agentId -
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - localStart
```
void localStart(IAgentId agentId)
                throws cz.cuni.amis.utils.exception.PogamutException
```
    The component is being started inside the ILifecycleBus of the agent identified by 'agentId'. It should throw exception, if it can not start for the particular agent.
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - localPreStartPaused
```
void localPreStartPaused(IAgentId agentId)
                         throws cz.cuni.amis.utils.exception.PogamutException
```
    Called before IStartingPausedEvent of the component is broadcast into ILifecycleBus of the agent identified by 'agentId'.
    You may need to prepare some stuff before starting event is generated.
    
    Parameters:
    agentId -
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - localStartPaused
```
void localStartPaused(IAgentId agentId)
                      throws cz.cuni.amis.utils.exception.PogamutException
```
    Starts the component for the agent identified by 'agentId' but it assumes that the component just prepares whatever data structures it needs / make connections / handshake whatever it needs with the environment / etc.
    It should not let the agent to perform designers work (i.e., UT2004 bots should not start playing in the game).
    After this call, the component should behave as it would have been paused with IComponentControlHelper.pause().
    
    Parameters:
    agentId -
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - localPrePause
```
void localPrePause(IAgentId agentId)
                   throws cz.cuni.amis.utils.exception.PogamutException
```
    Called before the IPausingEvent of the component is broadcast into ILifecycleBus of the agent identified by 'agentId'.
    You may need to pre-clean some stuff.
    
    Parameters:
    agentId -
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - localPause
```
void localPause(IAgentId agentId)
                throws cz.cuni.amis.utils.exception.PogamutException
```
    Pauses the component for agent identified by 'agentId'.
    Called whenever IPausingEvent is caught from one of the dependencies of the given agent.
    
    Parameters:
    agentId -
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - localPreResume
```
void localPreResume(IAgentId agentId)
                    throws cz.cuni.amis.utils.exception.PogamutException
```
    Called before the IResumingEvent of the component is broadcast into ILifecycleBus of the agent identified by 'agentId'.
    You may need to pre-clean some stuff.
    
    Parameters:
    agentId -
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - localResume
```
void localResume(IAgentId agentId)
                 throws cz.cuni.amis.utils.exception.PogamutException
```
    Resumes the component for the agent identified by 'agentId'.
    Called whenever IPausingEvent is caught from one of the dependencies of the given agent.
    
    Parameters:
    agentId -
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - localPreStop
```
void localPreStop(IAgentId agentId)
                  throws cz.cuni.amis.utils.exception.PogamutException
```
    Called before the IStoppingEvent of the component is broadcast into ILifecycleBus of the agent identified by 'agentId'.
    You may need to pre-clean some stuff.
    
    Parameters:
    agentId -
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - localStop
```
void localStop(IAgentId agentId)
               throws cz.cuni.amis.utils.exception.PogamutException
```
    Stops the component for the agent identified by 'agentId'.
    It should throw an exception if the component can't be stopped for the given agent.
    
    Parameters:
    agentId -
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException
  - localKill
```
void localKill(IAgentId agentId)
```
    Kills the component for the agent identified by 'agentId'. It must be non-blocking method.
    Called whenever IFatalErrorEvent is caught for a given agent.
    Must not throw any exception whatsoever.
    
    Parameters:
    agentId -
  - localReset
```
void localReset(IAgentId agentId)
```
    Called whenever IResetEvent is caught at the ILifecycleBus of the agent identified by 'agentId'.
    It should reinitialize data structures of the component so it can be usable by the given agent again.
    Should throw an exception in case that the component can't be reseted for a given agent.
    
    Parameters:
    agentId -
    
    Throws:
    
    cz.cuni.amis.utils.exception.PogamutException

Interface ISharedComponentControlHelper

Method Summary

Method Detail

preStart

start

preStartPaused

startPaused

prePause

pause

preResume

resume

preStop

stop

kill

reset

localPreStart

localStart

localPreStartPaused

localStartPaused

localPrePause

localPause

localPreResume

localResume

localPreStop

localStop

localKill

localReset