AnalysisWorkerGroup.h

#ifndef ANALYSISWORKERGROUP_H
#define ANALYSISWORKERGROUP_H
#include "SctService/WorkerGroup.h"
#include <string>
#include <list>
#include <iostream>

namespace Sct {
class IOName;
}
class TestData;

using namespace SctService;
using std::string;
using std::list;
using boost::shared_ptr;

namespace SctAnalysis{

    class AnalysisAlgorithm;
    

    class AnalysisWorkerGroup : public WorkerGroup< shared_ptr<Sct::IOName> >{
    public:
    class TestAlgs; 
    
    void addTest(shared_ptr<const TestData> testdata);
    void removeTestsUpTo(shared_ptr<const TestData> testdata);

    shared_ptr<TestAlgs> findTest(const unsigned long runno, const unsigned long scanno) const throw();
    shared_ptr<TestAlgs> findTest(const TestData& testdata)const throw() ;

    std::ostream& printStatus(std::ostream& os) const throw();
    
    void purge() throw();
    
    virtual void work(shared_ptr<Sct::IOName> name) throw();
    
/*--------internal class-----------------------------------------------------------*/

    class TestAlgs {
    public:
        TestAlgs(shared_ptr<const TestData> testdata) : m_testdata(testdata) {} 
        const TestData& getTest() const {return *m_testdata;}
        shared_ptr<AnalysisAlgorithm> findAlgorithm(const string& modulename) ;
        shared_ptr<AnalysisAlgorithm> addAlgorithm(const string& modulename);
        void removeAlgorithm(shared_ptr<AnalysisAlgorithm> alg);
        ~TestAlgs();
        std::ostream& printStatus(std::ostream& os) const throw();
    private:
        shared_ptr<const TestData> m_testdata;               
        list< shared_ptr<AnalysisAlgorithm> > m_algorithms;  
        mutable boost::recursive_mutex m_access;                 
    };
    
    private:    
    list<shared_ptr<TestAlgs> > m_tests; 
    mutable boost::recursive_mutex m_tests_access; 
    };
    

    
}// end of namespace SctAnalysis

#endif // #define ANALYSISWORKERGROUP_H

---