L1TriggerKeyList.cc

Go to the documentation of this file.

// -*- 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
//