In This Package:

SmartIF.h

Go to the documentation of this file.

// $Id: SmartIF.h,v 1.10 2008/10/27 19:22:20 marcocle Exp $
#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 InterfaceID  m_iid;
  TYPE*              m_interface;
  void releaseInterface()   {
    if ( m_interface ) m_interface->release();
    m_interface = 0;
  }
  SmartIFBase(const InterfaceID& 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 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;
  }
  const TYPE* get() {
    return m_interface;
  }
  TYPE*& pRef() {
    return this->m_interface;
  }
  const TYPE* const & pRef() const  {
    return this->m_interface;
  }
  bool operator!() const { return !(this->isValid()) ; }
private:
  // disable copy
  SmartIFBase( const SmartIFBase& copy ); 
  // disable assignement
  SmartIFBase& operator=( const SmartIFBase& right ) ; 
};

template <class TYPE> class SmartIF : public SmartIFBase<TYPE>  {
public:
  SmartIF(const InterfaceID& iid, IInterface* iface) : SmartIFBase<TYPE>(iid)   {
    SmartIF<TYPE>::operator=(iface);
  }
  SmartIF(const InterfaceID& iid, TYPE* iface) : SmartIFBase<TYPE>(iid)    {
    SmartIF<TYPE>::operator=(iface);
  }
  SmartIF(const InterfaceID& iid) : SmartIFBase<TYPE>(iid)    {
  }
  SmartIF ( TYPE* iface ) : SmartIFBase<TYPE>(TYPE::interfaceID())    {
    SmartIF<TYPE>::operator=(iface);
  }
  SmartIF(IInterface* iface = 0) : SmartIFBase<TYPE>(TYPE::interfaceID())    {
    SmartIF<TYPE>::operator=(iface);
  }
  SmartIF( const SmartIF<TYPE>& copy) : SmartIFBase<TYPE>(copy.m_iid)  {
    SmartIF<TYPE>::operator=(copy.m_interface);
  }
  virtual ~SmartIF()    {
  }
  SmartIF<TYPE>& operator = (int /* iface = 0*/)   {
    this->releaseInterface();
    this->m_interface = 0;
    return *this;
  }
  template <class T>
  SmartIF<TYPE>& operator = ( const SmartIF<T>& iface )
  {
    T* ptr = iface.m_interface ;
    if ( (void*)ptr != (void*)this->m_interface )
    {
      TYPE* newIF = 0;
      if ( ptr != 0 )   {
        ptr->queryInterface(this->m_iid, pp_cast<void>(&newIF)).ignore();
      }
      this->releaseInterface();
      this->m_interface = newIF;
    }
    return *this;
  }
  SmartIF<TYPE>& operator = ( const SmartIF<TYPE>& iface)
  {
    TYPE* newIF = iface.m_interface ;
    return (*this)=newIF ;
  }
  SmartIF& operator = (IInterface* iface)
  {
    if ( iface != this->m_interface )
    {
      TYPE* newIF = 0;
      if ( iface != 0 )   {
        iface->queryInterface(this->m_iid, pp_cast<void>(&newIF)).ignore();
      }
      this->releaseInterface();
      this->m_interface = newIF;
    }
    return *this;
  }
  SmartIF<TYPE>& operator = (TYPE* iface)
  {
    if ( iface != this->m_interface )   {
      if ( iface != 0 )   {
        iface->addRef();
      }
      this->releaseInterface();
      this->m_interface = iface;
    }
    return *this;
  }
  bool operator!() const { return !(this->isValid()) ; }
};

template <> class SmartIF<IInterface> : public SmartIFBase<IInterface>  {
public:
  typedef IInterface TYPE;
  SmartIF( const 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);
  }
  template <class T>
  SmartIF( const SmartIF<T>& right )
    : SmartIFBase<IInterface>(IID_IInterface)
  {
    SmartIF<TYPE>::operator=(right.m_interface);
  }
  virtual ~SmartIF()    {
  }
  template <class T>
  SmartIF<TYPE>& operator = ( const SmartIF<T>& iface)
  {
    T* ptr = iface.m_interface ;
    if ( (void*)ptr != (void*)this->m_interface )   {
      TYPE* newIF = 0;
      if ( ptr != 0 )   {
        ptr->queryInterface(this->m_iid, (void**)&newIF).ignore();
      }
      this->releaseInterface();
      this->m_interface = newIF;
    }
    return *this;
  }
  SmartIF<TYPE>& operator = ( const SmartIF<TYPE>& iface)   {
    TYPE* newIF = iface.m_interface ;
    return (*this)=newIF ;
  }
  SmartIF<TYPE>& operator = (TYPE* iface)   {
    if ( iface != m_interface )   {
      if ( iface != 0 )   {
        iface->addRef();
      }
      releaseInterface();
      m_interface = iface;
    }
    return *this;
  }
  bool operator!() const { return !(this->isValid()) ; }
};

#endif // GAUDI_SMARTIF_H

---