DAQmanager.h

/* -*- mode: c++ -*- */
#ifndef __DAQpp_DAQmanager_h__
#define __DAQpp_DAQmanager_h__
#include <map>
#include <functional>
#include <algorithm>

#include <DAQ++/RunManager.h>
#include <DAQ++/Module.h>
#include <DAQ++/ObserverModel.h>
#include <DAQ++/Thread.h>

namespace DAQpp
{
    typedef std::map<std::string, RunManager *> RunManagerMap;
    typedef std::map<std::string, Module *> ModulesMap;

    class Semaphore;

    class DAQTrigger
    {
    public:
        DAQTrigger()
        {}

        virtual ~DAQTrigger()
        {}

        virtual bool operator()()
        {
            return true;
        }
    };


    class DAQmanager : public Observable
    {
    public:
        enum DAQstatus {
            Running  = 1,  
            Threaded = 2,  
            Loop     = 4,  
            Public   = 6   
        };

    private:
        class DAQinternal
        {
        protected:
            DAQmanager *mngr;
        public:
            DAQinternal() : mngr( DAQmanager::theDAQmanager() )
            {}
        };
        friend class DAQinternal; // DAQinternal is declared a friend.

        static DAQmanager theManager;

        RunManagerMap runm;

        class RunManagerSet : public std::set<RunManager *>, public Condition , public DAQinternal
        {
        public:
            RunManagerSet()
            {}
            std::pair<iterator, bool> insert(const value_type &x);
            iterator insert(iterator pos, const value_type &x);
            void erase(iterator pos);
            size_type erase(const key_type &k);
            void erase(iterator first, iterator last);
            void clear();
            bool condition();
        };
        RunManagerSet active;

        ModulesMap mmap;

        int state;


        class RunCondition : public DAQinternal, public Condition
        {
        public:
            RunCondition()
            {}
            bool condition()
            {
                bool rc = !mngr->isRunning();
                if (!mngr->isLooping() )
                    rc |= mngr->active.empty();

                return rc;
            }
        };
        RunCondition daq_cond;

        class DAQthread : public DAQinternal, public Thread
        {
        public:
            DAQthread()
            {}

            void run();
        };
        DAQthread thread;


        DAQTrigger *trigger;
    protected:
        DAQmanager();

        DAQmanager(const DAQmanager &);

        void operator=(const DAQmanager &)
        {}

    public:
        ~DAQmanager();

        static DAQmanager *theDAQmanager()
        {
            return &theManager;
        }

//---------------------------------------------------------------------
// Mantaining the list
//---------------------------------------------------------------------
        enum msg
        {
            startDAQ,     
            stopDAQ,      
            nwModule,     
            nwRunManager, 
            rmModule,     
            rmRunManager, 
            acRunManager, 
            dcRunManager  
        };

        typedef std::pair<msg, char *> newObjArg;

        void addModule(Module *m)
        {
            mmap[m->get_id()] = m;
            new_obj(nwModule, (char *)m);
        }

        Module * deleteModule(Module *m)
        {
            mmap.erase(m->get_id());
            new_obj(rmModule, (char *)m);
            return m;
        }

        Module *find_module(const DAQid &id)
        {
            ModulesMap::iterator it = mmap.find(id);

            if ( it == mmap.end() )
                return 0;
            else
                return (*it).second;
        }

        const ModulesMap & ModuleMap()
        {
            return mmap;
        }

        int countModules()
        {
            return mmap.size();
        }

        void addRunManager(RunManager *m)
        {
            runm[m->get_id()] = m;
            new_obj(nwRunManager, (char *)m);
        }

        RunManager *deleteRunManager(RunManager *m)
        {
            if ( m->isActive() )
                m->deActivate();
            runm.erase(m->get_id());
            new_obj(rmRunManager, (char *)m);
            return m;
        }

        int countRunManager()
        {
            return runm.size();
        }

        RunManager *find_runmanager(const DAQid &id)
        {
            RunManagerMap::iterator it = runm.find(id);

            if ( it == runm.end() )
                return 0;
            else
                return (*it).second;
        }

        const RunManagerMap & RunMmap()
        {
            return runm;
        }

        void addActiveRunManager(RunManager *rm);

        void removeActiveRunManager(RunManager *rm);

        int countActiveRunManager()
        {
            return active.size();
        }
//---------------------------------------------------------------------
// Acquisition
//---------------------------------------------------------------------
        class RunAcquire : public DAQinternal,
                           public std::unary_function<RunManager const *, void>
        {
        public:
            RunAcquire()
            {}
            void operator()( RunManager *rm);
        };

        void StartRun(int flags);

        void startRunManager(RunManager *);

        void stopRunManager(RunManager *);

        void WaitForEndOfRun(int tmout = -1);

        bool isRunning()
        {
            return (state & Running) != 0;
        }
        bool isLooping()
        {
            return (state & Loop) != 0;
        }
        bool isThreaded()
        {
            return (state & Threaded) != 0;
        }
        void StopRun();

//---------------------------------------------------------------------
// The trigger
//---------------------------------------------------------------------
        void set_trigger( DAQTrigger *func );

    private:
        void Acquire();

        void processTheEvent();

        void new_obj(msg tp, char *ptr)
        {
            Arg< newObjArg > arg( newObjArg(tp, ptr) );
            notifyObservers(&arg);
        }

    };


}
#endif

---