/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_6_2_7/src/DataFormats/Common/interface/HLTGlobalStatus.h

Go to the documentation of this file.

#ifndef DataFormats_Common_HLTGlobalStatus_h
#define DataFormats_Common_HLTGlobalStatus_h

#include "DataFormats/Common/interface/HLTenums.h"
#include "DataFormats/Common/interface/HLTPathStatus.h"

#include <vector>
#include <ostream>

namespace edm
{
  class HLTGlobalStatus {

  private:

    std::vector<HLTPathStatus> paths_;

  public:

    HLTGlobalStatus(const unsigned int n=0) : paths_(n) {}

    unsigned int size() const { return paths_.size(); }

    void reset() {
      const unsigned int n(size());
      for (unsigned int i = 0; i != n; ++i) paths_[i].reset();
    }

    // global "state" variables calculated on the fly!

    bool wasrun() const {return State(0);}
    bool accept() const {return State(1);}
    bool  error() const {return State(2);}

    // get hold of individual elements, using safe indexing with "at" which throws!

    const HLTPathStatus& at (const unsigned int i)   const { return paths_.at(i); }
          HLTPathStatus& at (const unsigned int i)         { return paths_.at(i); }
    const HLTPathStatus& operator[](const unsigned int i) const { return paths_.at(i); }
          HLTPathStatus& operator[](const unsigned int i)       { return paths_.at(i); }

    bool wasrun(const unsigned int i) const { return at(i).wasrun(); }
    bool accept(const unsigned int i) const { return at(i).accept(); }
    bool  error(const unsigned int i) const { return at(i).error() ; }

    hlt::HLTState state(const unsigned int i) const { return at(i).state(); }
    unsigned int  index(const unsigned int i) const { return at(i).index(); }
    void reset(const unsigned int i) { at(i).reset(); }
    void swap(HLTGlobalStatus& other) { paths_.swap(other.paths_); }
    HLTGlobalStatus& operator=(HLTGlobalStatus const& rhs) {
      HLTGlobalStatus temp(rhs);
      this->swap(temp);
      return *this;
    }

  private:

    bool State(unsigned int icase) const {
      bool flags[3] = {false, false, false};
      const unsigned int n(size());
      for (unsigned int i = 0; i != n; ++i) {
        const hlt::HLTState s(state(i));
        if (s!=hlt::Ready) {
          flags[0]=true;       // at least one trigger was run
          if (s==hlt::Pass) {
            flags[1]=true;     // at least one trigger accepted
          } else if (s==hlt::Exception) {
            flags[2]=true;     // at least one trigger with error
          }
        }
      }
      return flags[icase];
    }

  };

  inline
  void
  swap(HLTGlobalStatus& lhs, HLTGlobalStatus& rhs) {
    lhs.swap(rhs);
  }

  inline std::ostream& operator <<(std::ostream& ost, const HLTGlobalStatus& hlt) {
    std::vector<std::string> text(4); text[0]="n"; text[1]="1"; text[2]="0"; text[3]="e";
    const unsigned int n(hlt.size());
    for (unsigned int i = 0; i != n; ++i) ost << text.at(hlt.state(i));
    return ost;
  }

}

// The standard allows us to specialize std::swap for non-templates.
// This ensures that HLTGlobalStatus::swap() will be used in algorithms.

namespace std {
  template <> inline void swap(edm::HLTGlobalStatus& lhs, edm::HLTGlobalStatus& rhs) {
    lhs.swap(rhs);
  }
}

#endif // DataFormats_Common_HLTGlobalStatus_h