/afs/cern.ch/user/k/kolos/working/online/ipc/ipc/alarm.h

Go to the documentation of this file.

#ifndef IPC_ALARM_H
#define IPC_ALARM_H

//      server.h
//
//      header file for the IPC library
//
//      Sergei Kolos June 2003
//
//    description:
//      This file contains IPCAlarm class implementation
//

#include <omniORB4/CORBA.h>
#include <owl/mutex.h>
#include <owl/thread.h>
#include <owl/condition.h>

class IPCAlarm
{
 public:
    typedef bool (*Callback)( void * );
   
 private:
    class Thread : public OWLThread
    {
      public:
        Thread( long seconds, long nano_seconds, Callback cb, void * param )
        : condition_(&mutex_),
          suspended_(false),
          terminated_(false),
          seconds_(seconds),
          nano_seconds_(nano_seconds),
          callback_(cb),
          param_(param)
        { ; }

        void suspend() {
            OWLMutexLock ml( mutex_ );
            suspended_ = true;
        }

        void resume() {
            OWLMutexLock ml( mutex_ );
            suspended_ = false;
        }

        void start() {
            start_undetached();
        }

        void stop() {
            {
                OWLMutexLock ml( mutex_ );
                terminated_ = true;
                condition_.signal();
            }
            join(0);
        }
    
        void * run_undetached( void * )
        {
            unsigned long s, n;
            OWLThread::get_time( &s, &n, seconds_, nano_seconds_ );
            OWLMutexLock ml( mutex_ );
            while ( !terminated_ && condition_.timedwait( s, n ) == 0 )
            {
                if ( !suspended_ && !terminated_ )
                {
                    suspended_ = !callback_( param_ );
                }
                OWLThread::get_time( &s, &n, seconds_, nano_seconds_ );
            }
            return 0;
        }
    
    private:
        // Disallow object copying
        Thread ( Thread & );
        Thread & operator= ( Thread & );
        
        OWLMutex     mutex_;
        OWLCondition condition_;
        bool         suspended_;
        bool         terminated_;
        long         seconds_;
        long         nano_seconds_;
        Callback     callback_;
        void *       param_;
    };

  public:

    IPCAlarm( long seconds, long nano_seconds, IPCAlarm::Callback callback, void * param = 0 ) {
        alarm_thread_ = new Thread( seconds, nano_seconds, callback, param );
        alarm_thread_ -> start();
    }

    IPCAlarm( double period, IPCAlarm::Callback callback, void * param = 0 ) {
        alarm_thread_ = new Thread( (long)period, (long)((period-(double)((long)period))*1000000000.), callback, param );
        alarm_thread_ -> start();
    }

    ~IPCAlarm ( ) {
        alarm_thread_ -> stop();
    }
    
    void suspend( ) {
        alarm_thread_ -> suspend();
    }
    
    void resume( ) {
        alarm_thread_ -> resume();
    }
    
  private:
  
    // Disallow object copying
    IPCAlarm ( IPCAlarm & );
    IPCAlarm & operator= ( IPCAlarm & );    
        
    Thread * alarm_thread_;
};

#endif

---