| # Gaudi Framework, version v21r6 |

Home |  | Generated: 11 Nov 2009

# SmartIF< TYPE > Class Template Reference

`#include <GaudiKernel/SmartIF.h>`

Collaboration diagram for SmartIF< TYPE >:

[legend]

List of all members.

## Detailed Description

### template<class TYPE>
class SmartIF< TYPE >

Small smart pointer class with automatic reference counting for IInterface.

SmartIF simplifies the interaction with components in Gaudi by implementing an automatic reference counting and the casting (via IInterface::queryInterface).

Author:
  Markus Frank

  Sebastien Ponce

  Marco Clemencic

Definition at line 19 of file SmartIF.h.

## Public Member Functions
| SmartIF ()
| Default constructor.
| SmartIF (TYPE *ptr)
| Standard constructor from pointer.
template<class OTHER>
| SmartIF (OTHER *ptr)
| Standard constructor from any (IInterface-derived) pointer.
| SmartIF (const SmartIF &rhs)
| Copy constructor.
template<class T>
| SmartIF (const SmartIF< T > &rhs)
| Constructor from another SmartIF, with a different type.
| ~SmartIF ()
| Standard Destructor.
bool | isValid () const
| Allow for check if smart pointer is valid.
| operator TYPE * () const
| Automatic conversion to pointer.
TYPE * | operator-> () const
| Dereference operator.
TYPE & | operator* () const
| Dereference operator.
TYPE * | get () const
| Get interface pointer.
TYPE *& | pRef ()
| Get reference to the pointer.
void | reset (TYPE *ptr=0)
| Set the internal pointer to the passed one disposing of the old one.
template<class OTHER>
void | reset (OTHER *ptr)
| Set the internal pointer to the passed one disposing of the old one.
SmartIF & | operator= (IInterface *ptr)
| Assignment operator from IInterface pointer.
SmartIF & | operator= (const SmartIF &rhs)
| Assignment operator.
template<class T>
SmartIF & | operator= (const SmartIF< T > &rhs)
| Assignment operator from a different SmartIF.
## Private Attributes
TYPE * | m_interface
| Pointer to the instance.

## Constructor & Destructor Documentation

template<class TYPE>

SmartIF< TYPE >::SmartIF | ( |  | ) | `[inline]`

Default constructor.

Definition at line 26 of file SmartIF.h.

    00026 : m_interface(0) {}

template<class TYPE>

SmartIF< TYPE >::SmartIF | ( | TYPE * | ptr | ) | `[inline]`

Standard constructor from pointer.

Definition at line 28 of file SmartIF.h.

    00028                            : m_interface(ptr) {
    00029     if (m_interface) m_interface->addRef();
    00030   }

template<class TYPE>
template<class OTHER>

SmartIF< TYPE >::SmartIF | ( | OTHER * | ptr | ) | `[inline]`

Standard constructor from any (IInterface-derived) pointer.

Definition at line 33 of file SmartIF.h.

    00033                             : m_interface(0) {
    00034     if (ptr) reset(ptr);
    00035   }

template<class TYPE>

SmartIF< TYPE >::SmartIF | ( | const SmartIF< TYPE > & | rhs | ) | `[inline]`

Copy constructor.

Definition at line 37 of file SmartIF.h.

    00037                                     : m_interface(rhs.get()) {
    00038     if (m_interface) m_interface->addRef();
    00039   }

template<class TYPE>
template<class T>

SmartIF< TYPE >::SmartIF | ( | const SmartIF< T > & | rhs | ) | `[inline, explicit]`

Constructor from another SmartIF, with a different type.

Note:
  it cannot replace the copy constructor.

Definition at line 43 of file SmartIF.h.

    00043                                                 : m_interface(0) {
    00044     reset(rhs.get());
    00045   }

template<class TYPE>

SmartIF< TYPE >::~SmartIF | ( |  | ) | `[inline]`

Standard Destructor.

Definition at line 47 of file SmartIF.h.

    00047 { reset(); }

## Member Function Documentation

template<class TYPE>

