---

SmartIF.h

Go to the documentation of this file.

//====================================================================
//      SmartIF.h
//--------------------------------------------------------------------
//
//      Package    : Gaudi/Kernel (The LHCb Application Manager)
//
//  Description: Smart pointer class to handle interfaces
//
//      Author     : M.Frank
//  Created    : 30/10/98
//
//====================================================================
#ifndef GAUDI_SMARTIF_H
#define GAUDI_SMARTIF_H 1

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

// Forward declarations
template <class TYPE> class SmartIF;
template <> class SmartIF<IInterface>;
template <class TYPE> class SmartIFBase;

template <class TYPE> class SmartIFBase   {
protected:
  const IID   m_iid;
  TYPE*       m_interface;
  void releaseInterface()   {
    if ( m_interface ) m_interface->release();
    m_interface = 0;
  }
  SmartIFBase(const IID& iid)  :  m_iid(iid), m_interface(0)      {
  }
  virtual ~SmartIFBase()    {
    releaseInterface();
  }
public:
  bool isValid()   const   {
    return ( 0 != m_interface );
  }
  operator TYPE* ()   {
    return m_interface;
  }
  operator const TYPE* ()  const  {
    return m_interface;
  }
  bool operator !()   const   {
    return 0 == m_interface;
  }
  operator bool()   const   {
    return 0 != m_interface;
  }
  bool operator !=(const TYPE* test)   const   {
    return test != m_interface;
  }
  bool operator ==(const TYPE* test)   const   {
    return test == m_interface;
  }
  TYPE* operator->()    {
    return m_interface;
  }
  const TYPE* operator->()  const  {
    return m_interface;
  }
  void** operator & ()   {
    return (void**) &m_interface;
  }
};

template <class TYPE> class SmartIF : public SmartIFBase<TYPE>  {
public:
  SmartIF(const IID& iid, IInterface* iface) : SmartIFBase<TYPE>(iid)   {
    SmartIF<TYPE>::operator=(iface);
  }
  SmartIF(const IID& iid, TYPE* iface) : SmartIFBase<TYPE>(iid)    {
    SmartIF<TYPE>::operator=(iface);
  }
  SmartIF(const IID& iid) : SmartIFBase<TYPE>(iid)    {
  }
  SmartIF(TYPE* iface = 0) : SmartIFBase<TYPE>(IID_IInterface)    {
    SmartIF<TYPE>::operator=(iface);
  }
  SmartIF(SmartIF<TYPE>& copy) : SmartIFBase<TYPE>(copy.m_iid)  {
    SmartIF<TYPE>::operator=(copy.m_interface);
  }
  virtual ~SmartIF()    {
  }
  SmartIF& operator = (IInterface* iface)   {
    if ( iface != m_interface )   {
      TYPE* newIF = 0;
      if ( iface != 0 )   {
        iface->queryInterface(m_iid, (void**)&newIF);
      }
      releaseInterface();
      m_interface = newIF;
    }
    return *this;
  }
  SmartIFBase<TYPE>& operator = (TYPE* iface)   {
    if ( iface != m_interface )   {
      if ( iface != 0 )   {
        iface->addRef();
      }
      releaseInterface();
      m_interface = iface;
    }
    return *this;
  }
  template <class T> SmartIFBase<TYPE>& operator = (SmartIFBase<T>& iface)   {
    T* ptr = iface.operator->();
    if ( (void*)ptr != (void*)m_interface )   {
      TYPE* newIF = 0;
      if ( ptr != 0 )   {
        ptr->queryInterface(m_iid, (void**)&newIF);
      }
      releaseInterface();
      m_interface = newIF;
    }
    return *this;
  }
  SmartIFBase<TYPE>& operator = (SmartIFBase<TYPE>& iface)   {
    TYPE* newIF = iface.operator->();
    if ( (void*)newIF != (void*)m_interface )   {
      newIF->addRef();
      releaseInterface();
      m_interface = newIF;
    }
    return *this;
  }
  TYPE*& pRef() {
    return m_interface;
  }
  const TYPE* const & pRef() const  {
    return m_interface;
  }
};

template <> class SmartIF<IInterface> : public SmartIFBase<IInterface>  {
public:
  typedef IInterface TYPE;
  SmartIF(SmartIF<IInterface>& copy) 
  : SmartIFBase<IInterface>(copy.m_iid)
  {
    SmartIF<TYPE>::operator=(copy.m_interface);
  }
  SmartIF(IInterface* iface = 0) 
  : SmartIFBase<IInterface>(IID_IInterface)    
  {
    SmartIF<TYPE>::operator=(iface);
  }
  virtual ~SmartIF()    {
  }
  template <class T> SmartIFBase<TYPE>& operator = (SmartIFBase<T>& iface)   {
    T* ptr = iface.operator->();
    if ( (void*)ptr != (void*)m_interface )   {
      TYPE* newIF = 0;
      if ( ptr != 0 )   {
        ptr->queryInterface(m_iid, (void**)&newIF);
      }
      releaseInterface();
      m_interface = newIF;
    }
    return *this;
  }
  SmartIFBase<TYPE>& operator = (SmartIFBase<TYPE>& iface)   {
    TYPE* newIF = iface.operator->();
    if ( (void*)newIF != (void*)m_interface )   {
      newIF->addRef();
      releaseInterface();
      m_interface = newIF;
    }
    return *this;
  }
  SmartIFBase<TYPE>& operator = (TYPE* iface)   {
    if ( iface != m_interface )   {
      if ( iface != 0 )   {
        iface->addRef();
      }
      releaseInterface();
      m_interface = iface;
    }
    return *this;
  }
  IInterface* & pRef() {
    return m_interface;
  }
  const IInterface* const & pRef() const  {
    return m_interface;
  }
};

#endif // GAUDI_SMARTIF_H

---