ArchivingWorkerGroup.h

#ifndef ARCHIVINGWORKERGROUP_H
#define ARCHIVINGWORKERGROUP_H

#include "SctService/WorkerGroup.h"
#include <boost/shared_ptr.hpp>
#include "Sct/Serializable.h"
#include "CalibrationController/IS/TestData.h"
#include "archiving/ArchRawScanResult.h"
#include "archiving/ArchFitScanResult.h"

using boost::shared_ptr;
using Sct::Serializable;
using SctService::WorkerGroup;

namespace SctArchivingService {
    
class ArchivingWorkerGroup : public WorkerGroup<shared_ptr<Serializable> > {
 
 public:
  
  class TestAlgs;   
  void addTest(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() ;

  //void RawScanWork(shared_ptr<const RawScanResult> raw) throw();
  //void FitScanWork(shared_ptr<const FitScanResult> fit) throw();

  shared_ptr<ArchScanResult>  getScanFromMap(shared_ptr<Serializable> ob);
  
  /*--------internal class-----------------------------------------------------------*/

    class TestAlgs {
    public:
        TestAlgs(shared_ptr<const TestData> testdata) : m_testdata(testdata) {} 
        const TestData& getTest() const {return *m_testdata;}
        
        ~TestAlgs();
        ostream& printStatus(ostream& os) const throw();
    private:
        shared_ptr<const TestData> m_testdata;               

        //AT mutable boost::recursive_mutex m_access;                 ///< lock results
    };

 private:
    
    virtual void work(shared_ptr<Serializable>) throw();
    
    list<shared_ptr<TestAlgs> > m_tests; 
    mutable boost::recursive_mutex m_tests_access; 
    mutable boost::recursive_mutex m_file_access; 

  
    
    
};
    
}

#endif //ARCHIVINGWORKERGROUP_H

---