SmartIF.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2019 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#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