Control/SGTools/SGTools/DataStore.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 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 "CxxUtils/ConcurrentMap.h"
#include "CxxUtils/SimpleUpdater.h"
#include "GaudiKernel/ClassID.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 : virtual 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 { 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);
    virtual DataProxy* proxy(const TransientAddress* tAddr) const; 
    virtual DataProxy* proxy(const CLID& id, 
                 const std::string& key=SG::DEFAULTKEY) const;
 
    SG::DataProxy* proxy_exact (sgkey_t sgkey) const;
 
    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;
 
    StatusCode removeProxy(DataProxy* proxy, bool forceRemove, bool hard);
 
    StatusCode addSymLink(const CLID& linkid, DataProxy* proxy);
 
    StatusCode addAlias(const std::string& aliasKey, DataProxy* proxy);
 
    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 = CxxUtils::ConcurrentMap<
      sgkey_t, DataProxy*,
      CxxUtils::SimpleUpdater,
      SGKeyHash, SGKeyEqual,
      0,
      static_cast<CxxUtils::detail::ConcurrentHashmapVal_t> (-1)>;
    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();
    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