JetKeyDescriptorInstance Class Reference

#include <JetKeyDescriptor.h>

Collaboration diagram for JetKeyDescriptorInstance:

Public Types
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

Public Member Functions
virtual	~JetKeyDescriptorInstance ()
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
const key_t &	getKey (const category_t &cat, size_t index) const
const std::vector< key_t > &	getKeys (const category_t &cat) const
const std::vector< category_t > &	getCategories () const
bool	isValid (size_t index) const
void	printOut (MsgStream &msgStream) const
JetKeyDescriptor *	getKeyStore ()

Static Public Member Functions
static JetKeyDescriptorInstance *	instance ()

Protected Member Functions
	JetKeyDescriptorInstance (bool create=true)
void	createKeyStore () const

Protected Attributes
JetKeyDescriptor *	m_Stores
const JetKeyDescriptor *	m_ConstStores

Static Private Attributes
static const size_t	m_invalid = size_t(-1)
static const std::string	m_notFound = "unknown"
static const std::vector< key_t >	m_invalidKeys
static const bool	m_persistified = false

Friends
class	JetKeyDescriptor
class	JetCollection
class	JetKeyDescriptorCnv_p1
class	JetCollectionCnv_p2
class	JetCollectionCnv_p3
class	JetCollectionCnv_p4
class	JetCollectionCnv_p5
class	JetCollectionCnv_p6

Detailed Description

Theses classes implement a mapping between string and index used by jets. they are used for jet moments, jet associations, etc... There are 2 classes :

• JetKeyDescriptor is the data class where the mappings are stored. There is only 1 such class per event. This class is stored in SG and persistified.
• JetKeyDescriptorInstance : the class used to access the mapings in the above data class. Each JetCollection holds a JetKeyDescriptorInstance. There is also a global JetKeyDescriptorInstance, which is used by jets not associated to a JetCollection. When only 1 event is read in memory, all JetKeyDescriptorInstance point to the same JetKeyDescriptor. When 2 events are read at the same time (in some ARA analysis), JetCollection's JetKeyDescriptorInstance point to the JetKeyDescriptor from the event they belong to. The global JetKeyDescriptorInstance points to the last event read.

///////////////////////////////////////////////////////

Definition at line 99 of file JetKeyDescriptor.h.

Member Typedef Documentation

category_t

typedef std::string JetKeyDescriptorInstance::category_t

Definition at line 113 of file JetKeyDescriptor.h.

catlist_t

typedef std::vector<category_t> JetKeyDescriptorInstance::catlist_t

Definition at line 118 of file JetKeyDescriptor.h.

key_t

typedef std::string JetKeyDescriptorInstance::key_t

Definition at line 114 of file JetKeyDescriptor.h.

keystore_t

typedef std::vector<key_t> JetKeyDescriptorInstance::keystore_t

Definition at line 116 of file JetKeyDescriptor.h.

storelist_t

typedef std::vector<keystore_t> JetKeyDescriptorInstance::storelist_t

Definition at line 117 of file JetKeyDescriptor.h.

Constructor & Destructor Documentation

~JetKeyDescriptorInstance()

JetKeyDescriptorInstance::~JetKeyDescriptorInstance ( )

virtualdefault

JetKeyDescriptorInstance()

JetKeyDescriptorInstance::JetKeyDescriptorInstance ( bool  create = true )

protected

Definition at line 23 of file JetKeyDescriptor.cxx.

                                                              :
  m_Stores(nullptr),
  m_ConstStores(nullptr)
{
  // create a JetKeyDescriptorInstance :
  if (create) createKeyStore();
}

Member Function Documentation

createKeyStore()

void JetKeyDescriptorInstance::createKeyStore ( ) const

protected

Definition at line 34 of file JetKeyDescriptor.cxx.

                                                    {
   if (m_ConstStores) {
     throw std::runtime_error ("Attempt to modify const JetKeyDescriptor");
   }
   m_Stores = new JetKeyDescriptor();
   m_ConstStores = m_Stores;
}  

getCategories()

const std::vector< JetKeyDescriptorInstance::category_t > & JetKeyDescriptorInstance::getCategories ( ) const

inline

Definition at line 176 of file JetKeyDescriptor.h.

{
  if(bool(m_ConstStores))
    return m_ConstStores->m_catStore;
  static const std::vector<JetKeyDescriptorInstance::category_t> v;
  return v;
}

getIndex() [1/2]

size_t JetKeyDescriptorInstance::getIndex	(	const category_t &	cat,
		const key_t &	key
	)		const

