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