Thread.h

/* -*- mode: c++ -*- */
#ifndef __DAQpp_thread_h__
#define __DAQpp_thread_h__

#include <string>
#include <pthread.h>
#include <semaphore.h>

namespace DAQpp
{

class Mutex
{
protected:
    bool             debug;

    pthread_mutex_t _mtx;

    pthread_t       _owner;

    int             _count;
public:
    Mutex();
    ~Mutex();

    void set_debug(bool x)
    {
        debug = x;
    }

    int  acquire();
    bool busy();
    int  release();

};

class Condition : public Mutex
{
private:
    pthread_cond_t _cond;
public:
    Condition();

    virtual ~Condition();


    bool wait(int timeout = -1);

    void notify();

    void notify_all();

    virtual bool condition() = 0;
    virtual void exec()
    {}

};

class Semaphore
{
private:
    sem_t _sem;
public:
    Semaphore(int ifirst);
    ~Semaphore();

    int wait(bool block = true);

    void post();

    int count();
};

class Thread
{
private:
    pthread_t _thread;

    bool           _started;

    bool           _stopped;

    int            _nice;
public:
    enum CancelType {
        deferred,
        asynchronous,
        disable
    };

    Thread();

    virtual ~Thread()
    {};

    void nice(int x)
    {
        _nice = x;
    }

    void test_cancel();

    void set_cancel(CancelType);

    void exit(int v = 0);

    virtual void start();

    virtual void stop();

    virtual void run() = 0;

    static void *_run(void *);

    bool is_running()
    {
        return _started;
    }

    bool is_stopped()
    {
        return _stopped;
    }

};

}
#endif

---