Module.h

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

#include <map>
#include <DAQ++/DAQObject.h>
#include <DAQ++/RunCommand.h>

namespace DAQpp
{
class Module : public DAQObject, public Observer
{
private:
    RunCommand *cmd;
    bool local;

    void init();
    void update(Observable *o, Argument *arg);

    static std::allocator<char> data_allocator;

    static std::map<void *, int> allocator_map;
public:
    Module(const DAQid &id);

    virtual ~Module();

    // operations

    virtual int PrepareForRun() = 0;
    virtual int Start(int mode = 0) = 0;
    virtual int Stop(int mode = 0) = 0;
    virtual int Pause() = 0;
    virtual int Continue() = 0;
    virtual int Reset() = 0;
    virtual int GetReady() = 0;
    virtual int Trigger() = 0;
    virtual void flush() = 0;
    virtual bool hasData() = 0;

    virtual char *getData(int &size) = 0;

    static char *allocate_real(int size)
    {
        char *ptr = data_allocator.allocate(size);
        allocator_map[(void *)ptr] = size;
        return ptr;
    }

    static void  deallocate_real(char *ptr)
    {
        std::map<void *, int>::iterator ip;
        ip = allocator_map.find( (void *)ptr);
        if (ip != allocator_map.end())
            data_allocator.deallocate((char *)ip->first, ip->second);
    }

    virtual char *allocate(int size)
    {
        return allocate_real(size);
    }

    virtual void  deallocate(char *ptr)
    {
        deallocate_real(ptr);
    }

    bool is_global()
    {
        return !local;
    }

    void in_global(RunCommand *rc = 0)
    {
        if ( rc )
            RegisterDAQ(rc);
        else
        {
            if ( cmd )
                RegisterDAQ(cmd);
        }
        local = false;
    }

    bool is_local()
    {
        return local;
    }
    void in_local()
    {
        if ( cmd )
            UnRegisterDAQ();
        local = true;
    }

    void RegisterDAQ(RunCommand *rc)
    {
        if ( rc )
        {
            cmd = rc;
            rc->addObserver(*this);
        }
    }
    void UnRegisterDAQ(bool reset = false)
    {
        if ( cmd )
        {
            cmd->deleteObserver(*this);
            if (reset)
                cmd = 0;
        }
    }
};
}


#endif

---