CalibrationController.cpp

#include "CalibrationController.h"
#include "ScanLibrary.h"
#include "TestLibrary.h"
#include "SequenceLibrary.h"
#include "SequenceRequest.h"
#include "TestRequest.h"
#include "Sct/SctNames.h"
#include <ipc/server.h>

#include <iostream>

using namespace std;
using namespace Sct;

namespace SctCalibrationController {
namespace Ipc {
    
CalibrationController::CalibrationController() : 
  IPCNamedObject<POA_Sct_CalibrationController::CalibrationController, ipc::multi_thread>(SctNames::getPartition(),
                                              Sct_CalibrationController::CalibrationController::instanceName) {
    cout << "CalibrationController::CalibrationController()" << endl;
}

CalibrationController::~CalibrationController() {
    cout << "CalibrationController::~CalibrationController()" << endl;
}

  /*
    IPCServer& CalibrationController::getServer() {
    static IPCServer server (Sct_CalibrationController_C_CalibrationController_serverName, SctNames::getPartition());
    return server;
    }
  */

  /*
Sct_CalibrationController::ScanLibrary_ptr CalibrationController::getScanLibrary_corba () {
    cout << "External get Scan library" << endl;
    ScanLibrary& sl = getScanLibrary_nonCorba();
    return sl._this();
}

Sct_CalibrationController::TestLibrary_ptr CalibrationController::getTestLibrary_corba () {
    cout << "External get Test library" << endl;
    TestLibrary& tl = getTestLibrary_nonCorba();
    tl.incRef();
    return &tl;
}

Sct_CalibrationController::SequenceLibrary * CalibrationController::getSequenceLibrary_corba () {
    cout << "External Get Sequence Library" << endl;
    SequenceLibrary& sl = getSequenceLibrary_nonCorba();
    sl.incRef();
    return &sl;
}

//We need a null deleter for the internal XXXRequest objects

template<typename T>
class NullDeleter {
public:
    void operator() (T* t) throw () {}
};

void CalibrationController::updateWith (Sct_CalibrationControllerStatus *_status, bool force, ilu_T_CString testResultInIs){
  updateWith(testResultInIs, force);
}

void CalibrationController::doScan (Sct_CalibrationController::ScanRequest * s) {
  shared_ptr<ScanRequest> req (dynamic_cast<ScanRequest*>(s), NullDeleter<ScanRequest>());
  if (!req) {
    req = shared_ptr<ScanRequest>(new ScanRequestAdapter(s));
  }
  doScan(req);
}

void CalibrationController::doTest (class Sct_CalibrationController::TestRequest *t) {
    shared_ptr<TestRequest> req (dynamic_cast<TestRequest*>(t), NullDeleter<TestRequest>());
    if (!req) {
    req = shared_ptr<TestRequest>(new TestRequestAdapter(t));
    }
    
    doTest(req); 
}

void CalibrationController::doSequence (class Sct_CalibrationController::SequenceRequest * r) {
    shared_ptr<SequenceRequest> req (dynamic_cast<SequenceRequest*>(r), NullDeleter<SequenceRequest>());
    if (!req) {
    req = shared_ptr<SequenceRequest>(new SequenceRequestAdapter(r));
    }
    doSequence(req);
}

void CalibrationController::abort () {
    abort();
}

Sct_SctApi::Scan * CalibrationController::getScan (ilu_Cardinal runNumber, ilu_Cardinal scanNumber) {
    return getScan(runNumber, scanNumber);
}
  */

}
}

---