CaloClusterMomentStore.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef CALOEVENT_CALOCLUSTERMOMENTSTORE_H
#define CALOEVENT_CALOCLUSTERMOMENTSTORE_H
 
#include "CaloEvent/CaloClusterMoment.h"
 
#include <vector>
#include <map>
#include <cstddef>
 
class CaloClusterMomentStore
{
 public:

  CaloClusterMomentStore();
  explicit CaloClusterMomentStore(const CaloClusterMomentStore& rMomStore);
  explicit CaloClusterMomentStore(const CaloClusterMomentStore* pMomStore);
  CaloClusterMomentStore& operator=(const CaloClusterMomentStore& rMomStore);
  virtual ~CaloClusterMomentStore();

  typedef CaloClusterMoment                         moment_value;
  typedef CaloClusterMoment::MomentType             moment_type;
  typedef int                                       moment_key;
  typedef std::map<moment_key,moment_value>         moment_store;
  typedef moment_store::const_iterator              moment_store_const_iter;
  typedef moment_store::iterator                    moment_store_iter;
  typedef std::vector<moment_type>                  moment_type_list;
 
  // Work around ROOT-9709.  Hide m_actual from cling --- but that means
  // that we also need to ensure that the inline functions defined here
  // are actually emitted out-of-line.
#ifdef __CLING__
#  define ATH_CLING_BODY(BODY) ;
#else
#  define ATH_CLING_BODY(BODY) __attribute__((used)) BODY
#endif

  class CaloClusterMomentIterator
    {
    public:
      CaloClusterMomentIterator() ATH_CLING_BODY( { } )
      CaloClusterMomentIterator(moment_store_const_iter iStore)
    ATH_CLING_BODY (: m_actual(iStore) { } )
#ifdef __clang__
      ~CaloClusterMomentIterator();
#else
      ~CaloClusterMomentIterator() ATH_CLING_BODY( { } )
#endif

      CaloClusterMomentIterator next()
        ATH_CLING_BODY( { ++m_actual; return *this; } )
      CaloClusterMomentIterator operator++()    { return this->next(); }

      CaloClusterMomentIterator operator++(int) { return this->next(); }
      
      CaloClusterMomentIterator prev()
        ATH_CLING_BODY( { --m_actual; return *this; } )
      CaloClusterMomentIterator operator--()    { return this->prev(); }

      CaloClusterMomentIterator operator--(int) { return this->prev(); }

      bool operator==(const CaloClusterMomentIterator& anOtherIter) const
        ATH_CLING_BODY( { return m_actual == anOtherIter.m_actual; } )
      bool operator==(CaloClusterMomentIterator& anOtherIter)
        ATH_CLING_BODY( { return m_actual == anOtherIter.m_actual; } )

      bool operator!=(const CaloClusterMomentIterator& anOtherIter) const
        ATH_CLING_BODY( { return m_actual != anOtherIter.m_actual; } )
      bool operator!=(CaloClusterMomentIterator& anOtherIter)
        ATH_CLING_BODY( { return m_actual != anOtherIter.m_actual; } )

      //      CaloClusterMoment& operator*() { return this->getMoment(); }
      const CaloClusterMoment& operator*() const { return this->getMoment(); }

      //      CaloClusterMoment& getMoment() { return (*m_actual).second; }
      const CaloClusterMoment& getMoment() const
        ATH_CLING_BODY( { return (*m_actual).second; } )
      moment_type getMomentType() const   
        ATH_CLING_BODY( { return (moment_type)(*m_actual).first; } )
 
    private:
#ifndef __CLING__
      moment_store_const_iter m_actual;
#endif
    };

  typedef CaloClusterMomentIterator           moment_iterator;

  virtual void insert(const moment_type&  rMomType,
              const moment_value& rMomData);
  virtual bool retrieve(const moment_type& rMomType,
            moment_value&      rMomData) const;
  virtual bool retrieve(const moment_iterator& rMomIter,
            moment_value&          rMomData) const;
  virtual bool retrieveMomentTypes(moment_type_list& rMomTypeList) const;
  virtual moment_iterator begin() const; 
  virtual moment_iterator end() const;   
  virtual moment_iterator find(const moment_type& rMomType) const; 
  virtual bool contains(const moment_type& rMomType) const;
  size_t size() const;

  virtual const moment_store& momentStore() const;
  virtual void setMomentStore(const moment_store& rMomStore );
  virtual void setMomentStore(moment_store&& rMomStore );
 
 private:
 
  moment_store m_store;
};
 
inline void CaloClusterMomentStore::insert(const moment_type&  rMomType,
                       const moment_value& rMomData)
{
  (*(m_store.insert(moment_store::value_type((moment_key)rMomType,rMomData))).first).second = rMomData;
}
 
inline CaloClusterMomentStore::moment_iterator 
CaloClusterMomentStore::begin() const
{
  return moment_iterator(m_store.begin());
}
 
inline CaloClusterMomentStore::moment_iterator
CaloClusterMomentStore::end() const
{
  return moment_iterator(m_store.end());
}
 
inline CaloClusterMomentStore::moment_iterator
CaloClusterMomentStore::find(const moment_type& rMomType) const
{
  return moment_iterator(m_store.find((moment_key)rMomType)); 
}
 
inline bool CaloClusterMomentStore::contains(const moment_type& rMomType) const
{
  return m_store.find((moment_key)rMomType) != m_store.end();
}
 
inline size_t CaloClusterMomentStore::size() const
{
  return m_store.size();
}
 
inline const CaloClusterMomentStore::moment_store&
CaloClusterMomentStore::momentStore() const
{
  return m_store;
}
 
inline void CaloClusterMomentStore::setMomentStore(const moment_store&
                           rMomStore)
{
  m_store = rMomStore;
}
inline void CaloClusterMomentStore::setMomentStore(moment_store&&
                           rMomStore)
{
  m_store = std::move(rMomStore);
}

#endif