AnalysisAlgorithm.h

#ifndef ANALYSISALGORITHM_H
#define ANALYSISALGORITHM_H

#include <string>
#include <vector>
#include <boost/thread.hpp>
#include <boost/shared_ptr.hpp>
#include "Sct/IoExceptions.h"
#include "Sct/LogicErrors.h"

namespace SctData {
class TestResult;
class RawScanResult;
class FitScanResult;
}
namespace Sct {
class IOName;
}

class TestData;

using std::string;
using std::vector;
using boost::shared_ptr;

namespace SctAnalysis {
  
class AnalysisAlgorithm {
public:
    virtual ~AnalysisAlgorithm() throw();
    const TestData& getTestData() const throw() {return m_test;}

    const std::string getModuleName() const throw() {return m_modulename;}

    virtual boost::shared_ptr<AnalysisAlgorithm> clone(const TestData& testData, const string& moduleName) const throw() =0;
    void addFitScanResult(shared_ptr<Sct::IOName> name);
    void addRawScanResult(shared_ptr<Sct::IOName> name);
    void checkTestResultExists();
    bool isDone() const throw() {return m_done;}
    
    void finish();
    
    boost::shared_ptr<SctData::TestResult> getTestResult() const{return m_result;}
    
    boost::recursive_mutex& getMutex() const {return m_access;}
    
    virtual bool canAnalyze() const = 0;
    
    virtual void analyze() = 0;
    
    virtual void loadData() = 0;
    

    void addFailure();
    void addPass();
    void addIOTime(double ioTime);
    
    void addAnalysisTime(double time);
    
    void addOverheadTime(double time);
    
    string getStatus() const;
    
protected:
    AnalysisAlgorithm(const TestData& testData, const string& moduleName, const AnalysisAlgorithm& prototype) throw();
    
    virtual shared_ptr<SctData::TestResult> createTestResult() const = 0;
    void loadAllFits();
    void loadAllRaws();
    
    bool hasAllRaws() const;
    bool hasAllFits() const;
    
    shared_ptr<SctData::RawScanResult> getRaw(unsigned int index) const;
    
    shared_ptr<SctData::FitScanResult> getFit(unsigned int index) const;

    
    void mergeDefects();
    
    AnalysisAlgorithm() ;

private:
    void initializeTestResult();
    
    class ScanData {
    public:
    ScanData();
    bool rawAvailable;
    bool fitAvailable;
    string rawName;
    string fitName;
        shared_ptr<SctData::RawScanResult> raw;
        shared_ptr<SctData::FitScanResult> fit;
    };

    const string m_modulename;              
    shared_ptr<SctData::TestResult> m_result;  
    const TestData& m_test;      
    vector<ScanData> scanData;          
    bool m_done;                      
    mutable boost::recursive_mutex m_access;      
    
    //Timing stuff
    mutable boost::recursive_mutex m_status_access;      
    const AnalysisAlgorithm& prototype;         
    mutable double ioTime;                  
    mutable double analysisTime;                
    mutable double overheadTime;                
    mutable unsigned int nCalls;                
    mutable unsigned int nAnalyses;             
    mutable unsigned int nPassed;                            
    mutable unsigned int nFailed;                           
};

inline void AnalysisAlgorithm::addPass(){
  boost::recursive_mutex::scoped_lock lock(m_status_access);
  ++prototype.nPassed;
}

inline void AnalysisAlgorithm::addFailure(){
  boost::recursive_mutex::scoped_lock lock(m_status_access);
    ++prototype.nFailed;
}

inline void AnalysisAlgorithm::addIOTime(double ioTime) {
  boost::recursive_mutex::scoped_lock lock(m_status_access);
    prototype.ioTime += ioTime;
}
    
inline void AnalysisAlgorithm::addAnalysisTime(double time) {
  boost::recursive_mutex::scoped_lock lock(m_status_access);
    prototype.analysisTime += time;
    ++prototype.nAnalyses;
}
    
inline void AnalysisAlgorithm::addOverheadTime(double time) {
  boost::recursive_mutex::scoped_lock lock(m_status_access);
    prototype.overheadTime += time;
    ++prototype.nCalls;
}

}

#endif //#ifndef ANALYSISALGORITHM_H

---