Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages

acsComponentSmartPtr.h File Reference

#include <logging.h>
#include <lokiThreads.h>
#include <lokiSmartPtr.h>
#include <maciErrType.h>

Include dependency graph for acsComponentSmartPtr.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Namespaces

namespace  maci
namespace  std

Classes

class  maci::ComponentStorage< T, H >
class  maci::SmartPtr< T, H, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >
struct  maci::SmartPtr< T, H, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >::Tester
struct  maci::SmartPtr< T, H, OwnershipPolicy, ConversionPolicy, CheckingPolicy, StoragePolicy, ConstnessPolicy >::Insipid
struct  std::less< maci::SmartPtr< T, H, OP, CP, KP, SP, CNP > >

Functions

template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP1, typename U> bool operator== (const SmartPtr< T, H, OP, CP, KP, SP, CNP1 > &lhs, U *rhs)
template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP1, typename U> bool operator== (U *lhs, const SmartPtr< T, H, OP, CP, KP, SP, CNP1 > &rhs)
template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U> bool operator!= (const SmartPtr< T, H, OP, CP, KP, SP, CNP > &lhs, U *rhs)
template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U> bool operator!= (U *lhs, const SmartPtr< T, H, OP, CP, KP, SP, CNP > &rhs)
template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U> bool operator< (const SmartPtr< T, H, OP, CP, KP, SP, CNP > &lhs, U *rhs)
template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U> bool operator< (U *lhs, const SmartPtr< T, H, OP, CP, KP, SP, CNP > &rhs)
template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U> bool operator> (const SmartPtr< T, H, OP, CP, KP, SP, CNP > &lhs, U *rhs)
 //////////////////////////////////////////////////////////////////////////////
template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U> bool operator> (U *lhs, const SmartPtr< T, H, OP, CP, KP, SP, CNP > &rhs)
template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U> bool operator<= (const SmartPtr< T, H, OP, CP, KP, SP, CNP > &lhs, U *rhs)
template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U> bool operator<= (U *lhs, const SmartPtr< T, H, OP, CP, KP, SP, CNP > &rhs)
template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U> bool operator>= (const SmartPtr< T, H, OP, CP, KP, SP, CNP > &lhs, U *rhs)
template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U> bool operator>= (U *lhs, const SmartPtr< T, H, OP, CP, KP, SP, CNP > &rhs)


Function Documentation

template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U>
bool operator!= U *  lhs,
const SmartPtr< T, H, OP, CP, KP, SP, CNP > &  rhs
[inline]
 

operator!= for lhs = raw pointer, rhs = SmartPtr

template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U>
bool operator!= const SmartPtr< T, H, OP, CP, KP, SP, CNP > &  lhs,
U *  rhs
[inline]
 

operator!= for lhs = SmartPtr, rhs = raw pointer

template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U>
bool operator< U *  lhs,
const SmartPtr< T, H, OP, CP, KP, SP, CNP > &  rhs
[inline]
 

operator< for lhs = raw pointer, rhs = SmartPtr

template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U>
bool operator< const SmartPtr< T, H, OP, CP, KP, SP, CNP > &  lhs,
U *  rhs
[inline]
 

operator< for lhs = SmartPtr, rhs = raw pointer

template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U>
bool operator<= U *  lhs,
const SmartPtr< T, H, OP, CP, KP, SP, CNP > &  rhs
[inline]
 

operator<= for lhs = raw pointer, rhs = SmartPtr

template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U>
bool operator<= const SmartPtr< T, H, OP, CP, KP, SP, CNP > &  lhs,
U *  rhs
[inline]
 

operator<= for lhs = SmartPtr, rhs = raw pointer

template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP1, typename U>
bool operator== U *  lhs,
const SmartPtr< T, H, OP, CP, KP, SP, CNP1 > &  rhs
[inline]
 

operator== for lhs = raw pointer, rhs = SmartPtr

template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP1, typename U>
bool operator== const SmartPtr< T, H, OP, CP, KP, SP, CNP1 > &  lhs,
U *  rhs
[inline]
 

operator== for lhs = SmartPtr, rhs = raw pointer

template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U>
bool operator> U *  lhs,
const SmartPtr< T, H, OP, CP, KP, SP, CNP > &  rhs
[inline]
 

operator> for lhs = raw pointer, rhs = SmartPtr

template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U>
bool operator> const SmartPtr< T, H, OP, CP, KP, SP, CNP > &  lhs,
U *  rhs
[inline]
 

//////////////////////////////////////////////////////////////////////////////

template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U>
bool operator>= U *  lhs,
const SmartPtr< T, H, OP, CP, KP, SP, CNP > &  rhs
[inline]
 

operator>= for lhs = raw pointer, rhs = SmartPtr

template<typename T, typename H, template< class > class OP, class CP, template< class > class KP, template< class, class > class SP, template< class > class CNP, typename U>
bool operator>= const SmartPtr< T, H, OP, CP, KP, SP, CNP > &  lhs,
U *  rhs
[inline]
 

operator>= for lhs = SmartPtr, rhs = raw pointer


Generated on Thu Apr 30 02:31:02 2009 for ACS C++ API by doxygen 1.3.8