AnaToolHandle.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/

 
 
 
#ifndef ASG_TOOLS__ANA_TOOL_HANDLE_H
#define ASG_TOOLS__ANA_TOOL_HANDLE_H
 
// Author: Will Buttinger
 
 
#include <AsgTools/AsgTool.h>
#include <AsgTools/AsgToolConfig.h>
#include <AsgTools/ToolHandle.h>
#include <type_traits>
#include <atomic>
#include <list>
#include <map>
#include <mutex>
 
namespace asg
{
#ifdef XAOD_STANDALONE
   typedef INamedInterface parentType_t;
   typedef IAsgTool interfaceType_t;
#else
   typedef INamedInterface parentType_t;
   typedef IAlgTool interfaceType_t;
#endif
 
  template<class T> class AnaToolHandle;
 
  namespace detail
  {
    class AnaToolShare;
 
 

 
    enum class AnaToolHandleMode
    {
      EMPTY,

      CREATE_PRIVATE,

      CREATE_SHARED,

      RETRIEVE_SHARED,

      USER
    };
  }
 
 

  template <typename T>
  std::ostream& operator << (std::ostream& str, const AnaToolHandle<T>& obj);
 

 
  template<class T>
  class AnaToolHandle final
  {
    //
    // public interface
    //

  public:
    void testInvariant () const;
 

  public:
    explicit AnaToolHandle (const std::string& val_name = "",
                parentType_t *val_parent = nullptr);
 

  public:
    AnaToolHandle (AnaToolHandle<T>&& that);
 

  public:
    AnaToolHandle (const AnaToolHandle<T>& that);
 

  public:
    ~AnaToolHandle () noexcept;
 

  public:
    AnaToolHandle& operator = (const AnaToolHandle<T>& that);
 

  public:
    AnaToolHandle<T>& operator = (AnaToolHandle<T>&& that);
 

  public:
    void swap (AnaToolHandle<T>& that) noexcept;
 

  public:
    bool empty () const;

  public:
    bool isPublic () const noexcept;

  public:
    bool isInitialized () const noexcept;
 

  public:
    template<typename T2> void
    declarePropertyFor (T2 *tool, const std::string& name,
            const std::string& description = "");

  public:
    const ToolHandle<T>& getHandle () const noexcept;
 

  public:
    // ToolHandle and ToolHandleArray have ctors that can accept a single int,
    // so use enable_if to avoid ambiguities.
    template <class T2> StatusCode
    setProperty (const std::string& property, const T2& value);
    template <class T2>
    typename std::enable_if<std::is_base_of_v<parentType_t, T2>, StatusCode>::type
    setProperty (const std::string& property, const ToolHandle<T2>& value);
    template <class T2> StatusCode
    setProperty (const std::string& property, const AnaToolHandle<T2>& value);
    template <class T2>
    typename std::enable_if<std::is_base_of_v<parentType_t, T2>, StatusCode>::type
    setProperty (const std::string& property, const ToolHandleArray<T2>& value);
 

  public:
    const std::string& type () const noexcept;

  public:
    void setType (std::string val_type) noexcept;
 

  public:
    const std::string& name () const noexcept;

  public:
    void setName (std::string val_name) noexcept;

  public:
    std::string fullName () const;
 

  public:
    std::string typeAndName () const;

  public:
    void setTypeAndName (const std::string& val_typeAndName);

  public:
    void setTypeAndName (std::string val_type, std::string val_name) noexcept;
 

  public:
    StatusCode initialize ();

  public:
    StatusCode retrieve ();
 

  public:
    T *operator -> ();

  public:
    const T *operator -> () const;

  public:
    T& operator * ();

  public:
    const T& operator * () const;

  public:
    T *get ();

  public:
    const T *get () const;
 

  public:
    bool isUserConfigured () const;
 

  public:
    detail::AnaToolHandleMode mode () const;
 

  public:
    const AsgToolConfig& config () const;
 

  public:
    bool allowEmpty () const noexcept;
 
 

  public:
    void setAllowEmpty (bool val_allowEmpty = true) noexcept;
 
 
 
    //
    // deprecated interface
    //

  public:
    bool isConfigurable () const;
 
  public:
    [[deprecated("please use isInitialized() instead")]]
    bool inPremakeState () const noexcept {
      return !isInitialized();}
 
  public:
    [[deprecated("please use isInitialized() instead")]]
    bool inBrokenState () const noexcept {
      return false;};
 
  public:
    [[deprecated("no longer need to call make()")]]
    StatusCode make () {
      return StatusCode::SUCCESS;};
 
  public:
    [[deprecated("please use setType() or setTypeAndName() instead")]]
    StatusCode make (const std::string& val_type) noexcept {
      if (!val_type.empty()) {
    if (val_type.find ('/') != std::string::npos)
      setTypeAndName (val_type);
    else
      setType (val_type); }
      return StatusCode::SUCCESS; };
 
 
 
    //
    // private interface
    //

  private:
    std::vector<std::function<StatusCode ()>> m_extraInit;

  private:
    std::shared_ptr<void> m_cleanup;

  private:
    AsgToolConfig m_config;

  private:
    std::string m_name;

  private:
    parentType_t *m_parentPtr = nullptr;
 

  private:
    std::shared_ptr<ToolHandle<T>> m_handleUser;

  private:
    std::string m_originalTypeAndName;

  private:
    std::atomic<bool> m_isInitialized {false};

  private:
    std::atomic<T*> m_toolPtr = nullptr;

  private:
    detail::AnaToolHandleMode m_mode = detail::AnaToolHandleMode::EMPTY;

  private:
    detail::AnaToolHandleMode
    getMode (std::shared_ptr<detail::AnaToolShare>& sharedTool) const;

  private:
    detail::AnaToolHandleMode
    getMode () const;
 

  private:
    bool m_allowEmpty = false;
 

  private:
    StatusCode makeToolRetrieve
      (T*& toolPtr, ToolHandle<T>& toolHandle) const;
 

  private:
    std::recursive_mutex m_initializeMutex;
  };
}

#define ASG_MAKE_ANA_TOOL(handle,type)  \
  (ASG_SET_ANA_TOOL_TYPE(handle,type), StatusCode (StatusCode::SUCCESS))

#define ASG_SET_ANA_TOOL_TYPE(handle,type)  \
  (handle).setType (#type)
 
#include <AsgTools/AnaToolHandle.icc>
 
 
#endif