TestResult.h

#ifndef SCTDATA_TESTRESULT_H
#define SCTDATA_TESTRESULT_H

#include <string>
#include <vector>
#include <boost/shared_ptr.hpp>
#include "Sct/LogicErrors.h"
#include "Sct/IoExceptions.h"
#include "Sct/Exception.h"
#include "ModuleConfiguration.h"
#include "DefectList.h"
#include "Result.h"

using namespace Sct;
using boost::shared_ptr;

namespace SctData {
class FitScanResult;
class RawScanResult;
class ConfigurationVariable;
class DcsData;
class OpeResult;

class TestResult:public virtual Result {
public:
    ~TestResult() throw() {};
    
    virtual Sct::UniqueID getUniqueID() const throw(LogicError) ;    
    
    unsigned int getRunNumber() const throw();

    void setRunNumber(unsigned int runNumber) throw();

    string getModuleName() const throw();

    void setModuleName(string name) throw();

    const ConfigurationVariable& getScanVariable() const throw();

    void setScanVariable(const ConfigurationVariable& scanVariable) throw();
    
    virtual const ResultHeader& getHeader() const;
    
    virtual ResultHeader& getHeader();
    

    const ConfigurationVariable& getTestVariable() const throw();

    void setTestVariable(const ConfigurationVariable& testVariable) throw();

    unsigned getScanNumberAt(unsigned int i) const throw(LogicError);

    double getTestPointAt(unsigned int i) const throw(LogicError);

    const DefectList& getDefects() const throw() ;
    DefectList& getDefects() throw() ;

    bool getPassed() const throw();
    
    void setPassed(bool passed) throw();
    
    bool getProblem() const throw();
    
    void setProblem(bool problem) throw();
    
    vector<string> getComments() const throw(); 
    
    void addComment(string comment) throw();
    
    virtual void addScan(const unsigned int scanNumber, const double testPoint) throw(LogicError);


    //ScanNumberIterator& getScanNumbers();

    const unsigned int getNScans() const throw() {
        return data.size();
    }

    unsigned int getIndex(const unsigned int scanNumber) const throw(LogicError) ;

    shared_ptr<const DcsData> getDcsData() const;
    void setDcsData(boost::shared_ptr<const DcsData> dcs);
    shared_ptr<const OpeResult> getOpeResult() const;
    void setOpeResult(boost::shared_ptr<const OpeResult> ope);
protected:
    TestResult() throw();

    TestResult(const unsigned int runNumber, const string & moduleName, const ConfigurationVariable& testVariable,
           const ConfigurationVariable& scanVariable) throw ();

    class ScanData {
    public:

        ScanData(const unsigned int scanNumber, const double testPoint) throw();


        bool operator<(const ScanData & s) const throw();
        bool operator>(const ScanData & s) const throw();
        bool operator==(const unsigned int aScanNumber) const throw();

        unsigned int scanNumber;    
        double testPoint;   
    };

    vector <ScanData> data; 
    ResultHeader header;                
    const ConfigurationVariable* testVariable;      
    DefectList defects;                                 
    bool passed;                    
    bool problem;                   
    vector<string> comments;                
    boost::shared_ptr<const DcsData> m_dcsData;         
    boost::shared_ptr<const OpeResult> m_opeResult;     
};

}               // end of namespace SctData
#endif              //SCTDATA_TESTRESULT_H

---