L1TriggerKey.h

Go to the documentation of this file.

#ifndef CondFormats_L1TObjects_L1TriggerKey_h
#define CondFormats_L1TObjects_L1TriggerKey_h
 
#include "CondFormats/Serialization/interface/Serializable.h"
 
#include <string>
#include <map>
 
/* L1 key used to load all other configuration data from offline db.
 * This class is just a proxy to the real data. It will contain mapping from data and record
 * pair to the payload token that could be used to read data. So the use case could be as follows:
 *   1. User read L1TriggerKey for given Tag and IOV pair.
 *   2. For each record and type that user whant to load, it ask method get for the payload.
 *   3. Reads the data with payloads extracted from step 2.
 *
 * It is not adviced for user to use this class and direct Pool DB manipulation. One should use
 * DataReader and DataWriter classes.
 *
 * The good point to note is that IOV of all L1 trigger condfiguration is controled bay IOV of L1TriggeKey.
 * If new configuration has to be created - new L1TriggerKey has to be saved/loaded. More then one key can use
 * the same paylaod token. This would just mean that data pointed by this payload token has not changed.
 */
class L1TriggerKey {
public:
  typedef std::map<std::string, std::string> RecordToKey;
 
  enum L1Subsystems { kCSCTF, kDTTF, kRPC, kGMT, kRCT, kGCT, kGT, kTSP0, kNumberSubsystems };
 
  // Empty strings cannot be stored in the CondDB, so define a null key string.
  const static std::string kNullKey;
 
  const static std::string kEmptyKey;
 
  // Constructors
  L1TriggerKey() {
    for (int i = 0; i < kNumberSubsystems; ++i) {
      m_subsystemKeys[i] = kNullKey;
    }
  }
 
  /* Adds new record and type mapping to payload. If such exists, nothing happens */
  void add(const std::string& record, const std::string& type, const std::string& key) {
    m_recordToKey.insert(std::make_pair(record + "@" + type, key.empty() ? kNullKey : key));
  }
 
  void add(const RecordToKey& map) {
    for (RecordToKey::const_iterator itr = map.begin(); itr != map.end(); ++itr) {
      m_recordToKey.insert(std::make_pair(itr->first, itr->second.empty() ? kNullKey : itr->second));
    }
  }
 
  void setTSCKey(const std::string& tscKey) { m_tscKey = tscKey; }
 
  void setSubsystemKey(L1Subsystems subsystem, const std::string& key) {
    m_subsystemKeys[subsystem] = key.empty() ? kNullKey : key;
  }
 
  /* Gets payload key for record and type. If no such paylaod exists, emtpy string
     * is returned.
     */
  std::string get(const std::string& record, const std::string& type) const {
    RecordToKey::const_iterator it = m_recordToKey.find(record + "@" + type);
    if (it == m_recordToKey.end())
      return std::string();
    else
      return it->second == kNullKey ? kEmptyKey : it->second;
  }
 
  const std::string& tscKey() const { return m_tscKey; }
 
  const std::string& subsystemKey(L1Subsystems subsystem) const {
    return m_subsystemKeys[subsystem] == kNullKey ? kEmptyKey : m_subsystemKeys[subsystem];
  }
 
  // NB: null keys are represented by kNullKey, not by an empty string
  const RecordToKey& recordToKeyMap() const { return m_recordToKey; }
 
protected:
  /* Mapping from records and types to tokens.
     * I as unvable to make type std::map<std::pair<std::string, std::string>, std::string> persistent
     * so record and type are concatanated with @ sign and resulting string is used as a key.
     */
 
  // wsun 03/2008: instead of tokens, store the configuration keys instead.
  /*     typedef std::map<std::string, std::string> RecordsToToken; */
  /*     RecordsToToken recordsToToken; */
  RecordToKey m_recordToKey;
 
  // wsun 03/2008: add data member for TSC key
  std::string m_tscKey;
  std::string m_subsystemKeys[kNumberSubsystems];
 
  COND_SERIALIZABLE;
};
 
#endif