Monitor.h

/* -*- mode: c++ -*- */
#ifndef __DAQpp_Monitor_h__
#define __DAQpp_Monitor_h__
#include <queue>
#include <memory>
#include <DAQ++/Thread.h>

namespace DAQpp
{
class Event
{
private:
    int _size;
    char *_data;

    void cpy(const Event &e);

    static std::allocator<Event> event_allocator;
    static std::allocator<char> data_allocator;

    void free_data() 
    {
        data_allocator.deallocate(_data, _size);
        _data = 0;
    }
public:
    Event(int s, const char *d);
    Event(const Event &e) : _size(0), _data(0)
    {
        cpy(e);
    }
    Event &operator=(const Event &e)
    {
        if ( &e != this ) cpy(e);
        return *this;
    }

    ~Event();

    int size() const
    {
        return _size;
    }
    const char *data() const
    {
        return _data;
    }

    inline void* operator new(size_t);   

    inline void  operator delete(void*); 

};


// overloaded new operator
inline void* Event::operator new(size_t)
{
    void* anEvent;
    anEvent = event_allocator.allocate(1);
    return anEvent;
}

// implementation of overloaded delete operator
inline void Event::operator delete(void* anEvent)
{
    event_allocator.deallocate((Event *)anEvent, 1);
}

class Monitor : public std::queue<Event *>, public Thread, public Condition
{
private:
    unsigned long mxsize;
    Mutex mtx;

public:
    static Event *MonitorDie;
    static Event *MonitorTimeOut;
    Monitor(int sz = 50);
    ~Monitor();

    void push_event( Event *ev );

    Event *get_event(int timeout = -1);

    bool condition()
    {
        return !empty();
    }

    void set_max_size(unsigned long s)
    {
        mxsize = s;
    }

    unsigned long get_max_size() const
    {
        return mxsize;
    }

    bool full()
    {
        return size() > mxsize;
    }

    void clean();

    void start_monitor();

    void stop_monitor();

};

}

#endif

---