UpdateHandle.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_UPDATEHANDLE_H
#define STOREGATE_SG_UPDATEHANDLE_H 1
 
 
#include "StoreGate/VarHandleBase.h"
#include "StoreGate/UpdateHandleKey.h"
#include "StoreGate/StoreGateSvc.h" /* needed by clients */
#include "GaudiKernel/EventContext.h"
#include <string>
 
 
 
namespace SG {
 
 
   // Helper for testing thread_safe.
   // Unless explicitly specialized,
   // IsThreadSafeForUH<T, std::true_type>::type will be true_type if
   // T has a `typedef std::true_type thread_safe', and false_type otherwise.
   template <class T, class VALT>
   struct IsThreadSafeForUH
   {
     typedef std::false_type type;
   };
   template <class T>
   struct IsThreadSafeForUH<T, typename T::thread_safe>
   {
     typedef std::true_type type;
   };
 
 
  template <class T>
  class UpdateHandle
    : 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;
 
    
  private:
    // Verify that the payload has a thread_safe typedef yielding std::true_type.
    static_assert (IsThreadSafeForUH<T, std::true_type>::type::value,
                   "Use of UpdateHandle is restricted to a few explicitly thread-safe types.  If you think you need to use UpdateHandle, please consult with the core and reconstruction groups.");
  public:
 
 
    //************************************************************************
    // Constructors, etc.
    //
 
 
    UpdateHandle();
 
 
    UpdateHandle(const std::string& sgkey,
                 const std::string& storename = StoreID::storeName(StoreID::EVENT_STORE));
 
 
    explicit UpdateHandle(const std::string& sgkey,
                          const EventContext& ctx);
 
 
    explicit UpdateHandle(const std::string& sgkey,
                          const std::string& storename,
                          const EventContext& ctx);
 
 
    explicit UpdateHandle (const UpdateHandleKey<T>& key);
 
 
    explicit UpdateHandle (const UpdateHandleKey<T>& key,const EventContext& ctx);
 
 
    // Disallow initialization from a temporary Key object.
    explicit UpdateHandle (SG::UpdateHandleKey<T>&& key) = delete; // Not allowed from a temporary.
    explicit UpdateHandle (SG::UpdateHandleKey<T>&& key, 
                           const EventContext& ctx) = delete; // Not allowed from a temporary.
 
 
    UpdateHandle( const UpdateHandle& rhs );
 
 
    UpdateHandle( UpdateHandle&& rhs );
 
 
    UpdateHandle& operator=( const UpdateHandle& rhs ); 
 
 
    UpdateHandle& operator=( UpdateHandle&& rhs ); 
 
 
    //************************************************************************
    // Dereference.
    //
 
 
    pointer_type operator->();
 
 
    reference_type operator*();
 
 
    const_pointer_type cptr();
 
 
    pointer_type ptr();
 
  
    pointer_type cachedPtr();
 
 
    virtual bool isValid() override final;
 
 
    // FIXME: Remove this once IResetable is cleaned up.
    using IResetable::reset;
 
 
    virtual void reset (bool hard) override;
 
  
  private:
    pointer_type checkedPtr();
  }; 
 
 
  template <class T>
  UpdateHandle<T> makeHandle (const UpdateHandleKey<T>& key);
 
 
  template <class T>
  UpdateHandle<T> makeHandle (const UpdateHandleKey<T>& key,
                              const EventContext& ctx);
 
 
} /* namespace SG */
 
 
#include "StoreGate/UpdateHandle.icc"
 
 
#ifndef NO_LEGACY_HANDLES
namespace SG {
  template <class T>
  using RWVar = UpdateHandle<T>;
} 
#endif
 
#endif //> !STOREGATE_SG_UPDATEHANDLE_H