UpdateHandle.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
/**
 * @file StoreGate/UpdateHandle.icc
 * @author S. Binet, P. Calafiura, scott snyder <snyder@bnl.gov>
 * @date Updated: Feb, 2016
 * @brief Handle class for modifying an existing object in StoreGate.
 */
 
#ifndef STOREGATE_SG_UPDATEHANDLE_ICC
#define STOREGATE_SG_UPDATEHANDLE_ICC 1
 
 
#include "StoreGate/exceptions.h"
#include "AthenaKernel/ClassID_traits.h"
#include <stdexcept>
 
 
namespace SG {
 
 
/**
 * @brief Default constructor.
 *
 * The handle will not be usable until a non-blank key is assigned.
 */
template <class T>
inline
UpdateHandle<T>::UpdateHandle() 
  : VarHandleBase(ClassID_traits<T>::ID(), Gaudi::DataHandle::Reader)
{
}
 
 
/**
 * @brief Constructor specifying the key as a string.
 * @param sgkey StoreGate key of the referenced object.
 * @param storename Name of the referenced event store.
 */
template <class T>
inline
UpdateHandle<T>::UpdateHandle(const std::string& sgkey,
                              const std::string& storename /*= "StoreGateSvc"*/)
  : VarHandleBase( ClassID_traits<T>::ID(),
                   sgkey, Gaudi::DataHandle::Reader, storename, nullptr )
{
}
 
 
/**
 * @brief Constructor specifying the key as a string, with context.
 * @param sgkey StoreGate key of the referenced object.
 * @param ctx The event context.
 */
template <class T>
inline
UpdateHandle<T>::UpdateHandle(const std::string& sgkey, const EventContext& ctx)
  : UpdateHandle(sgkey, StoreID::storeName(StoreID::EVENT_STORE), ctx)
{
}
 
 
/**
 * @brief Constructor specifying the key as a string, with data store.
 * @param sgkey StoreGate key of the referenced object.
 * @param sg Data store.
 */
template <class T>
inline
UpdateHandle<T>::UpdateHandle(const std::string& sgkey, IProxyDict* sg)
  : VarHandleBase(ClassID_traits<T>::ID(), sgkey, Gaudi::DataHandle::Reader, sg)
{
}
 
 
/**
 * @brief Constructor specifying the key as a string, with context.
 * @param sgkey StoreGate key of the referenced object.
 * @param storename Name of the referenced event store.
 * @param ctx The event context.
 */
template <class T>
inline
UpdateHandle<T>::UpdateHandle(const std::string& sgkey,
                              const std::string& storename,
                              const EventContext& ctx)
  : VarHandleBase( ClassID_traits<T>::ID(),
                   sgkey, Gaudi::DataHandle::Reader, storename, &ctx )
{
}
 
 
/**
 * @brief Constructor from an UpdateHandleKey.
 * @param key The key object holding the clid/key/store.
 *
 * This will raise an exception if the StoreGate key is blank,
 * or if the event store cannot be found.
 */
template <class T>
inline
UpdateHandle<T>::UpdateHandle (const UpdateHandleKey<T>& key)
  : VarHandleBase (key, nullptr)
{
}
 
 
/**
 * @brief Constructor from an UpdateHandleKey and an explicit event context.
 * @param key The key object holding the clid/key.
 * @param ctx The event context.
 *
 * This will raise an exception if the StoreGate key is blank,
 * or if the event store cannot be found.
 *
 * If the default event store has been requested, then the thread-specific
 * store from the event context will be used.
 */
template <class T>
UpdateHandle<T>::UpdateHandle (const UpdateHandleKey<T>& key,
                               const EventContext& ctx)
  : VarHandleBase (key, &ctx)
{
}
 
 
/**
 * @brief Copy constructor.
 */
template <class T>
inline
UpdateHandle<T>::UpdateHandle(const UpdateHandle& h)
  : VarHandleBase(h)
{
}
 
/**
 * @brief Move constructor.
 */
template <class T>
inline
UpdateHandle<T>::UpdateHandle(UpdateHandle&& h)
  : VarHandleBase(std::move(h))
{
}
 
 
/**
 * @brief Assignment operator.
 */
template <class T>
inline
UpdateHandle<T>& 
UpdateHandle<T>::UpdateHandle::operator= (const UpdateHandle& h)
{
  if (this != &h) {
    this->VarHandleBase::operator=(h);
  }
  return *this;
}
 
 
/**
 * @brief Move operator.
 */
template <class T>
inline
UpdateHandle<T>& 
UpdateHandle<T>::UpdateHandle::operator= (UpdateHandle&& h)
{
  if (this != &h) {
    this->VarHandleBase::operator=(std::move(h));
  }
  return *this;
}
 
 
//************************************************************************
// Dereference.
//
 
 
/**
 * @brief Dereference the pointer.
 * Throws ExcNullReadHandle on failure.
 *
 * This will inform Hive that the object has been modified.
 */
template <class T>
inline
typename UpdateHandle<T>::pointer_type
UpdateHandle<T>::operator->()
{
  return checkedPtr();
}
 
 
/**
 * @brief Dereference the pointer.
 * Throws ExcNullReadHandle on failure.
 *
 * This will inform Hive that the object has been modified.
 */
template <class T>
inline
typename UpdateHandle<T>::reference_type UpdateHandle<T>::operator*()
{
  return *checkedPtr();
}
 
 
/**
 * @brief Dereference the pointer.
 * Returns nullptr on failure.
 *
 * This will _not_ inform Hive that the object has been modified.
 */
template <class T>
inline
typename UpdateHandle<T>::const_pointer_type UpdateHandle<T>::cptr()
{
  return reinterpret_cast<const_pointer_type>(this->typeless_cptr());
}
 
 
/**
 * @brief Dereference the pointer.
 * Returns nullptr on failure.
 *
 * This will inform Hive that the object has been modified.
 */
template <class T>
typename UpdateHandle<T>::pointer_type
UpdateHandle<T>::ptr()
{
  pointer_type ptr = reinterpret_cast<pointer_type>(this->typeless_ptr());
  return ptr;
}
 
 
/**
 * @brief Return the cached pointer directly; no lookup.
 */
template <class T>
inline
typename UpdateHandle<T>::pointer_type
UpdateHandle<T>::cachedPtr()
{
  return reinterpret_cast<pointer_type>(this->m_ptr);
}
 
 
/**
 * @brief Can the handle be successfully dereferenced?
 */
template <class T>
inline
bool UpdateHandle<T>::isValid()
{ 
  const bool QUIET=true;
  if (0 != this->typeless_dataPointer(QUIET))
    return !isConst();
  return false;
}
 
 
/**
 * @brief Reset this handle.
 * @param hard If true, anything depending on the event store is cleared.
 *
 * Call reset() from the base class.
 */
template <class T>
void UpdateHandle<T>::reset (bool hard)
{
  VarHandleBase::reset (hard);
}
 
 
/**
 * @brief Helper: dereference the pointer.
 * Throws ExcNullUpdateHandle on failure.
 */
template <class T>
inline
typename UpdateHandle<T>::pointer_type
UpdateHandle<T>::checkedPtr()
{
  pointer_type p = this->ptr();
  if (!p)
    throwExcNullUpdateHandle (clid(), key(), store());
  return p;
}
 
 
/**
 * @brief Return an @c UpdateHandle referencing @c key.
 * @param key The key object holding the clid/key/store.
 *
 * This will raise an exception if the StoreGate key is blank,
 * or if the event store cannot be found.
 */
template <class T>
UpdateHandle<T> makeHandle (const UpdateHandleKey<T>& key)
{
  return UpdateHandle<T> (key);
}
 
 
/**
 * @brief Return an @c UpdateHandle referencing @c key for an explicit context.
 * @param key The key object holding the clid/key/store.
 * @param ctx The event context.
 *
 * This will raise an exception if the StoreGate key is blank,
 * or if the event store cannot be found.
 *
 * If the default event store has been requested, then the thread-specific
 * store from the event context will be used.
 */
template <class T>
UpdateHandle<T> makeHandle (const UpdateHandleKey<T>& key,
                            const EventContext& ctx)
{
  return UpdateHandle<T> (key, ctx);
}
 
 
} /* namespace SG */
 
 
#endif //> !STOREGATE_SG_UPDATEHANDLE_ICC