SmartIF.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 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.                                             *
\***********************************************************************************/
#pragma once
 
#include <GaudiKernel/IInterface.h>
#include <memory>

template <class TYPE>
class SmartIF {
private:
  TYPE* m_interface = nullptr;
 
public:
  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(); }
 
  template <class T>
  inline SmartIF( std::unique_ptr<T>&& rhs ) {
    reset( rhs.release() );
  }

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

  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; }
 
  // ---------- 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<const IInterface*>( ptr ) == static_cast<const IInterface*>( m_interface ) ) return;
    if ( m_interface ) m_interface->release();
    if ( ptr ) {
      m_interface = ptr->template cast<TYPE>();
      if ( m_interface ) m_interface->addRef();
    } 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 };
}