PCaller Class Reference

Protected Caller. More...

#include <PCaller.h>

Collaboration diagram for PCaller:

Classes
class	Initializer
struct	PCallOperation

Public Types
enum	PCallOperationType {   BLOCK_NO_OPERATION, BLOCK_INITIALIZE, BLOCK_EXECUTE, BLOCK_EXECUTE_IF_UNSATISFIED,   BLOCK_UNINITIALIZE, PCALLER_START, PCALLER_TERMINATE }

Public Member Functions
	PCaller (bool idleThread, Logger &logger)
	Constructor. More...
virtual	~PCaller ()
	Destructor. More...
bool	pInitialize (Component &component)
bool	pExecute (Component &component)
bool	pExecuteIfUnsatisfied (Behavior &component, bool &satisfied)
bool	pUninitialize (Component &component)

Private Member Functions
bool	startThread ()
void	stopThread ()
bool	pCall (Component &component, PCallOperationType operation, bool *returnValue)
	Executes the specified method of this component with signal catching Returns true on normal run termination, false if a signal has occurred. More...
void	containedWait ()
	The entry point for the protected thread. More...
void	ownerWait ()
	Wait for another thread to activate this thread. More...
void	yieldToContained ()
	Just yield execution to the waiting contained thread. More...
void	yieldToOwner ()
	Just yield execution to the waiting owner thread. More...
	PCaller (const PCaller &old)

Static Private Member Functions
static void	ShowInfo (Component *component, int signal, int errno, int code, size_t addr, size_t backtraceCount, char **backtraceStrings)
static const char *	PCallOperationToChars (const PCallOperationType operation)
static void *	PThreadRun (void *pCaller)
static void	RegisterDefaultSignals (void)
static void	DefaultSignalHandler (int signal, siginfo_t *sigIngo, void *context)
static const char *	SignalMessage (int signal, int code)

Private Attributes
Logger &	logger_
Mutex	pCallMutex_
Mutex	threadConditionMutex_
ThreadCondition	threadCondition_
pthread_t	containedThread_
pthread_t	ownerThread_
pthread_t	runningThread_
Component *	currentComponent_
PCallOperation	currentOperation_
pthread_attr_t	threadAttributes_
bool	threadRunning_
bool	threadDone_
bool	idle_

Static Private Attributes
static Initializer	Initializer_
	Runs static intialization code. More...
static FlexArray< PCaller * >	PCallers_

Detailed Description

Protected Caller.

Can be used by a Handler or Component to make signal-handling protected calls to the execute(), initialize(), or uninitialize() methods of a component.

Member Enumeration Documentation

enum PCaller::PCallOperationType

Enumerator
BLOCK_NO_OPERATION
BLOCK_INITIALIZE
BLOCK_EXECUTE
BLOCK_EXECUTE_IF_UNSATISFIED
BLOCK_UNINITIALIZE
PCALLER_START
PCALLER_TERMINATE

Constructor & Destructor Documentation

PCaller::PCaller	(	bool	idleThread,
		Logger &	logger
	)

Constructor.

References PCaller::PCallOperation::component_, currentOperation_, PCaller::PCallOperation::operation_, PCALLER_START, PCallers_, FlexArray< T >::push(), PCaller::PCallOperation::returnValue_, startThread(), and threadAttributes_.

PCaller::~PCaller ( )

virtual

Destructor.

References containedThread_, currentComponent_, currentOperation_, PCaller::PCallOperation::operation_, PCALLER_TERMINATE, PCallers_, FlexArray< T >::pop(), stopThread(), threadAttributes_, threadRunning_, and yieldToContained().

PCaller::PCaller ( const PCaller &  old )

private

Member Function Documentation

void PCaller::containedWait ( )

private

The entry point for the protected thread.

A static function. Wait for another thread to activate this thread.

References Mutex::lock(), runningThread_, threadCondition_, threadConditionMutex_, Mutex::unlock(), and ThreadCondition::wait().

Referenced by PThreadRun().

void PCaller::DefaultSignalHandler ( int  signal, siginfo_t *  sigIngo, void *  context  )

staticprivate

References containedThread_, currentComponent_, FlexArrayBase::getMaxIndex(), FlexArrayBase::getMinIndex(), PCallers_, Component::setFailure(), ShowInfo(), SignalMessage(), FailureMode::SOFTWARE, threadRunning_, and yieldToOwner().

Referenced by RegisterDefaultSignals().

void PCaller::ownerWait ( )

private

Wait for another thread to activate this thread.

References Mutex::lock(), runningThread_, threadCondition_, threadConditionMutex_, Mutex::unlock(), and ThreadCondition::wait().

Referenced by pCall(), and startThread().

bool PCaller::pCall ( Component &  component, PCallOperationType  operation, bool *  returnValue  )

private

Executes the specified method of this component with signal catching Returns true on normal run termination, false if a signal has occurred.

References BLOCK_EXECUTE, BLOCK_EXECUTE_IF_UNSATISFIED, BLOCK_INITIALIZE, BLOCK_UNINITIALIZE, PCaller::PCallOperation::component_, currentComponent_, currentOperation_, Component::getRunState(), Component::isFailed(), Component::isFailureUninitialized(), Component::isUsingRunState(), Mutex::lock(), PCaller::PCallOperation::operation_, ownerThread_, ownerWait(), pCallMutex_, Component::requestStart(), Component::requestStop(), PCaller::PCallOperation::returnValue_, Component::setFailureUninitialized(), startThread(), Component::STOPPED, threadRunning_, Mutex::unlock(), and yieldToContained().

