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


Classes

class  maci::MockManager
class  maci::ComponentListener
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
class  maci::ComponentStateManager
class  maci::ContainerServices
class  maci::BlockingComponentListener
class  maci::MACIComponentStateManager
class  maci::ContainerImpl
struct  maci::ContainerImpl::ContainerComponentInfo
 Structure to hold components information. More...
class  maci::MACIContainerServices
class  maci::ContainerThreadHook
 Container Thread Start-up hook. More...
class  maci::HeartbeatHandler
class  maci::HeartbeatInitializationHandler
class  maci::HeartbeatController
class  maci::MACIHelper
class  maci::LibraryManager
struct  maci::LibraryManager::LibraryInfo
 Structure to store data about loaded libraries. More...
class  maci::ORBTask
class  maci::MACIServantManager
class  maci::ComponentSmartPtr< T, H >
class  maci::SimpleClient
class  maci::SimpleClientThreadHook
 Simple Client Thread Start-up hook. More...

Typedefs

typedef PortableServer::Servant(* ConstructComponentFunc )(maci::Handle h, const char *name, const char *type, ContainerServices *containerServices)

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)

Typedef Documentation

typedef PortableServer::Servant(* maci::ConstructComponentFunc)(maci::Handle h, const char *name, const char *type, ContainerServices *containerServices)
 

Each DLL is expected to export a function with public name "ConstructComponentFunc", returning a pointer of a created servant.

Parameters:
h handle of the component
poa reference of the poa activating components
name name of the component
type type of the component
Returns:
newly created servant

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:37:29 2009 for ACS C++ API by doxygen 1.3.8