DefectList.cpp

#include "DefectList.h"
#include "DefectPrototype.h"
#include "Defect.h"
#include <vector>

namespace SctData {

DefectList::DefectList() {}

string DefectList::getClassName() const throw() {
    return "SctData::DefectList";
}

void DefectList::addDefect(Defect defect) {
  DefectCollection::iterator i=defectList.begin();
  while(i!=defectList.end()){

    const ModuleElement& ei = (*i).getModuleElement();
    const ModuleElement& ej = defect.getModuleElement();
    const DefectPrototype& pi = (*i).getPrototype();
    const DefectPrototype& pj = defect.getPrototype();
    
    // if the defect is of the same type:
    if ( pi==pj ){
      // if new defect already contaned, then redundant:
      if ( ei.contains(ej) ) return;
      // if new defect contains existing one, replace:
      if ( ej.contains(ei) ) {
    *i=defect;
    return;
      }
      
      // if they overlap or are adjacent, replace with combined defect:
      if ( ei.overlaps(ej) || ei.adjacentTo(ej) ){
    unsigned first = ei.getFirst() < ej.getFirst() ? ei.getFirst() : ej.getFirst();
    unsigned last  = ei.getLast() > ej.getLast() ? ei.getLast() : ej.getLast();
    i=defectList.erase(i);
    defectList.push_back(Defect(pi,ModuleElement(first,last)));
    return;
      }
    }
    ++i;
  }
  defectList.push_back(defect);
}

const DefectList::DefectCollection& DefectList::getAllDefects() const {
    return defectList;
}

auto_ptr<DefectList> DefectList::getDefectsAffectingElement(ModuleElement element) const {
    auto_ptr<DefectList> newDefects(new DefectList());
    for (DefectCollection::const_iterator i=defectList.begin(); 
     i!=defectList.end(); 
     ++i) {
      if ( (*i).getModuleElement().overlaps(element))
    newDefects->addDefect(*i);
    }
    return newDefects;
}

DefectSeverity DefectList::defectSeverityAffectingElement(ModuleElement element) const {
    DefectSeverity s = NONE;
    for (DefectCollection::const_iterator i=defectList.begin(); 
     i!=defectList.end(); 
     ++i) {
        if ( (*i).getModuleElement().overlaps(element) && (*i).getPrototype().getSeverity() > s)
      s = (*i).getPrototype().getSeverity();
    };
    return s;
}

auto_ptr<DefectList> DefectList::getDefectsEncompassingElement(ModuleElement element) const {
    auto_ptr<DefectList> newDefects(new DefectList());
    for (DefectCollection::const_iterator i=defectList.begin(); 
     i!=defectList.end(); 
     ++i) {
      if ( (*i).getModuleElement().contains(element))
    newDefects->addDefect(*i);
    }
    return newDefects;
}

DefectSeverity DefectList::defectSeverityEncompassingElement(ModuleElement element) const {
    DefectSeverity s = NONE;
    for (DefectCollection::const_iterator i=defectList.begin(); 
     i!=defectList.end(); 
     ++i) {
      if ((*i).getModuleElement().contains(element) && (*i).getPrototype().getSeverity() > s)
    s = (*i).getPrototype().getSeverity();
    };
    return s;
}
  
DefectList& DefectList::operator +=(const DefectList& toadd) {
    for (DefectCollection::const_iterator i=toadd.defectList.begin(); 
     i!=toadd.defectList.end(); 
     ++i) {
      if (!this->containsDefect(*i))
    this->addDefect(*i);
    }
    return *this;
}

bool DefectList::containsDefect(Defect defect) const {
  for (DefectCollection::const_iterator i=defectList.begin(); 
     i!=defectList.end(); 
     ++i) {
    if (*i == defect) return true;
  }
  return false;
}
  
unsigned DefectList::nChannelsAffected(DefectSeverity s, ModuleElement e) const{
  std::vector<bool> good(nChannelModule, true);
  for (DefectCollection::const_iterator i=defectList.begin(); 
     i!=defectList.end(); 
       ++i) {
    if ((*i).getPrototype().getSeverity() >= s){
      for (unsigned channel=(*i).getModuleElement().getFirst();
       channel<=(*i).getModuleElement().getLast(); ++channel){
    good[channel]=false;
      }
    }    
  }
  unsigned nbad=0;
  for (unsigned channel=e.getFirst(); channel<=e.getLast(); ++channel){
    if (!good[channel]) ++nbad;
  }
  
  return nbad;
}
}

std::ostream& operator << (std::ostream& os, const SctData::DefectList& d){
  const SctData::DefectList::DefectCollection& defectList = d.getAllDefects();
  for (SctData::DefectList::DefectCollection::const_iterator i=defectList.begin(); 
       i!=defectList.end(); 
       ++i) {
    os << *i;
    os << "------------------------------------------------" << std::endl;
  }
  return os;
}

---