StoreGate/StoreGate/WriteDecorHandleKey.icc

Go to the documentation of this file.

/*
 * Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration.
 */
/**
 * @file StoreGate/WriteDecorHandleKey.icc
 * @author scott snyder <snyder@bnl.gov>
 * @date Mar, 2017
 * @brief Property holding a SG store/key/clid/attr name from which a
 *        WriteDecorHandle is made.
 */
 
 
#include "StoreGate/DecorKeyHelpers.h"
#include "GaudiKernel/IDataHandleHolder.h"
 
 
namespace SG {
 
 
namespace detail {
 
 
/**
 * @brief Optionally register read dependency of a @c WriteDecorHandleKey.
 */
void registerWriteDecorHandleKey (IDataHandleHolder* owner,
                                  const DataObjID& contHandleKey);
 
 
} // namespace detail
 
 
/**
 * @brief Constructor.
 * @param key The StoreGate key for the object.
 * @param storeName Name to use for the store, if it's not encoded in sgkey.
 *
 * The provided key may actually start with the name of the store,
 * separated by a "+":  "MyStore+Obj".  If no "+" is present
 * the store named by @c storeName is used.
 */
template <class T>
WriteDecorHandleKey<T>::WriteDecorHandleKey (const std::string& key /*= ""*/,
                                             const std::string& storeName /*= "StoreGateSvc"*/) :
  Base (key, storeName),
  m_contHandleKey (contKeyFromKey (key), storeName)
{
}
 
 
/**
 * @brief Constructor with associated container.
 * @param contKey WriteHandleKey of the associated container
 * @param decorKey The decoration name.
 * @param storeName Name to use for the store.
 *
 * The decoration @decorKey will be applied on the container referenced
 * by @contKey.
 */
template <class T>
WriteDecorHandleKey<T>::WriteDecorHandleKey (const VarHandleKey& contKey,
                                             const std::string& decorKey /*= ""*/,
                                             const std::string& storeName /*= "StoreGateSvc"*/) :
  Base (makeContDecorKey (contKey, decorKey), storeName),
  m_contHandleKey (contKey.key(), storeName),
  m_contKey(&contKey)
{
}
 
 
/**
 * @brief auto-declaring Property Constructor.
 * @param owner Owning component.
 * @param name name of the Property
 * @param key  default StoreGate key for the object.
 * @param doc Documentation string.
 *
 * will associate the named Property with this key via declareProperty
 *
 * The provided key may actually start with the name of the store,
 * separated by a "+":  "MyStore+Obj".  If no "+" is present
 * the store named by @c storeName is used.
 */
template <class T>
template <class OWNER,
          typename /*= typename std::enable_if<std::is_base_of<IProperty, OWNER>::value>::type*/>
inline
WriteDecorHandleKey<T>::WriteDecorHandleKey( OWNER* owner,
                                             const std::string& name,
                                             const std::string& key /*={}*/,
                                             const std::string& doc /*=""*/)
  : Base (owner, name, key, doc),
    m_contHandleKey (contKeyFromKey (key), StoreID::storeName(StoreID::EVENT_STORE) )
{
}
 
 
/**
 * @brief auto-declaring Property Constructor.
 * @param owner Owning component.
 * @param name name of the Property
 * @param contKey WriteHandleKey of the associated container
 * @param decorKey name The decoration name.
 * @param doc Documentation string.
 *
 * will associate the named Property with this WDHK via declareProperty
 */
template <class T>
template <class OWNER,
          typename /*= typename std::enable_if<std::is_base_of<IProperty, OWNER>::value>::type*/>
inline
WriteDecorHandleKey<T>::WriteDecorHandleKey( OWNER* owner,
                                             const std::string& name,
                                             const VarHandleKey& contKey,
                                             const std::string& decorKey /*={}*/,
                                             const std::string& doc /*=""*/)
  : Base (owner, name, makeContDecorKey (contKey, decorKey), doc),
    m_contHandleKey (contKey.key(), StoreID::storeName(StoreID::EVENT_STORE)),
    m_contKey(&contKey)
{
}
 
 
 
 
/**
 * @brief Change the key of the object to which we're referring.
 * @param sgkey The StoreGate key for the object.
 * 
 * The provided key may actually start with the name of the store,
 * separated by a "+":  "MyStore+Obj".  If no "+" is present,
 * the store is not changed.
 */
template <class T>
WriteDecorHandleKey<T>&
WriteDecorHandleKey<T>::operator= (const std::string& sgkey)
{
  const std::string key = m_contKey ? makeContDecorKey(*m_contKey, sgkey) : sgkey;
  m_contHandleKey = contKeyFromKey (key);
  Base::operator= (key);
  return *this;
}
 
 
/**
 * @brief Change the key of the object to which we're referring.
 * @param sgkey The StoreGate key for the object.
 * 
 * The provided key may actually start with the name of the store,
 * separated by a "+":  "MyStore+Obj".  If no "+" is present
 * the store is not changed.  A key name that starts with a "+"
 * is interpreted as a hierarchical key name, not an empty store name.
 *
 * Returns failure the key string format is bad.
 */
template <class T>
StatusCode WriteDecorHandleKey<T>::assign (const std::string& sgkey)
{
  const std::string key = m_contKey ? makeContDecorKey(*m_contKey, sgkey) : sgkey;
  if (m_contHandleKey.assign (contKeyFromKey (key)).isFailure())
    return StatusCode::FAILURE;
  return Base::assign (key);
}
 
 
/**
 * @brief If this object is used as a property, then this should be called
 *        during the initialize phase.  It will fail if the requested
 *        StoreGate service cannot be found or if the key is blank.
 *
 * @param used If false, then this handle is not to be used.
 *             Instead of normal initialization, the key will be cleared.
 */
template <class T>
StatusCode WriteDecorHandleKey<T>::initialize (bool used /*= true*/)
{
  // If a parent container is used, its key may have changed
  if (m_contKey){
    m_contHandleKey = m_contKey->key();
    std::string decorKey=decorKeyFromKey(this->key());
    VarHandleKey::operator=(makeContDecorKey (m_contKey->key(), decorKey));
  }           
  detail::registerWriteDecorHandleKey (this->owner(), m_contHandleKey.fullKey());
  if (m_contHandleKey.initialize (used).isFailure())
    return StatusCode::FAILURE;
  return Base::initialize (used);
}
 
 
/**
 * @brief Python representation of Handle.
 */
template <class T>
std::string WriteDecorHandleKey<T>::pythonRepr() const
{
  std::string repr = Base::pythonRepr();
  // With a parent container our representation becomes the decoration name only.
  if (m_contKey) {
    removeContFromDecorKey(*m_contKey, repr);
  }
  return repr;
}
 
 
/**
 * @brief Return the handle key for the container.
 */
template <class T>
const ReadHandleKey<T>& WriteDecorHandleKey<T>::contHandleKey() const
{
  return m_contHandleKey;
}
 
 
/**
 * @brief Return the handle key for the container.
 */
template <class T>
ReadHandleKey<T>& WriteDecorHandleKey<T>::contHandleKey_nc()
{
  return m_contHandleKey;
}
 
 
/**
 * @brief Declare that this item does not participate in scheduling.
 *
 * If a WriteDataHandleKey is renounced, then we skip creating the
 * output alias.  Further, we skip the check that the element provided
 * is a member of the declared container.  A WriteDataHandle initialized
 * from a renounced key will effectively behave like a simple Decorator.
 */
template <class T>
inline
void WriteDecorHandleKey<T>::renounce()
{
  m_renounced = true;
}
 
 
/**
 * @brief Return the renounced flag.
 */
template <class T>
inline
bool WriteDecorHandleKey<T>::renounced() const
{
  return m_renounced;
}
 
 
} // namespace SG