maci Namespace Reference

Classes
class	MockManager
class	ComponentListener
class	ComponentStorage
class	SmartPtr
class	ComponentStateManager
class	ContainerServices
class	MockContainerServices
class	BlockingComponentListener
class	MACIComponentStateManager
class	MethodRequestThreadPool
class	ContainerImpl
class	MyCBlongImpl
class	ComponentReleaseCallback
class	MACIContainerServices
class	ContainerThreadHook
	Container Thread Start-up hook. More...
class	HeartbeatHandler
class	HeartbeatInitializationHandler
class	HeartbeatController
class	MACIHelper
class	LibraryManager
class	ORBTask
class	MACIServantManager
class	ComponentSmartPtr
class	SimpleClient
class	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 maci::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 maci::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 maci::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 maci::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 maci::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 maci::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 CNP1, typename U >

bool maci::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 maci::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 maci::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 maci::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 maci::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 maci::operator>=	(	const SmartPtr< T, H, OP, CP, KP, SP, CNP > &	lhs,
		U *	rhs
	)			[inline]

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