SmartIF.h

Go to the documentation of this file.

#ifndef GAUDI_SMARTIF_H
#define GAUDI_SMARTIF_H 1

// Framework include files
#include "GaudiKernel/IInterface.h"

template <class TYPE> class SmartIF {
private:
  TYPE* m_interface = nullptr;
public:
  // ---------- Construction and destruction ----------
  inline SmartIF() = default;
  inline SmartIF(TYPE* ptr): m_interface(ptr) {
    if (m_interface) m_interface->addRef();
  }
  template <class OTHER>
  inline SmartIF(OTHER* ptr) {
    if (ptr) reset(ptr);
  }
  inline SmartIF(const SmartIF& rhs): m_interface(rhs.get()) {
    if (m_interface) m_interface->addRef();
  }
  inline SmartIF(SmartIF&& rhs) : m_interface( rhs.m_interface ){
     rhs.m_interface = nullptr;
  }
  inline SmartIF& operator=(SmartIF&& rhs) {
    if (m_interface) m_interface->release();
    m_interface = rhs.m_interface;
    rhs.m_interface = nullptr;
    return *this;
  }

  template <class T>
  inline explicit SmartIF(const SmartIF<T>& rhs) {
    reset(rhs.get());
  }
  inline ~SmartIF() { reset(); }

  // ---------- Boolean and comparison methods ----------
  inline bool isValid() const { return m_interface != nullptr; }

  inline explicit operator bool() const { return isValid(); }
  inline bool operator!() const { return !isValid(); }

  // ---------- Pointer access methods ----------
  inline operator TYPE* () const { return m_interface; }
  inline TYPE* operator->() const { return m_interface; }
  inline TYPE& operator *() const { return *m_interface; }
  inline TYPE* get() const { return m_interface; }
#if !defined(GAUDI_V22_API) && !defined(NEW_SMARTIF)
  inline TYPE*& pRef() {
    return m_interface;
  }
#endif

  // ---------- Cast methods ----------
  inline void reset(TYPE* ptr = nullptr) {
    if (ptr == m_interface) return;
    if (m_interface) m_interface->release();
    m_interface = ptr;
    if (m_interface) m_interface->addRef();
  }
  template <class OTHER>
  inline void reset(OTHER* ptr) {
    if (static_cast<IInterface*>(ptr) == static_cast<IInterface*>(m_interface)) return;
    if (m_interface) m_interface->release();
    if (ptr) {
      ptr->queryInterface(TYPE::interfaceID(), pp_cast<void>(&m_interface)).ignore();
    } else {
      m_interface = nullptr;
    }
  }


  template <typename IFace>
  SmartIF<IFace> as() const {
      return SmartIF<IFace>{ *this };
  }

  // ---------- Special hacks ----------
  inline SmartIF& operator = (IInterface* ptr) {
    reset(ptr);
    return *this;
  }
  inline SmartIF& operator = (const SmartIF& rhs) {
    reset(rhs.get());
    return *this;
  }
  template <class T>
  inline SmartIF& operator = (const SmartIF<T>& rhs) {
    reset(rhs.get());
    return *this;
  }
};

// helper function to turn a pointer to an interface into
// the corresponding SmartIF -- this avoids having to type
// the typename twice, and thus insures consistency
template <typename IFace>
SmartIF<IFace> make_SmartIF( IFace* iface)
{ return SmartIF<IFace>{ iface }; }

#endif // GAUDI_SMARTIF_H