JetMapBase.h

Go to the documentation of this file.

// -*- C++ -*-
 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef JETEVENT_JETMAPBASE_H
#define JETEVENT_JETMAPBASE_H
 
#include "AthContainers/OwnershipPolicy.h"
#include <vector>
#include <map>
#include <memory>
 
template<class P>
class JetMapBase 
{
public:
 
  typedef P                      data_t;
  typedef std::vector<data_t>    record_t;

  class record_ptr_t {
  public:
    record_ptr_t(record_t* r=NULL) : m_ptr(r) {};
    bool isValid()const{return m_ptr !=NULL;}
    const record_t& operator*() const {return *m_ptr;}
    const record_t* operator->() const {return m_ptr;}
    const record_t* get() const {return m_ptr;}
    record_t& operator*() {return *m_ptr;}
    record_t* operator->() {return m_ptr;}
    record_t* get() {return m_ptr;}
    void destroy() {if (isValid()) delete m_ptr; m_ptr=NULL;}
    void set(record_t *r){m_ptr = r;}
  protected:
    record_t * m_ptr;
  };

  typedef size_t    key_t;   
  typedef std::map<key_t, record_ptr_t>  map_t;
 

  JetMapBase();
  JetMapBase(const JetMapBase& base) = delete;
  JetMapBase& operator=(const JetMapBase& base) = delete;
  virtual ~JetMapBase();

  virtual bool addRecord(size_t jetIndex) const;

  virtual const record_t* getRecord(size_t jetIndex) const;

  virtual void assignRecord(size_t jetIndex, record_t* rec) const;

  virtual void addData(size_t jetIndex,size_t keyIndex,const data_t& data)
    const; 
  virtual bool retrieveData(size_t jetIndex,size_t keyIndex,data_t& data) 
    const;
 
  virtual const data_t& accessData(size_t jetIndex,size_t keyIndex) const;
 
  virtual size_t numberOfMoments(size_t jetIndex) const;
 
  virtual void clear();
  virtual void clear(SG::OwnershipPolicy ){clear();}
 
  SG::OwnershipPolicy ownPolicy(){return m_ownPolicy;};
 
protected:

  virtual void removeRecord(size_t jetIndex) const;

  virtual void transferRecord(const JetMapBase<P> *fromMap, size_t oldIndex, size_t newIndex ) const;
 
  friend class Jet;
  template <class T>
  friend class JetMomentMapConverterBase;
 
  map_t& map();
  const map_t& map() const;
 
 
#if !defined(__REFLEX__) && !defined(__CLING__)
  // /*! @brief Store last valid record index */
  // mutable size_t m_lastIndex; not used so remove it for simplicity
  mutable map_t  m_store;
  static const data_t m_nullData;
#endif
 
  
  SG::OwnershipPolicy m_ownPolicy ;
};
 
class OrphanJetCounter {
public:
  size_t getNewId() {m_counter++;return m_counter;};
  
protected:
  void reset(){m_counter=0;}
 
  size_t m_counter{};
  
 
};

 
#if !defined(__REFLEX__) && !defined(__CLING__)
#include "JetEvent/JetMapBase.icc"
#endif
 
#endif