/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/AsgTools/AsgTools/AnaToolHandle.h

#ifndef ASG_TOOLS__ANA_TOOL_HANDLE_H
#define ASG_TOOLS__ANA_TOOL_HANDLE_H

//        Copyright Iowa State University 2014.
//                  Author: Nils Krumnack
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

// Please feel free to contact me (nils.erik.krumnack@cern.ch) for bug
// reports, feature suggestions, praise and complaints.


// Author: Will Buttinger


#include <AsgTools/AsgTool.h>
#include <AsgTools/Deprecated.h>
#include <AsgTools/ToolHandle.h>
#include <atomic>
#include <list>
#include <map>
#include <mutex>

namespace asg
{
#ifdef ROOTCORE
   typedef asg::AsgTool 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;


    class AnaToolCleanup
    {
      //
      // public interface
      //

    public:
      void swap (AnaToolCleanup& that);


    public:
      void addCleanup (AnaToolCleanup val_cleanup, bool post = true);

    public:
      void addCleanup (const std::shared_ptr<void>& val_cleanup,
               bool post = true);



      //
      // private interface
      //

    private:
      std::list<std::shared_ptr<void> > m_cleanup;
    };




    class AnaToolProperty
    {
      //
      // public interface
      //

    public:
      virtual ~AnaToolProperty () noexcept = default;

#ifdef ROOTCORE
    public:
      virtual StatusCode
      applyPropertyRootCore (AsgTool& tool, const std::string& name,
                 AnaToolCleanup& cleanup)
    const = 0;
#endif

#ifndef ROOTCORE
    public:
      virtual StatusCode
      applyPropertyAthena (const std::string& toolName,
               const std::string& name,
               AnaToolCleanup& cleanup)
    const = 0;
#endif
    };




    class AnaToolConfig
    {
      //
      // public interface
      //

    public:
      void swap (AnaToolConfig& that) noexcept;


    public:
      bool empty () const noexcept;


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

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

#ifdef ROOTCORE
    public:
      template<typename Type>
      void registerNew ();
#endif


    public:
      template<typename Type> StatusCode
      setProperty (const std::string& val_name, const Type& val_value);

    public:
      template<typename Type> StatusCode
      setProperty (const std::string& val_name,
           const AnaToolHandle<Type>& val_value);

#ifndef ROOTCORE
    public:
      template<typename Type> StatusCode
      setProperty (const std::string& val_name,
           const ToolHandle<Type>& val_value);

    public:
      template<typename Type> StatusCode
      setProperty (const std::string& val_name,
           const ToolHandleArray<Type>& val_value);
#endif


    public:
      StatusCode
      setProperty (const std::string& val_name,
           const char *val_value);


    public:
      void addProperty (const std::string& name,
            const std::shared_ptr<AnaToolProperty>& property);


    public:
      template<typename ToolType> StatusCode
      makeTool (const std::string& name,
                parentType_t *parent,
        ToolHandle<ToolType>& th,
        AnaToolCleanup& cleanup) const;


    public:
      StatusCode
      makeBaseTool (const std::string& name,
                    parentType_t *parent,
                    ToolHandle<interfaceType_t>& th,
                    AnaToolCleanup& cleanup) const;


#ifndef ROOTCORE
    public:
      StatusCode
      applyPropertiesAthena (const std::string& toolName,
                 AnaToolCleanup& cleanup) const;
#endif



      //
      // private interface
      //

    private:
      std::string m_type;

    private:
      std::function<StatusCode (AsgTool*&, const std::string&)> m_factory;

    private:
      std::map<std::string,std::shared_ptr<AnaToolProperty> > m_properties;


#ifdef ROOTCORE
    private:
      StatusCode
      makeToolRootCore (const std::string& toolName, IAsgTool*& toolPtr,
            detail::AnaToolCleanup& cleanup) const;
#endif


#ifdef ROOTCORE
    private:
      StatusCode
      allocateTool (AsgTool*& toolPtr, const std::string& toolName) const;
#endif
    };




    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:
    template <class T2> StatusCode
    setProperty (const std::string& property, const T2& value);


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

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

#ifdef ROOTCORE
  public:
    template<class T2>
    void setTypeRegisterNew (std::string val_type);
#endif


  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 noexcept;


  public:
    detail::AnaToolHandleMode mode () const;


  public:
    const detail::AnaToolConfig& config () const;


  public:
    bool allowEmpty () const noexcept;



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



    //
    // deprecated interface
    //

  public:
    bool isConfigurable () const;

  public:
    ASG_DEPRECATED ("please use isInitialized() instead")
    bool inPremakeState () const noexcept {
      return !isInitialized();}

  public:
    ASG_DEPRECATED ("please use isInitialized() instead")
    bool inBrokenState () const noexcept {
      return false;};

  public:
    ASG_DEPRECATED ("no longer need to call make()")
    StatusCode make () {
      return StatusCode::SUCCESS;};

  public:
    ASG_DEPRECATED ("please use setType() or setTypeAndName() instead")
    StatusCode make (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; };

  // public:
  //   ASG_DEPRECATED ("please use either getHandle() or declarePropertyFor() instead")
  //   ToolHandle<T>& handle () {
  //     return *m_handleUser;};

#ifdef ROOTCORE
  public:
    template<class T2>
    ASG_DEPRECATED ("please use setTypeRegisterNew() instead")
    StatusCode makeNew (std::string val_type) {
      setTypeRegisterNew<T2> (std::move (val_type));
      return StatusCode::SUCCESS;}
#endif



    //
    // private interface
    //

  private:
    detail::AnaToolCleanup m_cleanup;

  private:
    detail::AnaToolConfig m_config;

  private:
    std::string m_name;

  private:
    std::string m_parentName;

  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:
    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))

#ifdef ROOTCORE
#define ASG_SET_ANA_TOOL_TYPE(handle,type)  \
  (handle).template setTypeRegisterNew<type> (#type)
#else
#define ASG_SET_ANA_TOOL_TYPE(handle,type)  \
  (handle).setType (#type)
#endif

#include <AsgTools/AnaToolHandle.icc>


#endif

---