CalibrationControllerImpl.h

#ifndef CALIBRATIONCONTROLLERIMPL_H
#define CALIBRATIONCONTROLLERIMPL_H

#include "ipc/CalibrationController.h"
#include "IS/CalibrationControllerStatus.h"
#include <boost/noncopyable.hpp>
#include <boost/thread.hpp>
#include <boost/shared_ptr.hpp>

#include <memory>

using std::auto_ptr;

namespace SctCalibrationController {

class Test;
class ConfigUpdater;
class RunControl;
class SctApiAccessException;
class Sequence;

using namespace Ipc;

class CalibrationControllerImpl : public CalibrationController, private boost::noncopyable {
public:
  virtual void shutdown() { };
  static CalibrationControllerImpl & initialize(RunControl& rc);

    //static CalibrationControllerImpl& instance();
    static Sct_CalibrationController::CalibrationController_ptr instance();

    virtual Sct_CalibrationController::ScanLibrary_ptr getScanLibrary();
    virtual Sct_CalibrationController::TestLibrary_ptr getTestLibrary();
    virtual Sct_CalibrationController::SequenceLibrary_ptr getSequenceLibrary();
    virtual void doScan(Sct_CalibrationController::ScanRequest_ptr r);
    virtual void doTest(Sct_CalibrationController::TestRequest_ptr t);
    virtual void doSequence(Sct_CalibrationController::SequenceRequest_ptr r);
    virtual void abort();
    virtual Sct_SctApi::Scan_ptr getScan(unsigned long runNumber, unsigned long scanNumber);
    virtual void setUpdateOption(Sct_CalibrationController::CalibrationController::UpdateOption opt);
    virtual void updateWith (const char* testResultInIs, bool force);


    void setApi(Sct_SctApi::SctApiIPC_ptr api);

    void takeControl(unsigned int runNumber);

    void giveupControl();

    void reset();




    Sct_SctApi::SctApiIPC_ptr getApi();

    unsigned int getRunNumber() const;

    unsigned int getNextScanNumber() const;

private:
    CalibrationControllerImpl(RunControl& rc);
    virtual ~CalibrationControllerImpl();
    void updateStatus();

    bool isInControl();
    bool isBusy();
    void setBusy(bool busy);
    Sct_SctApi::SctApiIPC_ptr m_api;

    void executeSequence(Sct_CalibrationController::SequenceRequest_ptr sr);

    auto_ptr<Test> executeTest(Sct_CalibrationController::TestRequest_ptr tr, boost::shared_ptr<const Sequence> s);

    void executeScan (Sct_CalibrationController::ScanRequest_ptr s, unsigned int index);

    void applyChanges(const unsigned long runNumber, const unsigned long scanNumber, const std::list<std::string>& list );

    void sctApiError(SctApiAccessException& e);

    void setNextScanNumber(unsigned int scanNumber);

    static std::list<std::string> getAllModulesForScan(Sct_SctApi::Scan_ptr scan);

    CalibrationControllerStatus status;                         
    RunControl& rc;                                             
    unsigned int runNumber;                                     
    unsigned int nextScanNumber;                                
    volatile bool abortNow;                                     
    volatile bool abortRightNow;                                
    static CalibrationControllerImpl * inst;                     
    static CalibrationControllerImpl * underlyingInstance() { return inst; };
    boost::thread_group m_sequence_request_thread_group;        

    friend class SequenceRequestWorker;                         
};
}

#endif //#ifndef CALIBRATIONCONTROLLERIMPL_H

---