Definition at line 111 of file JetKeyDescriptor.cxx.

{
  if ( ! bool(m_ConstStores) ) {
    return m_invalid;
  }
 
  // first find category
  catlist_t::const_iterator
    fCat(std::find(m_ConstStores->m_catStore.begin(),m_ConstStores->m_catStore.end(),cat));
  if (  fCat == m_ConstStores->m_catStore.end() )
    return m_invalid;
  else
    {
      size_t iCat = fCat - m_ConstStores->m_catStore.begin();
 
      if ( iCat < m_ConstStores->m_keyStore.size() )  // really impossible!
    {
      keystore_t::const_iterator fKey(std::find((m_ConstStores->m_keyStore[iCat]).begin(),
                                                    (m_ConstStores->m_keyStore[iCat]).end(),
                                                    key));
      if ( fKey == (m_ConstStores->m_keyStore[iCat]).end() )
          return m_invalid;
      else
        {
          return fKey - (m_ConstStores->m_keyStore[iCat]).begin();
        }
    }
      // should never be reached!
      return m_invalid;
    }
}

getIndex() [2/2]

size_t JetKeyDescriptorInstance::getIndex	(	const category_t &	cat,
		const key_t &	key,
		bool	createIfMissing = true
	)

Definition at line 47 of file JetKeyDescriptor.cxx.

{
  //std::cout <<" getIndex cat="<<cat<<"  key="<<key<<"   has store ="<< m_Stores << "  if missing="<< createIfMissing << std::endl;
  if ( ! bool(m_ConstStores) ) {
    if ( createIfMissing )
      createKeyStore();
    else
      return m_invalid;
  }
 
  //  std::cout <<& m_Stores->m_catStore << " Cat store size="<< m_Stores->m_catStore.size() << std::endl;
  // first find category
  catlist_t::const_iterator
    fCat(std::find(m_ConstStores->m_catStore.begin(),m_ConstStores->m_catStore.end(),cat));
  if (  fCat == m_ConstStores->m_catStore.end() ) {
    if ( createIfMissing )
      {
        if (!m_Stores) {
          createKeyStore();
        }
        // cppcheck-suppress nullPointerRedundantCheck; false positive
    m_Stores->m_catStore.push_back(cat);
    keystore_t kStore; kStore.push_back(key);
        // cppcheck-suppress nullPointerRedundantCheck; false positive
    m_Stores->m_keyStore.push_back(kStore);
    return 0;
      }
    else
      return m_invalid;
  }
  else
    {
      size_t iCat = fCat - m_ConstStores->m_catStore.begin();
 
      if ( iCat < m_ConstStores->m_keyStore.size() )  // really impossible!
    {
      keystore_t::const_iterator fKey(std::find((m_ConstStores->m_keyStore[iCat]).begin(),
                                                    (m_ConstStores->m_keyStore[iCat]).end(),
                                                    key));
      if ( fKey == (m_ConstStores->m_keyStore[iCat]).end() )
        if ( createIfMissing )
          {
                if (!m_Stores) {
                  createKeyStore();
                }
                // cppcheck-suppress nullPointerRedundantCheck; false positive
        (m_Stores->m_keyStore[iCat]).push_back(key);
                // cppcheck-suppress nullPointerRedundantCheck; false positive
        return (m_Stores->m_keyStore[iCat]).size()-1;
          }
        else
          return m_invalid;
      else
        {
          return fKey - (m_ConstStores->m_keyStore[iCat]).begin();
        }
    }
      // should never be reached!
      return m_invalid;
    }
}

getKey()

const JetKeyDescriptorInstance::key_t & JetKeyDescriptorInstance::getKey	(	const category_t &	cat,
		size_t	index
	)		const

Definition at line 161 of file JetKeyDescriptor.cxx.

{
  if ( ! bool(m_ConstStores) ) createKeyStore();
  // find category
  catlist_t::const_iterator fCat(std::find(m_ConstStores->m_catStore.begin(),
                       m_ConstStores->m_catStore.end(),
                       cat));
  if ( fCat == m_ConstStores->m_catStore.end() ) return m_notFound;
  // find key
  size_t iCat(fCat-m_ConstStores->m_catStore.begin());
  return index < (m_ConstStores->m_keyStore[iCat]).size()
    ? (m_ConstStores->m_keyStore[iCat])[index]
    : m_notFound;
}

getKeys()

const std::vector< JetKeyDescriptorInstance::key_t > & JetKeyDescriptorInstance::getKeys

(

const category_t &

cat

)

