StoreGate/StoreGate/WriteHandle.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_WRITEHANDLE_H
#define STOREGATE_SG_WRITEHANDLE_H 1
 
 
#include "StoreGate/VarHandleBase.h"
#include "StoreGate/WriteHandleKey.h"
#include "StoreGate/StoreGateSvc.h" /* needed by clients */
#include "GaudiKernel/EventContext.h"
#include <string>
#include <memory> /*unique_ptr*/
 
 
template <class DV> class ConstDataVector;
 
 
namespace SG {
 
 
template <class T>
class WriteHandle
  : 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.
  //
 
 
  WriteHandle();
 
 
  explicit WriteHandle(const std::string& sgkey, 
                       const std::string& storename = StoreID::storeName(StoreID::EVENT_STORE));
 
 
  explicit WriteHandle(const std::string& sgkey,
                       const EventContext& ctx);
 
 
  explicit WriteHandle(const std::string& sgkey,
                       const std::string& storename,
                       const EventContext& ctx);
 
 
  explicit WriteHandle (const WriteHandleKey<T>& key);
 
 
  explicit WriteHandle (const WriteHandleKey<T>& key, const EventContext& ctx);
 
  
  // Disallow initialization from a temporary Key object.
  explicit WriteHandle (SG::WriteHandleKey<T>&& key) = delete; // Not allowed from a temporary.
  explicit WriteHandle (SG::WriteHandleKey<T>&& key, 
                        const EventContext& ctx) = delete; // Not allowed from a temporary.
 
 
  WriteHandle( const WriteHandle& rhs );
 
 
  WriteHandle( WriteHandle&& rhs );
 
 
  WriteHandle& operator=( const WriteHandle& rhs ); 
 
 
  WriteHandle& operator=( WriteHandle&& rhs );
 
 
  ~WriteHandle();
 
 
  //************************************************************************
  // Deference.  These all return only the cached pointer.
  //
 
 
  pointer_type operator->();
 
 
  reference_type operator*();
 
 
  const_pointer_type cptr() const;
 
 
  pointer_type ptr();
 
 
  pointer_type cachedPtr();
 
 
  virtual bool isValid() override final;
 
 
  //************************************************************************
  // Record.
  //
 
 
  StatusCode record (std::unique_ptr<T> data);
 
 
  StatusCode recordNonConst (std::unique_ptr<T> data);
 
  
  template <class AUXSTORE>
  StatusCode record (std::unique_ptr<T> data,
                     std::unique_ptr<AUXSTORE> store);
 
 
  template <class AUXSTORE>
  StatusCode recordNonConst (std::unique_ptr<T> data,
                             std::unique_ptr<AUXSTORE> store);
 
 
  StatusCode record (SG::DataObjectSharedPtr<T> data);
 
 
  StatusCode recordNonConst (SG::DataObjectSharedPtr<T> data);
 
 
  const_pointer_type put (std::unique_ptr<T> data,
                          bool returnExisting = false) const;
 
 
  const_pointer_type put (std::unique_ptr<const T> data,
                          bool returnExisting = false) const;
 
 
  const_pointer_type put (std::unique_ptr<const ConstDataVector<T> > data,
                          bool returnExisting = false) const;
 
 
  const_pointer_type put (const EventContext& ctx,
                          std::unique_ptr<const ConstDataVector<T> > data,
                          bool returnExisting = false) const;
 
 
  const_pointer_type put (const EventContext& ctx,
                          std::unique_ptr<T> data,
                          bool returnExisting = false) const;
 
 
  const_pointer_type put (const EventContext& ctx,
                          std::unique_ptr<const T> data,
                          bool returnExisting = false) const;
 
 
  const_pointer_type put (SG::DataObjectSharedPtr<T> data) const;
 
 
  const_pointer_type put (const EventContext& ctx,
                          SG::DataObjectSharedPtr<T> data) const;
 
 
  template <class AUXSTORE>
  const_pointer_type
  put (std::unique_ptr<T> data,
       std::unique_ptr<AUXSTORE> auxstore) const;
 
 
  template <class AUXSTORE>
  const_pointer_type
  put (std::unique_ptr<const T> data,
       std::unique_ptr<const AUXSTORE> auxstore) const;
 
 
  template <class AUXSTORE>
  const_pointer_type
  put (const EventContext& ctx,
       std::unique_ptr<T> data,
       std::unique_ptr<AUXSTORE> auxstore) const;
 
 
  template <class AUXSTORE>
  const_pointer_type
  put (const EventContext& ctx,
       std::unique_ptr<const T> data,
       std::unique_ptr<const AUXSTORE> auxstore) const;
 
 
  WriteHandle& operator=( std::unique_ptr<T> data );
 
 
  StatusCode alias (const WriteHandleKey<T>& key);
 
 
  template <class U>
  StatusCode symLink (const WriteHandleKey<U>& key);
 
  
private:
  pointer_type checkedCachedPtr();
 
 
  template <class U>
  StatusCode doRecord (U data,
                       bool isConst,
                       bool returnExisting);
 
 
  template <class U>
  const_pointer_type doPut (const EventContext* ctx,
                            U data,
                            bool returnExisting,
                            IProxyDict* & store) const;
  
 
  template <class AUXSTORE>
  typename WriteHandle<T>::const_pointer_type
  doPut (const EventContext* ctx,
         std::unique_ptr<T> data,
         std::unique_ptr<AUXSTORE> auxstore) const;
 
 
  template <class AUXSTORE>
  typename WriteHandle<T>::const_pointer_type
  doPut (const EventContext* ctx,
         std::unique_ptr<const T> data,
         std::unique_ptr<const AUXSTORE> auxstore) const;
 
 
  template <class AUXSTORE>
  StatusCode
  record (std::unique_ptr<T> data,
          std::unique_ptr<AUXSTORE> auxstore,
          bool isConst);
 
 
private:
  SG::DataProxy* m_lockAuxPending = nullptr;
}; 
 
 
template <class T>
WriteHandle<T> makeHandle (const WriteHandleKey<T>& key);
 
 
template <class T>
WriteHandle<T> makeHandle (const WriteHandleKey<T>& key,
                           const EventContext& ctx);
 
 
} /* namespace SG */
 
 
#include "StoreGate/WriteHandle.icc"
 
 
#ifndef NO_LEGACY_HANDLES
namespace SG {
  template <class T>
  using WVar = WriteHandle<T>;
} 
#endif
#endif //> !STOREGATE_SG_WRITEHANDLE_H