TransientAddress.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#include "SGTools/TransientAddress.h"
#include "SGTools/DataProxy.h"
#include "AthenaKernel/IAddressProvider.h"
#include "AthenaKernel/IProxyDict.h"
#include "GaudiKernel/IOpaqueAddress.h"
 
#include <assert.h>
 
using SG::TransientAddress;
 
const std::string TransientAddress::s_emptyString;
 
// Default Constructor:
TransientAddress::TransientAddress()
  : TransientAddress (CLID_NULL, "", nullptr, true, false)
{
}
 
// Constructor with CLID and string key:
// (typically used through a StoreGate::record()
TransientAddress::TransientAddress(CLID id, const std::string& key)
  : TransientAddress (id, key, nullptr, true, false)
{ 
  if (id != CLID_NULL)
    m_transientID.push_back(id);
}
 
// Constructor with CLID, string key and IOpaqueAddress:
// (typically used by a ProxyProvider)
TransientAddress::TransientAddress(CLID id, const std::string& key, 
                   CxxUtils::RefCountedPtr<IOpaqueAddress> addr,
                   bool clearAddress)
  : TransientAddress (id, key, std::move(addr), clearAddress, true)
{
  if (id != CLID_NULL)
    m_transientID.push_back(id);
}
 
 
// Constructor giving full list of symlinked IDs
// --- used from DataHeaderElement::getAddress().
TransientAddress::TransientAddress(CLID id, const std::string& key, 
                   CxxUtils::RefCountedPtr<IOpaqueAddress> addr,
                                   const std::vector<CLID>& clids)
  : TransientAddress (id, key, std::move(addr), true, true)
{
  m_transientID.reserve (clids.size() + 1);
  m_transientID = clids;
  if (id != CLID_NULL) {
    m_transientID.push_back (id);
    std::ranges::sort (m_transientID);
  }
}
 
 
// Note: this is a private ctor, only used from other ctors.
// It does not initialize m_transientID.
TransientAddress::TransientAddress(CLID id, const std::string& key, 
                   CxxUtils::RefCountedPtr<IOpaqueAddress> addr,
                   bool clearAddress,
                                   bool consultProvider)
  : m_clid(id),
    m_sgkey(0),
    m_storeID(StoreID::UNKNOWN),
    m_clearAddress(clearAddress),
    m_consultProvider(consultProvider),
    m_address(std::move(addr)),
    m_pAddressProvider(nullptr)
{
  if (!key.empty()) {
    m_name.store (key);
  }
}
 
 
TransientAddress::TransientAddress (const TransientAddress& other)
  : m_clid (static_cast<CLID>(other.m_clid)),
    m_sgkey (static_cast<sgkey_t>(other.m_sgkey)),
    m_storeID (other.m_storeID),
    m_clearAddress (other.m_clearAddress),
    m_consultProvider (other.m_consultProvider),
    m_address (other.m_address),
    m_pAddressProvider (other.m_pAddressProvider),
    m_name (other.m_name),
    m_transientID (other.m_transientID),
    m_transientAlias (other.m_transientAlias)
{
}
 
 
TransientAddress::TransientAddress (TransientAddress&& other)
  : m_clid (static_cast<CLID>(other.m_clid)),
    m_sgkey (static_cast<sgkey_t>(other.m_sgkey)),
    m_storeID (other.m_storeID),
    m_clearAddress (other.m_clearAddress),
    m_consultProvider (other.m_consultProvider),
    m_address (std::move (other.m_address)),
    m_pAddressProvider (other.m_pAddressProvider),
    m_name (std::move (other.m_name)),
    m_transientID (std::move (other.m_transientID)),
    m_transientAlias (std::move (other.m_transientAlias))
{
}
 
 
// Destructor
TransientAddress::~TransientAddress() 
{ 
}
 
 
TransientAddress& TransientAddress::operator= (const TransientAddress& other)
{
  if (this != &other) {
    m_clid = static_cast<CLID>(other.m_clid);
    m_name = other.m_name;
    m_transientID = other.m_transientID;
    m_transientAlias = other.m_transientAlias;
    m_clearAddress = other.m_clearAddress;
    m_consultProvider = other.m_consultProvider;
    m_pAddressProvider = other.m_pAddressProvider;
    m_storeID = other.m_storeID;
    m_sgkey = static_cast<sgkey_t>(other.m_sgkey);
    m_address = other.m_address;
  }
  return *this;
}
 
 
TransientAddress& TransientAddress::operator= (TransientAddress&& other)
{
  if (this != &other) {
    m_clid = static_cast<CLID>(other.m_clid);
    m_name = std::move (other.m_name);
    m_transientID = std::move (other.m_transientID);
    m_transientAlias = std::move (other.m_transientAlias);
    m_clearAddress = other.m_clearAddress;
    m_consultProvider = other.m_consultProvider;
    m_pAddressProvider = other.m_pAddressProvider;
    m_storeID = other.m_storeID;
    m_sgkey = static_cast<sgkey_t>(other.m_sgkey);
    m_address = std::move (other.m_address);
  }
  return *this;
}
 
 
void TransientAddress::setTransientID(CLID id)
{
  if (m_transientID.empty()) {
    m_transientID.push_back (id);
  }
  else if (!transientID (id)) {
    m_transientID.push_back (id);
    std::sort (m_transientID.begin(), m_transientID.end());
  }
}
 
 
void TransientAddress::setID (CLID id, const std::string& key)
{
  assert (m_clid == CLID_NULL && !m_name.isValid() && m_transientID.empty() &&
          m_transientAlias.empty());
  m_clid = id;
  m_name.set (key);
  if (id != CLID_NULL)
    m_transientID.push_back(id);
}
 
// Reset the TransientAddress
void TransientAddress::reset()
{
  if (m_clearAddress) m_address.reset();
}
 
void TransientAddress::setAddress(CxxUtils::RefCountedPtr<IOpaqueAddress> pAddress)
{ 
  m_address = std::move(pAddress);
}
 
bool TransientAddress::isValid(const EventContext* ctx,
                               bool forceUpdate /*= false*/)
{
  if (!forceUpdate && 0 != address()) return true;
 
  if (ctx && m_consultProvider && 0 != provider()) {
    if ((provider()->updateAddress(storeID(), this, *ctx)).isSuccess())
      return true;
  }
  return false;
}