---

TestResult.cpp

Go to the documentation of this file.

#include "TestResult.h"
#include "FitScanResult.h"
#include "RawScanResult.h"
#include "ConfigurationVariable.h"
#include "NullVariable.h"
#include "Sct/SctNames.h"
#include "Sct/IS/IOManagerIS.h"
#include "Sct/IS/IONameIS.h"
#include <algorithm>
#include <sstream>

using namespace std;
using namespace Sct;
using namespace Sct::IS;
using namespace boost;

namespace SctData {

TestResult::TestResult(const unsigned int runNumber, const string & moduleName,
               const ConfigurationVariable& testVariable, const ConfigurationVariable& scanVariable) throw ()
                       : runNumber(runNumber), moduleName(moduleName), testVariable(&testVariable),
               scanVariable(&scanVariable), passed(false), problem(false) {
}


TestResult::TestResult() throw() : runNumber(0), moduleName(""), testVariable(&NullVariable::instance()),
    scanVariable(&NullVariable::instance()), passed(false), problem(false) {

}

void TestResult::setRunNumber(unsigned int runNumber) throw() {
    this->runNumber = runNumber;
}

void TestResult::setModuleName(string name) throw() {
    this->moduleName = name;
}

const ModuleDefectList& TestResult::getDefects() const throw() {
    return defects;
}

ModuleDefectList& TestResult::getDefects() throw() {
    return defects;
}

const ConfigurationVariable& TestResult::getScanVariable() const throw() {
    return *scanVariable;
}

void TestResult::setScanVariable(const ConfigurationVariable& scanVariable) throw() {
    this->scanVariable = &scanVariable;
}

const ConfigurationVariable& TestResult::getTestVariable() const throw() {
    return *testVariable;
}

void TestResult::setTestVariable(const ConfigurationVariable& testVariable) throw() {
    this->testVariable = &testVariable;
}

bool TestResult::getPassed() const throw() {
    return passed;
}
    
void TestResult::setPassed(bool passed) throw() {
    this->passed = passed;
}
    
bool TestResult::getProblem() const throw() {
    return problem;
}
    
void TestResult::setProblem(bool problem) throw() {
    this->problem = problem;
}

vector<string> TestResult::getComments() const throw() {
    return comments;
}
    
void TestResult::addComment(string comment) throw() {
    comments.push_back(comment);
}

void TestResult::addScan(const unsigned int scanNumber, const double testPoint) throw(LogicError) {
    data.push_back(ScanData(scanNumber, testPoint));
    sort(data.begin(), data.end());
}

string TestResult::getUniqueID() const throw(LogicError) {
    if (data.size() > 0) {
        return ScanHeader::getUniqueID(runNumber, data[0].scanNumber, moduleName);
    }
    throw IllegalStateError("TestResult::getUniqueID() : empty test result", __FILE__, __LINE__);
}

unsigned TestResult::getScanNumberAt(unsigned int i) const throw(LogicError) {
    if ( i>=data.size() )
        throw OutOfRangeError<unsigned>("TestPoint::getScanNumberAt", __FILE__, __LINE__,i,0,data.size()-1);
    return data[i].scanNumber;
}

double TestResult::getTestPointAt(unsigned int i) const throw(LogicError) {
    if ( i>=data.size() )
        throw OutOfRangeError<unsigned>("TestPoint::getTestPointAt", __FILE__, __LINE__,i,0,data.size()-1);
    return data[i].testPoint;
}

const ModuleConfiguration& TestResult::getUpdatedConfiguration() const throw() {
    return updatedConfig;
}

ModuleConfiguration& TestResult::getUpdatedConfiguration() throw() {
    return updatedConfig;
}

shared_ptr<const FitScanResult> TestResult::getFit(unsigned int index) const throw(LogicError,IoError) {
    return data[index].fit;
}

shared_ptr<const RawScanResult> TestResult::getRaw(unsigned int index) const throw(LogicError,IoError) {
    return data[index].raw;
}

void TestResult::addFit(shared_ptr<const FitScanResult> fit) throw (LogicError){
    unsigned index = getIndex( fit->getHeader().getScanNumber() );
    data[index].fit=fit;
}

void TestResult::addRaw(shared_ptr<const RawScanResult> raw) throw (LogicError){
    unsigned index = getIndex( raw->getHeader().getScanNumber() );
    data[index].raw=raw;
}

bool TestResult::hasAllFits() const throw() {
    for (unsigned i=0; i<data.size(); ++i){
    if (data[i].fit.get()==0) return false;
    }
    return true;
}

bool TestResult::hasAllRaws() const throw() {
    for (unsigned i=0; i<data.size(); ++i){
    if (data[i].raw.get()==0) return false;
    }
    return true;
}

unsigned int TestResult::getIndex(unsigned int scanNumber) const throw(LogicError) {
    vector<ScanData>::const_iterator i=find(data.begin(), data.end(), scanNumber);
    if (i==data.end() ) {
        ostringstream text;
        text << "TestResult::findScanData scan not found scanNumber="<< scanNumber;
        throw InvalidArgumentError( text.str(), __FILE__, __LINE__ );
    }
    return i-data.begin();
}

TestResult::ScanData::ScanData(const unsigned int scanNumber, const double testPoint,
                               shared_ptr<const RawScanResult> raw, shared_ptr<const FitScanResult> fit ) throw()
        : scanNumber(scanNumber), testPoint(testPoint), raw(raw), fit(fit) {}

TestResult::ScanData::ScanData(const unsigned int scanNumber, const double testPoint) throw()
        : scanNumber(scanNumber), testPoint(testPoint) {}

bool TestResult::ScanData::operator<(const ScanData& s) const throw() {
    if (this->scanNumber<s.scanNumber)
        return true;
    return false;
}

bool TestResult::ScanData::operator>(const ScanData& s) const throw() {
    if (this->scanNumber>s.scanNumber)
        return true;
    return false;
}

bool TestResult::ScanData::operator==(const unsigned int aScanNumber) const throw() {
    if (this->scanNumber==aScanNumber)
        return true;
    return false;
}
}

---