DetectorIDInterpreter.h

#ifndef DETDESCR_DETECTORIDINTERPRETER_H
#define DETDESCR_DETECTORIDINTERPRETER_H
 
// STL
#include <iostream>
#include <vector>
 
// LDMX
#include "DetDescr/DetectorID.h"
#include "DetDescr/IDField.h"
 
namespace ldmx {
 
class DetectorIDInterpreter {
 public:
  DetectorIDInterpreter();
  DetectorIDInterpreter(DetectorID detid);
 
  ~DetectorIDInterpreter();
 
  typedef unsigned FieldValue;
 
  typedef std::vector<FieldValue> FieldValueList;
 
  DetectorID getId() const { return id_; }
 
  void setRawValue(DetectorID rawValue);
 
  FieldValue getFieldValue(int i) const;
 
  void setFieldValue(int i, FieldValue value);
 
  void setFieldValue(const std::string& fieldName, FieldValue fieldValue);
 
  int getFieldCount() const { return int(p_fieldInfo_->fieldList_.size()); }
 
  const IDField::IDFieldList& getFieldList() const {
    return p_fieldInfo_->fieldList_;
  }
 
  const IDField* getField(const std::string& fieldName) const;
 
  FieldValue getFieldValue(const std::string& fieldName) const;
 
  static void registerInterpreter(SubdetectorIDType idtype,
                                  const IDField::IDFieldList& fieldList);
 
  static void registerInterpreter(SubdetectorIDType idtype, unsigned int mask,
                                  unsigned int equality,
                                  const IDField::IDFieldList& fieldList);
 
 private:
  static void loadStandardInterpreters();
 
  void init();
 
  void unpack();
 
  void pack();
 
  DetectorID id_;
 
  FieldValueList fieldValues_;
 
  struct SubdetectorIDFields {
    IDField::IDFieldMap fieldMap_;
    IDField::IDFieldList fieldList_;
  };
 
  struct IDSignature {
    unsigned int mask_;
    unsigned int comparison_;
    bool operator<(const IDSignature& id) const {
      return (comparison_ & mask_) < (id.comparison_ & id.mask_);
    }
  };
 
  static std::map<IDSignature, const SubdetectorIDFields*> g_rosettaStone;
 
  const SubdetectorIDFields* p_fieldInfo_;
};
 
}  // namespace ldmx
 
#endif