StoreGate/StoreGate/VarHandleKey.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef STOREGATE_VARHANDLEKEY_H
#define STOREGATE_VARHANDLEKEY_H
 
 
#include "AthenaKernel/IProxyDict.h"
#include "AthenaKernel/StoreID.h"
#include "GaudiKernel/DataHandle.h"
#include "GaudiKernel/ServiceHandle.h"
#include <format>
#include <concepts>
 
 
namespace SG {
 
 
enum AllowEmptyEnum {
  AllowEmpty = 1
};
 
 
class VarHandleBase;
class VarHandleKeyProperty;

class VarHandleKey
  : public Gaudi::DataHandle
{
public:
  constexpr static bool isDecorHandleKey = false;

  VarHandleKey (CLID clid,
                const std::string& sgkey,
                Gaudi::DataHandle::Mode a,
                const std::string& storeName = StoreID::storeName(StoreID::EVENT_STORE),
                bool isCond = false);
 

  using PropertyType = SG::VarHandleKeyProperty;
 

  VarHandleKey& operator= (const std::string& sgkey);
 

  virtual StatusCode assign (const std::string& sgkey);
 
  
  StatusCode initialize (bool used = true);
 

  StatusCode initialize (AllowEmptyEnum);
 

  CLID clid() const;
 

  const std::string& key() const;
 

  bool empty() const;
 

  const ServiceHandle<IProxyDict>& storeHandle() const;
 

  VarHandleBase* owningHandle();
 

  bool isEventStore() const;
 

  virtual StatusCode start();
 

  SG::sgkey_t hashedKey() const;
 
protected:
  virtual std::string pythonRepr() const override;
 
private:
  friend class VarHandleBase;
  void setOwningHandle (VarHandleBase* handle);
 

  virtual void setKey(DataObjID key) override final;
  virtual void updateKey(std::string key) override final;
 

  void parseKey (const std::string& sgkey, const std::string& storeName);
 

  void updateHandle (const std::string& name);

  ServiceHandle<IProxyDict> m_storeHandle;

  std::string m_sgKey;

  SG::sgkey_t m_hashedKey = 0;

  bool m_isEventStore = false;

  VarHandleBase* m_owningHandle = nullptr;
};
 
 
std::ostream& operator<<(std::ostream& s, const SG::VarHandleKey& m);
 
 
} // namespace SG
 
 
namespace std {
 
 
// C++23 compatible formatter.
template <std::derived_from<SG::VarHandleKey> T>
struct formatter<T>
  : public formatter<string_view>
{
  template <class FmtContext>
  FmtContext::iterator format(const T& k, FmtContext& ctx) const;
};
 
 
} // namespace std
 
 
#include "StoreGate/VarHandleKey.icc"
 
 
#endif // not STOREGATE_VARHANDLEKEY_H