MNTimer.h

Go to the documentation of this file.

/* Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, code may be used in unmodified form provided
 * that this copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This software is provided "as is" and without any express or implied
 * warranties, including, without limitation, the implied warranty of
 * fitness for a particular purpose.
 *
 * The code may be subjected to the GNU General Public License, Version 2,
 * and re-distributed under the terms of this license.
 * As a special exception, permission is granted to link this code
 * with the Qt library and distribute executables, as long as you
 * follow the requirements of the GNU GPL in regard to all of the
 * software in the executable aside from Qt.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after express negotiation of conditions
 * with the authors.
 */
#ifndef MN_TIMER_H
#define MN_TIMER_H

#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include "MNThread.h"
#include "MNMutex.h"
#include "MNTimerCall.h"
#include "MNTimerEntry.h"
#include "MNProtectedVar.h"
#include "MNTimeval.h"
#include "MNSelector.h"
#include "dictionary.h"

class MNTimer;
class AutonomousTimer;

/***********************************************************************
 * MNTimer
 ***********************************************************************/

class MNTimer
{
    MNSelector& _sel;

public:
    static const bool InCallback    = true;
    static const bool NotInCallback = false;

public:
    MNTimer( MNSelector& selector, const char* debug_creator_string );

    virtual ~MNTimer( );

    void insert_abs_timer( TimerCallBase*        timerptr,
                           const struct timeval& timeout,
                           bool                  inCallback,
                           const char*           owner );

    void reschedule_abs_timer( TimerCallBase*        timerptr,
                               const struct timeval& timeout,
                               bool                  inCallback,
                               const char*           owner );

    void insert_rel_timer( TimerCallBase*        timerptr,
                           const struct timeval& timeout,
                           bool                  inCallback,
                           const char*           owner );

    void reschedule_rel_timer( TimerCallBase*        timerptr,
                               const struct timeval& timeout,
                               bool                  inCallback,
                               const char*           owner );

    void insert_periodic_timer( TimerCallBase*        timerptr,
                                const struct timeval& timeout,
                                bool                  inCallback,
                                const char*           owner );

    void cancel_timer( TimerCallBase* timerptr );
    
    void cancel_all_timer();

    void wait_usec(long time_);

    virtual void start_timer();

    virtual void terminate_timer();

    MNSelector& getSelector( );
private:
    MNTimer( const MNTimer& );
    MNTimer& operator=( const MNTimer& );
};

/***********************************************************************
 * AutonomousTimer
 ***********************************************************************/

class AutonomousTimer : public MNTimer
                      , public MNThread
{
    MNSelector _autonomous_selector;

    ProtectedBool _started;

    ProtectedBool _ende;

    MNMutex       _initialized;

    virtual void run();

public:
    AutonomousTimer( const char* debug_creator_string );

    virtual ~AutonomousTimer( );

    virtual void start_timer();

    virtual void terminate_timer();
};

#endif /* MN_TIMER_H */

---