DataHandle.h

Go to the documentation of this file.

/* -*- C++ -*- */
 
/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/

#ifndef STOREGATE_DATAHANDLE_H
#define STOREGATE_DATAHANDLE_H
 
#include "AthenaKernel/DataBucket.h"
#include "AthenaKernel/IResetable.h"
#include "AthenaKernel/IProxyDict.h"
#include "SGTools/ProxyMap.h"
#include "SGTools/DataProxy.h"
#include "SGTools/DataProxy_cast.h"
#include "SGTools/DataHandleBase.h"
#include "CxxUtils/checker_macros.h"
#include <iterator>
#include <iostream>

template <typename DATA> 
class ATLAS_NOT_THREAD_SAFE DataHandle :
  public DataHandleBase
{
public:
  using iterator_category = std::forward_iterator_tag;
  using value_type = DATA;
  using difference_type = std::ptrdiff_t;
  using pointer = value_type*;
  using reference = value_type&;
 
  typedef pointer pointer_type;  // `using' here gives cppcheck false positives
  using const_pointer_type = const DATA*;
  using reference_type = reference;
  using const_reference_type = const DATA&;
 
  typedef DataHandleBase::ID_type ID_type;


  DataHandle();
  DataHandle(const DataHandle& h);
  DataHandle& operator= (const DataHandle& h);
  DataHandle& operator= (const DATA& d) 
  { 
    typename DataHandle<DATA>::pointer_type ptr = m_ptr;
    if (ptr) {
      *ptr = d; 
    } else {
      std::cerr << "invalid proxy\n";
    }
    return *this; 
  }
 
  virtual ~DataHandle();  


  bool isValid() const; 
 
  // FIXME op! is to keep backward compatibility with Gaudi
  // FIXME similar to checking the SmartDataPtr
  // FIXME dangerous stuff: remove!
  bool operator !() const { return !isValid(); }
 
  //FIXME VERY dangerous stuff: remove!
  operator int() const  { return isValid(); }


  const DataHandle& operator++ () const;        
  DataHandle operator++ (int) const;           
    
  const_pointer_type operator->() const   { return cptr(); }
 
  const_reference_type operator*() const    { return *cptr(); }   


  operator const_pointer_type() const { return cptr(); } 
 
  const_pointer_type cptr() const;   
 
  virtual void reset (bool /*hard*/) override { m_ptr = 0; }        


  DataHandle(SG::DataProxy* proxy); 
  DataHandle(const SG::ConstProxyIterator& itr1,
             const SG::ConstProxyIterator& itr2);


  virtual CLID clid() const override { return ClassID_traits<DATA>::ID(); }
 
  friend
  bool operator== ATLAS_NOT_THREAD_SAFE (const DataHandle<DATA>& h1,
                                         const DataHandle<DATA>& h2)
  {
    return h1.m_proxy == h2.m_proxy;
  }
 
  friend
  bool operator!= ATLAS_NOT_THREAD_SAFE (const DataHandle<DATA>& h1,
                                         const DataHandle<DATA>& h2)
  {
    return h1.m_proxy != h2.m_proxy;
  }
    
private:
 
  // OK since DataHandle should only be used locally, not shared between threads.
  // Eventually we'd like to deprecate DataHandle anyway.
  mutable const_pointer_type m_ptr;
  const_pointer_type dataPointer() const;
 
 
};
 
#include "StoreGate/DataHandle.icc"
 
/* FIXME LEGACY - No dependency on ActiveStoreSvc here, but a number of Muon AtlasEvent packages are 
   getting the include through this one!!!! */
 
#include "StoreGate/ActiveStoreSvc.h"
 
#endif // STOREGATE_DATAHANDLE_H