EventSvc.h

/* -*- C++ -*-
 *  Copyright (c) 2005-2010, Isode Limited, London, England.
 *  All rights reserved.
 *                                                                       
 *  Acquisition and use of this software and related materials for any      
 *  purpose requires a written licence agreement from Isode Limited,
 *  or a written licence from an organisation licenced by Isode Limited
 *  to grant such a licence.
 */
 
/* 
 *
 * \file EventSvc.h
 *
 * \brief Interface for core Event service framework. 
 *
 * @VERSION@
 */
 
#ifndef _EVENTSVC_H_
#define _EVENTSVC_H_
 
#include "cdecl.h"
#include <isode/base/messages.h>
 
#ifdef __cplusplus
 
namespace Event {
    class Manager;
    class Receiver;
    class AsyncEventRef;
 
    //
 
    class AsyncEvent {
    private:
        // Note: this is maintained by the AsyncEventRef under the
        // control of the main event service
        AsyncEventRef   *_queued;
 
        Receiver        *_rcvr;
 
        // This is a friend class, as it sets the _queued value
        friend class AsyncEventRef;
 
    protected:
        inline void SetReceiver (Receiver *rcvr) { _rcvr = rcvr; }
 
    public:
        AsyncEvent () : _queued (0), _rcvr (0) { }
 
        virtual ~AsyncEvent () { if ( _queued ) Cancel(); }
 
        inline AsyncEventRef *Reference () const { return _queued; }
 
        Receiver *GetReceiver () const { return _rcvr; }
 
        virtual void Deliver() = 0;
 
        virtual bool ShouldDelete () const { return false; }
 
        inline void Cancel ();
    };
 
    // This is used when the manager should queue the event to this receiver
    // So that the event is on a queue until delivery is serialized for the
    // receiver object.
    class Receiver {
    public:
        virtual ~Receiver() {}
 
        virtual void Queue (AsyncEvent *event) = 0;
 
        virtual void Extract (AsyncEvent *event) = 0;
 
        virtual void Process() = 0;
 
    };
 
 
    class AsyncEventRef {
    private:
        AsyncEvent *_event;
 
        // This is a friend class, as it can call Extract()
        friend class Manager;
 
        virtual void extract() = 0;
 
    protected:
        AsyncEventRef(AsyncEvent *event) :  _event(event) {
            event->_queued = this;
        }
 
        AsyncEventRef() : _event(0) {}
 
        virtual ~AsyncEventRef() {}
 
        void Set (AsyncEvent *event) {
            _event = event;
            event->_queued = this;
        }
 
    public:
        inline AsyncEvent *Extract () {
            AsyncEvent *ep = _event;
 
            ep->_queued = 0;
 
            extract();
 
            return ep;
        }
    };
 
    //
 
    class Manager {
    private:
        static EVENTSVC_DLL Manager *_instance;
 
    public:
        virtual ~Manager() {}
 
        static inline Manager *GetManager() {
            return _instance;
        }
 
        virtual bool IsThreaded () = 0;
 
        virtual void Dequeue (AsyncEvent *event) = 0;
 
        virtual void Run (bool isthread) = 0;
 
        // Returns true if there are significant events queued,
        // so that it can be called again to deliver them.
        virtual bool Poll (
            const timespec *when,
            bool immediate,
            pthread_mutex_t *mutex,
            pthread_cond_t *cond) = 0;
 
        virtual void Terminate(
            unsigned int millisecs 
        ) = 0;
 
        virtual void Blocking() = 0;
 
        virtual void Unblocked() = 0;
 
        static inline void about2Block() {
            if ( _instance ) _instance->Blocking();
        }
 
        static inline void nowUnblocked() {
            if ( _instance ) _instance->Unblocked();
        }
 
        virtual bool LongLived() = 0;
 
        // (Cannot be Yield() as this fails on Windows)
        static inline bool Yielding() {
            if ( _instance ) return _instance->LongLived();
 
            return false;
        }
 
        virtual void SetThreads (
            int activethreads, 
            int maxthreads     
        ) = 0;
 
        virtual int GetActiveLimit () = 0;
 
        static const int MAXPRIO = 100; 
 
        virtual void Queue (
            AsyncEvent *event,     
            unsigned priority = 0, 
            bool nostart = false   
        ) = 0;
 
        virtual void QueueAt (
            AsyncEvent *event,             
            const struct timespec *abstime 
        ) = 0;
 
        virtual void QueueAt (
            AsyncEvent *event,             
            unsigned millisec              
        ) = 0;
 
        virtual void QueueAtExit (AsyncEvent *event) = 0;
 
        virtual const struct timespec *NextEventDue () = 0;
 
        //
        static int ManagerFactory (
            const char *type,  
            MSGstruct  *msg    
        );
    };
 
    inline void AsyncEvent::Cancel () {
        // Note: must call the Dequeue routine
        // Whether the event is queued or not needs to be under the
        // control of the main manager mutex.
        Manager::GetManager()->Dequeue (this);
    }
 
 
 
    template<class U, class D> class AsyncEventAux  : public AsyncEvent {
    private:
        U        *_user;
        D         _data;
 
    public:
        AsyncEventAux () : _user(0) {}
 
        void SetUser (U *u) { _user = u; }
 
        void SetUserData (U *u, D &d) { _user = u; _data = d; }
 
        virtual void Deliver () {
            _user->Deliver (&_data);
        }
 
        virtual void Deliver (D *dp) {
            _user->Deliver (dp);
        }
 
        void Send (Manager *mgr, D *dp) {
            _data = *dp;
 
            mgr->Queue (this, 0);
        }
    };
 
}
#endif /* __cplusplus */
 
IC_CDECL EVENTSVC_DLL int EventServiceInit (
    const char *managertype,  
    const char *pollertype,   
    MSGstruct *msp            
);
 
/* Manager types */
 
#define EVENTSVC_THREADMANAGER "thread"
#define EVENTSVC_POLLMANAGER "poll"
 
IC_CDECL EVENTSVC_DLL void EventServiceRun (void);
 
IC_CDECL EVENTSVC_DLL void EventServiceLongLived (void);
 
IC_CDECL EVENTSVC_DLL void EventServiceTerminate (
    int millisecs            
);
 
 
#endif  /* _EVENTSVC_H_ */