Syncmsgobj< C > Class Template Reference

Template class for protecting an object. More...

#include <Syncmsg.h>

Inheritance diagram for Syncmsgobj< C >:

Public Member Functions
virtual void	Queue (Event::AsyncEvent *event)
	Queue event from Event Manager.
virtual void	Extract (Event::AsyncEvent *event)
	Remove event from queue.
virtual void	Process ()
	Process queued events for the object.
template<class M >
void	msgDeliver (M *msg)
	template function for delivering message of given type to receiver

Protected Member Functions
void	dieAux ()

Detailed Description

template<class C>
class Syncmsgobj< C >

Template class for protecting an object.

The key idea here is that when the object is busy, then the thread which delivers the event object does not wait. It stores the event on a queue, which is processed when the current operation has finished. A subclass of this class would be defined so that Deliver (M *msg) can be defined. We cannot have virtual template functions within this class.

Definition at line 166 of file Syncmsg.h.

Constructor & Destructor Documentation

Syncmsgobj()

template<class C >

Syncmsgobj< C >::Syncmsgobj ( )

inline

Definition at line 192 of file Syncmsg.h.

                         : _busy(false), _die(false), _dying(false), _qcount(0) {
        pthread_mutex_init (&_mutex, 0);
    }

~Syncmsgobj()

template<class C >

virtual Syncmsgobj< C >::~Syncmsgobj ( )

inlinevirtual

Definition at line 196 of file Syncmsg.h.

                           {
        Event::AsyncEvent *item;
 
        while ( (item = _queue.First()) != 0 )
            if ( item->ShouldDelete() )
                delete item;
 
        pthread_mutex_destroy (&_mutex);
    }

Member Function Documentation

dieAux()

template<class C >

void Syncmsgobj< C >::dieAux ( )

inlineprotected

Definition at line 176 of file Syncmsg.h.

                          {
        int rc = pthread_mutex_lock (&_mutex);
 
        _die = true;
 
        bool killit = !_busy && !_dying && _qcount <= 0;
 
        if ( killit )
            _dying = true;
 
        if ( rc == 0 ) pthread_mutex_unlock (&_mutex);
 
        if ( killit ) delete this;
    }

Queue()

template<class C >

virtual void Syncmsgobj< C >::Queue ( Event::AsyncEvent *  event )

inlinevirtual

Queue event from Event Manager.

Definition at line 208 of file Syncmsg.h.

                                                {
        if ( pthread_mutex_lock (&_mutex) != 0 )
            return;
 
        _queue.Insert (event);
 
        _qcount++;
 
        pthread_mutex_unlock (&_mutex);    
    }

References SyncEventQueue::Insert().

Extract()

template<class C >

virtual void Syncmsgobj< C >::Extract ( Event::AsyncEvent *  event )

inlinevirtual

Remove event from queue.

Definition at line 220 of file Syncmsg.h.

                                                  {
        if ( pthread_mutex_lock (&_mutex) != 0 )
            return;
 
        Event::AsyncEventRef *ref = event->Reference();
 
        if ( ref != 0 )
            ref->Extract();
 
        pthread_mutex_unlock (&_mutex);    
    }

Process()

template<class C >

virtual void Syncmsgobj< C >::Process ( )

inlinevirtual

Process queued events for the object.

Definition at line 234 of file Syncmsg.h.

                            {
        if ( pthread_mutex_lock (&_mutex) != 0 )
            return;
 
        _qcount--;
 
        if ( _busy ) {
 
            pthread_mutex_unlock (&_mutex);
 
            return;
        }
 
        _busy = true;
 
        Event::AsyncEvent *item;
 
        while ( (item = _queue.First ()) ) {
 
            if ( _die ) {
                if ( item->ShouldDelete() )
                    delete item;
                continue;
            }
 
            pthread_mutex_unlock (&_mutex);
 
            // As the delivery of the item may delete the underlying object,
            // we need to find out whether this should delete it beforehand
            bool shouldDelete = item->ShouldDelete();
 
            item->Deliver ();
 
            if ( shouldDelete )
                delete item;
 
            if ( pthread_mutex_lock (&_mutex) != 0 )
                return;
        }
 
        _busy = false;
 
        bool killit = _die && !_dying && _qcount <= 0;
 
        if ( killit )
            _dying = true;
 
        pthread_mutex_unlock (&_mutex);
 
        if ( killit )
            delete this;
    }

References SyncEventQueue::First().

msgDeliver()

template<class C >

template<class M >

void Syncmsgobj< C >::msgDeliver ( M *  msg )

inline

template function for delivering message of given type to receiver

Definition at line 288 of file Syncmsg.h.

                                                       {
 
        if ( pthread_mutex_lock (&_mutex) != 0 )
            return;
 
        if ( _die || _busy ) {
 
            // Don't bother to queue this message if the entity is going away
            if ( !_die )
                _queue.Insert (new SyncEvent<M,C> (msg, this));
                
            pthread_mutex_unlock (&_mutex);
 
            return;
        }
 
        _busy = true;
        pthread_mutex_unlock (&_mutex);
 
        this->actualDeliver (msg);
 
        if ( pthread_mutex_lock (&_mutex) != 0 )
            return;
 
        Event::AsyncEvent *item;
 
        while ( (item = _queue.First ()) ) {
 
            if ( _die ) {
                if ( item->ShouldDelete() )
                    delete item;
                continue;
            }
 
            pthread_mutex_unlock (&_mutex);
 
            bool shouldDelete =  item->ShouldDelete();
 
            item->Deliver ();
 
            if ( shouldDelete )
                delete item;
 
            if ( pthread_mutex_lock (&_mutex) != 0 )
                return;
        }
 
        _busy = false;
 
        bool killit = _die && !_dying && _qcount <= 0;
 
        if ( killit )
            _dying = true;
 
        pthread_mutex_unlock (&_mutex);
 
        if ( killit ) delete this;
    }

References SyncEventQueue::First(), and SyncEventQueue::Insert().

---

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

• Syncmsg.h