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 "CxxUtils/RefCountedPtr.h"
#include "CxxUtils/CachedValue.h"
#include "CxxUtils/checker_macros.h"
#include "GaudiKernel/ClassID.h"
#include "GaudiKernel/IOpaqueAddress.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, 
             CxxUtils::RefCountedPtr<IOpaqueAddress> addr,
                     bool clearAddress = true);

    TransientAddress(CLID id, const std::string& key, 
             CxxUtils::RefCountedPtr<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(CxxUtils::RefCountedPtr<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, 
             CxxUtils::RefCountedPtr<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;

    CxxUtils::RefCountedPtr<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:

  inline
  IOpaqueAddress* TransientAddress::address ATLAS_NOT_CONST_THREAD_SAFE () const 
  {
    IOpaqueAddress* addr ATLAS_THREAD_SAFE = const_cast<IOpaqueAddress*> (m_address.get());
    return addr;
  }

  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