bool SmartIF< TYPE >::isValid | ( |  | ) | const`[inline]`

Allow for check if smart pointer is valid.

Definition at line 51 of file SmartIF.h.

    00051 { return m_interface != 0; }

template<class TYPE>

SmartIF< TYPE >::operator TYPE * | ( |  | ) | const`[inline]`

Automatic conversion to pointer.

It is also used by the compiler for automatic conversion to boolean.

Definition at line 56 of file SmartIF.h.

    00056 { return m_interface; }

template<class TYPE>

TYPE* SmartIF< TYPE >::operator-> | ( |  | ) | const`[inline]`

Dereference operator.

Definition at line 58 of file SmartIF.h.

    00058 { return m_interface; }

template<class TYPE>

TYPE& SmartIF< TYPE >::operator* | ( |  | ) | const`[inline]`

Dereference operator.

Definition at line 60 of file SmartIF.h.

    00060 { return *m_interface; }

template<class TYPE>

TYPE* SmartIF< TYPE >::get | ( |  | ) | const`[inline]`

Get interface pointer.

Definition at line 62 of file SmartIF.h.

    00062 { return m_interface; }

template<class TYPE>

TYPE*& SmartIF< TYPE >::pRef | ( |  | ) | `[inline]`

Get reference to the pointer.

Definition at line 65 of file SmartIF.h.

    00065                        {
    00066     return m_interface;
    00067   }

template<class TYPE>

void SmartIF< TYPE >::reset | ( | TYPE * | ptr = `0` | ) | `[inline]`

Set the internal pointer to the passed one disposing of the old one.

Version for pointers of the same type of the managed ones (no call to queryInterface needed).

Definition at line 74 of file SmartIF.h.

    00074                                    {
    00075     if (ptr == m_interface) return;
    00076     if (m_interface) m_interface->release();
    00077     if (ptr) {
    00078       m_interface = ptr;
    00079       m_interface->addRef();
    00080     } else {
    00081       m_interface = 0;
    00082     }
    00083   }

template<class TYPE>
template<class OTHER>

void SmartIF< TYPE >::reset | ( | OTHER * | ptr | ) | `[inline]`

Set the internal pointer to the passed one disposing of the old one.

Version for pointers of types inheriting from IInterface.

Definition at line 87 of file SmartIF.h.

    00087                                 {
    00088     if (static_cast<IInterface*>(ptr) == static_cast<IInterface*>(m_interface)) return;
    00089     if (m_interface) m_interface->release();
    00090     if (ptr) {
    00091       ptr->queryInterface(TYPE::interfaceID(), pp_cast<void>(&m_interface)).ignore();
    00092     } else {
    00093       m_interface = 0;
    00094     }
    00095   }

template<class TYPE>

SmartIF& SmartIF< TYPE >::operator= | ( | IInterface * | ptr | ) | `[inline]`

Assignment operator from IInterface pointer.

It allows things like `SmartIF<T> x; x = 0;`

Definition at line 104 of file SmartIF.h.

    00104                                                {
    00105     reset(ptr);
    00106     return *this;
    00107   }

template<class TYPE>

SmartIF& SmartIF< TYPE >::operator= | ( | const SmartIF< TYPE > & | rhs | ) | `[inline]`

Assignment operator.

Definition at line 109 of file SmartIF.h.

    00109                                                   {
    00110     reset(rhs.get());
    00111     return *this;
    00112   }

template<class TYPE>
template<class T>

SmartIF& SmartIF< TYPE >::operator= | ( | const SmartIF< T > & | rhs | ) | `[inline]`

Assignment operator from a different SmartIF.

Note:
  it cannot replace the assignment operator.

Definition at line 116 of file SmartIF.h.

    00116                                                      {
    00117     reset(rhs.get());
    00118     return *this;
    00119   }

## Member Data Documentation

template<class TYPE>

TYPE* SmartIF< TYPE >::m_interface`[private]`

Pointer to the instance.

Definition at line 22 of file SmartIF.h.

The documentation for this class was generated from the following file:

- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r6/GaudiKernel/GaudiKernel/SmartIF.h