EventSvc.C

// -*- 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.
 
// 
//
// EventSvc.C
//
// Event Service Manager
//
// @VERSION@
 
 
#include <isode/base/compat.h>
 
#define DEFAULTMANAGER EVENTSVC_POLLMANAGER
 
// These depends on platform
#define DEFAULTSTREAMPROVIDER "socketpoll"
#define DEFAULTDATAGRAMPROVIDER "socketpoll"
 
#include "Event_p.h"
 
#include "../include/AsyncObject.h"
 
#include <isode/messages/base.h>
 
class MutexLock {
    pthread_mutex_t   *mutex;
 
public:
    MutexLock (pthread_mutex_t *mp) : mutex(mp) {
        if ( pthread_mutex_lock (mutex) != 0 ) {
            MSG_Base_Tmutexlock_LOG ("event mutex");
        }
    }
 
    ~MutexLock () {
        if ( pthread_mutex_unlock (mutex) != 0 ) {
            MSG_Base_Tunlock_LOG ("event mutex");
        }
    }
};
 
IC_CDECL int EventServiceInit (
    const char *managertype,
    const char *pollertype,
    MSGstruct *msp
)
{
    int rc;
 
    rc = ::Event::Manager::ManagerFactory (managertype, msp);
    if ( rc != 0 )
        return rc;
 
    rc = ::Poll::Provider::ProviderFactory (pollertype, msp);
    if ( rc != 0 )
        return rc;
 
    return rc;
}
//␌
 
namespace Event {
#if defined(__clang__)
    const int Manager::MAXPRIO;
#endif
    Manager *Manager::_instance;
    static pthread_mutex_t manager_mutex = PTHREAD_MUTEX_INITIALIZER;
 
    int Manager::ManagerFactory (const char *type, MSGstruct *msp)
    {
        MutexLock mlock (&manager_mutex);
 
        if ( _instance != 0 ) {
            MSG_IOevent_ManagerCreated_LOG ();
            return 0;
        }
 
        if ( type == NULL )
            type = DEFAULTMANAGER;
 
        if ( strcmp (type, EVENTSVC_THREADMANAGER) == 0 ) {
            _instance = CreateThreadManager ();
            if ( _instance != 0 )
                return 0;
        }
 
        if ( strcmp (type, EVENTSVC_POLLMANAGER) == 0 ) {
            _instance = CreatePollManager ();
            if ( _instance != 0 )
                return 0;
        }
 
        MSG_IOevent_Managertype_SET (msp, type);
        return MSG_IOevent_Managertype;
    }
}
//␌
 
namespace Poll {
    Provider *Provider::instance;
    static pthread_mutex_t poller_mutex = PTHREAD_MUTEX_INITIALIZER;
 
    int Provider::ProviderFactory (const char *type, MSGstruct *msp)
    {
        MutexLock mlock (&poller_mutex);
 
        if ( instance != 0 ) {
            MSG_IOevent_PollProviderCreated_LOG ();
            return 0;
        }
 
        if ( type == 0 || strcmp (type, "epoll") == 0 ) {
            instance = CreatePollepollProvider ();
            if ( instance != 0 )
                return 0;
        }
 
        if ( type == 0 || strcmp (type, "port") == 0 ) {
            instance = CreatePollportProvider ();
            if ( instance != 0 )
                return 0;
        }
 
        if ( type == 0 || strcmp (type, "poll") == 0 ) {
            instance = CreatePollpollProvider ();
            if ( instance != 0 )
                return 0;
        }
 
        if ( type == 0 || strcmp (type, "select") == 0 ) {
            instance = CreatePollselectProvider ();
            if ( instance != 0 )
                return 0;
        }
 
        MSG_IOevent_PollProvidertype_SET (msp, type);
        return MSG_IOevent_PollProvidertype;
    }
}
//␌
 
namespace Stream {
 
    Provider *Provider::ProviderFactory (const char *type, MSGstruct *msp)
    {
        if ( type == NULL )
            type = DEFAULTSTREAMPROVIDER;
 
        if ( strcmp (type, "socketpoll") == 0 ) {
            // If no poll provider, create using the default
            if ( ::Poll::Provider::GetPollService() == 0 &&
                 ::Poll::Provider::ProviderFactory (0, msp) != 0 )
                return 0;
 
            return CreateSocketPollProvider ();
        }
 
        MSG_IOevent_StreamProvidertype_SET (msp, type);
        return 0;
    }
}
//␌
 
namespace Datagram {
 
    Provider *Provider::ProviderFactory (const char *type, MSGstruct *msp)
    {
        if ( type == NULL )
            type = DEFAULTDATAGRAMPROVIDER;
 
        if ( strcmp (type, "socketpoll") == 0 ) {
            // If no poll provider, create using the default
            if ( ::Poll::Provider::GetPollService() == 0 &&
                 ::Poll::Provider::ProviderFactory (0, msp) != 0 )
                return 0;
 
            return CreateSocketPollProvider ();
        }
 
        MSG_IOevent_StreamProvidertype_SET (msp, type);
        return 0;
    }
}
 
//␌
// C interfaces
 
IC_CDECL void EventServiceRun (void)
{
    Event::Manager::GetManager()->Run(false);
}
 
 
IC_CDECL void EventAsyncDispatch (void (*func)(void *), void *param)
{
    Event::AsyncObject::Invoke (reinterpret_cast<Event::AsyncObject::FuncPtr>(func),
                                param);
 
}
 
IC_CDECL void EventServiceLongLived (void)
{
    Event::Manager::GetManager()->LongLived();
}
 
IC_CDECL void EventServiceTerminate (int millisecs)
{
    Event::Manager::GetManager()->Terminate(millisecs);
}