TAO_PortableServer  2.0.8
Public Types | Public Member Functions | Static Public Member Functions | Private Attributes
PortableServer::Servant_var< T > Class Template Reference

Provides a type safe counted reference to servants. More...

#include <Servant_var.h>

List of all members.

Public Types

typedef T servant_type

Public Member Functions

 Servant_var (T *p=0)
 Constructor. Assumes ownership of p.
 Servant_var (Servant_var< T > const &rhs)
 Copy constructor. Adds reference to rhs.
Servant_var< T > & operator= (Servant_var< T > const &rhs)
 Assignment operator. Adds reference to rhs.
 ~Servant_var (void)
Servant_var< T > & operator= (T *p)
 Assignment operator. Assumes ownership of p.
T * operator-> () const
 Smart pointer operator-> provides access to the underlying object.
T const & operator* () const
 Dereference the underlying object.
T & operator* ()
 Dereference the underlying object.
 operator void const * () const
T * in () const
 As an IN parameter.
T *& inout ()
 As an INOUT parameter.
T *& out ()
 As an OUT parameter.
T * _retn ()
void swap (Servant_var< T > &rhs)

Static Public Member Functions

static T * _duplicate (T *)
 Increment the reference count and return the servant.

Private Attributes

T * ptr_

Detailed Description

template<class T>
class PortableServer::Servant_var< T >

Provides a type safe counted reference to servants.

Author:
Jody Hagins
Todo:
Life would be much easier if _add_ref() and _remove_ref() had throw specs of "throw ()", that can be hidden in static methods though.

Member Typedef Documentation

template<class T >
typedef T PortableServer::Servant_var< T >::servant_type

Constructor & Destructor Documentation

template<class T >
PortableServer::Servant_var< T >::Servant_var ( T *  p = 0)

Constructor. Assumes ownership of p.

template<class T >
PortableServer::Servant_var< T >::Servant_var ( Servant_var< T > const &  rhs)

Copy constructor. Adds reference to rhs.

template<class T >
PortableServer::Servant_var< T >::~Servant_var ( void  )

Destructor. Removes a reference from the underlying object, possibly destroying it. This destructor doesn't throw exceptions.


Member Function Documentation

template<class T >
T * PortableServer::Servant_var< T >::_duplicate ( T *  p) [static]

Increment the reference count and return the servant.

It is safe to pass in a null pointer, the pointer is simply returned in that case.

Todo:
We might want to catch all (potential) exceptions in _add_ref().
Todo:
It might be useful to add a _release() method that handles any potential exceptions...
template<class T >
T * PortableServer::Servant_var< T >::_retn ( void  )

Return a pointer to the underlying object, and this counted reference will no longer own the object.

template<class T >
T * PortableServer::Servant_var< T >::in ( void  ) const

As an IN parameter.

template<class T >
T *& PortableServer::Servant_var< T >::inout ( void  )

As an INOUT parameter.

template<class T >
PortableServer::Servant_var< T >::operator void const * ( ) const

Return a void pointer to the underlying object. This allows it to be used in conditional code and tested against 0.

template<class T >
T const & PortableServer::Servant_var< T >::operator* ( ) const

Dereference the underlying object.

template<class T >
T & PortableServer::Servant_var< T >::operator* ( )

Dereference the underlying object.

template<class T >
T * PortableServer::Servant_var< T >::operator-> ( ) const

Smart pointer operator-> provides access to the underlying object.

template<class T >
PortableServer::Servant_var< T > & PortableServer::Servant_var< T >::operator= ( Servant_var< T > const &  rhs)

Assignment operator. Adds reference to rhs.

template<class T >
PortableServer::Servant_var< T > & PortableServer::Servant_var< T >::operator= ( T *  p)

Assignment operator. Assumes ownership of p.

template<class T >
T *& PortableServer::Servant_var< T >::out ( void  )

As an OUT parameter.

template<class T >
void PortableServer::Servant_var< T >::swap ( Servant_var< T > &  rhs)

Swap the contents of a Servant_var<T> with another Servant_var<T> Non-throwing swap operation. Often used to implement strong exception safety.


Member Data Documentation

template<class T >
T* PortableServer::Servant_var< T >::ptr_ [private]

The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines