TrigPassFlags.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGSTEERINGEVENT_TRIGPASSFLAGS_H
#define TRIGSTEERINGEVENT_TRIGPASSFLAGS_H
 
#include <vector>
#include <algorithm>
#include <stdexcept>
 
#include "xAODCore/CLASS_DEF.h"

class TrigPassFlags {
public:
   TrigPassFlags();
   TrigPassFlags(const unsigned int size, const unsigned int flagSize, const void *cont=0);
   
   void setFlagBit(const unsigned int position, const unsigned int bitPosition, const bool bitValue, const void *cont=0 ); 

   void setFlag(const unsigned int position, const std::vector<bool>& flag, const void *cont=0 ); 
   
   bool getFlagBit(const unsigned int position, const unsigned int bitPosition) const;

   const std::vector<bool>& getFlag(const unsigned int position) const;

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

   unsigned int flagSize() const { return m_flagsPerObject[0].size(); }
 
private:
   friend class TrigPassFlagsCnv_p1;
 
   const void *m_container_ptr;
   std::vector<std::vector<bool> > m_flagsPerObject; 
};
 
CLASS_DEF( TrigPassFlags , 74395451 , 1 )
 
 

namespace HLT {
   template<class CONTAINER>
   TrigPassFlags* makeTrigPassFlags(const CONTAINER* cont,const unsigned int flagSize) {
      return new TrigPassFlags(cont->size(), flagSize, (const void*)cont );
   }
   
   template<class T, class CONTAINER>
   void setFlagBit(TrigPassFlags * flags, const T* obj, const CONTAINER* container, const unsigned int bitPosition, const bool bitValue = true) {
      typename CONTAINER::const_iterator i = std::find(container->begin(), container->end(), obj);
      if ( i != container->end() ) 
         flags->setFlagBit(i-container->begin(), bitPosition, bitValue, container); 
      else
         throw std::runtime_error("The CONTAINER passed does not match the CONTAINER that created the TrigPassFlags");
   }
 

   template<class T, class CONTAINER>
   void setFlag(TrigPassFlags * flags,  const T* obj, const CONTAINER* container, const std::vector<bool>& flag) {
      typename CONTAINER::const_iterator i = std::find(container->begin(), container->end(), obj);
      if ( i != container->end() ) 
         flags->setFlag(i-container->begin(), flag, container); 
      else
         throw std::runtime_error("The CONTAINER passed does not match the CONTAINER that created the TrigPassFlags");
   }
 

   template<class T, class CONTAINER>
   bool getFlagBit(const TrigPassFlags *flags,const T* obj, const CONTAINER* container, const unsigned int position, const unsigned int bitPosition) {
      typename CONTAINER::const_iterator i = std::find(container->begin(), container->end(), obj);
      if ( i != container->end() )
         return flags->getFlagBit(i-container->begin(),position, bitPosition);
      throw std::runtime_error("The CONTAINER passed does not match the CONTAINER that created the TrigPassFlags");
   }
   
   template<class T, class CONTAINER>
   const std::vector<bool>& getFlag(const TrigPassFlags *flags,const T* obj, const CONTAINER* container, const size_t position) {
      typename CONTAINER::const_iterator i = std::find(container->begin(), container->end(), obj);
      if ( i != container->end() )
         return flags->getFlag(i-container->begin(),position);
      throw std::runtime_error("The CONTAINER passed does not match the CONTAINER that created the TrigPassFlags");
   }
   
   template<typename T>
   std::vector<bool> AsFlag(T flag_t, const size_t size) {  // T should be an unsigned type, otherwise this will give a compilation warning
      if(size>8*sizeof(T)) // check of T has at list 'size' bits
         throw std::runtime_error("AsFlag(): type T has less bits than required by 'size'");
      if(flag_t >= ( ((unsigned long long)1)<<size)  ) // check of T has at least 'size' bits (with 'size' bits '1<<size' is the lowest number I can not represent.)
         throw std::runtime_error("AsFlag(): the flag is larger then bits available");
 
 
      std::vector<bool> flag(size);
      int mask = 0x01;
      for(size_t idx=0; idx<size; ++idx, mask<<=1)
         flag[idx] = (flag_t&mask)!=0;
      return flag;
   }
 
   template<typename T>
   T FlagAs(const std::vector<bool>& flag) {
      if(8*sizeof(T)<flag.size()) // check of T has enough bits to represent flag
         throw std::runtime_error("FlagAs(): the flag size does not fit into the requested type");
      T v = 0;
      int mask = 0x01;
      for(size_t idx=0; idx<flag.size(); ++idx, mask<<=1)
         if(flag[idx]) v += mask;
      return v;
   }
 
} // eof HLT namespace
 
 
#endif