Control/SGTools/SGTools/DataStore.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef STOREGATE_DATASTORE_H
#define STOREGATE_DATASTORE_H
 
 
#include "SGTools/ProxyMap.h"
#include "SGTools/T2pMap.h"
#include "AthenaKernel/IProxyDict.h"
#include "AthenaKernel/DefaultKey.h"
#include "AthenaKernel/IProxyRegistry.h"
#include "SGCore/sgkey_t.h"
#include "CxxUtils/sgkey_utilities.h"
#include "GaudiKernel/ClassID.h"
#include "GaudiKernel/SmartIF.h"
#include "GaudiKernel/StatusCode.h"
 
#include <exception>
#include <list>
#include <vector>
#include <map>
#include <string>
#include <typeinfo> /*typeid*/
#include <utility>  /*std::pair*/
#include <unordered_map>
#include <mutex>
 
 
class ISvcLocator;
class ISGAudSvc;
class MsgStream;
class IPageAccessControlSvc;
 
namespace SG {
 
  class DataProxy;
 

  class DataStore : public IProxyRegistry
  {
 
  public:
 
    typedef IStringPool::sgkey_t                sgkey_t;
    typedef std::map<CLID, SG::ProxyMap>        StoreMap;
    typedef StoreMap::iterator                  StoreIterator;
    typedef StoreMap::const_iterator            ConstStoreIterator;
 
    typedef std::pair<SG::ConstProxyIterator, SG::ConstProxyIterator> constProxyRange;

    DataStore (IProxyDict& pool);
    virtual ~DataStore();
 
    void setStoreID(StoreID::type id) { m_storeID = id;}
    virtual StoreID::type storeID() const override { return m_storeID; }
 
    // If FORCE is true, then force deleting of all proxies,
    // even if they would normally only be reset.
    void clearStore(bool force, bool hard, MsgStream* pmlog);


    virtual StatusCode addToStore(const CLID& id, DataProxy* proxy) override;
    virtual DataProxy* proxy(const TransientAddress* tAddr) const override;
    virtual DataProxy* proxy(const CLID& id,
                 const std::string& key=SG::DEFAULTKEY) const override;

    virtual SG::DataProxy* proxy_exact (sgkey_t sgkey) const override;

    SG::DataProxy* proxy_exact_unlocked (sgkey_t sgkey,
                                         std::recursive_mutex& mutex) const;

    virtual SG::DataProxy* proxy_exact(const CLID& id,
                                       const std::string& key) const override;

    StatusCode removeProxy(DataProxy* proxy, bool forceRemove, bool hard);

    StatusCode addSymLink(const CLID& linkid, DataProxy* proxy);

    virtual StatusCode addAlias(const std::string& aliasKey, DataProxy* proxy) override;

    int typeCount(const CLID& id) const;

    StatusCode tRange(ConstStoreIterator& f, ConstStoreIterator& e) const;

    StatusCode pRange(const CLID& id, SG::ConstProxyIterator& f,
              SG::ConstProxyIterator& e) const;
 

    void setPac(IPageAccessControlSvc* pac) { m_t2p.setPac(pac); }
    std::vector<const DataProxy*> pacReport() const { return m_t2p.pacReport();}

    StatusCode t2pRegister(const void* const pTrans, DataProxy* const pPers);
    void t2pRemove(const void* const pTrans);

    DataProxy* locatePersistent(const void* const pTransient) const;
 
    // return list of keys associated with an object
    void keys(const CLID& id, std::vector<std::string>& vkeys,
          bool includeAlias, bool onlyValid);

    const std::vector<DataProxy*>& proxies() const;
 
 
  private:
    IProxyDict& m_pool;

    std::vector<DataProxy*> m_proxies;

    StoreMap m_storeMap;

    using KeyMap_t = ConcurrentSGKeyMap<DataProxy*>;
    KeyMap_t m_keyMap;
 
    StoreID::type m_storeID;
 
    // Map to hold the relation between transient and persistent object:
    // we have changed to DataProxy as it is faster while recording
    // to check if it already exists
    T2pMap  m_t2p;
 
    void setSGAudSvc();
    SmartIF<ISGAudSvc> m_pSGAudSvc;
    bool m_noAudSvc;
    inline bool doAudit() {
      if (!m_noAudSvc) setSGAudSvc();
      return (m_pSGAudSvc);
    }
 
    ISvcLocator* m_pSvcLoc;
    StatusCode setSvcLoc();
 

    DataProxy* findDummy (CLID id, const std::string& key);
 

    StatusCode removeFromKeyMap (DataProxy* proxy);
 

    StatusCode
    removeProxyImpl (DataProxy* proxy, int index);
  };

  inline void
  DataStore::t2pRemove(const void* const pTrans)
  {
    m_t2p.t2pRemove(pTrans);
  }

} //end namespace SG
 
 
#endif  // STOREGATE_DATASTORE