Referenced by pExecute(), pExecuteIfUnsatisfied(), pInitialize(), and pUninitialize().

const char * PCaller::PCallOperationToChars ( const PCallOperationType  operation )

staticprivate

References BLOCK_EXECUTE, BLOCK_EXECUTE_IF_UNSATISFIED, BLOCK_INITIALIZE, BLOCK_NO_OPERATION, BLOCK_UNINITIALIZE, PCALLER_START, and PCALLER_TERMINATE.

bool PCaller::pExecute ( Component &  component )

inline

References BLOCK_EXECUTE, and pCall().

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

bool PCaller::pExecuteIfUnsatisfied ( Behavior &  component, bool &  satisfied  )

inline

References BLOCK_EXECUTE_IF_UNSATISFIED, and pCall().

bool PCaller::pInitialize ( Component &  component )

inline

References BLOCK_INITIALIZE, and pCall().

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

void * PCaller::PThreadRun ( void *  pCaller )

staticprivate

References BLOCK_EXECUTE, BLOCK_EXECUTE_IF_UNSATISFIED, BLOCK_INITIALIZE, BLOCK_NO_OPERATION, BLOCK_UNINITIALIZE, PCaller::PCallOperation::component_, containedThread_, containedWait(), currentOperation_, Component::execute(), Behavior::executeIfUnsatisfied(), Syslog::INFO, Component::initialize(), logger_, PCaller::PCallOperation::operation_, PCALLER_START, PCALLER_TERMINATE, PCaller::PCallOperation::returnValue_, Logger::syslog(), threadDone_, Component::uninitialize(), and yieldToOwner().

Referenced by startThread().

bool PCaller::pUninitialize ( Component &  component )

inline

References BLOCK_UNINITIALIZE, and pCall().

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

void PCaller::RegisterDefaultSignals ( void  )

staticprivate

References DefaultSignalHandler().

Referenced by PCaller::Initializer::Initializer().

void PCaller::ShowInfo ( Component *  component, int  signal, int  errno, int  code, size_t  addr, size_t  backtraceCount, char **  backtraceStrings  )

staticprivate

References Syslog::CRITICAL, Component::getLogger(), SignalMessage(), and Logger::syslog().

Referenced by DefaultSignalHandler().

const char * PCaller::SignalMessage ( int  signal, int  code  )

staticprivate

Referenced by DefaultSignalHandler(), and ShowInfo().

bool PCaller::startThread ( )

private

References BLOCK_NO_OPERATION, containedThread_, Syslog::CRITICAL, currentOperation_, Syslog::DEBUG, idle_, logger_, PCaller::PCallOperation::operation_, ownerWait(), PThreadRun(), SCHED_IDLE, stopThread(), Logger::syslog(), threadAttributes_, threadRunning_, and yieldToContained().

Referenced by pCall(), and PCaller().

void PCaller::stopThread ( )

private

References containedThread_, and threadRunning_.

Referenced by startThread(), and ~PCaller().

void PCaller::yieldToContained ( )

private

Just yield execution to the waiting contained thread.

References containedThread_, Mutex::lock(), runningThread_, ThreadCondition::signal(), threadCondition_, threadConditionMutex_, and Mutex::unlock().

Referenced by pCall(), startThread(), and ~PCaller().

void PCaller::yieldToOwner ( )

private

Just yield execution to the waiting owner thread.

References Mutex::lock(), ownerThread_, runningThread_, ThreadCondition::signal(), threadCondition_, threadConditionMutex_, and Mutex::unlock().

Referenced by DefaultSignalHandler(), and PThreadRun().

Member Data Documentation

pthread_t PCaller::containedThread_

private

Referenced by DefaultSignalHandler(), PThreadRun(), startThread(), stopThread(), yieldToContained(), and ~PCaller().

Component* PCaller::currentComponent_

private

Referenced by DefaultSignalHandler(), pCall(), and ~PCaller().

PCallOperation PCaller::currentOperation_

private

Referenced by pCall(), PCaller(), PThreadRun(), startThread(), and ~PCaller().

bool PCaller::idle_

private

Referenced by startThread().

PCaller::Initializer PCaller::Initializer_

staticprivate

Runs static intialization code.

Logger& PCaller::logger_

private

Referenced by PThreadRun(), and startThread().

pthread_t PCaller::ownerThread_

private

Referenced by pCall(), and yieldToOwner().

FlexArray< PCaller * > PCaller::PCallers_

staticprivate

Referenced by DefaultSignalHandler(), PCaller(), and ~PCaller().

Mutex PCaller::pCallMutex_

private

Referenced by pCall().

pthread_t PCaller::runningThread_

private

Referenced by containedWait(), ownerWait(), yieldToContained(), and yieldToOwner().

pthread_attr_t PCaller::threadAttributes_

private

Referenced by PCaller(), startThread(), and ~PCaller().

ThreadCondition PCaller::threadCondition_

private

Referenced by containedWait(), ownerWait(), yieldToContained(), and yieldToOwner().

Mutex PCaller::threadConditionMutex_

private

Referenced by containedWait(), ownerWait(), yieldToContained(), and yieldToOwner().

bool PCaller::threadDone_

private

Referenced by PThreadRun().

bool PCaller::threadRunning_

private

Referenced by DefaultSignalHandler(), pCall(), startThread(), stopThread(), and ~PCaller().

---

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

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