CondFormats/L1TObjects/src/L1TriggerKeyList.cc - master - githubmirror/cmssw

CondFormats/L1TObjects/src/L1TriggerKeyList.cc
197 строк5 KB
Cms Build
Clang-Format
31 май 2019, 08:35
31 май 2019, 08:35ea50c02
// -*- C++ -*-
//
// Package:     L1TObjects
// Class  :     L1TriggerKeyList
//
// Implementation:
//     <Notes on implementation>
//
// Original Author:
//         Created:  Fri Feb 29 21:00:24 CET 2008
// $Id: L1TriggerKeyList.cc,v 1.2 2008/10/09 19:02:22 wsun Exp $
//

// system include files

// user include files
#include "CondFormats/L1TObjects/interface/L1TriggerKeyList.h"

//
// constants, enums and typedefs
//

//
// static data member definitions
//

//
// constructors and destructor
//
L1TriggerKeyList::L1TriggerKeyList() {}

// L1TriggerKeyList::L1TriggerKeyList(const L1TriggerKeyList& rhs)
// {
//    // do actual copying here;
// }

L1TriggerKeyList::~L1TriggerKeyList() {}

//
// assignment operators
//
// const L1TriggerKeyList& L1TriggerKeyList::operator=(const L1TriggerKeyList& rhs)
// {
//   //An exception safe implementation is
//   L1TriggerKeyList temp(rhs);
//   swap(rhs);
//
//   return *this;
// }

//
// member functions
//

bool L1TriggerKeyList::addKey(const std::string& tscKey, const std::string& payloadToken, bool overwriteKey) {
  std::pair<KeyToToken::iterator, bool> result = m_tscKeyToToken.insert(std::make_pair(tscKey, payloadToken));

  if (!result.second && overwriteKey) {
    // Erase previous entry
    m_tscKeyToToken.erase(result.first);

    // Try again
    result = m_tscKeyToToken.insert(std::make_pair(tscKey, payloadToken));
  }

  return result.second;
}

bool L1TriggerKeyList::addKey(const std::string& recordType,
                              const std::string& key,
                              const std::string& payloadToken,
                              bool overwriteKey) {
  RecordToKeyToToken::iterator it = m_recordKeyToken.find(recordType);

  if (it == m_recordKeyToken.end()) {
    it = m_recordKeyToken.insert(std::make_pair(recordType, KeyToToken())).first;
  }

  std::pair<KeyToToken::iterator, bool> result = it->second.insert(std::make_pair(key, payloadToken));

  if (!result.second && overwriteKey) {
    // Erase previous entry
    it->second.erase(result.first);

    // Try again
    result = it->second.insert(std::make_pair(key, payloadToken));
  }

  return result.second;
}

//
// const member functions
//

std::string L1TriggerKeyList::token(const std::string& tscKey) const {
  KeyToToken::const_iterator it = m_tscKeyToToken.find(tscKey);

  if (it == m_tscKeyToToken.end()) {
    return std::string();
  } else {
    return it->second;
  }
}

std::string L1TriggerKeyList::token(const std::string& recordName,
                                    const std::string& dataType,
                                    const std::string& key) const {
  std::string recordType = recordName + "@" + dataType;
  return token(recordType, key);
}

std::string L1TriggerKeyList::token(const std::string& recordType, const std::string& key) const {
  RecordToKeyToToken::const_iterator it = m_recordKeyToken.find(recordType);

  if (it == m_recordKeyToken.end()) {
    return std::string();
  } else {
    KeyToToken::const_iterator it2 = it->second.find(key);

    if (it2 == it->second.end()) {
      return std::string();
    } else {
      return it2->second;
    }
  }
}

// std::string
// L1TriggerKeyList::objectKey( const std::string& recordName,
// 			     const std::string& dataType,
// 			     const std::string& payloadToken ) const
// {
//   return objectKey( recordName + "@" + dataType,
// 		    payloadToken ) ;
// }

// std::string
// L1TriggerKeyList::objectKey( const std::string& recordType,// "record@type"
// 			     const std::string& payloadToken ) const
// {
//   RecordToKeyToToken::const_iterator keyTokenMap =
//     m_recordKeyToken.find( recordType ) ;

//   if( keyTokenMap != m_recordKeyToken.end() )
//     {
//       // Find object key with matching payload token.
//       KeyToToken::const_iterator iKey = keyTokenMap.second.begin();
//       KeyToToken::const_iterator eKey = keyTokenMap.second.end() ;
//       for( ; iKey != eKey ; ++iKey )
// 	{
// 	  if( iKey->second == payloadToken )
// 	    {
// 	      return iKey->first ;
// 	    }
// 	}
//     }

//   return std::string() ;
// }

std::string L1TriggerKeyList::objectKey(const std::string& recordName, const std::string& payloadToken) const {
  RecordToKeyToToken::const_iterator iRecordType = m_recordKeyToken.begin();
  for (; iRecordType != m_recordKeyToken.end(); ++iRecordType) {
    // Extract record name from recordType
    std::string recordInMap(iRecordType->first, 0, iRecordType->first.find_first_of("@"));
    if (recordInMap == recordName) {
      // Find object key with matching payload token.
      KeyToToken::const_iterator iKey = iRecordType->second.begin();
      KeyToToken::const_iterator eKey = iRecordType->second.end();
      for (; iKey != eKey; ++iKey) {
        if (iKey->second == payloadToken) {
          return iKey->first;
        }
      }
    }
  }

  return std::string();
}

std::string L1TriggerKeyList::tscKey(const std::string& triggerKeyPayloadToken) const {
  // Find object key with matching payload token.
  KeyToToken::const_iterator iKey = m_tscKeyToToken.begin();
  KeyToToken::const_iterator eKey = m_tscKeyToToken.end();
  for (; iKey != eKey; ++iKey) {
    if (iKey->second == triggerKeyPayloadToken) {
      return iKey->first;
    }
  }

  return std::string();
}

//
// static member functions
//