TransientAddress.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef SGTOOLS_TRANSIENTADDRESS_H
#define SGTOOLS_TRANSIENTADDRESS_H
 
#include <string>
#include <set>
#include <vector>
#include <algorithm>
#include <atomic>
 
 
#include "AthenaKernel/IStringPool.h"
#include "AthenaKernel/StoreID.h"
#include "GaudiKernel/ClassID.h"
#include "CxxUtils/CachedValue.h"
#include "CxxUtils/checker_macros.h"
 
class IOpaqueAddress;
class IAddressProvider;
class IProxyDict;
class EventContext;
 
namespace SG {
 
  class TransientAddress
  {
 
  public:
 
    typedef std::vector<CLID> TransientClidSet;
 
    typedef std::vector<std::string> TransientAliasSet;
    typedef IStringPool::sgkey_t sgkey_t;
 
    TransientAddress();
 
    TransientAddress(CLID id, const std::string& key);
 
    TransientAddress(CLID id, const std::string& key, 
             IOpaqueAddress* addr, bool clearAddress = true);
 
    TransientAddress(CLID id, const std::string& key, 
             IOpaqueAddress* addr,
                     const std::vector<CLID>& clids);
 
    TransientAddress (const TransientAddress&);
    TransientAddress (TransientAddress&&);
 
    ~TransientAddress();
 
    TransientAddress& operator= (const TransientAddress&);
    TransientAddress& operator= (TransientAddress&&);
 
    void setID (CLID id, const std::string& key);
 
    void reset();
 
    // Can't change the signature here to satisfy the thread-safety
    // checker as this should match the signature in the Gaudi IRegistry.
    IOpaqueAddress* address ATLAS_NOT_CONST_THREAD_SAFE () const; 
 
    void setAddress(IOpaqueAddress* pAddress);
 
    CLID clID() const;
 
    const std::string& name() const;
 
    sgkey_t sgkey() const;
 
    void setSGKey (sgkey_t sgkey);
 
    bool transientID (CLID id) const;
 
    void setTransientID(CLID id);
 
    const TransientClidSet& transientID() const;
 
    void setAlias(const std::string& key);
 
    void setAlias(const std::vector<std::string>& keys);
 
    void setAlias(std::vector<std::string>&& keys);
 
    bool removeAlias(const std::string& key);
 
    bool hasAlias(const std::string& key) const;
 
    const TransientAliasSet& alias() const;
 
    void clearAddress(const bool& flag);
 
    bool clearAddress() const;
 
    void consultProvider(const bool& flag);
 
    bool isValid (const EventContext* ctx, bool forceUpdate = false);
 
    IAddressProvider* provider();
    StoreID::type storeID() const;
    void setProvider(IAddressProvider* provider, StoreID::type storeID);
 
  private:
    TransientAddress(CLID id, const std::string& key, 
             IOpaqueAddress* addr,
                     bool clearAddress,
                     bool consultProvider);
 
 
    // PLEASE NOTE: The data members of this class are ordered so that
    // the most frequently accessed members are grouped together, within
    // the first cache line, when it is embedded in DataProxy.  See the layout
    // at the end of DataProxy.h.
    // Be aware of this when making changes to the layout of this class.
 
 
    std::atomic<CLID> m_clid;
 
    std::atomic<sgkey_t> m_sgkey;
 
    StoreID::type m_storeID;
 
    bool m_clearAddress;
 
    bool m_consultProvider;
 
    IOpaqueAddress* m_address;
 
    IAddressProvider* m_pAddressProvider;
 
    CxxUtils::CachedValue<std::string> m_name;
 
    TransientClidSet m_transientID; 
 
    TransientAliasSet m_transientAlias;
 
    static const std::string s_emptyString;
  };
  // inlined code:
 
  // Reset the TransientAddress
  inline
  void TransientAddress::reset()
  {
    if (m_clearAddress) setAddress(0);
  }
 
  inline
  IOpaqueAddress* TransientAddress::address ATLAS_NOT_CONST_THREAD_SAFE () const 
  { 
    return m_address; 
  }
 
  inline
  CLID TransientAddress::clID() const 
  { 
    return m_clid; 
  }
 
  inline
  const std::string& TransientAddress::name() const
  {
    // Most of the time, m_name is set when the TransientAddress is created
    // and then never changed.  To handle dummy proxies though, m_name
    // can be created as blank and filled in later, but then never changed
    // again.  Used CachedValue to avoid having to use a lock for this.
    if (m_name.isValid()) {
      return *m_name.ptr();
    }
    return s_emptyString;
  }
 
  inline
  TransientAddress::sgkey_t TransientAddress::sgkey() const
  {
    return m_sgkey;
  }
 
  inline
  void TransientAddress::setSGKey (sgkey_t sgkey)
  {
    m_sgkey = sgkey;
  }
 
  inline
  bool TransientAddress::transientID(CLID id) const
  {
    return std::find (m_transientID.begin(), m_transientID.end(), id) !=
      m_transientID.end();
  }
 
  inline
  const TransientAddress::TransientClidSet& TransientAddress::transientID() const 
  {
    return m_transientID; 
  }
 
  inline 
  void TransientAddress::setAlias(const std::string& key)
  {
    auto it = std::ranges::lower_bound (m_transientAlias, key);
    if (it == m_transientAlias.end() || *it != key) {
      m_transientAlias.insert (it, key);
    }
  } 
 
  inline 
  void TransientAddress::setAlias(const std::vector<std::string>& keys)
  {
    m_transientAlias = keys;
  } 
 
  inline 
  void TransientAddress::setAlias(std::vector<std::string>&& keys)
  {
    m_transientAlias = std::move(keys);
  } 
 
  inline bool TransientAddress::removeAlias(const std::string& key)
  {
    auto it = std::ranges::lower_bound (m_transientAlias, key);
    if (it != m_transientAlias.end() && *it == key) {
      m_transientAlias.erase (it);
      return true;
    }
    return false;
  }
 
  inline bool TransientAddress::hasAlias(const std::string& key) const
  {
    return std::ranges::binary_search (m_transientAlias, key);
  }
 
  inline
  const TransientAddress::TransientAliasSet& TransientAddress::alias() const
  { 
    return m_transientAlias;
  }
 
  inline
  void TransientAddress::clearAddress(const bool& flag) 
  {
    m_clearAddress = flag;
  }
 
  inline
  bool TransientAddress::clearAddress() const
  {
    return m_clearAddress;
  }
 
  inline
  void TransientAddress::consultProvider(const bool& flag)
  {
    m_consultProvider = flag;
  }
 
  inline
  IAddressProvider* TransientAddress::provider()
  {
    return m_pAddressProvider;
  }
  inline
  StoreID::type TransientAddress::storeID() const
  {
    return m_storeID;
  }
 
  inline
    void TransientAddress::setProvider(IAddressProvider* provider, 
                       StoreID::type storeID)
  {
    m_pAddressProvider = provider;
    m_consultProvider = true;
    m_storeID=storeID;
  }
} //end namespace SG
 
#endif // STOREGATE_TRANSIENTADDRESS