StoreGate/StoreGate/ReadHandle.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef STOREGATE_SG_READHANDLE_H
#define STOREGATE_SG_READHANDLE_H 1
 
 
#include "StoreGate/VarHandleBase.h"
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/WriteHandleKey.h"
#include "AthenaKernel/ClassID_traits.h"
#include "GaudiKernel/EventContext.h"
#include <string>
 
 
 
namespace SG {
 
 
template <class T>
class ReadHandle
  : public SG::VarHandleBase
{ 
public: 
  typedef T*               pointer_type; // FIXME: better handling of
  typedef const T*   const_pointer_type; //        qualified T type ?
  typedef T&             reference_type;
  typedef const T& const_reference_type;
 
 
  //************************************************************************
  // Constructors, etc.
  //
 
 
  ReadHandle();
 
 
  explicit ReadHandle(const std::string& sgkey, 
                      const std::string& storename = StoreID::storeName(StoreID::EVENT_STORE));
 
 
  explicit ReadHandle(const std::string& sgkey,
                      const EventContext& ctx);
 
 
  explicit ReadHandle(const std::string& sgkey,
                      const std::string& storename,
                      const EventContext& ctx);
 
 
  explicit ReadHandle (const ReadHandleKey<T>& key);
 
 
  explicit ReadHandle (const ReadHandleKey<T>& key, const EventContext& ctx);
 
 
  explicit ReadHandle (SG::DataProxy* proxy);
 
 
  // Disallow initialization from a temporary Key object.
  explicit ReadHandle (SG::ReadHandleKey<T>&& key) = delete; // Not allowed from a temporary.
  explicit ReadHandle (SG::ReadHandleKey<T>&& key, 
                       const EventContext& ctx) = delete; // Not allowed from a temporary.
 
 
  ReadHandle( const ReadHandle& rhs );
 
 
  ReadHandle( ReadHandle&& rhs );
 
 
  ReadHandle& operator=( const ReadHandle& rhs ); 
 
 
  ReadHandle& operator=( ReadHandle&& rhs ); 
 
 
  //************************************************************************
  // Dereference.
  //
 
  
  const_pointer_type  operator->();
 
 
  const_reference_type operator*();
 
 
  const_pointer_type cptr();
 
 
  const_pointer_type ptr();
 
 
  const_pointer_type cachedPtr() const;
 
 
  virtual bool isValid() override final;
 
 
  const_pointer_type get() const;
 
 
  const_pointer_type get (const EventContext& ctx) const;
 
 
  //************************************************************************
  // Alias.
  //
 
 
  StatusCode alias (const WriteHandleKey<T>& key);
 
 
protected:
  explicit ReadHandle (const VarHandleKey& key, const EventContext* ctx);
 
 
private:
  const_pointer_type checkedCPtr();
}; 
 
 
template <class T>
ReadHandle<T> makeHandle (const ReadHandleKey<T>& key);
 
 
template <class T>
ReadHandle<T> makeHandle (const ReadHandleKey<T>& key,
                          const EventContext& ctx);
 
 
template <class T>
const T* get (const ReadHandleKey<T>& key);
 
 
 
template <class T>
const T* get (const ReadHandleKey<T>& key,
              const EventContext& ctx);
 
 
} /* namespace SG */
 
 
 
#include "StoreGate/ReadHandle.icc"
 
 
#ifndef NO_LEGACY_HANDLES
namespace SG {
  template <class T>
  using RVar = ReadHandle<T>;
} 
#endif
 
 
#endif //> !STOREGATE_SG_READHANDLE_H