#include <ReentrantLock.h>

Collaboration diagram for Sync::StatusHandler< Status_t >:

Public Member Functions
	StatusHandler (Status_t initialStatus)

	~StatusHandler ()

void	Post (Status_t newStatus)

Status_t	Get () const

bool	CompareAndPost (Status_t oldStatus, Status_t newStatus)

template<class Comparator >
bool	CompareAndPost (Status_t oldStatus, Status_t newStatus, Comparator comp)

Status_t	CompareAndWait (Status_t oldStatus) const

template<class Comparator >
Status_t	CompareAndWait (Status_t oldStatus, Comparator comp) const

Status_t	ComparePostAndWait (Status_t oldStatus, Status_t newStatus)

template<class Comparator >
Status_t	ComparePostAndWait (Status_t oldStatus, Status_t newStatus, Comparator comp)

void	CompareWaitAndPost (Status_t theStatus, Status_t newStatus)

Private Attributes
Status_t	status

pthread_mutex_t	lock

pthread_cond_t	cond

Detailed Description

template<class Status_t>
class Sync::StatusHandler< Status_t >

The StatusHandler template is meant to be used to simplify having a status variable in a multi threaded application. The StatusHandler can be used much like an atomic variable or a blocking queue with size 1.

Future improvements to this might be to use actual atomic compare and set primatives for these operations rather than a lock and condition.

The ReentrantLock passed in the constructor must be valid for the lifetime of this object and you must hold the lock when calling any of the wait functions.

Definition at line 39 of file ReentrantLock.h.

Constructor & Destructor Documentation

template<class Status_t>

Sync::StatusHandler< Status_t >::StatusHandler ( Status_t initialStatus )

inline

Definition at line 60 of file StatusHandler.h.

                : status(initialStatus) {
             ENSURE(!pthread_mutex_init(&lock, 0));
             ENSURE(!pthread_cond_init(&cond, 0));
         }

template<class Status_t>

Sync::StatusHandler< Status_t >::~StatusHandler ( )

inline

Definition at line 66 of file StatusHandler.h.

                          {
             ENSURE_ABORT(!pthread_cond_destroy(&cond));
             ENSURE_ABORT(!pthread_mutex_destroy(&lock));
         }

Member Function Documentation

template<class Status_t>

bool Sync::StatusHandler< Status_t >::CompareAndPost	(	Status_t	oldStatus,
		Status_t	newStatus
	)

inline

Post a change in status only if the current status is oldStatus.

Parameters

oldStatus	the status to compare to
newStatus	the new status to change to

Returns: true if the status changed

Definition at line 96 of file StatusHandler.h.

Referenced by CPN::Kernel::EntryPoint(), and CPN::Kernel::NotifyTerminate().

                                                                     {
             Internal::ScopeMutex l(lock);
             if (oldStatus == status) {
                 status = newStatus;
                 pthread_cond_broadcast(&cond);
                 return true;
             }
             return false;
         }

Here is the caller graph for this function:

template<class Status_t>

template<class Comparator >

bool Sync::StatusHandler< Status_t >::CompareAndPost	(	Status_t	oldStatus,
		Status_t	newStatus,
		Comparator	comp
	)

inline

Definition at line 107 of file StatusHandler.h.

                                                                                      {
             Internal::ScopeMutex l(lock);
             if (comp(oldStatus, status)) {
                 status = newStatus;
                 pthread_cond_broadcast(&cond);
                 return true;
             }
             return false;
         }

template<class Status_t>

Status_t Sync::StatusHandler< Status_t >::CompareAndWait ( Status_t oldStatus ) const

inline

This function waits until the status is different than oldStatus.

Parameters

oldStatus the status to compare to the current status

Returns: the new status

Definition at line 124 of file StatusHandler.h.

Referenced by CPN::Kernel::Kernel(), and CPN::Kernel::Wait().

                                                           {
             Internal::ScopeMutex l(lock);
             while (oldStatus == status) { pthread_cond_wait(&cond, &lock); }
             return status;
         }

Here is the caller graph for this function:

template<class Status_t>

template<class Comparator >

Status_t Sync::StatusHandler< Status_t >::CompareAndWait	(	Status_t	oldStatus,
		Comparator	comp
	)		const

inline

Definition at line 131 of file StatusHandler.h.

                                                                            {
             Internal::ScopeMutex l(lock);
             while (comp(oldStatus, status)) { pthread_cond_wait(&cond, &lock); }
             return status;
         }

template<class Status_t>

Status_t Sync::StatusHandler< Status_t >::ComparePostAndWait	(	Status_t	oldStatus,
		Status_t	newStatus
	)

inline

This function compares status to oldStatus and if the same sets the status to newStatus. Then waits until the status is different than newStatus.

Parameters

oldStatus	the status to compare
newStatus	the status to set the status to

Returns: the status as of the return of this function

Definition at line 145 of file StatusHandler.h.

                                                                             {
             Internal::ScopeMutex l(lock);
             if (oldStatus == status) {
                 status = newStatus;
                 pthread_cond_broadcast(&cond);
                 while (status == newStatus) { pthread_cond_wait(&cond, &lock); }
             }
             return status;
         }

template<class Status_t>

template<class Comparator >

Status_t Sync::StatusHandler< Status_t >::ComparePostAndWait	(	Status_t	oldStatus,
		Status_t	newStatus,
		Comparator	comp
	)

inline

Definition at line 156 of file StatusHandler.h.

                                                                                              {
             Internal::ScopeMutex l(lock);
             if (comp(oldStatus, status)) {
                 status = newStatus;
                 pthread_cond_broadcast(&cond);
                 while (newStatus == status) { pthread_cond_wait(&cond, &lock); }
             }
             return status;
         }

template<class Status_t>

void Sync::StatusHandler< Status_t >::CompareWaitAndPost	(	Status_t	theStatus,
		Status_t	newStatus
	)

inline

Wait for the status to become theStatus then set to newStatus.

Definition at line 169 of file StatusHandler.h.

                                                                         {
             Internal::ScopeMutex l(lock);
             while (theStatus != status) { pthread_cond_wait(&cond, &lock); }
             status = newStatus;
             pthread_cond_broadcast(&cond);
         }

template<class Status_t>

Status_t Sync::StatusHandler< Status_t >::Get ( void ) const

inline

Returns: the current status

Definition at line 84 of file StatusHandler.h.

Referenced by CPN::Kernel::EntryPoint(), CPN::Kernel::InternalCreateNode(), CPN::Kernel::LogState(), CPN::Kernel::NodeTerminated(), and CPN::Kernel::Wait().

                              {
             Internal::ScopeMutex l(lock);
             return status;
         }

Here is the caller graph for this function:

template<class Status_t>

void Sync::StatusHandler< Status_t >::Post ( Status_t newStatus )

inline

Post a change in status.

Parameters

newStatus the new status

Definition at line 75 of file StatusHandler.h.

Referenced by CPN::Kernel::EntryPoint().

                                       {
             Internal::ScopeMutex l(lock);
             status = newStatus;
             pthread_cond_broadcast(&cond);
         }