StoreGate/StoreGate/VarHandleBase.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_SG_VARHANDLEBASE_H
#define STOREGATE_SG_VARHANDLEBASE_H 1
 
// STL includes
#include <string>
 
#include "StoreGate/VarHandleKey.h"
 
// fwk includes
#include "AthenaKernel/IProxyDict.h"
#include "AthenaKernel/IResetable.h"
#include "AthenaKernel/StoreID.h"
#include "AthenaKernel/StorableConversions.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/EventContext.h"
 
// SGTools includes
#include "SGTools/DataProxy.h"
#include "SGTools/ProxyMap.h"
#include "SGTools/BuiltinsClids.h"
#include "SGTools/StlVectorClids.h"
#include "SGTools/StlMapClids.h"
 
namespace SGTest {
  class TestStore;
}
namespace Athena_test {
  void varHandleTest(SGTest::TestStore&);
  void resetableTest(void);
  void refCountTest(void);
}
namespace SG {
  static constexpr bool defaultQuiet = false;
 

  class VarHandleBase : public IResetable
  {
    // For testing.
    friend void Athena_test::varHandleTest(SGTest::TestStore&);
    friend void Athena_test::resetableTest(void);
    friend void Athena_test::refCountTest(void);
 
  public: 
    explicit VarHandleBase(CLID clid, Gaudi::DataHandle::Mode mode);
 

    explicit VarHandleBase(CLID clid,
                           const std::string& sgkey,
                           Gaudi::DataHandle::Mode mode,
                           const std::string& storename,
                           const EventContext* ctx);
 

    explicit VarHandleBase(CLID clid,
                           const std::string& sgkey,
                           Gaudi::DataHandle::Mode mode,
                           IProxyDict* sg);
 

    explicit VarHandleBase (const VarHandleKey& key, const EventContext* ctx);
 

    explicit VarHandleBase (SG::DataProxy* proxy,
                            Gaudi::DataHandle::Mode mode);
 

    VarHandleBase( const VarHandleBase& rhs );
 

    VarHandleBase( VarHandleBase&& rhs ) noexcept;
 

    VarHandleBase& operator=( const VarHandleBase& rhs ); 
 

    VarHandleBase& operator=( VarHandleBase&& rhs ) noexcept; 
 

    virtual ~VarHandleBase() override;
 
 
    //*************************************************************************
    // Accessors
    //
 

    virtual const std::string& key() const override final;
 

    const std::string& name() const ;
 

    std::string store() const;
 
 
    //*************************************************************************
    // Validity checking.
    //
 

    virtual bool isValid() = 0;
 

    bool isPresent() const;
 

    bool isInitialized() const;
 

    virtual bool isSet() const override final;
 

    bool isConst() const;
 

    StatusCode initialize (bool used = true);
 

    StatusCode setState();
 
 
    //*************************************************************************
    // State setting.
    //
 
  
    virtual StatusCode setProxyDict (IProxyDict* store);
 

    virtual void reset (bool hard) override;
 

    virtual void finalReset() override final;
 

    StatusCode setConst();
 
 
    //*************************************************************************
    // @c VarHandleKey methods.
    //
 

    CLID clid() const;
 

    const ServiceHandle<IProxyDict>& storeHandle() const;
 

    Gaudi::DataHandle::Mode mode() const;
 

    const std::string& objKey() const;
 

    const DataObjID& fullKey() const;
 

    SG::VarHandleKey& vhKey();
 

    StatusCode assign (const std::string& sgkey);
 

    std::string toString() const;
 
    
  protected: 
    //*************************************************************************
    // Protected methods.
    //
 

    StatusCode setState(SG::DataProxy* proxy);
 

    StatusCode setState(IProxyDict* store, const std::string& name);
 

    StatusCode record_impl (std::unique_ptr<DataObject> dobj,
                            void* dataPtr,
                            bool allowMods,
                            bool returnExisting);
 

    const void* put_impl (const EventContext* ctx,
                          std::unique_ptr<DataObject> dobj,
                          const void* dataPtr,
                          bool allowMods,
                          bool returnExisting,
                          IProxyDict* & store) const;
 

    void* typeless_dataPointer_impl(bool quiet);
 

    void* typeless_dataPointer(bool quiet=defaultQuiet);
 

    const void* typeless_cptr();
 

    void* typeless_ptr(bool quiet=defaultQuiet);
 
 
    /*
     * @brief Retrieve an object from SG as a const pointer without caching.
     * @param ctx The event context, or nullptr to use the current context.
     * @param quiet If true, suppress failure messages.
     *
     * Like typeless_dataPointer_impl, except that we don't change
     * any members of the handle.
     */
    const void* get_impl (const EventContext* ctx,
                          bool quiet = defaultQuiet) const;
 

    StatusCode symLink_impl (CLID newClid, const std::string& newKey);
 

    bool isPresent_impl (const std::string& key) const;
 
 
    
  protected: 
    //*************************************************************************
    // Protected data.
    //

    void* m_ptr;

    SG::DataProxy* m_proxy;
  
    IProxyDict* m_store;

    bool m_storeWasSet;
 
 
  private:
    std::unique_ptr<VarHandleKey> m_ownedKey;

    const VarHandleKey* m_key;

    IProxyDict* storeFromHandle (const EventContext* ctx) const;
 

    bool setStoreFromHandle (const EventContext* ctx);
 

    void resetProxy();
 

    void setProxy (SG::DataProxy* proxy);
 

    void* 
    typeless_dataPointer_fromProxy (SG::DataProxy* proxy,
                                    bool quiet) const;
 
  }; 
 
 
  //*************************************************************************
  // Free functions.
  //
 

  std::ostream& operator<<( std::ostream& out, const VarHandleBase& o );
 

  bool operator==(const VarHandleBase& l, const VarHandleBase& r);
 

  bool operator!=(const VarHandleBase& l, const VarHandleBase& r);
 
 
} /* namespace SG */
 
 
namespace std {
 
// C++23 compatible formatter.
template <std::derived_from<SG::VarHandleBase> T>
struct formatter<T>
  : public formatter<string_view>
{
  template <class FmtContext>
  FmtContext::iterator format(const T& k, FmtContext& ctx) const;
};
 
} // namespace std
 
 
#include "StoreGate/VarHandleBase.icc"
 
 
#endif //> !STOREGATE_SG_VARHANDLEBASE_H