JetKeyDescriptor.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef JETEVENT_JETKEYDESCRIPTOR_H
#define JETEVENT_JETKEYDESCRIPTOR_H
 
#include <string>
#include <vector>
 
class MsgStream;
 
 
// forward declare some conversion class
template <class T1, class T2, class T3>
  class TPPolyCnvBase;
class JetKeyDescriptor_p1;
 
// payload for the JetKeyDescriptor framework.
class JetKeyDescriptor
{
  // allow access to private data members for these classes
  friend class JetKeyDescriptorCnv_p1;
  friend class JetKeyDescriptorInstance;
  friend class TPPolyCnvBase<JetKeyDescriptor,JetKeyDescriptor, JetKeyDescriptor_p1>;  
 public:
  
  typedef std::string      category_t;
  typedef std::string      key_t;
  
  typedef std::vector<key_t>       keystore_t;
  typedef std::vector<keystore_t>  storelist_t;
  typedef std::vector<category_t>  catlist_t;
  
  // dummy implementation, needed for the DataLink to call the converter
  void access() const { };
  
  
  virtual ~JetKeyDescriptor();
  
 
 
  // dummy implementation, just to be called from the converters
  JetKeyDescriptor();
 
  // For debugging.
  const storelist_t& keyStore() const { return m_keyStore; }
  const catlist_t&   catStore() const { return m_catStore; }
 
 protected:  
  
  storelist_t   m_keyStore;
  
  catlist_t     m_catStore;
  
};
 
#include "AthenaKernel/CLASS_DEF.h"
CLASS_DEF(JetKeyDescriptor,71458009,1)
 
struct JetKeyConstants {
  typedef JetKeyDescriptor::key_t key_t;

  static const key_t ShapeCat;
  static const key_t AssoCat;
  static const key_t TagCat;
  static const key_t InfoCat;
 
};
 
 
class JetKeyDescriptorInstance
{
  friend class JetKeyDescriptor;
  friend class JetCollection;
  friend class JetKeyDescriptorCnv_p1;
  friend class JetCollectionCnv_p2;
  friend class JetCollectionCnv_p3;
  friend class JetCollectionCnv_p4;
  friend class JetCollectionCnv_p5;
  friend class JetCollectionCnv_p6;
 
  
 public:
  
  typedef std::string      category_t;
  typedef std::string      key_t;
  
  typedef std::vector<key_t>       keystore_t;
  typedef std::vector<keystore_t>  storelist_t;
  typedef std::vector<category_t>  catlist_t;
  
  // singleton implementation for now
  virtual ~JetKeyDescriptorInstance();
  
  static JetKeyDescriptorInstance* instance()
    {
      static JetKeyDescriptorInstance instance;
      return &instance;
    }
 
  // get a unique index
  size_t getIndex(const category_t& cat,const key_t& key, bool createIfMissing = true );
  size_t getIndex(const category_t& cat,const key_t& key) const;
  
  // get key for a given category and index
  const key_t& getKey(const category_t& cat,size_t index) const;
  
  // get all keys for a given category
  const std::vector<key_t>& getKeys(const category_t& cat) const;
  
  // get all categories
  const std::vector<category_t>& getCategories() const;
  
  // check validity
  bool isValid(size_t index) const;
  
  // printout some stuff
  void printOut(MsgStream& msgStream) const;
 
  // retrieve the key store :
  JetKeyDescriptor* getKeyStore();
 
 protected:
  
  JetKeyDescriptorInstance(bool create=true);
  
  mutable JetKeyDescriptor*  m_Stores;
  mutable const JetKeyDescriptor*  m_ConstStores;
  
  void createKeyStore() const;
 
 private:
  
 
  static const size_t                  m_invalid;
  static const std::string             m_notFound;
  static const std::vector<key_t>      m_invalidKeys;
  
  static const bool                    m_persistified;
};
 
inline bool JetKeyDescriptorInstance::isValid(size_t index) const
{
  return index != m_invalid;
}
 
inline const std::vector<JetKeyDescriptorInstance::category_t>& 
JetKeyDescriptorInstance::getCategories() const
{
  if(bool(m_ConstStores))
    return m_ConstStores->m_catStore;
  static const std::vector<JetKeyDescriptorInstance::category_t> v;
  return v;
}

 
#endif