Trigger/TrigEvent/TrigCombinedEvent/TrigCombinedEvent/TrigComposite.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGCOMBINEDEVENT_TRIGCOMPOSITE_H
#define TRIGCOMBINEDEVENT_TRIGCOMPOSITE_H
#include <string>
#include <vector>
#include <cmath>
#include <limits>
#include <set>
#include "AthenaKernel/CLASS_DEF.h"
#include "GaudiKernel/ClassID.h"
#include "TrigNavigation/TrigFeatureLink.h"
#include "GaudiKernel/MsgStream.h"
 
 
 

class TrigComposite {
  
 public:
  
  TrigComposite(const std::string& name);

  TrigComposite(const std::string& name, std::string& label1, TrigFeatureLink t1, std::string& label2, TrigFeatureLink t2);
 
 
  inline const std::string& name() const { return m_name; }
 

  template<typename T>
  void setFormat(const std::vector<std::string>& keys,  bool mustBeSet=false);
  
  bool isValid() const;
  
  inline void lockFormat(){m_locked=true;}
  
  inline bool isFormatLocked() const {return m_locked; }
 

  inline void unlockFormat(){m_locked=false;}
 

  void addObject(const std::string& key, TrigFeatureLink link);
 

  void setObject(const std::string& key, TrigFeatureLink link);

  bool hasObject(const std::string& key) const; 

  const TrigFeatureLink& getObject(const std::string& key) const;
 

  template<typename T>
  std::vector<TrigFeatureLink> getObjectsByType(const std::string& keypart="") const;
 
  
  
  template<typename T>
  void addDetail(const std::string& key, const T& value=T());
  
  template<typename T>
  void setDetail(const std::string& key, const T& value);
 
    
  template<typename T>
  bool hasDetail(const std::string& key) const;
 
    
  template<typename T>
  const T&  getDetail(const std::string& key) const;
      
 
  template<class T>
  const std::map<std::string, T>& allDetails() const {
    return detailsMap<T>();
  }
 

  template<typename T>
  void eraseDetail(const std::string& key);

  TrigComposite();

  ~TrigComposite();
 
 
private:
  template<class T>
  void mustSet(const std::string& key);
 
  typedef std::set<std::string> MustSetList;
 
  std::map<std::string, TrigFeatureLink > m_links;
  MustSetList m_linksToBeSet;
  
  std::map<std::string, float > m_floats;
  MustSetList m_floatsToBeSet;
 
  std::map<std::string, int> m_ints;
  MustSetList m_intsToBeSet;
 
  std::map<std::string, std::string> m_strings;
  MustSetList m_stringsToBeSet;
 
  std::map<std::string, std::vector<float> > m_v_floats;
  MustSetList m_v_floatsToBeSet;
 
  std::map<std::string, std::vector<int> > m_v_ints;
  MustSetList m_v_intsToBeSet;
 
  std::map<std::string, std::vector<std::string> > m_v_strings;
  MustSetList m_v_stringsToBeSet;
 
  template<typename T>
  std::map<std::string, T>& detailsMap();
 
  template<typename T>
  const std::map<std::string, T>& detailsMap() const;
 
  template<typename T>
  MustSetList& detailsMustSetList();
 
 
  template<typename T>
  const T& specimen() const; // needed in order to produce the "NULL" detail
  
 
  std::string m_name;
  bool m_locked;
 
};

MsgStream& operator<< ( MsgStream& m, const TrigComposite& d );
 
 
template<typename T>
std::vector<TrigFeatureLink> TrigComposite::getObjectsByType(const std::string& keypart) const {
  const CLID requested_clid = ClassID_traits<T>::ID(); 
  std::vector<TrigFeatureLink> result;
  for ( std::map<std::string, TrigFeatureLink>::const_iterator i = m_links.begin(); i != m_links.end(); ++i ) {
    if ( i->second.clid() == requested_clid and i->first.find(keypart) != std::string::npos) 
      result.push_back(i->second);
  }
  return result;
}
 
 
 

CLASS_DEF( TrigComposite , 231914326 , 1 )
 
  
 
#endif // __TrigComposite_h__