cz.cuni.amis.pogamut.base.component.controller
Interface ISharedComponentControlHelper

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.

Method Summary

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 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:

PogamutException

start

void start()
           throws 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:

PogamutException

preStartPaused

void preStartPaused()
                    throws 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:

PogamutException

startPaused

void startPaused()
                 throws 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:

PogamutException

prePause

void prePause()
              throws 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:

PogamutException

pause

void pause()
           throws 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:

PogamutException

preResume

void preResume()
               throws 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:

PogamutException

resume

void resume()
            throws 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:

PogamutException

preStop

void preStop()
             throws 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:

PogamutException

stop

void stop()
          throws 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:

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 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:

PogamutException

localPreStart

void localPreStart(IAgentId agentId)
                   throws 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:

PogamutException

localStart

void localStart(IAgentId agentId)
                throws 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:

PogamutException

localPreStartPaused

void localPreStartPaused(IAgentId agentId)
                         throws 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:

PogamutException

localStartPaused

void localStartPaused(IAgentId agentId)
                      throws 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:

PogamutException

localPrePause

void localPrePause(IAgentId agentId)
                   throws 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:

PogamutException

localPause

void localPause(IAgentId agentId)
                throws 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:

PogamutException

localPreResume

void localPreResume(IAgentId agentId)
                    throws 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:

PogamutException

localResume

void localResume(IAgentId agentId)
                 throws 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:

PogamutException

localPreStop

void localPreStop(IAgentId agentId)
                  throws 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:

PogamutException

localStop

void localStop(IAgentId agentId)
               throws 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:

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:

PogamutException