const

Definition at line 178 of file JetKeyDescriptor.cxx.

{
  if ( ! bool(m_ConstStores) )
    return m_invalidKeys;
  catlist_t::const_iterator fCat(std::find(m_ConstStores->m_catStore.begin(),
                       m_ConstStores->m_catStore.end(),
                       cat));
  if ( fCat != m_ConstStores->m_catStore.end() )
    {
      size_t aInd(fCat-m_ConstStores->m_catStore.begin());
      return m_ConstStores->m_keyStore[aInd];
    }
  else
    {
      return m_invalidKeys;
    }
}

getKeyStore()

JetKeyDescriptor * JetKeyDescriptorInstance::getKeyStore

(

)

Definition at line 42 of file JetKeyDescriptor.cxx.

                                                       {
  if( ! bool(m_Stores) ) createKeyStore();
  return m_Stores;
}

instance()

static JetKeyDescriptorInstance* JetKeyDescriptorInstance::instance ( )

inlinestatic

Definition at line 123 of file JetKeyDescriptor.h.

    {
      static JetKeyDescriptorInstance instance;
      return &instance;
    }

isValid()

bool JetKeyDescriptorInstance::isValid ( size_t  index ) const

inline

Definition at line 170 of file JetKeyDescriptor.h.

{
  return index != m_invalid;
}

printOut()

void JetKeyDescriptorInstance::printOut

(

MsgStream &

msgStream

)

const

Definition at line 144 of file JetKeyDescriptor.cxx.

{
  if ( ! bool(m_ConstStores) ) return;
 
  msgStream << "Number of categories: " << m_ConstStores->m_catStore.size() << endmsg;
  for ( size_t i=0;i<m_ConstStores->m_catStore.size();i++ )
    {
      msgStream << m_ConstStores->m_catStore[i] << " Number of keys: "
            << (m_ConstStores->m_keyStore[i]).size() << endmsg;
      for ( size_t j=0;j<(m_ConstStores->m_keyStore[i]).size();j++ )
        {
          msgStream << "    index: " << j << " key <" << (m_ConstStores->m_keyStore[i])[j]
                << ">" << endmsg;
        }         
    }
}

Friends And Related Function Documentation

JetCollection

friend class JetCollection

friend

Definition at line 102 of file JetKeyDescriptor.h.

JetCollectionCnv_p2

friend class JetCollectionCnv_p2

friend

Definition at line 104 of file JetKeyDescriptor.h.

JetCollectionCnv_p3

friend class JetCollectionCnv_p3

friend

Definition at line 105 of file JetKeyDescriptor.h.

JetCollectionCnv_p4

friend class JetCollectionCnv_p4

friend

Definition at line 106 of file JetKeyDescriptor.h.

JetCollectionCnv_p5

friend class JetCollectionCnv_p5

friend

Definition at line 107 of file JetKeyDescriptor.h.

JetCollectionCnv_p6

friend class JetCollectionCnv_p6

friend

Definition at line 108 of file JetKeyDescriptor.h.

JetKeyDescriptor

friend class JetKeyDescriptor

friend

Definition at line 101 of file JetKeyDescriptor.h.

JetKeyDescriptorCnv_p1

friend class JetKeyDescriptorCnv_p1

friend

Definition at line 103 of file JetKeyDescriptor.h.

Member Data Documentation

m_ConstStores

const JetKeyDescriptor* JetKeyDescriptorInstance::m_ConstStores

mutableprotected

Definition at line 156 of file JetKeyDescriptor.h.

m_invalid

const size_t JetKeyDescriptorInstance::m_invalid = size_t(-1)

staticprivate

Definition at line 163 of file JetKeyDescriptor.h.

m_invalidKeys

const std::vector< JetKeyDescriptorInstance::key_t > JetKeyDescriptorInstance::m_invalidKeys

staticprivate

Definition at line 165 of file JetKeyDescriptor.h.

m_notFound

const std::string JetKeyDescriptorInstance::m_notFound = "unknown"

staticprivate

Definition at line 164 of file JetKeyDescriptor.h.

m_persistified

const bool JetKeyDescriptorInstance::m_persistified = false

staticprivate

Definition at line 167 of file JetKeyDescriptor.h.

m_Stores

JetKeyDescriptor* JetKeyDescriptorInstance::m_Stores

mutableprotected

Definition at line 155 of file JetKeyDescriptor.h.

---

The documentation for this class was generated from the following files:

• JetKeyDescriptor.h
• JetKeyDescriptor.cxx