Handler Class Reference

Base class for "handlers" of Components. More...

#include <Handler.h>

Inheritance diagram for Handler:

Collaboration diagram for Handler:

Public Member Functions
	Handler (Component &inComponent, const Str &name, bool idleThread=false)
	Constructor. More...
virtual	~Handler ()
	Destructor. More...
virtual void	run ()
	Run the component itself. More...
virtual bool	continueLoop (void)
	Supplemental end conditions. More...
virtual void	runOnce (void)
	Virtual function run only on first iteration of handler. More...
virtual void	runBetween (void)
	Virtual function run after the first iteration of the handler. More...
virtual void	shutdown (void)
	Stop the handler (and uninit the component) More...
virtual bool	isRunning (void)
	True if handler is running. More...
const Str &	getName ()
void	setAsLogHandler (bool logHandler)
void	setAsControlLoopHandler (bool controlLoopHandler)

Static Public Member Functions
static bool	IsFastSimAllowed ()

Protected Attributes
Component &	component_
	The "handled" Component. More...
Timestamp	componentStartTime_
	Keep track of when the component is supposed to start next. More...
Logger	logger_
PCaller *	pCaller_
	Used for making protected calls. More...
bool	running_

Static Protected Attributes
static const Timespan	SMALL_INTERVAL = Timespan::FromMicros( 800 )

Private Member Functions
	Handler (const Handler &old)

Private Attributes
bool	firstLoop_
	true at object initialization, false after the first iteration through the run() loop. More...
bool	controlLoopHandler_
bool	logHandler_

Detailed Description

Base class for "handlers" of Components.

Trying to make equivalence between Components which run within another thread (control, supervisor) and those that run in their own thread. ThreadHandler derives from this class. Decided that ThreadHandler would "have a" Component rather than "be a" Component.

Basic non-threaded component handler.

Essentially a glorified while(1) loop. Relies on the component to indicate when it's going to yield through Component::completed flag.

Should be moderately extensible through its virtual functions. Run() does the following:

1. component.initialize()
2. runOnce()
3. component.run()
4. check continueLoop(), if true continue, if false jump to end
5. runBetween()
6. component.run()
7. check continueLoop()
8. ...
9. At end, component.uninitialize()

So runonce() can be used to initialize the Handler itself And runBetween() can be used to update the Handler, sleep, wait for a signal or condition variable, etc

Constructor & Destructor Documentation

Handler::Handler	(	Component &	inComponent,
		const Str &	name,
		bool	idleThread = false
	)

Constructor.

Parameters

inComponent	The component being handled.
name	Name of the component (fed to its logger_)
idleThread	If true, run thread at idle priority

Handler::~Handler ( )

virtual

Destructor.

References pCaller_.

Handler::Handler ( const Handler &  old )

private

Member Function Documentation

bool Handler::continueLoop ( void  )

virtual

Supplemental end conditions.

Reimplemented in ThreadHandler.

References component_, and Component::isCompleted().

Referenced by ThreadHandler::continueLoop(), and run().

const Str& Handler::getName ( void  )

inline

References Logger::getFacility(), and logger_.

Referenced by ComponentRegistry::ShutdownThreads().

static bool Handler::IsFastSimAllowed ( )

inlinestatic

Referenced by CommandLine::commandQuick().

virtual bool Handler::isRunning ( void  )

inlinevirtual

True if handler is running.

Reimplemented in MultiHandler.

References running_.

Referenced by ComponentRegistry::StartThreads().

void Handler::run ( void  )

virtual

Run the component itself.

Initialize the component, run it, then un-initialize it.

Reimplemented in MultiHandler, ThreadHandler, and SyncHandler.

References component_, continueLoop(), firstLoop_, Syslog::INFO, logger_, pCaller_, PCaller::pExecute(), PCaller::pInitialize(), PCaller::pUninitialize(), runBetween(), running_, runOnce(), and Logger::syslog().

Referenced by ThreadHandler::runInThread(), Supervisor::startCommandLine(), and ComponentRegistry::StartThreads().

void Handler::runBetween ( void  )

virtual

Virtual function run after the first iteration of the handler.

References Timestamp::asDouble(), Component::BLOCK_CONTINUOUS, Component::BLOCK_PERIODIC, component_, componentStartTime_, controlLoopHandler_, ComponentRegistry::GetControlThreadPeriod(), Component::getPeriod(), Component::getState(), Component::isFailed(), Supervisor::IsRunningSimsInRealTime(), logHandler_, Timestamp::Now(), Timespan::sleepFor(), Timestamp::sleepTill(), and SMALL_INTERVAL.

Referenced by run().

void Handler::runOnce ( void  )

virtual

Virtual function run only on first iteration of handler.

Protected methods.

References componentStartTime_, and Timestamp::Now().

Referenced by run().

void Handler::setAsControlLoopHandler ( bool  controlLoopHandler )

inline

References controlLoopHandler_.

Referenced by ComponentRegistry::Insert().

void Handler::setAsLogHandler ( bool  logHandler )

inline

References logHandler_.

Referenced by ComponentRegistry::Insert().

void Handler::shutdown ( void  )

virtual

Stop the handler (and uninit the component)

Reimplemented in MultiHandler, and ThreadHandler.

References component_, and Component::setEnabled().

Referenced by ComponentRegistry::PurgeEntry(), ThreadHandler::shutdown(), ComponentRegistry::ShutdownThreads(), and Supervisor::uninitialize().

Member Data Documentation

Component& Handler::component_

protected

The "handled" Component.

Referenced by ThreadHandler::cleanup(), continueLoop(), ThreadHandler::joinThread(), run(), runBetween(), shutdown(), and MultiHandler::shutdown().

Timestamp Handler::componentStartTime_

protected

Keep track of when the component is supposed to start next.

Referenced by runBetween(), and runOnce().

bool Handler::controlLoopHandler_

private

Referenced by runBetween(), and setAsControlLoopHandler().

bool Handler::firstLoop_

private

true at object initialization, false after the first iteration through the run() loop.

Referenced by run().

Logger Handler::logger_

protected

Referenced by ThreadHandler::cancelThread(), getName(), run(), and ThreadHandler::runInThread().

bool Handler::logHandler_

private

Referenced by runBetween(), and setAsLogHandler().

PCaller* Handler::pCaller_

protected

Used for making protected calls.

Referenced by MultiHandler::addComponent(), run(), MultiHandler::runNext(), MultiHandler::shutdown(), and ~Handler().

bool Handler::running_

protected

Referenced by isRunning(), and run().

const Timespan Handler::SMALL_INTERVAL = Timespan::FromMicros( 800 )

staticprotected

Referenced by runBetween().

---

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

• /Volumes/ubuntu_share/lrauv-application/Source/process/Handler.h
• /Volumes/ubuntu_share/lrauv-application/Source/process/Handler.cpp