Ice Namespace Reference

Namespaces
namespace	Instrumentation

Classes
struct	ACM
	A collection of Active Connection Management configuration settings. More...
class	AdapterAlreadyActiveException
	This exception is raised if a server tries to set endpoints for an adapter that is already active. More...
class	AdapterNotFoundException
	This exception is raised if an adapter cannot be found. More...
class	AlreadyRegisteredException
	An attempt was made to register something more than once with the Ice run time. More...
class	AMD_Locator_findAdapterById
	AMD callback class for Ice::Locator::findAdapterById_async. More...
class	AMD_Locator_findObjectById
	AMD callback class for Ice::Locator::findObjectById_async. More...
class	AMD_LocatorRegistry_setAdapterDirectProxy
	AMD callback class for Ice::LocatorRegistry::setAdapterDirectProxy_async. More...
class	AMD_LocatorRegistry_setReplicatedAdapterDirectProxy
	AMD callback class for Ice::LocatorRegistry::setReplicatedAdapterDirectProxy_async. More...
class	AMD_LocatorRegistry_setServerProcessProxy
	AMD callback class for Ice::LocatorRegistry::setServerProcessProxy_async. More...
class	AMD_Object_ice_invoke
	Base class for the AMD callback for BlobjectAsync::ice_invoke_async. More...
class	AMDCallback
	Base class for generated AMD callback classes. More...
class	Application
	Singleton helper class that simplifies Ice initialization, finalization and signal handling. More...
class	AsyncResult
	Represents the result of an asynchronous invocation using the C++98 mapping. More...
class	BadMagicException
	This exception indicates that a message did not start with the expected magic number ('I', 'c', 'e', 'P'). More...
class	BatchRequest
	Represents an invocation on a proxy configured for batch-oneway or batch-datagram. More...
class	BatchRequestInterceptor
	The base class for a batch request interceptor. More...
class	Blobject
	Base class for dynamic dispatch servants. More...
class	BlobjectArray
	Base class for dynamic dispatch servants that uses the array mapping. More...
class	BlobjectArrayAsync
	Base class for asynchronous dynamic dispatch servants that uses the array mapping. More...
class	BlobjectAsync
	Base class for asynchronous dynamic dispatch servants. More...
class	Callback_Communicator_flushBatchRequests
	Type-safe asynchronous callback wrapper class used for calls to Ice::Communicator::begin_flushBatchRequests. More...
class	Callback_Communicator_flushBatchRequests_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::Communicator::begin_flushBatchRequests. More...
class	Callback_Connection_flushBatchRequests
	Type-safe asynchronous callback wrapper class used for calls to Ice::Connection::begin_flushBatchRequests. More...
class	Callback_Connection_flushBatchRequests_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::Connection::begin_flushBatchRequests. More...
class	Callback_Connection_heartbeat
	Type-safe asynchronous callback wrapper class used for calls to Ice::Connection::begin_heartbeat. More...
class	Callback_Connection_heartbeat_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::Connection::begin_heartbeat. More...
class	Callback_Locator_findAdapterById
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::Locator::begin_findAdapterById. More...
class	Callback_Locator_findAdapterById_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::Locator::begin_findAdapterById. More...
class	Callback_Locator_findObjectById
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::Locator::begin_findObjectById. More...
class	Callback_Locator_findObjectById_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::Locator::begin_findObjectById. More...
class	Callback_Locator_getRegistry
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::Locator::begin_getRegistry. More...
class	Callback_Locator_getRegistry_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::Locator::begin_getRegistry. More...
class	Callback_LocatorFinder_getLocator
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::LocatorFinder::begin_getLocator. More...
class	Callback_LocatorFinder_getLocator_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::LocatorFinder::begin_getLocator. More...
class	Callback_LocatorRegistry_setAdapterDirectProxy
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::LocatorRegistry::begin_setAdapterDirectProxy. More...
class	Callback_LocatorRegistry_setAdapterDirectProxy_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::LocatorRegistry::begin_setAdapterDirectProxy. More...
class	Callback_LocatorRegistry_setReplicatedAdapterDirectProxy
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::LocatorRegistry::begin_setReplicatedAdapterDirectProxy. More...
class	Callback_LocatorRegistry_setReplicatedAdapterDirectProxy_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::LocatorRegistry::begin_setReplicatedAdapterDirectProxy. More...
class	Callback_LocatorRegistry_setServerProcessProxy
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::LocatorRegistry::begin_setServerProcessProxy. More...
class	Callback_LocatorRegistry_setServerProcessProxy_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::LocatorRegistry::begin_setServerProcessProxy. More...
class	Callback_LoggerAdmin_attachRemoteLogger
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger. More...
class	Callback_LoggerAdmin_attachRemoteLogger_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger. More...
class	Callback_LoggerAdmin_detachRemoteLogger
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::LoggerAdmin::begin_detachRemoteLogger. More...
class	Callback_LoggerAdmin_detachRemoteLogger_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::LoggerAdmin::begin_detachRemoteLogger. More...
class	Callback_LoggerAdmin_getLog
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::LoggerAdmin::begin_getLog. More...
class	Callback_LoggerAdmin_getLog_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::LoggerAdmin::begin_getLog. More...
class	Callback_Object_ice_flushBatchRequests
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::Object::begin_ice_flushBatchRequests. More...
class	Callback_Object_ice_flushBatchRequests_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::Object::begin_ice_flushBatchRequests. More...
class	Callback_Object_ice_getConnection
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::Object::begin_ice_getConnection. More...
class	Callback_Object_ice_getConnection_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::Object::begin_ice_getConnection. More...
class	Callback_Object_ice_id
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::Object::begin_ice_id. More...
class	Callback_Object_ice_id_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::Object::begin_ice_id. More...
class	Callback_Object_ice_ids
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::Object::begin_ice_ids. More...
class	Callback_Object_ice_ids_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::Object::begin_ice_ids. More...
class	Callback_Object_ice_invoke
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::Object::begin_ice_invoke. More...
class	Callback_Object_ice_invoke_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::Object::begin_ice_invoke. More...
class	Callback_Object_ice_isA
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::Object::begin_ice_isA. More...
class	Callback_Object_ice_isA_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::Object::begin_ice_isA. More...
class	Callback_Object_ice_ping
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::Object::begin_ice_ping. More...
class	Callback_Object_ice_ping_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::Object::begin_ice_ping. More...
class	Callback_Process_shutdown
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::Process::begin_shutdown. More...
class	Callback_Process_shutdown_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::Process::begin_shutdown. More...
class	Callback_Process_writeMessage
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::Process::begin_writeMessage. More...
class	Callback_Process_writeMessage_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::Process::begin_writeMessage. More...
class	Callback_PropertiesAdmin_getPropertiesForPrefix
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::PropertiesAdmin::begin_getPropertiesForPrefix. More...
class	Callback_PropertiesAdmin_getPropertiesForPrefix_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::PropertiesAdmin::begin_getPropertiesForPrefix. More...
class	Callback_PropertiesAdmin_getProperty
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::PropertiesAdmin::begin_getProperty. More...
class	Callback_PropertiesAdmin_getProperty_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::PropertiesAdmin::begin_getProperty. More...
class	Callback_PropertiesAdmin_setProperties
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::PropertiesAdmin::begin_setProperties. More...
class	Callback_PropertiesAdmin_setProperties_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::PropertiesAdmin::begin_setProperties. More...
class	Callback_RemoteLogger_init
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::RemoteLogger::begin_init. More...
class	Callback_RemoteLogger_init_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::RemoteLogger::begin_init. More...
class	Callback_RemoteLogger_log
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::RemoteLogger::begin_log. More...
class	Callback_RemoteLogger_log_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::RemoteLogger::begin_log. More...
class	Callback_Router_addProxies
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::Router::begin_addProxies. More...
class	Callback_Router_addProxies_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::Router::begin_addProxies. More...
class	Callback_Router_getClientProxy
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::Router::begin_getClientProxy. More...
class	Callback_Router_getClientProxy_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::Router::begin_getClientProxy. More...
class	Callback_Router_getServerProxy
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::Router::begin_getServerProxy. More...
class	Callback_Router_getServerProxy_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::Router::begin_getServerProxy. More...
class	Callback_RouterFinder_getRouter
	Type-safe asynchronous callback wrapper class with cookie support used for calls to IceProxy::Ice::RouterFinder::begin_getRouter. More...
class	Callback_RouterFinder_getRouter_Base
	Base class for asynchronous callback wrapper classes used for calls to IceProxy::Ice::RouterFinder::begin_getRouter. More...
class	CallbackNC_Communicator_flushBatchRequests
	Type-safe asynchronous callback wrapper class used for calls to Ice::Communicator::begin_flushBatchRequests. More...
class	CallbackNC_Connection_flushBatchRequests
	Type-safe asynchronous callback wrapper class used for calls to Ice::Connection::begin_flushBatchRequests. More...
class	CallbackNC_Connection_heartbeat
	Type-safe asynchronous callback wrapper class used for calls to Ice::Connection::begin_heartbeat. More...
class	CallbackNC_Locator_findAdapterById
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::Locator::begin_findAdapterById. More...
class	CallbackNC_Locator_findObjectById
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::Locator::begin_findObjectById. More...
class	CallbackNC_Locator_getRegistry
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::Locator::begin_getRegistry. More...
class	CallbackNC_LocatorFinder_getLocator
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::LocatorFinder::begin_getLocator. More...
class	CallbackNC_LocatorRegistry_setAdapterDirectProxy
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::LocatorRegistry::begin_setAdapterDirectProxy. More...
class	CallbackNC_LocatorRegistry_setReplicatedAdapterDirectProxy
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::LocatorRegistry::begin_setReplicatedAdapterDirectProxy. More...
class	CallbackNC_LocatorRegistry_setServerProcessProxy
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::LocatorRegistry::begin_setServerProcessProxy. More...
class	CallbackNC_LoggerAdmin_attachRemoteLogger
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger. More...
class	CallbackNC_LoggerAdmin_detachRemoteLogger
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::LoggerAdmin::begin_detachRemoteLogger. More...
class	CallbackNC_LoggerAdmin_getLog
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::LoggerAdmin::begin_getLog. More...
class	CallbackNC_Object_ice_flushBatchRequests
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::Object::begin_ice_flushBatchRequests. More...
class	CallbackNC_Object_ice_getConnection
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::Object::begin_ice_getConnection. More...
class	CallbackNC_Object_ice_id
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::Object::begin_ice_id. More...
class	CallbackNC_Object_ice_ids
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::Object::begin_ice_ids. More...
class	CallbackNC_Object_ice_invoke
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::Object::begin_ice_invoke. More...
class	CallbackNC_Object_ice_isA
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::Object::begin_ice_isA. More...
class	CallbackNC_Object_ice_ping
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::Object::begin_ice_ping. More...
class	CallbackNC_Process_shutdown
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::Process::begin_shutdown. More...
class	CallbackNC_Process_writeMessage
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::Process::begin_writeMessage. More...
class	CallbackNC_PropertiesAdmin_getPropertiesForPrefix
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::PropertiesAdmin::begin_getPropertiesForPrefix. More...
class	CallbackNC_PropertiesAdmin_getProperty
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::PropertiesAdmin::begin_getProperty. More...
class	CallbackNC_PropertiesAdmin_setProperties
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::PropertiesAdmin::begin_setProperties. More...
class	CallbackNC_RemoteLogger_init
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::RemoteLogger::begin_init. More...
class	CallbackNC_RemoteLogger_log
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::RemoteLogger::begin_log. More...
class	CallbackNC_Router_addProxies
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::Router::begin_addProxies. More...
class	CallbackNC_Router_getClientProxy
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::Router::begin_getClientProxy. More...
class	CallbackNC_Router_getServerProxy
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::Router::begin_getServerProxy. More...
class	CallbackNC_RouterFinder_getRouter
	Type-safe asynchronous callback wrapper class used for calls to IceProxy::Ice::RouterFinder::begin_getRouter. More...
class	CFNetworkException
	This exception indicates CFNetwork errors. More...
class	CloneNotImplementedException
	An attempt was made to clone a class that does not support cloning. More...
class	CloseCallback
	An application can implement this interface to receive notifications when a connection closes. More...
class	CloseConnectionException
	This exception indicates that the connection has been gracefully shut down by the server. More...
class	CloseTimeoutException
	This exception indicates a connection closure timeout condition. More...
class	CollocationOptimizationException
	This exception is raised if a feature is requested that is not supported with collocation optimization. More...
class	Communicator
	The central object in Ice. More...
class	CommunicatorDestroyedException
	This exception is raised if the Communicator has been destroyed. More...
class	CommunicatorHolder
	A helper class that uses Resource Acquisition Is Initialization (RAII) to initialize and hold a communicator instance, and automatically destroy the communicator when the holder goes out of scope. More...
class	CompactIdResolver
	The base class for a compact ID resolver. More...
class	CompressionException
	This exception indicates a problem with compressing or uncompressing data. More...
class	ConnectFailedException
	This exception indicates connection failures. More...
class	Connection
	The user-level interface to a connection. More...
class	ConnectionInfo
	Base class providing access to the connection details. More...
class	ConnectionLostException
	This exception indicates a lost connection. More...
class	ConnectionManuallyClosedException
	This exception is raised by an operation call if the application closes the connection locally using Connection#close. More...
class	ConnectionNotValidatedException
	This exception is raised if a message is received over a connection that is not yet validated. More...
class	ConnectionRefusedException
	This exception indicates a connection failure for which the server host actively refuses a connection. More...
class	ConnectionTimeoutException
	This exception indicates that a connection has been shut down because it has been idle for some time. More...
class	ConnectTimeoutException
	This exception indicates a connection establishment timeout condition. More...
class	CtrlCHandler
	Provides a portable way to handle Ctrl-C and Ctrl-C like signals. More...
struct	Current
	Information about the current method invocation for servers. More...
class	DatagramLimitException
	A datagram exceeds the configured size. More...
class	Dispatcher
	Base class for a dispatcher. More...
class	DispatcherCall
	Encapsulates all the details of a request dispatch or AMI callback. More...
class	DispatchInterceptor
	Base class for a dispatch interceptor, which is a servant that dispatches requests to another servant. More...
class	DispatchInterceptorAsyncCallback
	Abstract callback class for an asynchronous dispatch interceptor. More...
class	DNSException
	This exception indicates a DNS problem. More...
class	EncapsulationException
	This exception indicates a malformed data encapsulation. More...
struct	EncodingVersion
	A version structure for the encoding version. More...
class	Endpoint
	The user-level interface to an endpoint. More...
class	EndpointInfo
	Base class providing access to the endpoint details. More...
class	EndpointParseException
	This exception is raised if there was an error while parsing an endpoint. More...
class	EndpointSelectionTypeParseException
	This exception is raised if there was an error while parsing an endpoint selection type. More...
class	FacetNotExistException
	This exception is raised if no facet with the given name exists, but at least one facet with the given identity exists. More...
class	FeatureNotSupportedException
	This exception is raised if an unsupported feature is used. More...
class	FileException
	This exception indicates file errors. More...
class	FixedProxyException
	This exception indicates that an attempt has been made to change the connection properties of a fixed proxy. More...
class	HeartbeatCallback
	An application can implement this interface to receive notifications when a connection receives a heartbeat message. More...
class	IconvInitializationException
	Indicates that Iconv does not support the code. More...
struct	Identity
	The identity of an Ice object. More...
class	IdentityParseException
	This exception is raised if there was an error while parsing a stringified identity. More...
class	IllegalIdentityException
	This exception is raised if an illegal identity is encountered. More...
class	IllegalMessageSizeException
	This exception indicates that a message size is less than the minimum required size. More...
class	IllegalServantException
	This exception is raised to reject an illegal servant (typically a null servant). More...
class	ImplicitContext
	An interface to associate implict contexts with communicators. More...
struct	InitializationData
	Encapsulates data to initialize a communicator. More...
class	InitializationException
	This exception is raised when a failure occurs during initialization. More...
class	InputStream
	Interface for input streams used to extract Slice types from a sequence of bytes. More...
class	InvalidReplicaGroupIdException
	This exception is raised if the replica group provided by the server is invalid. More...
class	InvocationCanceledException
	This exception indicates that an asynchronous invocation failed because it was canceled explicitly by the user. More...
class	InvocationTimeoutException
	This exception indicates that an invocation failed because it timed out. More...
class	IPConnectionInfo
	Provides access to the connection details of an IP connection. More...
class	IPEndpointInfo
	Provides access to the address details of a IP endpoint. More...
class	LocalException
	Base class for all Ice run-time exceptions. More...
class	LocalObject
	Base class for local Slice classes and interfaces. More...
class	Locator
	The Ice locator interface. More...
class	LocatorFinder
	This interface should be implemented by services implementing the Ice::Locator interface. More...
class	LocatorRegistry
	The Ice locator registry interface. More...
class	Logger
	The Ice message logger. More...
class	LoggerAdmin
	The interface of the admin object that allows an Ice application the attach its RemoteLogger to the Logger of this admin object's Ice communicator. More...
class	LoggerOutput
	Collects output and flushes it via a logger method. More...
class	LoggerOutputBase
	Base class for logger output utility classes. More...
class	LoggerPlugin
	A special plug-in that installs a logger during a communicator's initialization. More...
struct	LogMessage
	A complete log message. More...
class	MarshalException
	This exception is raised for errors during marshaling or unmarshaling data. More...
class	MemoryLimitException
	This exception is raised when Ice receives a request or reply message whose size exceeds the limit specified by the Ice.MessageSizeMax property. More...
class	NativePropertiesAdmin
	Base class for the Properties admin facet. More...
class	NoEndpointException
	This exception is raised if no suitable endpoint is available. More...
class	NotRegisteredException
	An attempt was made to find or deregister something that is not registered with the Ice run time or Ice locator. More...
class	NoValueFactoryException
	This exception is raised if no suitable value factory was found during unmarshaling of a Slice class instance. More...
class	Object
	The base class for servants. More...
class	ObjectAdapter
	The object adapter provides an up-call interface from the Ice run time to the implementation of Ice objects. More...
class	ObjectAdapterDeactivatedException
	This exception is raised if an attempt is made to use a deactivated ObjectAdapter. More...
class	ObjectAdapterIdInUseException
	This exception is raised if an ObjectAdapter cannot be activated. More...
class	ObjectFactory
	A factory for objects. More...
class	ObjectNotExistException
	This exception is raised if an object does not exist on the server, that is, if no facets with the given identity exist. More...
class	ObjectNotFoundException
	This exception is raised if an object cannot be found. More...
class	OpaqueEndpointInfo
	Provides access to the details of an opaque endpoint. More...
class	OperationInterruptedException
	This exception indicates a request was interrupted. More...
class	OperationNotExistException
	This exception is raised if an operation for a given object does not exist on the server. More...
class	OutputStream
	Interface for output streams used to create a sequence of bytes from Slice types. More...
class	Plugin
	A communicator plug-in. More...
class	PluginInitializationException
	This exception indicates that a failure occurred while initializing a plug-in. More...
class	PluginManager
	Each communicator has a plug-in manager to administer the set of plug-ins. More...
class	Process
	An administrative interface for process management. More...
class	Properties
	A property set used to configure Ice and Ice applications. More...
class	PropertiesAdmin
	The PropertiesAdmin interface provides remote access to the properties of a communicator. More...
class	PropertiesAdminUpdateCallback
	An application can be notified when its configuration properties are modified via the Properties admin facet. More...
class	ProtocolException
	A generic exception base for all kinds of protocol error conditions. More...
struct	ProtocolVersion
	A version structure for the protocol version. More...
class	Proxy
	Helper template that supplies proxy factory functions. More...
struct	ProxyIdentityAndFacetEqual
	A functor that compares the object identities and facets of two proxies. More...
struct	ProxyIdentityAndFacetLess
	A functor that compares the object identities and facets of two proxies. More...
struct	ProxyIdentityEqual
	A functor that compares the object identities of two proxies. More...
struct	ProxyIdentityLess
	A functor that compares the object identities of two proxies. More...
class	ProxyParseException
	This exception is raised if there was an error while parsing a stringified proxy. More...
class	ProxyUnmarshalException
	This exception is raised if inconsistent data is received while unmarshaling a proxy. More...
class	RemoteLogger
	The Ice remote logger interface. More...
class	RemoteLoggerAlreadyAttachedException
	Thrown when the provided RemoteLogger was previously attached to a LoggerAdmin. More...
class	Request
	Encapsulates details about a dispatch request. More...
class	RequestFailedException
	This exception is raised if a request failed. More...
class	ResponseSentException
	Indicates that the response to a request has already been sent; re-dispatching such a request is not possible. More...
class	Router
	The Ice router interface. More...
class	RouterFinder
	This interface should be implemented by services implementing the Ice::Router interface. More...
class	SecurityException
	This exception indicates a failure in a security subsystem, such as the IceSSL plug-in. More...
class	ServantLocator
	A servant locator is called by an object adapter to locate a servant that is not found in its active servant map. More...
class	ServerNotFoundException
	This exception is raised if a server cannot be found. More...
class	Service
	A singleton class comparable to Ice::Application but also provides the low-level, platform-specific initialization and shutdown procedures common to system services. More...
class	SlicedData
	Holds the slices of unknown types. More...
struct	SliceInfo
	Encapsulates the details of a slice for an unknown class or exception type. More...
class	SocketException
	This exception indicates socket errors. More...
class	StringConversionException
	This exception is raised when a string conversion to or from UTF-8 fails during marshaling or unmarshaling. More...
class	SyscallException
	This exception is raised if a system error occurred in the server or client process. More...
class	SystemException
	Base class for all Ice system exceptions. More...
class	TCPConnectionInfo
	Provides access to the connection details of a TCP connection. More...
class	TCPEndpointInfo
	Provides access to a TCP endpoint information. More...
class	ThreadHookPlugin
	A special plug-in that installs a thread hook during a communicator's initialization. More...
class	ThreadNotification
	Base class for a thread notification hook. More...
class	TimeoutException
	This exception indicates a timeout condition. More...
class	Trace
	Flushes output to Logger::trace. More...
class	TwowayOnlyException
	The operation can only be invoked with a twoway request. More...
class	UDPConnectionInfo
	Provides access to the connection details of a UDP connection. More...
class	UDPEndpointInfo
	Provides access to an UDP endpoint information. More...
class	UnexpectedObjectException
	This exception is raised if the type of an unmarshaled Slice class instance does not match its expected type. More...
class	UnknownException
	This exception is raised if an operation call on a server raises an unknown exception. More...
class	UnknownLocalException
	This exception is raised if an operation call on a server raises a local exception. More...
class	UnknownMessageException
	This exception indicates that an unknown protocol message has been received. More...
class	UnknownReplyStatusException
	This exception indicates that an unknown reply status has been received. More...
class	UnknownRequestIdException
	This exception indicates that a response for an unknown request ID has been received. More...
class	UnknownSlicedValue
	Represents an instance of an unknown type. More...
class	UnknownUserException
	An operation raised an incorrect user exception. More...
class	UnmarshalOutOfBoundsException
	This exception is raised if an out-of-bounds condition occurs during unmarshaling. More...
class	UnsupportedEncodingException
	This exception indicates an unsupported data encoding version. More...
class	UnsupportedProtocolException
	This exception indicates an unsupported protocol version. More...
class	UserException
	Base class for all Ice user exceptions. More...
class	UserExceptionFactory
	Creates and throws a user exception. More...
class	ValueFactory
	A factory for values. More...
class	ValueFactoryManager
	A value factory manager maintains a collection of value factories. More...
class	VersionMismatchException
	This exception is raised if the Ice library version does not match the version in the Ice header files. More...
class	VersionParseException
	This exception is raised if there was an error while parsing a version. More...
class	WSConnectionInfo
	Provides access to the connection details of a WebSocket connection. More...
class	WSEndpointInfo
	Provides access to a WebSocket endpoint information. More...

Typedefs
typedef ::IceUtil::Handle< ::Ice::AMD_Locator_findAdapterById >	AMD_Locator_findAdapterByIdPtr
typedef ::IceUtil::Handle< ::Ice::AMD_Locator_findObjectById >	AMD_Locator_findObjectByIdPtr
typedef ::IceUtil::Handle< ::Ice::AMD_LocatorRegistry_setAdapterDirectProxy >	AMD_LocatorRegistry_setAdapterDirectProxyPtr
typedef ::IceUtil::Handle< ::Ice::AMD_LocatorRegistry_setReplicatedAdapterDirectProxy >	AMD_LocatorRegistry_setReplicatedAdapterDirectProxyPtr
typedef ::IceUtil::Handle< ::Ice::AMD_LocatorRegistry_setServerProcessProxy >	AMD_LocatorRegistry_setServerProcessProxyPtr
typedef IceInternal::Handle< AMD_Object_ice_invoke >	AMD_Object_ice_invokePtr
typedef IceInternal::Handle< AsyncResult >	AsyncResultPtr
typedef IceUtil::Handle< BatchRequestInterceptor >	BatchRequestInterceptorPtr
typedef ::std::vector< bool >	BoolSeq
	A sequence of bools.
typedef unsigned char	Byte
	The mapping for the Slice byte type.
typedef ::std::vector< Byte >	ByteSeq
	A sequence of bytes.
typedef ::IceUtil::Handle< Callback_Communicator_flushBatchRequests_Base >	Callback_Communicator_flushBatchRequestsPtr
typedef ::IceUtil::Handle< Callback_Connection_flushBatchRequests_Base >	Callback_Connection_flushBatchRequestsPtr
typedef ::IceUtil::Handle< Callback_Connection_heartbeat_Base >	Callback_Connection_heartbeatPtr
typedef ::IceUtil::Handle< Callback_Locator_findAdapterById_Base >	Callback_Locator_findAdapterByIdPtr
typedef ::IceUtil::Handle< Callback_Locator_findObjectById_Base >	Callback_Locator_findObjectByIdPtr
typedef ::IceUtil::Handle< Callback_Locator_getRegistry_Base >	Callback_Locator_getRegistryPtr
typedef ::IceUtil::Handle< Callback_LocatorFinder_getLocator_Base >	Callback_LocatorFinder_getLocatorPtr
typedef ::IceUtil::Handle< Callback_LocatorRegistry_setAdapterDirectProxy_Base >	Callback_LocatorRegistry_setAdapterDirectProxyPtr
typedef ::IceUtil::Handle< Callback_LocatorRegistry_setReplicatedAdapterDirectProxy_Base >	Callback_LocatorRegistry_setReplicatedAdapterDirectProxyPtr
typedef ::IceUtil::Handle< Callback_LocatorRegistry_setServerProcessProxy_Base >	Callback_LocatorRegistry_setServerProcessProxyPtr
typedef ::IceUtil::Handle< Callback_LoggerAdmin_attachRemoteLogger_Base >	Callback_LoggerAdmin_attachRemoteLoggerPtr
typedef ::IceUtil::Handle< Callback_LoggerAdmin_detachRemoteLogger_Base >	Callback_LoggerAdmin_detachRemoteLoggerPtr
typedef ::IceUtil::Handle< Callback_LoggerAdmin_getLog_Base >	Callback_LoggerAdmin_getLogPtr
typedef ::IceUtil::Handle< Callback_Object_ice_flushBatchRequests_Base >	Callback_Object_ice_flushBatchRequestsPtr
typedef ::IceUtil::Handle< Callback_Object_ice_getConnection_Base >	Callback_Object_ice_getConnectionPtr
typedef ::IceUtil::Handle< Callback_Object_ice_id_Base >	Callback_Object_ice_idPtr
typedef ::IceUtil::Handle< Callback_Object_ice_ids_Base >	Callback_Object_ice_idsPtr
typedef ::IceUtil::Handle< Callback_Object_ice_invoke_Base >	Callback_Object_ice_invokePtr
typedef ::IceUtil::Handle< Callback_Object_ice_isA_Base >	Callback_Object_ice_isAPtr
typedef ::IceUtil::Handle< Callback_Object_ice_ping_Base >	Callback_Object_ice_pingPtr
typedef ::IceUtil::Handle< Callback_Process_shutdown_Base >	Callback_Process_shutdownPtr
typedef ::IceUtil::Handle< Callback_Process_writeMessage_Base >	Callback_Process_writeMessagePtr
typedef ::IceUtil::Handle< Callback_PropertiesAdmin_getPropertiesForPrefix_Base >	Callback_PropertiesAdmin_getPropertiesForPrefixPtr
typedef ::IceUtil::Handle< Callback_PropertiesAdmin_getProperty_Base >	Callback_PropertiesAdmin_getPropertyPtr
typedef ::IceUtil::Handle< Callback_PropertiesAdmin_setProperties_Base >	Callback_PropertiesAdmin_setPropertiesPtr
typedef ::IceUtil::Handle< Callback_RemoteLogger_init_Base >	Callback_RemoteLogger_initPtr
typedef ::IceUtil::Handle< Callback_RemoteLogger_log_Base >	Callback_RemoteLogger_logPtr
typedef ::IceUtil::Handle< Callback_Router_addProxies_Base >	Callback_Router_addProxiesPtr
typedef ::IceUtil::Handle< Callback_Router_getClientProxy_Base >	Callback_Router_getClientProxyPtr
typedef ::IceUtil::Handle< Callback_Router_getServerProxy_Base >	Callback_Router_getServerProxyPtr
typedef ::IceUtil::Handle< Callback_RouterFinder_getRouter_Base >	Callback_RouterFinder_getRouterPtr
typedef IceUtil::Handle< ::IceInternal::GenericCallbackBase >	CallbackPtr
typedef ::IceInternal::Handle< CloseCallback >	CloseCallbackPtr
typedef ::IceInternal::Handle< Communicator >	CommunicatorPtr
typedef IceUtil::Handle< CompactIdResolver >	CompactIdResolverPtr
typedef ::IceInternal::Handle< ConnectionInfo >	ConnectionInfoPtr
typedef ::IceInternal::Handle< Connection >	ConnectionPtr
typedef ::std::map< ::std::string, ::std::string >	Context
	A request context.
typedef void(*	CtrlCHandlerCallback) (int sig)
	Invoked when a signal occurs.
typedef IceUtil::Handle< DispatcherCall >	DispatcherCallPtr
typedef IceUtil::Handle< Dispatcher >	DispatcherPtr
typedef ::IceUtil::Handle< DispatchInterceptorAsyncCallback >	DispatchInterceptorAsyncCallbackPtr
typedef ::IceUtil::Handle< DispatchInterceptor >	DispatchInterceptorPtr
typedef double	Double
	The mapping for the Slice double type.
typedef ::std::vector< Double >	DoubleSeq
	A sequence of doubles.
typedef ::IceInternal::Handle< EndpointInfo >	EndpointInfoPtr
typedef ::IceInternal::Handle< Endpoint >	EndpointPtr
typedef ::std::vector< EndpointPtr >	EndpointSeq
	A sequence of endpoints.
typedef LoggerOutput< Logger, LoggerPtr, &Logger::error >	Error
	Flushes output to Logger::error.
typedef IceUtil::Exception	Exception
typedef ::std::map< ::std::string, ObjectPtr >	FacetMap
	A mapping from facet name to servant.
typedef float	Float
	The mapping for the Slice float type.
typedef ::std::vector< Float >	FloatSeq
	A sequence of floats.
typedef ::std::map< ::std::string, ::std::string >	HeaderDict
	A collection of HTTP headers.
typedef ::IceInternal::Handle< HeartbeatCallback >	HeartbeatCallbackPtr
typedef ::std::vector< Identity >	IdentitySeq
	A sequence of identities.
typedef IceUtil::IllegalConversionException	IllegalConversionException
	Indicates an error occurred during string conversion.
typedef ::IceInternal::Handle< ImplicitContext >	ImplicitContextPtr
typedef int	Int
	The mapping for the Slice int type.
typedef ::std::vector< Int >	IntSeq
	A sequence of ints.
typedef ::IceInternal::Handle< IPConnectionInfo >	IPConnectionInfoPtr
typedef ::IceInternal::Handle< IPEndpointInfo >	IPEndpointInfoPtr
typedef IceInternal::Handle< LocalObject >	LocalObjectPtr
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::LocatorFinder >	LocatorFinderPrx
typedef LocatorFinderPrx	LocatorFinderPrxPtr
typedef ::IceInternal::Handle< LocatorFinder >	LocatorFinderPtr
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::Locator >	LocatorPrx
typedef LocatorPrx	LocatorPrxPtr
typedef ::IceInternal::Handle< Locator >	LocatorPtr
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::LocatorRegistry >	LocatorRegistryPrx
typedef LocatorRegistryPrx	LocatorRegistryPrxPtr
typedef ::IceInternal::Handle< LocatorRegistry >	LocatorRegistryPtr
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::LoggerAdmin >	LoggerAdminPrx
typedef LoggerAdminPrx	LoggerAdminPrxPtr
typedef ::IceInternal::Handle< LoggerAdmin >	LoggerAdminPtr
typedef ::IceInternal::Handle< Logger >	LoggerPtr
typedef std::list< LogMessage >	LogMessageSeq
	A sequence of LogMessage.
typedef ::std::vector< LogMessageType >	LogMessageTypeSeq
	A sequence of LogMessageType.
typedef IceUtil::Int64	Long
	The mapping for the Slice long type.
typedef ::std::vector< Long >	LongSeq
	A sequence of longs.
typedef ::IceInternal::Handle< ObjectAdapter >	ObjectAdapterPtr
typedef ::std::map< Identity, ObjectPtr >	ObjectDict
	A mapping between identities and Ice objects.
typedef ::IceInternal::Handle< ObjectFactory >	ObjectFactoryPtr
typedef ::std::vector< ObjectPrx >	ObjectProxySeq
	A sequence of object proxies.
typedef IceInternal::ProxyHandle< ::IceProxy::Ice::Object >	ObjectPrx
	Smart pointer for an object proxy.
typedef ObjectPrx	ObjectPrxPtr
typedef IceInternal::Handle< Object >	ObjectPtr
typedef ::std::vector< ObjectPtr >	ObjectSeq
	A sequence of objects.
typedef ::IceInternal::Handle< OpaqueEndpointInfo >	OpaqueEndpointInfoPtr
typedef Ice::Plugin *(*	PluginFactory) (const ::Ice::CommunicatorPtr &communicator, const std::string &name, const ::Ice::StringSeq &args)
	A plug-in factory function is responsible for creating an Ice plug-in.
typedef ::IceInternal::Handle< PluginManager >	PluginManagerPtr
typedef ::IceInternal::Handle< Plugin >	PluginPtr
typedef LoggerOutput< Logger, LoggerPtr, &Logger::print >	Print
	Flushes output to Logger::print.
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::Process >	ProcessPrx
typedef ProcessPrx	ProcessPrxPtr
typedef ::IceInternal::Handle< Process >	ProcessPtr
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::PropertiesAdmin >	PropertiesAdminPrx
typedef PropertiesAdminPrx	PropertiesAdminPrxPtr
typedef ::IceInternal::Handle< PropertiesAdmin >	PropertiesAdminPtr
typedef IceUtil::Handle< PropertiesAdminUpdateCallback >	PropertiesAdminUpdateCallbackPtr
typedef ::IceInternal::Handle< Properties >	PropertiesPtr
typedef ::std::map< ::std::string, ::std::string >	PropertyDict
	A simple collection of properties, represented as a dictionary of key/value pairs.
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::RemoteLogger >	RemoteLoggerPrx
typedef RemoteLoggerPrx	RemoteLoggerPrxPtr
typedef ::IceInternal::Handle< RemoteLogger >	RemoteLoggerPtr
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::RouterFinder >	RouterFinderPrx
typedef RouterFinderPrx	RouterFinderPrxPtr
typedef ::IceInternal::Handle< RouterFinder >	RouterFinderPtr
typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::Router >	RouterPrx
typedef RouterPrx	RouterPrxPtr
typedef ::IceInternal::Handle< Router >	RouterPtr
typedef ::IceInternal::Handle< ServantLocator >	ServantLocatorPtr
typedef short	Short
	The mapping for the Slice short type.
typedef ::std::vector< Short >	ShortSeq
	A sequence of shorts.
typedef ::std::map< ::std::string, ::std::string >	SliceChecksumDict
	A mapping from type IDs to Slice checksums.
typedef IceInternal::Handle< SlicedData >	SlicedDataPtr
typedef IceInternal::Handle< SliceInfo >	SliceInfoPtr
typedef ::std::vector< SliceInfoPtr >	SliceInfoSeq
	The slices of unknown types.
typedef IceUtil::StringConverter	StringConverter
	Narrow string converter.
typedef IceUtil::StringConverterPtr	StringConverterPtr
typedef ::std::vector< ::std::string >	StringSeq
	A sequence of strings.
typedef ::IceInternal::Handle< TCPConnectionInfo >	TCPConnectionInfoPtr
typedef ::IceInternal::Handle< TCPEndpointInfo >	TCPEndpointInfoPtr
typedef IceUtil::Handle< ThreadNotification >	ThreadNotificationPtr
typedef ::IceInternal::Handle< UDPConnectionInfo >	UDPConnectionInfoPtr
typedef ::IceInternal::Handle< UDPEndpointInfo >	UDPEndpointInfoPtr
typedef IceInternal::Handle< UnknownSlicedValue >	UnknownSlicedValuePtr
typedef ::IceUtil::Handle< UserExceptionFactory >	UserExceptionFactoryPtr
typedef IceUtil::UTF8Buffer	UTF8Buffer
	Encapsulates bytes in the UTF-8 encoding.
typedef ::IceInternal::Handle< ValueFactoryManager >	ValueFactoryManagerPtr
typedef ::IceInternal::Handle< ValueFactory >	ValueFactoryPtr
typedef ObjectPtr	ValuePtr
typedef LoggerOutput< Logger, LoggerPtr, &Logger::warning >	Warning
	Flushes output to Logger::warning.
typedef ::IceInternal::Handle< WSConnectionInfo >	WSConnectionInfoPtr
typedef ::IceInternal::Handle< WSEndpointInfo >	WSEndpointInfoPtr
typedef IceUtil::WstringConverter	WstringConverter
	Wide string converter.
typedef IceUtil::WstringConverterPtr	WstringConverterPtr

Enumerations
enum	ACMClose {   CloseOff , CloseOnIdle , CloseOnInvocation , CloseOnInvocationAndIdle ,   CloseOnIdleForceful }
	Specifies the close semantics for Active Connection Management. More...
enum	ACMHeartbeat { HeartbeatOff , HeartbeatOnDispatch , HeartbeatOnIdle , HeartbeatAlways }
	Specifies the heartbeat semantics for Active Connection Management. More...
enum	CompressBatch { CompressBatchYes , CompressBatchNo , CompressBatchBasedOnProxy }
	The batch compression option when flushing queued batch requests. More...
enum	ConnectionClose { ConnectionCloseForcefully , ConnectionCloseGracefully , ConnectionCloseGracefullyWithWait }
	Determines the behavior when manually closing a connection. More...
enum	EndpointSelectionType { Random , Ordered }
	Determines the order in which the Ice run time uses the endpoints in a proxy when establishing a connection. More...
enum	FormatType { DefaultFormat , CompactFormat , SlicedFormat }
	Describes the possible formats for classes and exceptions. More...
enum	LogMessageType { PrintMessage , TraceMessage , WarningMessage , ErrorMessage }
	An enumeration representing the different types of log messages. More...
enum	OperationMode { Normal , Nonmutating , Idempotent }
	Determines the retry behavior an invocation in case of a (potentially) recoverable error. More...
enum	SignalPolicy { HandleSignals , NoSignalHandling }
enum	ToStringMode { Unicode , ASCII , Compat }
	The output mode for xxxToString method such as identityToString and proxyToString. More...

Functions
StringSeq	argsToStringSeq (int argc, const char *const argv[])
	Converts an argument vector into a string sequence.
template<typename P>
P	checkedCast (const ::Ice::ObjectPrx &b, const std::string &f, const ::Ice::Context &context=::Ice::noExplicitContext)
	Downcasts a proxy after confirming the target object's type via a remote invocation.
template<typename P, typename Y>
P	checkedCast (const ::IceInternal::ProxyHandle< Y > &b, const ::Ice::Context &context=::Ice::noExplicitContext)
	Downcasts a proxy after confirming the target object's type via a remote invocation.
template<typename charT>
::IceUtil::Handle< IceUtil::BasicStringConverter< charT > >	createIconvStringConverter (const std::string &internalCodeWithDefault="")
	Creates a string converter for the given code.
PropertiesPtr	createProperties ()
	Creates a new empty property set.
PropertiesPtr	createProperties (int &argc, char *argv[], const PropertiesPtr &defaults=0)
	Creates a property set initialized from command-line arguments and a default property set.
PropertiesPtr	createProperties (int &argc, const char *argv[], const PropertiesPtr &defaults=0)
	Creates a property set initialized from command-line arguments and a default property set.
PropertiesPtr	createProperties (StringSeq &seq, const PropertiesPtr &defaults=0)
	Creates a property set initialized from command-line arguments and a default property set.
WstringConverterPtr	createUnicodeWstringConverter ()
	Creates a string converter that converts between Unicode wide strings and UTF-8 strings.
inline ::std::string	encodingVersionToString (const Ice::EncodingVersion &v)
	Converts an encoding version into a string.
std::string	generateUUID ()
	Generates a UUID.
LoggerPtr	getProcessLogger ()
	Obtains the per-process logger.
StringConverterPtr	getProcessStringConverter ()
	Obtains the default narrow string converter for the process.
WstringConverterPtr	getProcessWstringConverter ()
	Obtains the default wide string converter for the process.
	ICE_DEFINE_PTR (NativePropertiesAdminPtr, NativePropertiesAdmin)
std::string	identityToString (const Identity &id, ToStringMode mode=Unicode)
	Converts an Identity structure into a string using the specified mode.
CommunicatorPtr	initialize (const char *configFile, int version=30711)
	Initializes a new communicator.
CommunicatorPtr	initialize (const InitializationData &initData=InitializationData(), int version=30711)
	Initializes a new communicator.
CommunicatorPtr	initialize (int &argc, char *argv[], const char *configFile, int version=30711)
	Initializes a new communicator.
CommunicatorPtr	initialize (int &argc, char *argv[], const InitializationData &initData=InitializationData(), int version=30711)
	Initializes a new communicator.
CommunicatorPtr	initialize (int &argc, const char *argv[], const char *configFile, int version=30711)
	Initializes a new communicator.
CommunicatorPtr	initialize (int &argc, const char *argv[], const InitializationData &initData=InitializationData(), int version=30711)
	Initializes a new communicator.
CommunicatorPtr	initialize (StringSeq &seq, const char *configFile, int version=30711)
	Initializes a new communicator.
CommunicatorPtr	initialize (StringSeq &seq, const InitializationData &initData=InitializationData(), int version=30711)
	Initializes a new communicator.
std::string	nativeToUTF8 (const std::string &str, const StringConverterPtr &nc)
	Converts a narrow string to a UTF-8 encoded string using a string converter.
template<class T>
CallbackPtr	newCallback (const IceUtil::Handle< T > &instance, void(T::*cb)(const AsyncResultPtr &), void(T::*sentcb)(const AsyncResultPtr &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
CallbackPtr	newCallback (T *instance, void(T::*cb)(const AsyncResultPtr &), void(T::*sentcb)(const AsyncResultPtr &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Communicator_flushBatchRequestsPtr	newCallback_Communicator_flushBatchRequests (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Communicator_flushBatchRequestsPtr	newCallback_Communicator_flushBatchRequests (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Type-safe asynchronous callback wrapper class used for calls to Ice::Communicator::begin_flushBatchRequests.
template<class T>
Callback_Communicator_flushBatchRequestsPtr	newCallback_Communicator_flushBatchRequests (T *instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Communicator_flushBatchRequestsPtr	newCallback_Communicator_flushBatchRequests (T *instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Type-safe asynchronous callback wrapper class used for calls to Ice::Communicator::begin_flushBatchRequests.
template<class T>
Callback_Connection_flushBatchRequestsPtr	newCallback_Connection_flushBatchRequests (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Connection_flushBatchRequestsPtr	newCallback_Connection_flushBatchRequests (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Connection_flushBatchRequestsPtr	newCallback_Connection_flushBatchRequests (T *instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Connection_flushBatchRequestsPtr	newCallback_Connection_flushBatchRequests (T *instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Connection_heartbeatPtr	newCallback_Connection_heartbeat (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Connection_heartbeatPtr	newCallback_Connection_heartbeat (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Connection_heartbeatPtr	newCallback_Connection_heartbeat (T *instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Connection_heartbeatPtr	newCallback_Connection_heartbeat (T *instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Locator_findAdapterByIdPtr	newCallback_Locator_findAdapterById (const IceUtil::Handle< T > &instance, void(T::*cb)(const ObjectPrx &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Locator_findAdapterByIdPtr	newCallback_Locator_findAdapterById (const IceUtil::Handle< T > &instance, void(T::*cb)(const ObjectPrx &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Locator_findAdapterByIdPtr	newCallback_Locator_findAdapterById (T *instance, void(T::*cb)(const ObjectPrx &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Locator_findAdapterByIdPtr	newCallback_Locator_findAdapterById (T *instance, void(T::*cb)(const ObjectPrx &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Locator_findObjectByIdPtr	newCallback_Locator_findObjectById (const IceUtil::Handle< T > &instance, void(T::*cb)(const ObjectPrx &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Locator_findObjectByIdPtr	newCallback_Locator_findObjectById (const IceUtil::Handle< T > &instance, void(T::*cb)(const ObjectPrx &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Locator_findObjectByIdPtr	newCallback_Locator_findObjectById (T *instance, void(T::*cb)(const ObjectPrx &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Locator_findObjectByIdPtr	newCallback_Locator_findObjectById (T *instance, void(T::*cb)(const ObjectPrx &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Locator_getRegistryPtr	newCallback_Locator_getRegistry (const IceUtil::Handle< T > &instance, void(T::*cb)(const LocatorRegistryPrx &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Locator_getRegistryPtr	newCallback_Locator_getRegistry (const IceUtil::Handle< T > &instance, void(T::*cb)(const LocatorRegistryPrx &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Locator_getRegistryPtr	newCallback_Locator_getRegistry (T *instance, void(T::*cb)(const LocatorRegistryPrx &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Locator_getRegistryPtr	newCallback_Locator_getRegistry (T *instance, void(T::*cb)(const LocatorRegistryPrx &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LocatorFinder_getLocatorPtr	newCallback_LocatorFinder_getLocator (const IceUtil::Handle< T > &instance, void(T::*cb)(const LocatorPrx &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LocatorFinder_getLocatorPtr	newCallback_LocatorFinder_getLocator (const IceUtil::Handle< T > &instance, void(T::*cb)(const LocatorPrx &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LocatorFinder_getLocatorPtr	newCallback_LocatorFinder_getLocator (T *instance, void(T::*cb)(const LocatorPrx &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LocatorFinder_getLocatorPtr	newCallback_LocatorFinder_getLocator (T *instance, void(T::*cb)(const LocatorPrx &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LocatorRegistry_setAdapterDirectProxyPtr	newCallback_LocatorRegistry_setAdapterDirectProxy (const IceUtil::Handle< T > &instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LocatorRegistry_setAdapterDirectProxyPtr	newCallback_LocatorRegistry_setAdapterDirectProxy (const IceUtil::Handle< T > &instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LocatorRegistry_setAdapterDirectProxyPtr	newCallback_LocatorRegistry_setAdapterDirectProxy (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LocatorRegistry_setAdapterDirectProxyPtr	newCallback_LocatorRegistry_setAdapterDirectProxy (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LocatorRegistry_setAdapterDirectProxyPtr	newCallback_LocatorRegistry_setAdapterDirectProxy (T *instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LocatorRegistry_setAdapterDirectProxyPtr	newCallback_LocatorRegistry_setAdapterDirectProxy (T *instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LocatorRegistry_setAdapterDirectProxyPtr	newCallback_LocatorRegistry_setAdapterDirectProxy (T *instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LocatorRegistry_setAdapterDirectProxyPtr	newCallback_LocatorRegistry_setAdapterDirectProxy (T *instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LocatorRegistry_setReplicatedAdapterDirectProxyPtr	newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy (const IceUtil::Handle< T > &instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LocatorRegistry_setReplicatedAdapterDirectProxyPtr	newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy (const IceUtil::Handle< T > &instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LocatorRegistry_setReplicatedAdapterDirectProxyPtr	newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LocatorRegistry_setReplicatedAdapterDirectProxyPtr	newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LocatorRegistry_setReplicatedAdapterDirectProxyPtr	newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy (T *instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LocatorRegistry_setReplicatedAdapterDirectProxyPtr	newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy (T *instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LocatorRegistry_setReplicatedAdapterDirectProxyPtr	newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy (T *instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LocatorRegistry_setReplicatedAdapterDirectProxyPtr	newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy (T *instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LocatorRegistry_setServerProcessProxyPtr	newCallback_LocatorRegistry_setServerProcessProxy (const IceUtil::Handle< T > &instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LocatorRegistry_setServerProcessProxyPtr	newCallback_LocatorRegistry_setServerProcessProxy (const IceUtil::Handle< T > &instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LocatorRegistry_setServerProcessProxyPtr	newCallback_LocatorRegistry_setServerProcessProxy (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LocatorRegistry_setServerProcessProxyPtr	newCallback_LocatorRegistry_setServerProcessProxy (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LocatorRegistry_setServerProcessProxyPtr	newCallback_LocatorRegistry_setServerProcessProxy (T *instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LocatorRegistry_setServerProcessProxyPtr	newCallback_LocatorRegistry_setServerProcessProxy (T *instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LocatorRegistry_setServerProcessProxyPtr	newCallback_LocatorRegistry_setServerProcessProxy (T *instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LocatorRegistry_setServerProcessProxyPtr	newCallback_LocatorRegistry_setServerProcessProxy (T *instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LoggerAdmin_attachRemoteLoggerPtr	newCallback_LoggerAdmin_attachRemoteLogger (const IceUtil::Handle< T > &instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LoggerAdmin_attachRemoteLoggerPtr	newCallback_LoggerAdmin_attachRemoteLogger (const IceUtil::Handle< T > &instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LoggerAdmin_attachRemoteLoggerPtr	newCallback_LoggerAdmin_attachRemoteLogger (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LoggerAdmin_attachRemoteLoggerPtr	newCallback_LoggerAdmin_attachRemoteLogger (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LoggerAdmin_attachRemoteLoggerPtr	newCallback_LoggerAdmin_attachRemoteLogger (T *instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LoggerAdmin_attachRemoteLoggerPtr	newCallback_LoggerAdmin_attachRemoteLogger (T *instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LoggerAdmin_attachRemoteLoggerPtr	newCallback_LoggerAdmin_attachRemoteLogger (T *instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LoggerAdmin_attachRemoteLoggerPtr	newCallback_LoggerAdmin_attachRemoteLogger (T *instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LoggerAdmin_detachRemoteLoggerPtr	newCallback_LoggerAdmin_detachRemoteLogger (const IceUtil::Handle< T > &instance, void(T::*cb)(bool), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LoggerAdmin_detachRemoteLoggerPtr	newCallback_LoggerAdmin_detachRemoteLogger (const IceUtil::Handle< T > &instance, void(T::*cb)(bool, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LoggerAdmin_detachRemoteLoggerPtr	newCallback_LoggerAdmin_detachRemoteLogger (T *instance, void(T::*cb)(bool), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LoggerAdmin_detachRemoteLoggerPtr	newCallback_LoggerAdmin_detachRemoteLogger (T *instance, void(T::*cb)(bool, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LoggerAdmin_getLogPtr	newCallback_LoggerAdmin_getLog (const IceUtil::Handle< T > &instance, void(T::*cb)(const LogMessageSeq &, const ::std::string &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LoggerAdmin_getLogPtr	newCallback_LoggerAdmin_getLog (const IceUtil::Handle< T > &instance, void(T::*cb)(const LogMessageSeq &, const ::std::string &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_LoggerAdmin_getLogPtr	newCallback_LoggerAdmin_getLog (T *instance, void(T::*cb)(const LogMessageSeq &, const ::std::string &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_LoggerAdmin_getLogPtr	newCallback_LoggerAdmin_getLog (T *instance, void(T::*cb)(const LogMessageSeq &, const ::std::string &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_flushBatchRequestsPtr	newCallback_Object_ice_flushBatchRequests (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_flushBatchRequestsPtr	newCallback_Object_ice_flushBatchRequests (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_flushBatchRequestsPtr	newCallback_Object_ice_flushBatchRequests (T *instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_flushBatchRequestsPtr	newCallback_Object_ice_flushBatchRequests (T *instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_getConnectionPtr	newCallback_Object_ice_getConnection (const IceUtil::Handle< T > &instance, void(T::*cb)(const ::Ice::ConnectionPtr &), void(T::*excb)(const ::Ice::Exception &))
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_getConnectionPtr	newCallback_Object_ice_getConnection (const IceUtil::Handle< T > &instance, void(T::*cb)(const ::Ice::ConnectionPtr &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &))
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_getConnectionPtr	newCallback_Object_ice_getConnection (T *instance, void(T::*cb)(const ::Ice::ConnectionPtr &), void(T::*excb)(const ::Ice::Exception &))
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_getConnectionPtr	newCallback_Object_ice_getConnection (T *instance, void(T::*cb)(const ::Ice::ConnectionPtr &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &))
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_idPtr	newCallback_Object_ice_id (const IceUtil::Handle< T > &instance, void(T::*cb)(const ::std::string &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_idPtr	newCallback_Object_ice_id (const IceUtil::Handle< T > &instance, void(T::*cb)(const ::std::string &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_idPtr	newCallback_Object_ice_id (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_idPtr	newCallback_Object_ice_id (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_idPtr	newCallback_Object_ice_id (T *instance, void(T::*cb)(const ::std::string &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_idPtr	newCallback_Object_ice_id (T *instance, void(T::*cb)(const ::std::string &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_idPtr	newCallback_Object_ice_id (T *instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_idPtr	newCallback_Object_ice_id (T *instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_idsPtr	newCallback_Object_ice_ids (const IceUtil::Handle< T > &instance, void(T::*cb)(const ::std::vector< ::std::string > &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_idsPtr	newCallback_Object_ice_ids (const IceUtil::Handle< T > &instance, void(T::*cb)(const ::std::vector< ::std::string > &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_idsPtr	newCallback_Object_ice_ids (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_idsPtr	newCallback_Object_ice_ids (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_idsPtr	newCallback_Object_ice_ids (T *instance, void(T::*cb)(const ::std::vector< ::std::string > &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_idsPtr	newCallback_Object_ice_ids (T *instance, void(T::*cb)(const ::std::vector< ::std::string > &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_idsPtr	newCallback_Object_ice_ids (T *instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_idsPtr	newCallback_Object_ice_ids (T *instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_invokePtr	newCallback_Object_ice_invoke (const IceUtil::Handle< T > &instance, void(T::*cb)(bool, const std::pair< const Byte *, const Byte * > &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_invokePtr	newCallback_Object_ice_invoke (const IceUtil::Handle< T > &instance, void(T::*cb)(bool, const std::pair< const Byte *, const Byte * > &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_invokePtr	newCallback_Object_ice_invoke (const IceUtil::Handle< T > &instance, void(T::*cb)(bool, const std::vector< Ice::Byte > &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_invokePtr	newCallback_Object_ice_invoke (const IceUtil::Handle< T > &instance, void(T::*cb)(bool, const std::vector< Ice::Byte > &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_invokePtr	newCallback_Object_ice_invoke (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_invokePtr	newCallback_Object_ice_invoke (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_invokePtr	newCallback_Object_ice_invoke (T *instance, void(T::*cb)(bool, const std::pair< const Byte *, const Byte * > &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_invokePtr	newCallback_Object_ice_invoke (T *instance, void(T::*cb)(bool, const std::pair< const Byte *, const Byte * > &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_invokePtr	newCallback_Object_ice_invoke (T *instance, void(T::*cb)(bool, const std::vector< Ice::Byte > &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_invokePtr	newCallback_Object_ice_invoke (T *instance, void(T::*cb)(bool, const std::vector< Ice::Byte > &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_invokePtr	newCallback_Object_ice_invoke (T *instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_invokePtr	newCallback_Object_ice_invoke (T *instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_isAPtr	newCallback_Object_ice_isA (const IceUtil::Handle< T > &instance, void(T::*cb)(bool), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_isAPtr	newCallback_Object_ice_isA (const IceUtil::Handle< T > &instance, void(T::*cb)(bool, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_isAPtr	newCallback_Object_ice_isA (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_isAPtr	newCallback_Object_ice_isA (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_isAPtr	newCallback_Object_ice_isA (T *instance, void(T::*cb)(bool), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_isAPtr	newCallback_Object_ice_isA (T *instance, void(T::*cb)(bool, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_isAPtr	newCallback_Object_ice_isA (T *instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_isAPtr	newCallback_Object_ice_isA (T *instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_pingPtr	newCallback_Object_ice_ping (const IceUtil::Handle< T > &instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_pingPtr	newCallback_Object_ice_ping (const IceUtil::Handle< T > &instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_pingPtr	newCallback_Object_ice_ping (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_pingPtr	newCallback_Object_ice_ping (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_pingPtr	newCallback_Object_ice_ping (T *instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_pingPtr	newCallback_Object_ice_ping (T *instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Object_ice_pingPtr	newCallback_Object_ice_ping (T *instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Object_ice_pingPtr	newCallback_Object_ice_ping (T *instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Process_shutdownPtr	newCallback_Process_shutdown (const IceUtil::Handle< T > &instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Process_shutdownPtr	newCallback_Process_shutdown (const IceUtil::Handle< T > &instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Process_shutdownPtr	newCallback_Process_shutdown (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Process_shutdownPtr	newCallback_Process_shutdown (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Process_shutdownPtr	newCallback_Process_shutdown (T *instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Process_shutdownPtr	newCallback_Process_shutdown (T *instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Process_shutdownPtr	newCallback_Process_shutdown (T *instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Process_shutdownPtr	newCallback_Process_shutdown (T *instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Process_writeMessagePtr	newCallback_Process_writeMessage (const IceUtil::Handle< T > &instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Process_writeMessagePtr	newCallback_Process_writeMessage (const IceUtil::Handle< T > &instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Process_writeMessagePtr	newCallback_Process_writeMessage (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Process_writeMessagePtr	newCallback_Process_writeMessage (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Process_writeMessagePtr	newCallback_Process_writeMessage (T *instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Process_writeMessagePtr	newCallback_Process_writeMessage (T *instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Process_writeMessagePtr	newCallback_Process_writeMessage (T *instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Process_writeMessagePtr	newCallback_Process_writeMessage (T *instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_PropertiesAdmin_getPropertiesForPrefixPtr	newCallback_PropertiesAdmin_getPropertiesForPrefix (const IceUtil::Handle< T > &instance, void(T::*cb)(const PropertyDict &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_PropertiesAdmin_getPropertiesForPrefixPtr	newCallback_PropertiesAdmin_getPropertiesForPrefix (const IceUtil::Handle< T > &instance, void(T::*cb)(const PropertyDict &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_PropertiesAdmin_getPropertiesForPrefixPtr	newCallback_PropertiesAdmin_getPropertiesForPrefix (T *instance, void(T::*cb)(const PropertyDict &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_PropertiesAdmin_getPropertiesForPrefixPtr	newCallback_PropertiesAdmin_getPropertiesForPrefix (T *instance, void(T::*cb)(const PropertyDict &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_PropertiesAdmin_getPropertyPtr	newCallback_PropertiesAdmin_getProperty (const IceUtil::Handle< T > &instance, void(T::*cb)(const ::std::string &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_PropertiesAdmin_getPropertyPtr	newCallback_PropertiesAdmin_getProperty (const IceUtil::Handle< T > &instance, void(T::*cb)(const ::std::string &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_PropertiesAdmin_getPropertyPtr	newCallback_PropertiesAdmin_getProperty (T *instance, void(T::*cb)(const ::std::string &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_PropertiesAdmin_getPropertyPtr	newCallback_PropertiesAdmin_getProperty (T *instance, void(T::*cb)(const ::std::string &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_PropertiesAdmin_setPropertiesPtr	newCallback_PropertiesAdmin_setProperties (const IceUtil::Handle< T > &instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_PropertiesAdmin_setPropertiesPtr	newCallback_PropertiesAdmin_setProperties (const IceUtil::Handle< T > &instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_PropertiesAdmin_setPropertiesPtr	newCallback_PropertiesAdmin_setProperties (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_PropertiesAdmin_setPropertiesPtr	newCallback_PropertiesAdmin_setProperties (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_PropertiesAdmin_setPropertiesPtr	newCallback_PropertiesAdmin_setProperties (T *instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_PropertiesAdmin_setPropertiesPtr	newCallback_PropertiesAdmin_setProperties (T *instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_PropertiesAdmin_setPropertiesPtr	newCallback_PropertiesAdmin_setProperties (T *instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_PropertiesAdmin_setPropertiesPtr	newCallback_PropertiesAdmin_setProperties (T *instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_RemoteLogger_initPtr	newCallback_RemoteLogger_init (const IceUtil::Handle< T > &instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_RemoteLogger_initPtr	newCallback_RemoteLogger_init (const IceUtil::Handle< T > &instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_RemoteLogger_initPtr	newCallback_RemoteLogger_init (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_RemoteLogger_initPtr	newCallback_RemoteLogger_init (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_RemoteLogger_initPtr	newCallback_RemoteLogger_init (T *instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_RemoteLogger_initPtr	newCallback_RemoteLogger_init (T *instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_RemoteLogger_initPtr	newCallback_RemoteLogger_init (T *instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_RemoteLogger_initPtr	newCallback_RemoteLogger_init (T *instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_RemoteLogger_logPtr	newCallback_RemoteLogger_log (const IceUtil::Handle< T > &instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_RemoteLogger_logPtr	newCallback_RemoteLogger_log (const IceUtil::Handle< T > &instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_RemoteLogger_logPtr	newCallback_RemoteLogger_log (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_RemoteLogger_logPtr	newCallback_RemoteLogger_log (const IceUtil::Handle< T > &instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_RemoteLogger_logPtr	newCallback_RemoteLogger_log (T *instance, void(T::*cb)(), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_RemoteLogger_logPtr	newCallback_RemoteLogger_log (T *instance, void(T::*cb)(const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_RemoteLogger_logPtr	newCallback_RemoteLogger_log (T *instance, void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_RemoteLogger_logPtr	newCallback_RemoteLogger_log (T *instance, void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Router_addProxiesPtr	newCallback_Router_addProxies (const IceUtil::Handle< T > &instance, void(T::*cb)(const ObjectProxySeq &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Router_addProxiesPtr	newCallback_Router_addProxies (const IceUtil::Handle< T > &instance, void(T::*cb)(const ObjectProxySeq &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Router_addProxiesPtr	newCallback_Router_addProxies (T *instance, void(T::*cb)(const ObjectProxySeq &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Router_addProxiesPtr	newCallback_Router_addProxies (T *instance, void(T::*cb)(const ObjectProxySeq &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Router_getClientProxyPtr	newCallback_Router_getClientProxy (const IceUtil::Handle< T > &instance, void(T::*cb)(const ObjectPrx &, const IceUtil::Optional< bool > &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Router_getClientProxyPtr	newCallback_Router_getClientProxy (const IceUtil::Handle< T > &instance, void(T::*cb)(const ObjectPrx &, const IceUtil::Optional< bool > &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Router_getClientProxyPtr	newCallback_Router_getClientProxy (T *instance, void(T::*cb)(const ObjectPrx &, const IceUtil::Optional< bool > &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Router_getClientProxyPtr	newCallback_Router_getClientProxy (T *instance, void(T::*cb)(const ObjectPrx &, const IceUtil::Optional< bool > &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Router_getServerProxyPtr	newCallback_Router_getServerProxy (const IceUtil::Handle< T > &instance, void(T::*cb)(const ObjectPrx &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Router_getServerProxyPtr	newCallback_Router_getServerProxy (const IceUtil::Handle< T > &instance, void(T::*cb)(const ObjectPrx &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_Router_getServerProxyPtr	newCallback_Router_getServerProxy (T *instance, void(T::*cb)(const ObjectPrx &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_Router_getServerProxyPtr	newCallback_Router_getServerProxy (T *instance, void(T::*cb)(const ObjectPrx &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_RouterFinder_getRouterPtr	newCallback_RouterFinder_getRouter (const IceUtil::Handle< T > &instance, void(T::*cb)(const RouterPrx &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_RouterFinder_getRouterPtr	newCallback_RouterFinder_getRouter (const IceUtil::Handle< T > &instance, void(T::*cb)(const RouterPrx &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T>
Callback_RouterFinder_getRouterPtr	newCallback_RouterFinder_getRouter (T *instance, void(T::*cb)(const RouterPrx &), void(T::*excb)(const ::Ice::Exception &), void(T::*sentcb)(bool)=0)
	Creates a callback wrapper instance that delegates to your object.
template<class T, typename CT>
Callback_RouterFinder_getRouterPtr	newCallback_RouterFinder_getRouter (T *instance, void(T::*cb)(const RouterPrx &, const CT &), void(T::*excb)(const ::Ice::Exception &, const CT &), void(T::*sentcb)(bool, const CT &)=0)
	Creates a callback wrapper instance that delegates to your object.
std::ostream &	operator<< (std::ostream &out, const EncodingVersion &version)
std::ostream &	operator<< (std::ostream &out, const ProtocolVersion &version)
inline ::std::string	protocolVersionToString (const Ice::ProtocolVersion &v)
	Converts a protocol version into a string.
bool	proxyIdentityAndFacetEqual (const ObjectPrx &lhs, const ObjectPrx &rhs)
	Compares the object identities and facets of two proxies.
bool	proxyIdentityAndFacetLess (const ObjectPrx &lhs, const ObjectPrx &rhs)
	Compares the object identities and facets of two proxies.
bool	proxyIdentityEqual (const ObjectPrx &lhs, const ObjectPrx &rhs)
	Compares the object identities of two proxies.
bool	proxyIdentityLess (const ObjectPrx &lhs, const ObjectPrx &rhs)
	Compares the object identities of two proxies.
void	registerIceBT (bool loadOnInitialize=true)
	When using static libraries, calling this function ensures the IceBT plug-in is linked with the application.
void	registerIceDiscovery (bool loadOnInitialize=true)
	When using static libraries, calling this function ensures the IceDiscovery plug-in is linked with the application.
void	registerIceLocatorDiscovery (bool loadOnInitialize=true)
	When using static libraries, calling this function ensures the IceLocatorDiscovery plug-in is linked with the application.
void	registerIceSSL (bool loadOnInitialize=true)
	When using static libraries, calling this function ensures the SSL transport is linked with the application.
void	registerIceStringConverter (bool loadOnInitialize=true)
	When using static libraries, calling this function ensures the string converter plug-in is linked with the application.
void	registerIceUDP (bool loadOnInitialize=true)
	When using static libraries, calling this function ensures the UDP transport is linked with the application.
void	registerIceWS (bool loadOnInitialize=true)
	When using static libraries, calling this function ensures the WebSocket transport is linked with the application.
void	registerPluginFactory (const std::string &name, PluginFactory factory, bool loadOnInit)
	Manually registers a plug-in factory function.
void	setProcessLogger (const LoggerPtr &logger)
	Sets the per-process logger.
void	setProcessStringConverter (const StringConverterPtr &c)
	Installs a default narrow string converter for the process.
void	setProcessWstringConverter (const WstringConverterPtr &c)
	Installs a default wide string converter for the process.
ICE_API SliceChecksumDict	sliceChecksums ()
	Obtains the map containing the checksums for Slice definitions.
void	stringSeqToArgs (const StringSeq &seq, int &argc, char *argv[])
	Updates the argument vector to match the contents of the string sequence.
void	stringSeqToArgs (const StringSeq &seq, int &argc, const char *argv[])
	Updates the argument vector to match the contents of the string sequence.
inline ::Ice::EncodingVersion	stringToEncodingVersion (const ::std::string &v)
	Converts a string into an encoding version.
Identity	stringToIdentity (const std::string &str)
	Converts a stringified identity into an Identity.
inline ::Ice::ProtocolVersion	stringToProtocolVersion (const ::std::string &v)
	Converts a string into a protocol version.
std::wstring	stringToWstring (const std::string &str, const StringConverterPtr &nc=0, const WstringConverterPtr &wc=0)
	Converts a narrow string to a wide string.
template<typename T, typename U>
bool	targetEqualTo (const T &lhs, const U &rhs)
	Compares the contents of two smart pointers.
template<typename T, typename U>
bool	targetGreater (const T &lhs, const U &rhs)
	Compares the contents of two smart pointers.
template<typename T, typename U>
bool	targetGreaterEqual (const T &lhs, const U &rhs)
	Compares the contents of two smart pointers.
template<typename T, typename U>
bool	targetLess (const T &lhs, const U &rhs)
	Compares the contents of two smart pointers.
template<typename T, typename U>
bool	targetLessEqual (const T &lhs, const U &rhs)
	Compares the contents of two smart pointers.
template<typename T, typename U>
bool	targetNotEqualTo (const T &lhs, const U &rhs)
	Compares the contents of two smart pointers.
template<typename P>
P	uncheckedCast (const ::Ice::ObjectPrx &b, const std::string &f)
	Downcasts a proxy without confirming the target object's type via a remote invocation.
template<typename P, typename Y>
P	uncheckedCast (const ::IceInternal::ProxyHandle< Y > &b)
	Downcasts a proxy without confirming the target object's type via a remote invocation.
IceUtil::Shared *	upCast (::Ice::AMD_Object_ice_invoke *)
IceUtil::Shared *	upCast (::Ice::AsyncResult *)
IceUtil::Shared *	upCast (::Ice::LocalObject *)
Object *	upCast (Object *)
IceUtil::Shared *	upCast (SlicedData *)
IceUtil::Shared *	upCast (SliceInfo *)
IceUtil::Shared *	upCast (UnknownSlicedValue *)
std::string	UTF8ToNative (const std::string &str, const StringConverterPtr &nc)
	Converts a UTF-8 encoded string to a narrow string using a string converter.
std::string	wstringToString (const std::wstring &str, const StringConverterPtr &nc=0, const WstringConverterPtr &wc=0)
	Converts a wide string to a narrow string.

Variables
const Short	BTEndpointType = 6
	Uniquely identifies Bluetooth endpoints.
const Short	BTSEndpointType = 7
	Uniquely identifies SSL Bluetooth endpoints.
const EncodingVersion	currentEncoding
	Identifies the latest encoding version.
const ProtocolVersion	currentProtocol
	Identifies the latest protocol version.
const EncodingVersion	currentProtocolEncoding
	Identifies the latest protocol encoding version.
const Current	emptyCurrent
	A default-initialized Current instance.
const EncodingVersion	Encoding_1_0
	Identifies encoding version 1.0.
const EncodingVersion	Encoding_1_1
	Identifies encoding version 1.1.
const Short	iAPEndpointType = 8
	Uniquely identifies iAP-based endpoints.
const Short	iAPSEndpointType = 9
	Uniquely identifies SSL iAP-based endpoints.
const Context	noExplicitContext
	Marker value used to indicate that no explicit context was passed to a proxy invocation.
const ProtocolVersion	Protocol_1_0
	Identifies protocol version 1.0.
const Short	SSLEndpointType = 2
	Uniquely identifies SSL endpoints.
const Short	TCPEndpointType = 1
	Uniquely identifies TCP endpoints.
const Short	UDPEndpointType = 3
	Uniquely identifies UDP endpoints.
const Short	WSEndpointType = 4
	Uniquely identifies TCP-based WebSocket endpoints.
const Short	WSSEndpointType = 5
	Uniquely identifies SSL-based WebSocket endpoints.

Typedef Documentation

AMD_Locator_findAdapterByIdPtr

typedef ::IceUtil::Handle< ::Ice::AMD_Locator_findAdapterById> Ice::AMD_Locator_findAdapterByIdPtr

AMD_Locator_findObjectByIdPtr

typedef ::IceUtil::Handle< ::Ice::AMD_Locator_findObjectById> Ice::AMD_Locator_findObjectByIdPtr

AMD_LocatorRegistry_setAdapterDirectProxyPtr

typedef ::IceUtil::Handle< ::Ice::AMD_LocatorRegistry_setAdapterDirectProxy> Ice::AMD_LocatorRegistry_setAdapterDirectProxyPtr

AMD_LocatorRegistry_setReplicatedAdapterDirectProxyPtr

typedef ::IceUtil::Handle< ::Ice::AMD_LocatorRegistry_setReplicatedAdapterDirectProxy> Ice::AMD_LocatorRegistry_setReplicatedAdapterDirectProxyPtr

AMD_LocatorRegistry_setServerProcessProxyPtr

typedef ::IceUtil::Handle< ::Ice::AMD_LocatorRegistry_setServerProcessProxy> Ice::AMD_LocatorRegistry_setServerProcessProxyPtr

AMD_Object_ice_invokePtr

typedef IceInternal::Handle<AMD_Object_ice_invoke> Ice::AMD_Object_ice_invokePtr

AsyncResultPtr

typedef IceInternal::Handle<AsyncResult> Ice::AsyncResultPtr

BatchRequestInterceptorPtr

typedef IceUtil::Handle<BatchRequestInterceptor> Ice::BatchRequestInterceptorPtr

BoolSeq

typedef ::std::vector<bool> Ice::BoolSeq

A sequence of bools.

Byte

typedef unsigned char Ice::Byte

The mapping for the Slice byte type.

ByteSeq

typedef ::std::vector<Byte> Ice::ByteSeq

A sequence of bytes.

Callback_Communicator_flushBatchRequestsPtr

typedef ::IceUtil::Handle< Callback_Communicator_flushBatchRequests_Base> Ice::Callback_Communicator_flushBatchRequestsPtr

Callback_Connection_flushBatchRequestsPtr

typedef ::IceUtil::Handle< Callback_Connection_flushBatchRequests_Base> Ice::Callback_Connection_flushBatchRequestsPtr

Callback_Connection_heartbeatPtr

typedef ::IceUtil::Handle< Callback_Connection_heartbeat_Base> Ice::Callback_Connection_heartbeatPtr

Callback_Locator_findAdapterByIdPtr

typedef ::IceUtil::Handle< Callback_Locator_findAdapterById_Base> Ice::Callback_Locator_findAdapterByIdPtr

Callback_Locator_findObjectByIdPtr

typedef ::IceUtil::Handle< Callback_Locator_findObjectById_Base> Ice::Callback_Locator_findObjectByIdPtr

Callback_Locator_getRegistryPtr

typedef ::IceUtil::Handle< Callback_Locator_getRegistry_Base> Ice::Callback_Locator_getRegistryPtr

Callback_LocatorFinder_getLocatorPtr

typedef ::IceUtil::Handle< Callback_LocatorFinder_getLocator_Base> Ice::Callback_LocatorFinder_getLocatorPtr

Callback_LocatorRegistry_setAdapterDirectProxyPtr

typedef ::IceUtil::Handle< Callback_LocatorRegistry_setAdapterDirectProxy_Base> Ice::Callback_LocatorRegistry_setAdapterDirectProxyPtr

Callback_LocatorRegistry_setReplicatedAdapterDirectProxyPtr

typedef ::IceUtil::Handle< Callback_LocatorRegistry_setReplicatedAdapterDirectProxy_Base> Ice::Callback_LocatorRegistry_setReplicatedAdapterDirectProxyPtr

Callback_LocatorRegistry_setServerProcessProxyPtr

typedef ::IceUtil::Handle< Callback_LocatorRegistry_setServerProcessProxy_Base> Ice::Callback_LocatorRegistry_setServerProcessProxyPtr

Callback_LoggerAdmin_attachRemoteLoggerPtr

typedef ::IceUtil::Handle< Callback_LoggerAdmin_attachRemoteLogger_Base> Ice::Callback_LoggerAdmin_attachRemoteLoggerPtr

Callback_LoggerAdmin_detachRemoteLoggerPtr

typedef ::IceUtil::Handle< Callback_LoggerAdmin_detachRemoteLogger_Base> Ice::Callback_LoggerAdmin_detachRemoteLoggerPtr

Callback_LoggerAdmin_getLogPtr

typedef ::IceUtil::Handle< Callback_LoggerAdmin_getLog_Base> Ice::Callback_LoggerAdmin_getLogPtr

Callback_Object_ice_flushBatchRequestsPtr

typedef ::IceUtil::Handle< Callback_Object_ice_flushBatchRequests_Base> Ice::Callback_Object_ice_flushBatchRequestsPtr

Callback_Object_ice_getConnectionPtr

typedef ::IceUtil::Handle< Callback_Object_ice_getConnection_Base> Ice::Callback_Object_ice_getConnectionPtr

Callback_Object_ice_idPtr

typedef ::IceUtil::Handle< Callback_Object_ice_id_Base> Ice::Callback_Object_ice_idPtr

Callback_Object_ice_idsPtr

typedef ::IceUtil::Handle< Callback_Object_ice_ids_Base> Ice::Callback_Object_ice_idsPtr

Callback_Object_ice_invokePtr

typedef ::IceUtil::Handle< Callback_Object_ice_invoke_Base> Ice::Callback_Object_ice_invokePtr

Callback_Object_ice_isAPtr

typedef ::IceUtil::Handle< Callback_Object_ice_isA_Base> Ice::Callback_Object_ice_isAPtr

Callback_Object_ice_pingPtr

typedef ::IceUtil::Handle< Callback_Object_ice_ping_Base> Ice::Callback_Object_ice_pingPtr

Callback_Process_shutdownPtr

typedef ::IceUtil::Handle< Callback_Process_shutdown_Base> Ice::Callback_Process_shutdownPtr

Callback_Process_writeMessagePtr

typedef ::IceUtil::Handle< Callback_Process_writeMessage_Base> Ice::Callback_Process_writeMessagePtr

Callback_PropertiesAdmin_getPropertiesForPrefixPtr

typedef ::IceUtil::Handle< Callback_PropertiesAdmin_getPropertiesForPrefix_Base> Ice::Callback_PropertiesAdmin_getPropertiesForPrefixPtr

Callback_PropertiesAdmin_getPropertyPtr

typedef ::IceUtil::Handle< Callback_PropertiesAdmin_getProperty_Base> Ice::Callback_PropertiesAdmin_getPropertyPtr

Callback_PropertiesAdmin_setPropertiesPtr

typedef ::IceUtil::Handle< Callback_PropertiesAdmin_setProperties_Base> Ice::Callback_PropertiesAdmin_setPropertiesPtr

Callback_RemoteLogger_initPtr

typedef ::IceUtil::Handle< Callback_RemoteLogger_init_Base> Ice::Callback_RemoteLogger_initPtr

Callback_RemoteLogger_logPtr

typedef ::IceUtil::Handle< Callback_RemoteLogger_log_Base> Ice::Callback_RemoteLogger_logPtr

Callback_Router_addProxiesPtr

typedef ::IceUtil::Handle< Callback_Router_addProxies_Base> Ice::Callback_Router_addProxiesPtr

Callback_Router_getClientProxyPtr

typedef ::IceUtil::Handle< Callback_Router_getClientProxy_Base> Ice::Callback_Router_getClientProxyPtr

Callback_Router_getServerProxyPtr

typedef ::IceUtil::Handle< Callback_Router_getServerProxy_Base> Ice::Callback_Router_getServerProxyPtr

Callback_RouterFinder_getRouterPtr

typedef ::IceUtil::Handle< Callback_RouterFinder_getRouter_Base> Ice::Callback_RouterFinder_getRouterPtr

CallbackPtr

typedef IceUtil::Handle< ::IceInternal::GenericCallbackBase> Ice::CallbackPtr

CloseCallbackPtr

typedef ::IceInternal::Handle< CloseCallback> Ice::CloseCallbackPtr

CommunicatorPtr

typedef::IceInternal::Handle< Communicator > Ice::CommunicatorPtr

CompactIdResolverPtr

typedef IceUtil::Handle<CompactIdResolver> Ice::CompactIdResolverPtr

ConnectionInfoPtr

typedef::IceInternal::Handle< ConnectionInfo > Ice::ConnectionInfoPtr

ConnectionPtr

typedef::IceInternal::Handle< Connection > Ice::ConnectionPtr

Context

typedef::std::map<::std::string,::std::string > Ice::Context

A request context.

Context is used to transmit metadata about a request from the server to the client, such as Quality-of-Service (QoS) parameters. Each operation on the client has a Context as its implicit final parameter.

Context is used to transmit metadata about a request from the server to the client, such as Quality-of-Service (QoS) parameters. Each remote operation on a proxy optionally accepts a Context parameter.

CtrlCHandlerCallback

typedef void(* IceUtil::CtrlCHandlerCallback) (int sig)

Invoked when a signal occurs.

The callback must not raise exceptions. On Linux and macOS, the callback is NOT a signal handler and can call functions that are not async-signal safe.

Parameters

sig	The signal number that occurred.

DispatcherCallPtr

typedef IceUtil::Handle<DispatcherCall> Ice::DispatcherCallPtr

DispatcherPtr

typedef IceUtil::Handle<Dispatcher> Ice::DispatcherPtr

DispatchInterceptorAsyncCallbackPtr

typedef ::IceUtil::Handle<DispatchInterceptorAsyncCallback> Ice::DispatchInterceptorAsyncCallbackPtr

DispatchInterceptorPtr

typedef ::IceUtil::Handle<DispatchInterceptor> Ice::DispatchInterceptorPtr

Double

typedef double Ice::Double

The mapping for the Slice double type.

DoubleSeq

typedef ::std::vector<Double> Ice::DoubleSeq

A sequence of doubles.

EndpointInfoPtr

typedef::IceInternal::Handle< EndpointInfo > Ice::EndpointInfoPtr

EndpointPtr

typedef::IceInternal::Handle< Endpoint > Ice::EndpointPtr

EndpointSeq

typedef ::std::vector<EndpointPtr> Ice::EndpointSeq

A sequence of endpoints.

Error

typedef LoggerOutput<Logger, LoggerPtr, &Logger::error> Ice::Error

Flushes output to Logger::error.

Exception

typedef IceUtil::Exception Ice::Exception

FacetMap

typedef ::std::map< ::std::string, ObjectPtr> Ice::FacetMap

A mapping from facet name to servant.

Float

typedef float Ice::Float

The mapping for the Slice float type.

FloatSeq

typedef ::std::vector<Float> Ice::FloatSeq

A sequence of floats.

HeaderDict

typedef ::std::map< ::std::string, ::std::string> Ice::HeaderDict

A collection of HTTP headers.

HeartbeatCallbackPtr

typedef ::IceInternal::Handle< HeartbeatCallback> Ice::HeartbeatCallbackPtr

IdentitySeq

typedef ::std::vector<Identity> Ice::IdentitySeq

A sequence of identities.

IllegalConversionException

typedef IceUtil::IllegalConversionException Ice::IllegalConversionException

Indicates an error occurred during string conversion.

ImplicitContextPtr

typedef::IceInternal::Handle< ImplicitContext > Ice::ImplicitContextPtr

Int

typedef int Ice::Int

The mapping for the Slice int type.

IntSeq

typedef ::std::vector<Int> Ice::IntSeq

A sequence of ints.

IPConnectionInfoPtr

typedef ::IceInternal::Handle< IPConnectionInfo> Ice::IPConnectionInfoPtr

IPEndpointInfoPtr

typedef::IceInternal::Handle< IPEndpointInfo > Ice::IPEndpointInfoPtr

LocalObjectPtr

typedef IceInternal::Handle< LocalObject > Ice::LocalObjectPtr

LocatorFinderPrx

typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::LocatorFinder> Ice::LocatorFinderPrx

LocatorFinderPrxPtr

typedef LocatorFinderPrx Ice::LocatorFinderPrxPtr

LocatorFinderPtr

typedef ::IceInternal::Handle< LocatorFinder> Ice::LocatorFinderPtr

LocatorPrx

typedef::IceInternal::ProxyHandle<::IceProxy::Ice::Locator > Ice::LocatorPrx

LocatorPrxPtr

typedef LocatorPrx Ice::LocatorPrxPtr

LocatorPtr

typedef::IceInternal::Handle< Locator > Ice::LocatorPtr

LocatorRegistryPrx

typedef::IceInternal::ProxyHandle<::IceProxy::Ice::LocatorRegistry > Ice::LocatorRegistryPrx

LocatorRegistryPrxPtr

typedef LocatorRegistryPrx Ice::LocatorRegistryPrxPtr

LocatorRegistryPtr

typedef::IceInternal::Handle< LocatorRegistry > Ice::LocatorRegistryPtr

LoggerAdminPrx

typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::LoggerAdmin> Ice::LoggerAdminPrx

LoggerAdminPrxPtr

typedef LoggerAdminPrx Ice::LoggerAdminPrxPtr

LoggerAdminPtr

typedef ::IceInternal::Handle< LoggerAdmin> Ice::LoggerAdminPtr

LoggerPtr

typedef::IceInternal::Handle< Logger > Ice::LoggerPtr

LogMessageSeq

typedef std::list<LogMessage> Ice::LogMessageSeq

A sequence of LogMessage.

LogMessageTypeSeq

typedef ::std::vector<LogMessageType> Ice::LogMessageTypeSeq

A sequence of LogMessageType.

Long

typedef IceUtil::Int64 Ice::Long

The mapping for the Slice long type.

LongSeq

typedef ::std::vector<Long> Ice::LongSeq

A sequence of longs.

ObjectAdapterPtr

typedef::IceInternal::Handle<::Ice::ObjectAdapter > Ice::ObjectAdapterPtr

ObjectDict

typedef ::std::map<Identity, ObjectPtr> Ice::ObjectDict

A mapping between identities and Ice objects.

ObjectFactoryPtr

typedef ::IceInternal::Handle< ObjectFactory> Ice::ObjectFactoryPtr

ObjectProxySeq

typedef ::std::vector<ObjectPrx> Ice::ObjectProxySeq

A sequence of object proxies.

ObjectPrx

typedef::IceInternal::ProxyHandle<::IceProxy::Ice::Object > Ice::ObjectPrx

Smart pointer for an object proxy.

ObjectPrxPtr

typedef ObjectPrx Ice::ObjectPrxPtr

ObjectPtr

typedef IceInternal::Handle<Object> Ice::ObjectPtr

ObjectSeq

typedef ::std::vector<ObjectPtr> Ice::ObjectSeq

A sequence of objects.

OpaqueEndpointInfoPtr

typedef ::IceInternal::Handle< OpaqueEndpointInfo> Ice::OpaqueEndpointInfoPtr

PluginFactory

typedef Ice::Plugin *(* Ice::PluginFactory) (const ::Ice::CommunicatorPtr &communicator, const std::string &name, const ::Ice::StringSeq &args)

A plug-in factory function is responsible for creating an Ice plug-in.

Parameters

communicator	The communicator in which the plug-in will be installed.
name	The name assigned to the plug-in.
args	Additional arguments included in the plug-in's configuration.

Returns

The new plug-in object. Returning nil will cause the run time to raise PluginInitializationException.

PluginManagerPtr

typedef::IceInternal::Handle< PluginManager > Ice::PluginManagerPtr

PluginPtr

typedef::IceInternal::Handle< Plugin > Ice::PluginPtr

Print

typedef LoggerOutput<Logger, LoggerPtr, &Logger::print> Ice::Print

Flushes output to Logger::print.

ProcessPrx

typedef::IceInternal::ProxyHandle<::IceProxy::Ice::Process > Ice::ProcessPrx

ProcessPrxPtr

typedef ProcessPrx Ice::ProcessPrxPtr

ProcessPtr

typedef::IceInternal::Handle< Process > Ice::ProcessPtr

PropertiesAdminPrx

typedef::IceInternal::ProxyHandle<::IceProxy::Ice::PropertiesAdmin > Ice::PropertiesAdminPrx

PropertiesAdminPrxPtr

typedef PropertiesAdminPrx Ice::PropertiesAdminPrxPtr

PropertiesAdminPtr

typedef::IceInternal::Handle< PropertiesAdmin > Ice::PropertiesAdminPtr

PropertiesAdminUpdateCallbackPtr

typedef IceUtil::Handle<PropertiesAdminUpdateCallback> Ice::PropertiesAdminUpdateCallbackPtr

PropertiesPtr

typedef::IceInternal::Handle< Properties > Ice::PropertiesPtr

PropertyDict

typedef ::std::map< ::std::string, ::std::string> Ice::PropertyDict

A simple collection of properties, represented as a dictionary of key/value pairs.

Both key and value are strings.

See also

Properties::getPropertiesForPrefix

RemoteLoggerPrx

typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::RemoteLogger> Ice::RemoteLoggerPrx

RemoteLoggerPrxPtr

typedef RemoteLoggerPrx Ice::RemoteLoggerPrxPtr

RemoteLoggerPtr

typedef ::IceInternal::Handle< RemoteLogger> Ice::RemoteLoggerPtr

RouterFinderPrx

typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::RouterFinder> Ice::RouterFinderPrx

RouterFinderPrxPtr

typedef RouterFinderPrx Ice::RouterFinderPrxPtr

RouterFinderPtr

typedef ::IceInternal::Handle< RouterFinder> Ice::RouterFinderPtr

RouterPrx

typedef::IceInternal::ProxyHandle<::IceProxy::Ice::Router > Ice::RouterPrx

RouterPrxPtr

typedef RouterPrx Ice::RouterPrxPtr

RouterPtr

typedef::IceInternal::Handle< Router > Ice::RouterPtr

ServantLocatorPtr

typedef::IceInternal::Handle< ServantLocator > Ice::ServantLocatorPtr

Short

typedef short Ice::Short

The mapping for the Slice short type.

ShortSeq

typedef ::std::vector<Short> Ice::ShortSeq

A sequence of shorts.

SliceChecksumDict

typedef ::std::map< ::std::string, ::std::string> Ice::SliceChecksumDict

A mapping from type IDs to Slice checksums.

The dictionary allows verification at run time that client and server use matching Slice definitions.

SlicedDataPtr

typedef IceInternal::Handle<SlicedData> Ice::SlicedDataPtr

SliceInfoPtr

typedef IceInternal::Handle<SliceInfo> Ice::SliceInfoPtr

SliceInfoSeq

typedef ::std::vector<SliceInfoPtr> Ice::SliceInfoSeq

The slices of unknown types.

StringConverter

typedef IceUtil::StringConverter Ice::StringConverter

Narrow string converter.

StringConverterPtr

typedef IceUtil::StringConverterPtr Ice::StringConverterPtr

StringSeq

typedef ::std::vector< ::std::string> Ice::StringSeq

A sequence of strings.

TCPConnectionInfoPtr

typedef ::IceInternal::Handle< TCPConnectionInfo> Ice::TCPConnectionInfoPtr

TCPEndpointInfoPtr

typedef::IceInternal::Handle< TCPEndpointInfo > Ice::TCPEndpointInfoPtr

ThreadNotificationPtr

typedef IceUtil::Handle<ThreadNotification> Ice::ThreadNotificationPtr

UDPConnectionInfoPtr

typedef ::IceInternal::Handle< UDPConnectionInfo> Ice::UDPConnectionInfoPtr

UDPEndpointInfoPtr

typedef::IceInternal::Handle< UDPEndpointInfo > Ice::UDPEndpointInfoPtr

UnknownSlicedValuePtr

typedef IceInternal::Handle<UnknownSlicedValue> Ice::UnknownSlicedValuePtr

UserExceptionFactoryPtr

typedef ::IceUtil::Handle<UserExceptionFactory> Ice::UserExceptionFactoryPtr

UTF8Buffer

typedef IceUtil::UTF8Buffer Ice::UTF8Buffer

Encapsulates bytes in the UTF-8 encoding.

ValueFactoryManagerPtr

typedef ::IceInternal::Handle< ValueFactoryManager> Ice::ValueFactoryManagerPtr

ValueFactoryPtr

typedef ::IceInternal::Handle< ValueFactory> Ice::ValueFactoryPtr

ValuePtr

typedef ObjectPtr Ice::ValuePtr

Warning

typedef LoggerOutput<Logger, LoggerPtr, &Logger::warning> Ice::Warning

Flushes output to Logger::warning.

WSConnectionInfoPtr

typedef::IceInternal::Handle< WSConnectionInfo > Ice::WSConnectionInfoPtr

WSEndpointInfoPtr

typedef::IceInternal::Handle< WSEndpointInfo > Ice::WSEndpointInfoPtr

WstringConverter

typedef IceUtil::WstringConverter Ice::WstringConverter

Wide string converter.

WstringConverterPtr

typedef IceUtil::WstringConverterPtr Ice::WstringConverterPtr

Enumeration Type Documentation

ACMClose

enum Ice::ACMClose

Specifies the close semantics for Active Connection Management.

Enumerator
CloseOff	Disables automatic connection closure.
CloseOnIdle	Gracefully closes a connection that has been idle for the configured timeout period.
CloseOnInvocation	Forcefully closes a connection that has been idle for the configured timeout period, but only if the connection has pending invocations.
CloseOnInvocationAndIdle	Combines the behaviors of CloseOnIdle and CloseOnInvocation.
CloseOnIdleForceful	Forcefully closes a connection that has been idle for the configured timeout period, regardless of whether the connection has pending invocations or dispatch.

ACMHeartbeat

enum Ice::ACMHeartbeat

Specifies the heartbeat semantics for Active Connection Management.

Enumerator
HeartbeatOff	Disables heartbeats.
HeartbeatOnDispatch	Send a heartbeat at regular intervals if the connection is idle and only if there are pending dispatch.
HeartbeatOnIdle	Send a heartbeat at regular intervals when the connection is idle.
HeartbeatAlways	Send a heartbeat at regular intervals until the connection is closed.

CompressBatch

enum Ice::CompressBatch

The batch compression option when flushing queued batch requests.

Enumerator
CompressBatchYes	Compress the batch requests.
CompressBatchNo	Don't compress the batch requests.
CompressBatchBasedOnProxy	Compress the batch requests if at least one request was made on a compressed proxy.

ConnectionClose

enum Ice::ConnectionClose

Determines the behavior when manually closing a connection.

Enumerator
ConnectionCloseForcefully	Close the connection immediately without sending a close connection protocol message to the peer and waiting for the peer to acknowledge it.
ConnectionCloseGracefully	Close the connection by notifying the peer but do not wait for pending outgoing invocations to complete. On the server side, the connection will not be closed until all incoming invocations have completed.
ConnectionCloseGracefullyWithWait	Wait for all pending invocations to complete before closing the connection.

EndpointSelectionType

enum Ice::EndpointSelectionType

Determines the order in which the Ice run time uses the endpoints in a proxy when establishing a connection.

Enumerator
Random	Random causes the endpoints to be arranged in a random order.
Ordered	Ordered forces the Ice run time to use the endpoints in the order they appeared in the proxy.

FormatType

enum Ice::FormatType

Describes the possible formats for classes and exceptions.

Enumerator
DefaultFormat	Indicates that no preference was specified.
CompactFormat	A minimal format that eliminates the possibility for slicing unrecognized types.
SlicedFormat	Allow slicing and preserve slices for unknown types.

LogMessageType

enum Ice::LogMessageType

An enumeration representing the different types of log messages.

Enumerator
PrintMessage	The Logger received a print message.
TraceMessage	The Logger received a trace message.
WarningMessage	The Logger received a warning message.
ErrorMessage	The Logger received an error message.

OperationMode

enum Ice::OperationMode

Determines the retry behavior an invocation in case of a (potentially) recoverable error.

Enumerator
Normal	Ordinary operations have Normal mode. These operations modify object state; invoking such an operation twice in a row has different semantics than invoking it once. The Ice run time guarantees that it will not violate at-most-once semantics for Normal operations.
Nonmutating	Operations that use the Slice nonmutating keyword must not modify object state. For C++, nonmutating operations generate const member functions in the skeleton. In addition, the Ice run time will attempt to transparently recover from certain run-time errors by re-issuing a failed request and propagate the failure to the application only if the second attempt fails. Nonmutating is deprecated; Use the idempotent keyword instead. For C++, to retain the mapping of nonmutating operations to C++ const member functions, use the ["cpp:const"] metadata directive.
Idempotent	Operations that use the Slice idempotent keyword can modify object state, but invoking an operation twice in a row must result in the same object state as invoking it once. For example, x = 1 is an idempotent statement, whereas x += 1 is not. For idempotent operations, the Ice run-time uses the same retry behavior as for nonmutating operations in case of a potentially recoverable error.

SignalPolicy

enum Ice::SignalPolicy

Enumerator
HandleSignals	Enables signal handling.
NoSignalHandling	Disables signal handling, meaning signals retain their default behavior.

ToStringMode

enum Ice::ToStringMode

The output mode for xxxToString method such as identityToString and proxyToString.

The actual encoding format for the string is the same for all modes: you don't need to specify an encoding format or mode when reading such a string.

Enumerator
Unicode	Characters with ordinal values greater than 127 are kept as-is in the resulting string. Non-printable ASCII characters with ordinal values 127 and below are encoded as \t, \n (etc.) or \unnnn.
ASCII	Characters with ordinal values greater than 127 are encoded as universal character names in the resulting string: \unnnn for BMP characters and \Unnnnnnnn for non-BMP characters. Non-printable ASCII characters with ordinal values 127 and below are encoded as \t, \n (etc.) or \unnnn.
Compat	Characters with ordinal values greater than 127 are encoded as a sequence of UTF-8 bytes using octal escapes. Characters with ordinal values 127 and below are encoded as \t, \n (etc.) or an octal escape. Use this mode to generate strings compatible with Ice 3.6 and earlier.

Function Documentation

argsToStringSeq()

StringSeq Ice::argsToStringSeq	(	int	argc,
		const char *const	argv[] )

Converts an argument vector into a string sequence.

Parameters

argc	The number of arguments in argv.
argv	The arguments.

Returns

A string sequence containing the arguments.

checkedCast() [1/2]

template<typename P>

P Ice::checkedCast ( const ::Ice::ObjectPrx & b, const std::string & f, const ::Ice::Context & context = ::Ice::noExplicitContext )

inline

Downcasts a proxy after confirming the target object's type via a remote invocation.

Parameters

b	The target proxy.
f	A facet name.
context	The context map for the invocation.

Returns

A proxy with the requested type and facet, or nil if the target proxy is nil or the target object does not support the requested type.

checkedCast() [2/2]

template<typename P, typename Y>

P Ice::checkedCast ( const ::IceInternal::ProxyHandle< Y > & b, const ::Ice::Context & context = ::Ice::noExplicitContext )

inline

Downcasts a proxy after confirming the target object's type via a remote invocation.

Parameters

b	The target proxy.
context	The context map for the invocation.

Returns

A proxy with the requested type, or nil if the target proxy is nil or the target object does not support the requested type.

createIconvStringConverter()

template<typename charT>

::IceUtil::Handle< IceUtil::BasicStringConverter< charT > > Ice::createIconvStringConverter

(

const std::string &

internalCodeWithDefault = ""

)

Creates a string converter for the given code.

Parameters

internalCodeWithDefault

The desired code. If empty or not provided, a default code is used.

Returns

The converter object.

Exceptions

IconvInitializationException

If the code is not supported.

createProperties() [1/4]

PropertiesPtr Ice::createProperties

(

)

Creates a new empty property set.

Returns

A new empty property set.

createProperties() [2/4]

PropertiesPtr Ice::createProperties ( int & argc, char * argv[], const PropertiesPtr & defaults = 0 )

inline

Creates a property set initialized from command-line arguments and a default property set.

Parameters

argc	The number of arguments in argv. Upon return, this argument is updated to reflect the arguments still remaining in argv.
argv	Command-line arguments, possibly containing options to set properties. If the arguments include a –Ice.Config option, the corresponding configuration files are parsed. If the same property is set in a configuration file and in the arguments, the arguments take precedence. Recognized options are removed from this vector upon return.
defaults	Default values for the property set. Settings in configuration files and the arguments override these defaults.

Returns

A new property set initialized with the property settings that were removed from the argument vector.

createProperties() [3/4]

PropertiesPtr Ice::createProperties	(	int &	argc,
		const char *	argv[],
		const PropertiesPtr &	defaults = 0 )

Creates a property set initialized from command-line arguments and a default property set.

Parameters

argc	The number of arguments in argv. Upon return, this argument is updated to reflect the arguments still remaining in argv.
argv	Command-line arguments, possibly containing options to set properties. If the arguments include a –Ice.Config option, the corresponding configuration files are parsed. If the same property is set in a configuration file and in the arguments, the arguments take precedence. Recognized options are removed from this vector upon return.
defaults	Default values for the property set. Settings in configuration files and the arguments override these defaults.

Returns

A new property set initialized with the property settings that were removed from the argument vector.

createProperties() [4/4]

PropertiesPtr Ice::createProperties	(	StringSeq &	seq,
		const PropertiesPtr &	defaults = 0 )

Creates a property set initialized from command-line arguments and a default property set.

Parameters

seq	Command-line arguments, possibly containing options to set properties. If the arguments include a –Ice.Config option, the corresponding configuration files are parsed. If the same property is set in a configuration file and in the arguments, the arguments take precedence. Recognized options are removed from this container upon return.
defaults	Default values for the property set. Settings in configuration files and the arguments override these defaults.

Returns

A new property set initialized with the property settings that were removed from the argument vector.

createUnicodeWstringConverter()

WstringConverterPtr IceUtil::createUnicodeWstringConverter

(

)

Creates a string converter that converts between Unicode wide strings and UTF-8 strings.

encodingVersionToString()

inline ::std::string Ice::encodingVersionToString

(

const Ice::EncodingVersion &

v

)

Converts an encoding version into a string.

Parameters

v	The encoding version.

Returns

A string representing the encoding version.

generateUUID()

std::string IceUtil::generateUUID

(

)

Generates a UUID.

getProcessLogger()

LoggerPtr Ice::getProcessLogger

(

)

Obtains the per-process logger.

This logger is used by all communicators that do not have their own specific logger established at the time a communicator is created.

Returns

The current per-process logger instance.

getProcessStringConverter()

StringConverterPtr IceUtil::getProcessStringConverter

(

)

Obtains the default narrow string converter for the process.

getProcessWstringConverter()

WstringConverterPtr IceUtil::getProcessWstringConverter

(

)

Obtains the default wide string converter for the process.

ICE_DEFINE_PTR()

Ice::ICE_DEFINE_PTR	(	NativePropertiesAdminPtr	,
		NativePropertiesAdmin	)

identityToString()

std::string Ice::identityToString	(	const Identity &	id,
		ToStringMode	mode = Unicode )

Converts an Identity structure into a string using the specified mode.

Parameters

id	The identity structure.
mode	Affects the handling of non-ASCII characters and non-printable ASCII characters.

Returns

The stringified identity.

initialize() [1/8]

CommunicatorPtr Ice::initialize	(	const char *	configFile,
		int	version = 30711 )

Initializes a new communicator.

Parameters

configFile	The name of an Ice configuration file.
version	Indicates the Ice version with which the application is compatible. If not specified, the version of the Ice installation is used.

Returns

The new communicator.

initialize() [2/8]

CommunicatorPtr Ice::initialize	(	const InitializationData &	initData = InitializationData(),
		int	version = 30711 )

Initializes a new communicator.

Parameters

initData	Configuration data for the new Communicator.
version	Indicates the Ice version with which the application is compatible. If not specified, the version of the Ice installation is used.

Returns

The new communicator.

initialize() [3/8]

CommunicatorPtr Ice::initialize ( int & argc, char * argv[], const char * configFile, int version = 30711 )

inline

Initializes a new communicator.

Parameters

argc	The number of arguments in argv. Upon return, this argument is updated to reflect the arguments still remaining in argv.
argv	Command-line arguments, possibly containing options to set properties. If the arguments include a –Ice.Config option, the corresponding configuration files are parsed. If the same property is set in a configuration file and in the arguments, the arguments take precedence. Recognized options are removed from this vector upon return.
configFile	The name of an Ice configuration file.
version	Indicates the Ice version with which the application is compatible. If not specified, the version of the Ice installation is used.

Returns

The new communicator.

initialize() [4/8]

CommunicatorPtr Ice::initialize ( int & argc, char * argv[], const InitializationData & initData = InitializationData(), int version = 30711 )

inline

Initializes a new communicator.

Parameters

argc	The number of arguments in argv. Upon return, this argument is updated to reflect the arguments still remaining in argv.
argv	Command-line arguments, possibly containing options to set properties. If the arguments include a –Ice.Config option, the corresponding configuration files are parsed. If the same property is set in a configuration file and in the arguments, the arguments take precedence. Recognized options are removed from this vector upon return.
initData	Configuration data for the new Communicator.
version	Indicates the Ice version with which the application is compatible. If not specified, the version of the Ice installation is used.

Returns

The new communicator.

initialize() [5/8]

CommunicatorPtr Ice::initialize	(	int &	argc,
		const char *	argv[],
		const char *	configFile,
		int	version = 30711 )

Initializes a new communicator.

Parameters

argc	The number of arguments in argv. Upon return, this argument is updated to reflect the arguments still remaining in argv.
argv	Command-line arguments, possibly containing options to set properties. If the arguments include a –Ice.Config option, the corresponding configuration files are parsed. If the same property is set in a configuration file and in the arguments, the arguments take precedence. Recognized options are removed from this vector upon return.
configFile	The name of an Ice configuration file.
version	Indicates the Ice version with which the application is compatible. If not specified, the version of the Ice installation is used.

Returns

The new communicator.

initialize() [6/8]

CommunicatorPtr Ice::initialize	(	int &	argc,
		const char *	argv[],
		const InitializationData &	initData = InitializationData(),
		int	version = 30711 )

Initializes a new communicator.

Parameters

argc	The number of arguments in argv. Upon return, this argument is updated to reflect the arguments still remaining in argv.
argv	Command-line arguments, possibly containing options to set properties. If the arguments include a –Ice.Config option, the corresponding configuration files are parsed. If the same property is set in a configuration file and in the arguments, the arguments take precedence. Recognized options are removed from this vector upon return.
initData	Configuration data for the new Communicator.
version	Indicates the Ice version with which the application is compatible. If not specified, the version of the Ice installation is used.

Returns

The new communicator.

initialize() [7/8]

CommunicatorPtr Ice::initialize	(	StringSeq &	seq,
		const char *	configFile,
		int	version = 30711 )

Initializes a new communicator.

Parameters

seq	Command-line arguments, possibly containing options to set properties. If the arguments include a –Ice.Config option, the corresponding configuration files are parsed. If the same property is set in a configuration file and in the arguments, the arguments take precedence. Recognized options are removed from this container upon return.
configFile	The name of an Ice configuration file.
version	Indicates the Ice version with which the application is compatible. If not specified, the version of the Ice installation is used.

Returns

The new communicator.

initialize() [8/8]

CommunicatorPtr Ice::initialize	(	StringSeq &	seq,
		const InitializationData &	initData = InitializationData(),
		int	version = 30711 )

Initializes a new communicator.

Parameters

seq	Command-line arguments, possibly containing options to set properties. If the arguments include a –Ice.Config option, the corresponding configuration files are parsed. If the same property is set in a configuration file and in the arguments, the arguments take precedence. Recognized options are removed from this container upon return.
initData	Configuration data for the new Communicator.
version	Indicates the Ice version with which the application is compatible. If not specified, the version of the Ice installation is used.

Returns

The new communicator.

nativeToUTF8()

std::string IceUtil::nativeToUTF8	(	const std::string &	str,
		const StringConverterPtr &	nc )

Converts a narrow string to a UTF-8 encoded string using a string converter.

No conversion is performed if the string converter is nil.

newCallback() [1/2]

template<class T>

CallbackPtr Ice::newCallback	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const AsyncResultPtr &),
		void(T::*	sentcb )(const AsyncResultPtr &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The completion callback.
sentcb	The sent callback.

Returns

A callback object that can be passed to an asynchronous invocation.

newCallback() [2/2]

template<class T>

CallbackPtr Ice::newCallback	(	T *	instance,
		void(T::*	cb )(const AsyncResultPtr &),
		void(T::*	sentcb )(const AsyncResultPtr &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The completion callback.
sentcb	The sent callback.

Returns

A callback object that can be passed to an asynchronous invocation.

newCallback_Communicator_flushBatchRequests() [1/4]

template<class T>

Callback_Communicator_flushBatchRequestsPtr Ice::newCallback_Communicator_flushBatchRequests	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of Ice::Communicator::begin_flushBatchRequests.

newCallback_Communicator_flushBatchRequests() [2/4]

template<class T, typename CT>

Callback_Communicator_flushBatchRequestsPtr Ice::newCallback_Communicator_flushBatchRequests	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Type-safe asynchronous callback wrapper class used for calls to Ice::Communicator::begin_flushBatchRequests.

Create a wrapper instance by calling Ice::newCallback_Communicator_flushBatchRequests.

newCallback_Communicator_flushBatchRequests() [3/4]

template<class T>

Callback_Communicator_flushBatchRequestsPtr Ice::newCallback_Communicator_flushBatchRequests	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of Ice::Communicator::begin_flushBatchRequests.

newCallback_Communicator_flushBatchRequests() [4/4]

template<class T, typename CT>

Callback_Communicator_flushBatchRequestsPtr Ice::newCallback_Communicator_flushBatchRequests	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Type-safe asynchronous callback wrapper class used for calls to Ice::Communicator::begin_flushBatchRequests.

Create a wrapper instance by calling Ice::newCallback_Communicator_flushBatchRequests.

newCallback_Connection_flushBatchRequests() [1/4]

template<class T>

Callback_Connection_flushBatchRequestsPtr Ice::newCallback_Connection_flushBatchRequests	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of Ice::Connection::begin_flushBatchRequests.

newCallback_Connection_flushBatchRequests() [2/4]

template<class T, typename CT>

Callback_Connection_flushBatchRequestsPtr Ice::newCallback_Connection_flushBatchRequests	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of Ice::Connection::begin_flushBatchRequests.

newCallback_Connection_flushBatchRequests() [3/4]

template<class T>

Callback_Connection_flushBatchRequestsPtr Ice::newCallback_Connection_flushBatchRequests	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of Ice::Connection::begin_flushBatchRequests.

newCallback_Connection_flushBatchRequests() [4/4]

template<class T, typename CT>

Callback_Connection_flushBatchRequestsPtr Ice::newCallback_Connection_flushBatchRequests	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of Ice::Connection::begin_flushBatchRequests.

newCallback_Connection_heartbeat() [1/4]

template<class T>

Callback_Connection_heartbeatPtr Ice::newCallback_Connection_heartbeat	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of Ice::Connection::begin_heartbeat.

newCallback_Connection_heartbeat() [2/4]

template<class T, typename CT>

Callback_Connection_heartbeatPtr Ice::newCallback_Connection_heartbeat	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of Ice::Connection::begin_heartbeat.

newCallback_Connection_heartbeat() [3/4]

template<class T>

Callback_Connection_heartbeatPtr Ice::newCallback_Connection_heartbeat	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of Ice::Connection::begin_heartbeat.

newCallback_Connection_heartbeat() [4/4]

template<class T, typename CT>

Callback_Connection_heartbeatPtr Ice::newCallback_Connection_heartbeat	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of Ice::Connection::begin_heartbeat.

newCallback_Locator_findAdapterById() [1/4]

template<class T>

Callback_Locator_findAdapterByIdPtr Ice::newCallback_Locator_findAdapterById	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const ObjectPrx &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Locator::begin_findAdapterById.

newCallback_Locator_findAdapterById() [2/4]

template<class T, typename CT>

Callback_Locator_findAdapterByIdPtr Ice::newCallback_Locator_findAdapterById	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const ObjectPrx &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Locator::begin_findAdapterById.

newCallback_Locator_findAdapterById() [3/4]

template<class T>

Callback_Locator_findAdapterByIdPtr Ice::newCallback_Locator_findAdapterById	(	T *	instance,
		void(T::*	cb )(const ObjectPrx &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Locator::begin_findAdapterById.

newCallback_Locator_findAdapterById() [4/4]

template<class T, typename CT>

Callback_Locator_findAdapterByIdPtr Ice::newCallback_Locator_findAdapterById	(	T *	instance,
		void(T::*	cb )(const ObjectPrx &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Locator::begin_findAdapterById.

newCallback_Locator_findObjectById() [1/4]

template<class T>

Callback_Locator_findObjectByIdPtr Ice::newCallback_Locator_findObjectById	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const ObjectPrx &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Locator::begin_findObjectById.

newCallback_Locator_findObjectById() [2/4]

template<class T, typename CT>

Callback_Locator_findObjectByIdPtr Ice::newCallback_Locator_findObjectById	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const ObjectPrx &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Locator::begin_findObjectById.

newCallback_Locator_findObjectById() [3/4]

template<class T>

Callback_Locator_findObjectByIdPtr Ice::newCallback_Locator_findObjectById	(	T *	instance,
		void(T::*	cb )(const ObjectPrx &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Locator::begin_findObjectById.

newCallback_Locator_findObjectById() [4/4]

template<class T, typename CT>

Callback_Locator_findObjectByIdPtr Ice::newCallback_Locator_findObjectById	(	T *	instance,
		void(T::*	cb )(const ObjectPrx &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Locator::begin_findObjectById.

newCallback_Locator_getRegistry() [1/4]

template<class T>

Callback_Locator_getRegistryPtr Ice::newCallback_Locator_getRegistry	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const LocatorRegistryPrx &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Locator::begin_getRegistry.

newCallback_Locator_getRegistry() [2/4]

template<class T, typename CT>

Callback_Locator_getRegistryPtr Ice::newCallback_Locator_getRegistry	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const LocatorRegistryPrx &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Locator::begin_getRegistry.

newCallback_Locator_getRegistry() [3/4]

template<class T>

Callback_Locator_getRegistryPtr Ice::newCallback_Locator_getRegistry	(	T *	instance,
		void(T::*	cb )(const LocatorRegistryPrx &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Locator::begin_getRegistry.

newCallback_Locator_getRegistry() [4/4]

template<class T, typename CT>

Callback_Locator_getRegistryPtr Ice::newCallback_Locator_getRegistry	(	T *	instance,
		void(T::*	cb )(const LocatorRegistryPrx &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Locator::begin_getRegistry.

newCallback_LocatorFinder_getLocator() [1/4]

template<class T>

Callback_LocatorFinder_getLocatorPtr Ice::newCallback_LocatorFinder_getLocator	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const LocatorPrx &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorFinder::begin_getLocator.

newCallback_LocatorFinder_getLocator() [2/4]

template<class T, typename CT>

Callback_LocatorFinder_getLocatorPtr Ice::newCallback_LocatorFinder_getLocator	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const LocatorPrx &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorFinder::begin_getLocator.

newCallback_LocatorFinder_getLocator() [3/4]

template<class T>

Callback_LocatorFinder_getLocatorPtr Ice::newCallback_LocatorFinder_getLocator	(	T *	instance,
		void(T::*	cb )(const LocatorPrx &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorFinder::begin_getLocator.

newCallback_LocatorFinder_getLocator() [4/4]

template<class T, typename CT>

Callback_LocatorFinder_getLocatorPtr Ice::newCallback_LocatorFinder_getLocator	(	T *	instance,
		void(T::*	cb )(const LocatorPrx &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorFinder::begin_getLocator.

newCallback_LocatorRegistry_setAdapterDirectProxy() [1/8]

template<class T>

Callback_LocatorRegistry_setAdapterDirectProxyPtr Ice::newCallback_LocatorRegistry_setAdapterDirectProxy	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setAdapterDirectProxy.

newCallback_LocatorRegistry_setAdapterDirectProxy() [2/8]

template<class T, typename CT>

Callback_LocatorRegistry_setAdapterDirectProxyPtr Ice::newCallback_LocatorRegistry_setAdapterDirectProxy	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setAdapterDirectProxy.

newCallback_LocatorRegistry_setAdapterDirectProxy() [3/8]

template<class T>

Callback_LocatorRegistry_setAdapterDirectProxyPtr Ice::newCallback_LocatorRegistry_setAdapterDirectProxy	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setAdapterDirectProxy.

newCallback_LocatorRegistry_setAdapterDirectProxy() [4/8]

template<class T, typename CT>

Callback_LocatorRegistry_setAdapterDirectProxyPtr Ice::newCallback_LocatorRegistry_setAdapterDirectProxy	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setAdapterDirectProxy.

newCallback_LocatorRegistry_setAdapterDirectProxy() [5/8]

template<class T>

Callback_LocatorRegistry_setAdapterDirectProxyPtr Ice::newCallback_LocatorRegistry_setAdapterDirectProxy	(	T *	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setAdapterDirectProxy.

newCallback_LocatorRegistry_setAdapterDirectProxy() [6/8]

template<class T, typename CT>

Callback_LocatorRegistry_setAdapterDirectProxyPtr Ice::newCallback_LocatorRegistry_setAdapterDirectProxy	(	T *	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setAdapterDirectProxy.

newCallback_LocatorRegistry_setAdapterDirectProxy() [7/8]

template<class T>

Callback_LocatorRegistry_setAdapterDirectProxyPtr Ice::newCallback_LocatorRegistry_setAdapterDirectProxy	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setAdapterDirectProxy.

newCallback_LocatorRegistry_setAdapterDirectProxy() [8/8]

template<class T, typename CT>

Callback_LocatorRegistry_setAdapterDirectProxyPtr Ice::newCallback_LocatorRegistry_setAdapterDirectProxy	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setAdapterDirectProxy.

newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy() [1/8]

template<class T>

Callback_LocatorRegistry_setReplicatedAdapterDirectProxyPtr Ice::newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setReplicatedAdapterDirectProxy.

newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy() [2/8]

template<class T, typename CT>

Callback_LocatorRegistry_setReplicatedAdapterDirectProxyPtr Ice::newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setReplicatedAdapterDirectProxy.

newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy() [3/8]

template<class T>

Callback_LocatorRegistry_setReplicatedAdapterDirectProxyPtr Ice::newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setReplicatedAdapterDirectProxy.

newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy() [4/8]

template<class T, typename CT>

Callback_LocatorRegistry_setReplicatedAdapterDirectProxyPtr Ice::newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setReplicatedAdapterDirectProxy.

newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy() [5/8]

template<class T>

Callback_LocatorRegistry_setReplicatedAdapterDirectProxyPtr Ice::newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy	(	T *	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setReplicatedAdapterDirectProxy.

newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy() [6/8]

template<class T, typename CT>

Callback_LocatorRegistry_setReplicatedAdapterDirectProxyPtr Ice::newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy	(	T *	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setReplicatedAdapterDirectProxy.

newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy() [7/8]

template<class T>

Callback_LocatorRegistry_setReplicatedAdapterDirectProxyPtr Ice::newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setReplicatedAdapterDirectProxy.

newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy() [8/8]

template<class T, typename CT>

Callback_LocatorRegistry_setReplicatedAdapterDirectProxyPtr Ice::newCallback_LocatorRegistry_setReplicatedAdapterDirectProxy	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setReplicatedAdapterDirectProxy.

newCallback_LocatorRegistry_setServerProcessProxy() [1/8]

template<class T>

Callback_LocatorRegistry_setServerProcessProxyPtr Ice::newCallback_LocatorRegistry_setServerProcessProxy	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setServerProcessProxy.

newCallback_LocatorRegistry_setServerProcessProxy() [2/8]

template<class T, typename CT>

Callback_LocatorRegistry_setServerProcessProxyPtr Ice::newCallback_LocatorRegistry_setServerProcessProxy	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setServerProcessProxy.

newCallback_LocatorRegistry_setServerProcessProxy() [3/8]

template<class T>

Callback_LocatorRegistry_setServerProcessProxyPtr Ice::newCallback_LocatorRegistry_setServerProcessProxy	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setServerProcessProxy.

newCallback_LocatorRegistry_setServerProcessProxy() [4/8]

template<class T, typename CT>

Callback_LocatorRegistry_setServerProcessProxyPtr Ice::newCallback_LocatorRegistry_setServerProcessProxy	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setServerProcessProxy.

newCallback_LocatorRegistry_setServerProcessProxy() [5/8]

template<class T>

Callback_LocatorRegistry_setServerProcessProxyPtr Ice::newCallback_LocatorRegistry_setServerProcessProxy	(	T *	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setServerProcessProxy.

newCallback_LocatorRegistry_setServerProcessProxy() [6/8]

template<class T, typename CT>

Callback_LocatorRegistry_setServerProcessProxyPtr Ice::newCallback_LocatorRegistry_setServerProcessProxy	(	T *	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setServerProcessProxy.

newCallback_LocatorRegistry_setServerProcessProxy() [7/8]

template<class T>

Callback_LocatorRegistry_setServerProcessProxyPtr Ice::newCallback_LocatorRegistry_setServerProcessProxy	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setServerProcessProxy.

newCallback_LocatorRegistry_setServerProcessProxy() [8/8]

template<class T, typename CT>

Callback_LocatorRegistry_setServerProcessProxyPtr Ice::newCallback_LocatorRegistry_setServerProcessProxy	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LocatorRegistry::begin_setServerProcessProxy.

newCallback_LoggerAdmin_attachRemoteLogger() [1/8]

template<class T>

Callback_LoggerAdmin_attachRemoteLoggerPtr Ice::newCallback_LoggerAdmin_attachRemoteLogger	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger.

newCallback_LoggerAdmin_attachRemoteLogger() [2/8]

template<class T, typename CT>

Callback_LoggerAdmin_attachRemoteLoggerPtr Ice::newCallback_LoggerAdmin_attachRemoteLogger	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger.

newCallback_LoggerAdmin_attachRemoteLogger() [3/8]

template<class T>

Callback_LoggerAdmin_attachRemoteLoggerPtr Ice::newCallback_LoggerAdmin_attachRemoteLogger	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger.

newCallback_LoggerAdmin_attachRemoteLogger() [4/8]

template<class T, typename CT>

Callback_LoggerAdmin_attachRemoteLoggerPtr Ice::newCallback_LoggerAdmin_attachRemoteLogger	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger.

newCallback_LoggerAdmin_attachRemoteLogger() [5/8]

template<class T>

Callback_LoggerAdmin_attachRemoteLoggerPtr Ice::newCallback_LoggerAdmin_attachRemoteLogger	(	T *	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger.

newCallback_LoggerAdmin_attachRemoteLogger() [6/8]

template<class T, typename CT>

Callback_LoggerAdmin_attachRemoteLoggerPtr Ice::newCallback_LoggerAdmin_attachRemoteLogger	(	T *	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger.

newCallback_LoggerAdmin_attachRemoteLogger() [7/8]

template<class T>

Callback_LoggerAdmin_attachRemoteLoggerPtr Ice::newCallback_LoggerAdmin_attachRemoteLogger	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger.

newCallback_LoggerAdmin_attachRemoteLogger() [8/8]

template<class T, typename CT>

Callback_LoggerAdmin_attachRemoteLoggerPtr Ice::newCallback_LoggerAdmin_attachRemoteLogger	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_attachRemoteLogger.

newCallback_LoggerAdmin_detachRemoteLogger() [1/4]

template<class T>

Callback_LoggerAdmin_detachRemoteLoggerPtr Ice::newCallback_LoggerAdmin_detachRemoteLogger	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(bool),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_detachRemoteLogger.

newCallback_LoggerAdmin_detachRemoteLogger() [2/4]

template<class T, typename CT>

Callback_LoggerAdmin_detachRemoteLoggerPtr Ice::newCallback_LoggerAdmin_detachRemoteLogger	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(bool, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_detachRemoteLogger.

newCallback_LoggerAdmin_detachRemoteLogger() [3/4]

template<class T>

Callback_LoggerAdmin_detachRemoteLoggerPtr Ice::newCallback_LoggerAdmin_detachRemoteLogger	(	T *	instance,
		void(T::*	cb )(bool),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_detachRemoteLogger.

newCallback_LoggerAdmin_detachRemoteLogger() [4/4]

template<class T, typename CT>

Callback_LoggerAdmin_detachRemoteLoggerPtr Ice::newCallback_LoggerAdmin_detachRemoteLogger	(	T *	instance,
		void(T::*	cb )(bool, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_detachRemoteLogger.

newCallback_LoggerAdmin_getLog() [1/4]

template<class T>

Callback_LoggerAdmin_getLogPtr Ice::newCallback_LoggerAdmin_getLog	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const LogMessageSeq &, const ::std::string &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_getLog.

newCallback_LoggerAdmin_getLog() [2/4]

template<class T, typename CT>

Callback_LoggerAdmin_getLogPtr Ice::newCallback_LoggerAdmin_getLog	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const LogMessageSeq &, const ::std::string &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_getLog.

newCallback_LoggerAdmin_getLog() [3/4]

template<class T>

Callback_LoggerAdmin_getLogPtr Ice::newCallback_LoggerAdmin_getLog	(	T *	instance,
		void(T::*	cb )(const LogMessageSeq &, const ::std::string &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_getLog.

newCallback_LoggerAdmin_getLog() [4/4]

template<class T, typename CT>

Callback_LoggerAdmin_getLogPtr Ice::newCallback_LoggerAdmin_getLog	(	T *	instance,
		void(T::*	cb )(const LogMessageSeq &, const ::std::string &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::LoggerAdmin::begin_getLog.

newCallback_Object_ice_flushBatchRequests() [1/4]

template<class T>

Callback_Object_ice_flushBatchRequestsPtr Ice::newCallback_Object_ice_flushBatchRequests	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_flushBatchRequests.

newCallback_Object_ice_flushBatchRequests() [2/4]

template<class T, typename CT>

Callback_Object_ice_flushBatchRequestsPtr Ice::newCallback_Object_ice_flushBatchRequests	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_flushBatchRequests.

newCallback_Object_ice_flushBatchRequests() [3/4]

template<class T>

Callback_Object_ice_flushBatchRequestsPtr Ice::newCallback_Object_ice_flushBatchRequests	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_flushBatchRequests.

newCallback_Object_ice_flushBatchRequests() [4/4]

template<class T, typename CT>

Callback_Object_ice_flushBatchRequestsPtr Ice::newCallback_Object_ice_flushBatchRequests	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_flushBatchRequests.

newCallback_Object_ice_getConnection() [1/4]

template<class T>

Callback_Object_ice_getConnectionPtr Ice::newCallback_Object_ice_getConnection	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const ::Ice::ConnectionPtr &),
		void(T::*	excb )(const ::Ice::Exception &) )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_getConnection.

newCallback_Object_ice_getConnection() [2/4]

template<class T, typename CT>

Callback_Object_ice_getConnectionPtr Ice::newCallback_Object_ice_getConnection	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const ::Ice::ConnectionPtr &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &) )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_getConnection.

newCallback_Object_ice_getConnection() [3/4]

template<class T>

Callback_Object_ice_getConnectionPtr Ice::newCallback_Object_ice_getConnection	(	T *	instance,
		void(T::*	cb )(const ::Ice::ConnectionPtr &),
		void(T::*	excb )(const ::Ice::Exception &) )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_getConnection.

newCallback_Object_ice_getConnection() [4/4]

template<class T, typename CT>

Callback_Object_ice_getConnectionPtr Ice::newCallback_Object_ice_getConnection	(	T *	instance,
		void(T::*	cb )(const ::Ice::ConnectionPtr &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &) )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_getConnection.

newCallback_Object_ice_id() [1/8]

template<class T>

Callback_Object_ice_idPtr Ice::newCallback_Object_ice_id	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const ::std::string &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_id.

newCallback_Object_ice_id() [2/8]

template<class T, typename CT>

Callback_Object_ice_idPtr Ice::newCallback_Object_ice_id	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const ::std::string &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_id.

newCallback_Object_ice_id() [3/8]

template<class T>

Callback_Object_ice_idPtr Ice::newCallback_Object_ice_id	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_id.

newCallback_Object_ice_id() [4/8]

template<class T, typename CT>

Callback_Object_ice_idPtr Ice::newCallback_Object_ice_id	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_id.

newCallback_Object_ice_id() [5/8]

template<class T>

Callback_Object_ice_idPtr Ice::newCallback_Object_ice_id	(	T *	instance,
		void(T::*	cb )(const ::std::string &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_id.

newCallback_Object_ice_id() [6/8]

template<class T, typename CT>

Callback_Object_ice_idPtr Ice::newCallback_Object_ice_id	(	T *	instance,
		void(T::*	cb )(const ::std::string &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_id.

newCallback_Object_ice_id() [7/8]

template<class T>

Callback_Object_ice_idPtr Ice::newCallback_Object_ice_id	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_id.

newCallback_Object_ice_id() [8/8]

template<class T, typename CT>

Callback_Object_ice_idPtr Ice::newCallback_Object_ice_id	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_id.

newCallback_Object_ice_ids() [1/8]

template<class T>

Callback_Object_ice_idsPtr Ice::newCallback_Object_ice_ids	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const ::std::vector< ::std::string > &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ids.

newCallback_Object_ice_ids() [2/8]

template<class T, typename CT>

Callback_Object_ice_idsPtr Ice::newCallback_Object_ice_ids	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const ::std::vector< ::std::string > &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ids.

newCallback_Object_ice_ids() [3/8]

template<class T>

Callback_Object_ice_idsPtr Ice::newCallback_Object_ice_ids	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ids.

newCallback_Object_ice_ids() [4/8]

template<class T, typename CT>

Callback_Object_ice_idsPtr Ice::newCallback_Object_ice_ids	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ids.

newCallback_Object_ice_ids() [5/8]

template<class T>

Callback_Object_ice_idsPtr Ice::newCallback_Object_ice_ids	(	T *	instance,
		void(T::*	cb )(const ::std::vector< ::std::string > &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ids.

newCallback_Object_ice_ids() [6/8]

template<class T, typename CT>

Callback_Object_ice_idsPtr Ice::newCallback_Object_ice_ids	(	T *	instance,
		void(T::*	cb )(const ::std::vector< ::std::string > &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ids.

newCallback_Object_ice_ids() [7/8]

template<class T>

Callback_Object_ice_idsPtr Ice::newCallback_Object_ice_ids	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ids.

newCallback_Object_ice_ids() [8/8]

template<class T, typename CT>

Callback_Object_ice_idsPtr Ice::newCallback_Object_ice_ids	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ids.

newCallback_Object_ice_invoke() [1/12]

template<class T>

Callback_Object_ice_invokePtr Ice::newCallback_Object_ice_invoke	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(bool, const std::pair< const Byte *, const Byte * > &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.

newCallback_Object_ice_invoke() [2/12]

template<class T, typename CT>

Callback_Object_ice_invokePtr Ice::newCallback_Object_ice_invoke	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(bool, const std::pair< const Byte *, const Byte * > &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.

newCallback_Object_ice_invoke() [3/12]

template<class T>

Callback_Object_ice_invokePtr Ice::newCallback_Object_ice_invoke	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(bool, const std::vector< Ice::Byte > &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.

newCallback_Object_ice_invoke() [4/12]

template<class T, typename CT>

Callback_Object_ice_invokePtr Ice::newCallback_Object_ice_invoke	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(bool, const std::vector< Ice::Byte > &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.

newCallback_Object_ice_invoke() [5/12]

template<class T>

Callback_Object_ice_invokePtr Ice::newCallback_Object_ice_invoke	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.

newCallback_Object_ice_invoke() [6/12]

template<class T, typename CT>

Callback_Object_ice_invokePtr Ice::newCallback_Object_ice_invoke	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.

newCallback_Object_ice_invoke() [7/12]

template<class T>

Callback_Object_ice_invokePtr Ice::newCallback_Object_ice_invoke	(	T *	instance,
		void(T::*	cb )(bool, const std::pair< const Byte *, const Byte * > &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.

newCallback_Object_ice_invoke() [8/12]

template<class T, typename CT>

Callback_Object_ice_invokePtr Ice::newCallback_Object_ice_invoke	(	T *	instance,
		void(T::*	cb )(bool, const std::pair< const Byte *, const Byte * > &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.

newCallback_Object_ice_invoke() [9/12]

template<class T>

Callback_Object_ice_invokePtr Ice::newCallback_Object_ice_invoke	(	T *	instance,
		void(T::*	cb )(bool, const std::vector< Ice::Byte > &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.

newCallback_Object_ice_invoke() [10/12]

template<class T, typename CT>

Callback_Object_ice_invokePtr Ice::newCallback_Object_ice_invoke	(	T *	instance,
		void(T::*	cb )(bool, const std::vector< Ice::Byte > &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.

newCallback_Object_ice_invoke() [11/12]

template<class T>

Callback_Object_ice_invokePtr Ice::newCallback_Object_ice_invoke	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.

newCallback_Object_ice_invoke() [12/12]

template<class T, typename CT>

Callback_Object_ice_invokePtr Ice::newCallback_Object_ice_invoke	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.

newCallback_Object_ice_isA() [1/8]

template<class T>

Callback_Object_ice_isAPtr Ice::newCallback_Object_ice_isA	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(bool),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_isA.

newCallback_Object_ice_isA() [2/8]

template<class T, typename CT>

Callback_Object_ice_isAPtr Ice::newCallback_Object_ice_isA	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(bool, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_isA.

newCallback_Object_ice_isA() [3/8]

template<class T>

Callback_Object_ice_isAPtr Ice::newCallback_Object_ice_isA	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_isA.

newCallback_Object_ice_isA() [4/8]

template<class T, typename CT>

Callback_Object_ice_isAPtr Ice::newCallback_Object_ice_isA	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_isA.

newCallback_Object_ice_isA() [5/8]

template<class T>

Callback_Object_ice_isAPtr Ice::newCallback_Object_ice_isA	(	T *	instance,
		void(T::*	cb )(bool),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_isA.

newCallback_Object_ice_isA() [6/8]

template<class T, typename CT>

Callback_Object_ice_isAPtr Ice::newCallback_Object_ice_isA	(	T *	instance,
		void(T::*	cb )(bool, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_isA.

newCallback_Object_ice_isA() [7/8]

template<class T>

Callback_Object_ice_isAPtr Ice::newCallback_Object_ice_isA	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_isA.

newCallback_Object_ice_isA() [8/8]

template<class T, typename CT>

Callback_Object_ice_isAPtr Ice::newCallback_Object_ice_isA	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_isA.

newCallback_Object_ice_ping() [1/8]

template<class T>

Callback_Object_ice_pingPtr Ice::newCallback_Object_ice_ping	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ping.

newCallback_Object_ice_ping() [2/8]

template<class T, typename CT>

Callback_Object_ice_pingPtr Ice::newCallback_Object_ice_ping	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ping.

newCallback_Object_ice_ping() [3/8]

template<class T>

Callback_Object_ice_pingPtr Ice::newCallback_Object_ice_ping	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ping.

newCallback_Object_ice_ping() [4/8]

template<class T, typename CT>

Callback_Object_ice_pingPtr Ice::newCallback_Object_ice_ping	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ping.

newCallback_Object_ice_ping() [5/8]

template<class T>

Callback_Object_ice_pingPtr Ice::newCallback_Object_ice_ping	(	T *	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ping.

newCallback_Object_ice_ping() [6/8]

template<class T, typename CT>

Callback_Object_ice_pingPtr Ice::newCallback_Object_ice_ping	(	T *	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ping.

newCallback_Object_ice_ping() [7/8]

template<class T>

Callback_Object_ice_pingPtr Ice::newCallback_Object_ice_ping	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ping.

newCallback_Object_ice_ping() [8/8]

template<class T, typename CT>

Callback_Object_ice_pingPtr Ice::newCallback_Object_ice_ping	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ping.

newCallback_Process_shutdown() [1/8]

template<class T>

Callback_Process_shutdownPtr Ice::newCallback_Process_shutdown	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Process::begin_shutdown.

newCallback_Process_shutdown() [2/8]

template<class T, typename CT>

Callback_Process_shutdownPtr Ice::newCallback_Process_shutdown	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Process::begin_shutdown.

newCallback_Process_shutdown() [3/8]

template<class T>

Callback_Process_shutdownPtr Ice::newCallback_Process_shutdown	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Process::begin_shutdown.

newCallback_Process_shutdown() [4/8]

template<class T, typename CT>

Callback_Process_shutdownPtr Ice::newCallback_Process_shutdown	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Process::begin_shutdown.

newCallback_Process_shutdown() [5/8]

template<class T>

Callback_Process_shutdownPtr Ice::newCallback_Process_shutdown	(	T *	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Process::begin_shutdown.

newCallback_Process_shutdown() [6/8]

template<class T, typename CT>

Callback_Process_shutdownPtr Ice::newCallback_Process_shutdown	(	T *	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Process::begin_shutdown.

newCallback_Process_shutdown() [7/8]

template<class T>

Callback_Process_shutdownPtr Ice::newCallback_Process_shutdown	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Process::begin_shutdown.

newCallback_Process_shutdown() [8/8]

template<class T, typename CT>

Callback_Process_shutdownPtr Ice::newCallback_Process_shutdown	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Process::begin_shutdown.

newCallback_Process_writeMessage() [1/8]

template<class T>

Callback_Process_writeMessagePtr Ice::newCallback_Process_writeMessage	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Process::begin_writeMessage.

newCallback_Process_writeMessage() [2/8]

template<class T, typename CT>

Callback_Process_writeMessagePtr Ice::newCallback_Process_writeMessage	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Process::begin_writeMessage.

newCallback_Process_writeMessage() [3/8]

template<class T>

Callback_Process_writeMessagePtr Ice::newCallback_Process_writeMessage	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Process::begin_writeMessage.

newCallback_Process_writeMessage() [4/8]

template<class T, typename CT>

Callback_Process_writeMessagePtr Ice::newCallback_Process_writeMessage	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Process::begin_writeMessage.

newCallback_Process_writeMessage() [5/8]

template<class T>

Callback_Process_writeMessagePtr Ice::newCallback_Process_writeMessage	(	T *	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Process::begin_writeMessage.

newCallback_Process_writeMessage() [6/8]

template<class T, typename CT>

Callback_Process_writeMessagePtr Ice::newCallback_Process_writeMessage	(	T *	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Process::begin_writeMessage.

newCallback_Process_writeMessage() [7/8]

template<class T>

Callback_Process_writeMessagePtr Ice::newCallback_Process_writeMessage	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Process::begin_writeMessage.

newCallback_Process_writeMessage() [8/8]

template<class T, typename CT>

Callback_Process_writeMessagePtr Ice::newCallback_Process_writeMessage	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Process::begin_writeMessage.

newCallback_PropertiesAdmin_getPropertiesForPrefix() [1/4]

template<class T>

Callback_PropertiesAdmin_getPropertiesForPrefixPtr Ice::newCallback_PropertiesAdmin_getPropertiesForPrefix	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const PropertyDict &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::PropertiesAdmin::begin_getPropertiesForPrefix.

newCallback_PropertiesAdmin_getPropertiesForPrefix() [2/4]

template<class T, typename CT>

Callback_PropertiesAdmin_getPropertiesForPrefixPtr Ice::newCallback_PropertiesAdmin_getPropertiesForPrefix	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const PropertyDict &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::PropertiesAdmin::begin_getPropertiesForPrefix.

newCallback_PropertiesAdmin_getPropertiesForPrefix() [3/4]

template<class T>

Callback_PropertiesAdmin_getPropertiesForPrefixPtr Ice::newCallback_PropertiesAdmin_getPropertiesForPrefix	(	T *	instance,
		void(T::*	cb )(const PropertyDict &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::PropertiesAdmin::begin_getPropertiesForPrefix.

newCallback_PropertiesAdmin_getPropertiesForPrefix() [4/4]

template<class T, typename CT>

Callback_PropertiesAdmin_getPropertiesForPrefixPtr Ice::newCallback_PropertiesAdmin_getPropertiesForPrefix	(	T *	instance,
		void(T::*	cb )(const PropertyDict &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::PropertiesAdmin::begin_getPropertiesForPrefix.

newCallback_PropertiesAdmin_getProperty() [1/4]

template<class T>

Callback_PropertiesAdmin_getPropertyPtr Ice::newCallback_PropertiesAdmin_getProperty	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const ::std::string &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::PropertiesAdmin::begin_getProperty.

newCallback_PropertiesAdmin_getProperty() [2/4]

template<class T, typename CT>

Callback_PropertiesAdmin_getPropertyPtr Ice::newCallback_PropertiesAdmin_getProperty	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const ::std::string &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::PropertiesAdmin::begin_getProperty.

newCallback_PropertiesAdmin_getProperty() [3/4]

template<class T>

Callback_PropertiesAdmin_getPropertyPtr Ice::newCallback_PropertiesAdmin_getProperty	(	T *	instance,
		void(T::*	cb )(const ::std::string &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::PropertiesAdmin::begin_getProperty.

newCallback_PropertiesAdmin_getProperty() [4/4]

template<class T, typename CT>

Callback_PropertiesAdmin_getPropertyPtr Ice::newCallback_PropertiesAdmin_getProperty	(	T *	instance,
		void(T::*	cb )(const ::std::string &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::PropertiesAdmin::begin_getProperty.

newCallback_PropertiesAdmin_setProperties() [1/8]

template<class T>

Callback_PropertiesAdmin_setPropertiesPtr Ice::newCallback_PropertiesAdmin_setProperties	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::PropertiesAdmin::begin_setProperties.

newCallback_PropertiesAdmin_setProperties() [2/8]

template<class T, typename CT>

Callback_PropertiesAdmin_setPropertiesPtr Ice::newCallback_PropertiesAdmin_setProperties	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::PropertiesAdmin::begin_setProperties.

newCallback_PropertiesAdmin_setProperties() [3/8]

template<class T>

Callback_PropertiesAdmin_setPropertiesPtr Ice::newCallback_PropertiesAdmin_setProperties	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::PropertiesAdmin::begin_setProperties.

newCallback_PropertiesAdmin_setProperties() [4/8]

template<class T, typename CT>

Callback_PropertiesAdmin_setPropertiesPtr Ice::newCallback_PropertiesAdmin_setProperties	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::PropertiesAdmin::begin_setProperties.

newCallback_PropertiesAdmin_setProperties() [5/8]

template<class T>

Callback_PropertiesAdmin_setPropertiesPtr Ice::newCallback_PropertiesAdmin_setProperties	(	T *	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::PropertiesAdmin::begin_setProperties.

newCallback_PropertiesAdmin_setProperties() [6/8]

template<class T, typename CT>

Callback_PropertiesAdmin_setPropertiesPtr Ice::newCallback_PropertiesAdmin_setProperties	(	T *	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::PropertiesAdmin::begin_setProperties.

newCallback_PropertiesAdmin_setProperties() [7/8]

template<class T>

Callback_PropertiesAdmin_setPropertiesPtr Ice::newCallback_PropertiesAdmin_setProperties	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::PropertiesAdmin::begin_setProperties.

newCallback_PropertiesAdmin_setProperties() [8/8]

template<class T, typename CT>

Callback_PropertiesAdmin_setPropertiesPtr Ice::newCallback_PropertiesAdmin_setProperties	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::PropertiesAdmin::begin_setProperties.

newCallback_RemoteLogger_init() [1/8]

template<class T>

Callback_RemoteLogger_initPtr Ice::newCallback_RemoteLogger_init	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_init.

newCallback_RemoteLogger_init() [2/8]

template<class T, typename CT>

Callback_RemoteLogger_initPtr Ice::newCallback_RemoteLogger_init	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_init.

newCallback_RemoteLogger_init() [3/8]

template<class T>

Callback_RemoteLogger_initPtr Ice::newCallback_RemoteLogger_init	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_init.

newCallback_RemoteLogger_init() [4/8]

template<class T, typename CT>

Callback_RemoteLogger_initPtr Ice::newCallback_RemoteLogger_init	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_init.

newCallback_RemoteLogger_init() [5/8]

template<class T>

Callback_RemoteLogger_initPtr Ice::newCallback_RemoteLogger_init	(	T *	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_init.

newCallback_RemoteLogger_init() [6/8]

template<class T, typename CT>

Callback_RemoteLogger_initPtr Ice::newCallback_RemoteLogger_init	(	T *	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_init.

newCallback_RemoteLogger_init() [7/8]

template<class T>

Callback_RemoteLogger_initPtr Ice::newCallback_RemoteLogger_init	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_init.

newCallback_RemoteLogger_init() [8/8]

template<class T, typename CT>

Callback_RemoteLogger_initPtr Ice::newCallback_RemoteLogger_init	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_init.

newCallback_RemoteLogger_log() [1/8]

template<class T>

Callback_RemoteLogger_logPtr Ice::newCallback_RemoteLogger_log	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_log.

newCallback_RemoteLogger_log() [2/8]

template<class T, typename CT>

Callback_RemoteLogger_logPtr Ice::newCallback_RemoteLogger_log	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_log.

newCallback_RemoteLogger_log() [3/8]

template<class T>

Callback_RemoteLogger_logPtr Ice::newCallback_RemoteLogger_log	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_log.

newCallback_RemoteLogger_log() [4/8]

template<class T, typename CT>

Callback_RemoteLogger_logPtr Ice::newCallback_RemoteLogger_log	(	const IceUtil::Handle< T > &	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_log.

newCallback_RemoteLogger_log() [5/8]

template<class T>

Callback_RemoteLogger_logPtr Ice::newCallback_RemoteLogger_log	(	T *	instance,
		void(T::*	cb )(),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_log.

newCallback_RemoteLogger_log() [6/8]

template<class T, typename CT>

Callback_RemoteLogger_logPtr Ice::newCallback_RemoteLogger_log	(	T *	instance,
		void(T::*	cb )(const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_log.

newCallback_RemoteLogger_log() [7/8]

template<class T>

Callback_RemoteLogger_logPtr Ice::newCallback_RemoteLogger_log	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_log.

newCallback_RemoteLogger_log() [8/8]

template<class T, typename CT>

Callback_RemoteLogger_logPtr Ice::newCallback_RemoteLogger_log	(	T *	instance,
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RemoteLogger::begin_log.

newCallback_Router_addProxies() [1/4]

template<class T>

Callback_Router_addProxiesPtr Ice::newCallback_Router_addProxies	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const ObjectProxySeq &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Router::begin_addProxies.

newCallback_Router_addProxies() [2/4]

template<class T, typename CT>

Callback_Router_addProxiesPtr Ice::newCallback_Router_addProxies	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const ObjectProxySeq &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Router::begin_addProxies.

newCallback_Router_addProxies() [3/4]

template<class T>

Callback_Router_addProxiesPtr Ice::newCallback_Router_addProxies	(	T *	instance,
		void(T::*	cb )(const ObjectProxySeq &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Router::begin_addProxies.

newCallback_Router_addProxies() [4/4]

template<class T, typename CT>

Callback_Router_addProxiesPtr Ice::newCallback_Router_addProxies	(	T *	instance,
		void(T::*	cb )(const ObjectProxySeq &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Router::begin_addProxies.

newCallback_Router_getClientProxy() [1/4]

template<class T>

Callback_Router_getClientProxyPtr Ice::newCallback_Router_getClientProxy	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const ObjectPrx &, const IceUtil::Optional< bool > &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Router::begin_getClientProxy.

newCallback_Router_getClientProxy() [2/4]

template<class T, typename CT>

Callback_Router_getClientProxyPtr Ice::newCallback_Router_getClientProxy	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const ObjectPrx &, const IceUtil::Optional< bool > &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Router::begin_getClientProxy.

newCallback_Router_getClientProxy() [3/4]

template<class T>

Callback_Router_getClientProxyPtr Ice::newCallback_Router_getClientProxy	(	T *	instance,
		void(T::*	cb )(const ObjectPrx &, const IceUtil::Optional< bool > &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Router::begin_getClientProxy.

newCallback_Router_getClientProxy() [4/4]

template<class T, typename CT>

Callback_Router_getClientProxyPtr Ice::newCallback_Router_getClientProxy	(	T *	instance,
		void(T::*	cb )(const ObjectPrx &, const IceUtil::Optional< bool > &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Router::begin_getClientProxy.

newCallback_Router_getServerProxy() [1/4]

template<class T>

Callback_Router_getServerProxyPtr Ice::newCallback_Router_getServerProxy	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const ObjectPrx &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Router::begin_getServerProxy.

newCallback_Router_getServerProxy() [2/4]

template<class T, typename CT>

Callback_Router_getServerProxyPtr Ice::newCallback_Router_getServerProxy	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const ObjectPrx &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Router::begin_getServerProxy.

newCallback_Router_getServerProxy() [3/4]

template<class T>

Callback_Router_getServerProxyPtr Ice::newCallback_Router_getServerProxy	(	T *	instance,
		void(T::*	cb )(const ObjectPrx &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Router::begin_getServerProxy.

newCallback_Router_getServerProxy() [4/4]

template<class T, typename CT>

Callback_Router_getServerProxyPtr Ice::newCallback_Router_getServerProxy	(	T *	instance,
		void(T::*	cb )(const ObjectPrx &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::Router::begin_getServerProxy.

newCallback_RouterFinder_getRouter() [1/4]

template<class T>

Callback_RouterFinder_getRouterPtr Ice::newCallback_RouterFinder_getRouter	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const RouterPrx &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RouterFinder::begin_getRouter.

newCallback_RouterFinder_getRouter() [2/4]

template<class T, typename CT>

Callback_RouterFinder_getRouterPtr Ice::newCallback_RouterFinder_getRouter	(	const IceUtil::Handle< T > &	instance,
		void(T::*	cb )(const RouterPrx &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RouterFinder::begin_getRouter.

newCallback_RouterFinder_getRouter() [3/4]

template<class T>

Callback_RouterFinder_getRouterPtr Ice::newCallback_RouterFinder_getRouter	(	T *	instance,
		void(T::*	cb )(const RouterPrx &),
		void(T::*	excb )(const ::Ice::Exception &),
		void(T::*	sentcb )(bool) = 0 )

Creates a callback wrapper instance that delegates to your object.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RouterFinder::begin_getRouter.

newCallback_RouterFinder_getRouter() [4/4]

template<class T, typename CT>

Callback_RouterFinder_getRouterPtr Ice::newCallback_RouterFinder_getRouter	(	T *	instance,
		void(T::*	cb )(const RouterPrx &, const CT &),
		void(T::*	excb )(const ::Ice::Exception &, const CT &),
		void(T::*	sentcb )(bool, const CT &) = 0 )

Creates a callback wrapper instance that delegates to your object.

Use this overload when your callback methods receive a cookie value.

Parameters

instance	The callback object.
cb	The success method of the callback object.
excb	The exception method of the callback object.
sentcb	The sent method of the callback object.

Returns

An object that can be passed to an asynchronous invocation of IceProxy::Ice::RouterFinder::begin_getRouter.

operator<<() [1/2]

std::ostream & Ice::operator<< ( std::ostream & out, const EncodingVersion & version )

inline

operator<<() [2/2]

std::ostream & Ice::operator<< ( std::ostream & out, const ProtocolVersion & version )

inline

protocolVersionToString()

inline ::std::string Ice::protocolVersionToString

(

const Ice::ProtocolVersion &

v

)

Converts a protocol version into a string.

Parameters

v	The protocol version.

Returns

A string representing the protocol version.

proxyIdentityAndFacetEqual()

bool Ice::proxyIdentityAndFacetEqual	(	const ObjectPrx &	lhs,
		const ObjectPrx &	rhs )

Compares the object identities and facets of two proxies.

Parameters

lhs	A proxy.
rhs	A proxy.

Returns

True if the identity and facet in lhs compare equal to the identity and facet in rhs, false otherwise.

proxyIdentityAndFacetLess()

bool Ice::proxyIdentityAndFacetLess	(	const ObjectPrx &	lhs,
		const ObjectPrx &	rhs )

Compares the object identities and facets of two proxies.

Parameters

lhs	A proxy.
rhs	A proxy.

Returns

True if the identity and facet in lhs compare less than the identity and facet in rhs, false otherwise.

proxyIdentityEqual()

bool Ice::proxyIdentityEqual	(	const ObjectPrx &	lhs,
		const ObjectPrx &	rhs )

Compares the object identities of two proxies.

Parameters

lhs	A proxy.
rhs	A proxy.

Returns

True if the identity in lhs compares equal to the identity in rhs, false otherwise.

proxyIdentityLess()

bool Ice::proxyIdentityLess	(	const ObjectPrx &	lhs,
		const ObjectPrx &	rhs )

Compares the object identities of two proxies.

Parameters

lhs	A proxy.
rhs	A proxy.

Returns

True if the identity in lhs compares less than the identity in rhs, false otherwise.

registerIceBT()

void Ice::registerIceBT

(

bool

loadOnInitialize = true

)

When using static libraries, calling this function ensures the IceBT plug-in is linked with the application.

Parameters

loadOnInitialize

If true, the plug-in is loaded (created) during communicator initialization. If false, the plug-in is only loaded during communicator initialization if its corresponding plug-in property is set to 1.

registerIceDiscovery()

void Ice::registerIceDiscovery

(

bool

loadOnInitialize = true

)

When using static libraries, calling this function ensures the IceDiscovery plug-in is linked with the application.

Parameters

loadOnInitialize

If true, the plug-in is loaded (created) during communicator initialization. If false, the plug-in is only loaded during communicator initialization if its corresponding plug-in property is set to 1.

registerIceLocatorDiscovery()

void Ice::registerIceLocatorDiscovery

(

bool

loadOnInitialize = true

)

When using static libraries, calling this function ensures the IceLocatorDiscovery plug-in is linked with the application.

Parameters

loadOnInitialize

If true, the plug-in is loaded (created) during communicator initialization. If false, the plug-in is only loaded during communicator initialization if its corresponding plug-in property is set to 1.

registerIceSSL()

void Ice::registerIceSSL

(

bool

loadOnInitialize = true

)

When using static libraries, calling this function ensures the SSL transport is linked with the application.

Parameters

loadOnInitialize

If true, the plug-in is loaded (created) during communicator initialization. If false, the plug-in is only loaded during communicator initialization if its corresponding plug-in property is set to 1.

registerIceStringConverter()

void Ice::registerIceStringConverter

(

bool

loadOnInitialize = true

)

When using static libraries, calling this function ensures the string converter plug-in is linked with the application.

Parameters

loadOnInitialize

If true, the plug-in is loaded (created) during communicator initialization. If false, the plug-in is only loaded during communicator initialization if its corresponding plug-in property is set to 1.

registerIceUDP()

void Ice::registerIceUDP

(

bool

loadOnInitialize = true

)

When using static libraries, calling this function ensures the UDP transport is linked with the application.

Parameters

loadOnInitialize

If true, the plug-in is loaded (created) during communicator initialization. If false, the plug-in is only loaded during communicator initialization if its corresponding plug-in property is set to 1.

registerIceWS()

void Ice::registerIceWS

(

bool

loadOnInitialize = true

)

When using static libraries, calling this function ensures the WebSocket transport is linked with the application.

Parameters

loadOnInitialize

If true, the plug-in is loaded (created) during communicator initialization. If false, the plug-in is only loaded during communicator initialization if its corresponding plug-in property is set to 1.

registerPluginFactory()

void Ice::registerPluginFactory	(	const std::string &	name,
		PluginFactory	factory,
		bool	loadOnInit )

Manually registers a plug-in factory function.

Parameters

name	The name assigned to the plug-in.
factory	The factory function.
loadOnInit	If true, the plug-in is always loaded (created) during communicator initialization, even if Ice.Plugin.name is not set. When false, the plug-in is loaded (created) during communication initialization only if Ice.Plugin.name is set to a non-empty value (e.g.: Ice.Plugin.IceSSL=1).

setProcessLogger()

void Ice::setProcessLogger

(

const LoggerPtr &

logger

)

Sets the per-process logger.

This logger is used by all communicators that do not have their own specific logger established at the time a communicator is created.

Parameters

logger

The new per-process logger instance.

setProcessStringConverter()

void IceUtil::setProcessStringConverter

(

const StringConverterPtr &

c

)

Installs a default narrow string converter for the process.

setProcessWstringConverter()

void IceUtil::setProcessWstringConverter

(

const WstringConverterPtr &

c

)

Installs a default wide string converter for the process.

sliceChecksums()

ICE_API SliceChecksumDict Ice::sliceChecksums

(

)

Obtains the map containing the checksums for Slice definitions.

Returns

The checksum map.

stringSeqToArgs() [1/2]

void Ice::stringSeqToArgs ( const StringSeq & seq, int & argc, char * argv[] )

inline

Updates the argument vector to match the contents of the string sequence.

This function assumes that the string sequence only contains elements of the argument vector. The function shifts the the argument vector elements so that the vector matches the contents of the sequence.

Parameters

seq	The string sequence returned from a call to argsToStringSeq.
argc	Updated to reflect the size of the sequence.
argv	Elements are shifted to match the sequence.

stringSeqToArgs() [2/2]

void Ice::stringSeqToArgs	(	const StringSeq &	seq,
		int &	argc,
		const char *	argv[] )

Updates the argument vector to match the contents of the string sequence.

This function assumes that the string sequence only contains elements of the argument vector. The function shifts the the argument vector elements so that the vector matches the contents of the sequence.

Parameters

seq	The string sequence returned from a call to argsToStringSeq.
argc	Updated to reflect the size of the sequence.
argv	Elements are shifted to match the sequence.

stringToEncodingVersion()

inline ::Ice::EncodingVersion Ice::stringToEncodingVersion

(

const ::std::string &

v

)

Converts a string into an encoding version.

Parameters

v	The string containing a stringified encoding version.

Returns

The encoding version.

Exceptions

VersionParseException

If the given string is not in the X.Y format.

stringToIdentity()

Identity Ice::stringToIdentity

(

const std::string &

str

)

Converts a stringified identity into an Identity.

Parameters

str	The stringified identity.

Returns

An Identity structure containing the name and category components.

stringToProtocolVersion()

inline ::Ice::ProtocolVersion Ice::stringToProtocolVersion

(

const ::std::string &

v

)

Converts a string into a protocol version.

Parameters

v	The string containing a stringified protocol version.

Returns

The protocol version.

Exceptions

VersionParseException

If the given string is not in the X.Y format.

stringToWstring()

std::wstring IceUtil::stringToWstring	(	const std::string &	str,
		const StringConverterPtr &	nc = 0,
		const WstringConverterPtr &	wc = 0 )

Converts a narrow string to a wide string.

targetEqualTo()

template<typename T, typename U>

bool Ice::targetEqualTo ( const T & lhs, const U & rhs )

inline

Compares the contents of two smart pointers.

Parameters

lhs	The left-hand side.
rhs	The right-hand side.

Returns

True if the contents are equal, false otherwise.

targetGreater()

template<typename T, typename U>

bool Ice::targetGreater ( const T & lhs, const U & rhs )

inline

Compares the contents of two smart pointers.

Parameters

lhs	The left-hand side.
rhs	The right-hand side.

Returns

True if the left-hand side compares greater than the right-hand side, false otherwise.

targetGreaterEqual()

template<typename T, typename U>

bool Ice::targetGreaterEqual ( const T & lhs, const U & rhs )

inline

Compares the contents of two smart pointers.

Parameters

lhs	The left-hand side.
rhs	The right-hand side.

Returns

True if the left-hand side compares greater than or equal to the right-hand side, false otherwise.

targetLess()

template<typename T, typename U>

bool Ice::targetLess ( const T & lhs, const U & rhs )

inline

Compares the contents of two smart pointers.

Parameters

lhs	The left-hand side.
rhs	The right-hand side.

Returns

True if the left-hand side compares less than the right-hand side, false otherwise.

targetLessEqual()

template<typename T, typename U>

bool Ice::targetLessEqual ( const T & lhs, const U & rhs )

inline

Compares the contents of two smart pointers.

Parameters

lhs	The left-hand side.
rhs	The right-hand side.

Returns

True if the left-hand side compares less than or equal to the right-hand side, false otherwise.

targetNotEqualTo()

template<typename T, typename U>

bool Ice::targetNotEqualTo ( const T & lhs, const U & rhs )

inline

Compares the contents of two smart pointers.

Parameters

lhs	The left-hand side.
rhs	The right-hand side.

Returns

True if the contents are not equal, false otherwise.

uncheckedCast() [1/2]

template<typename P>

P Ice::uncheckedCast ( const ::Ice::ObjectPrx & b, const std::string & f )

inline

Downcasts a proxy without confirming the target object's type via a remote invocation.

Parameters

b	The target proxy.
f	A facet name.

Returns

A proxy with the requested type and facet.

uncheckedCast() [2/2]

template<typename P, typename Y>

P Ice::uncheckedCast ( const ::IceInternal::ProxyHandle< Y > & b )

inline

Downcasts a proxy without confirming the target object's type via a remote invocation.

Parameters

b	The target proxy.

Returns

A proxy with the requested type.

upCast() [1/7]

IceUtil::Shared * Ice::upCast

(

::Ice::AMD_Object_ice_invoke *

)

upCast() [2/7]

IceUtil::Shared * Ice::upCast

(

::Ice::AsyncResult *

)

upCast() [3/7]

IceUtil::Shared * Ice::upCast

(

::Ice::LocalObject *

)

upCast() [4/7]

Object * Ice::upCast

(

Object *

)

upCast() [5/7]

IceUtil::Shared * Ice::upCast

(

SlicedData *

)

upCast() [6/7]

IceUtil::Shared * Ice::upCast

(

SliceInfo *

)

upCast() [7/7]

IceUtil::Shared * Ice::upCast

(

UnknownSlicedValue *

)

UTF8ToNative()

std::string IceUtil::UTF8ToNative	(	const std::string &	str,
		const StringConverterPtr &	nc )

Converts a UTF-8 encoded string to a narrow string using a string converter.

No conversion is performed if the string converter is nil.

wstringToString()

std::string IceUtil::wstringToString	(	const std::wstring &	str,
		const StringConverterPtr &	nc = 0,
		const WstringConverterPtr &	wc = 0 )

Converts a wide string to a narrow string.

Variable Documentation

BTEndpointType

const Short Ice::BTEndpointType = 6

Uniquely identifies Bluetooth endpoints.

BTSEndpointType

const Short Ice::BTSEndpointType = 7

Uniquely identifies SSL Bluetooth endpoints.

currentEncoding

const EncodingVersion Ice::currentEncoding

extern

Identifies the latest encoding version.

currentProtocol

const ProtocolVersion Ice::currentProtocol

extern

Identifies the latest protocol version.

currentProtocolEncoding

const EncodingVersion Ice::currentProtocolEncoding

extern

Identifies the latest protocol encoding version.

emptyCurrent

const Current Ice::emptyCurrent

extern

A default-initialized Current instance.

Encoding_1_0

const EncodingVersion Ice::Encoding_1_0

extern

Identifies encoding version 1.0.

Encoding_1_1

const EncodingVersion Ice::Encoding_1_1

extern

Identifies encoding version 1.1.

iAPEndpointType

const Short Ice::iAPEndpointType = 8

Uniquely identifies iAP-based endpoints.

iAPSEndpointType

const Short Ice::iAPSEndpointType = 9

Uniquely identifies SSL iAP-based endpoints.

noExplicitContext

const Context Ice::noExplicitContext

extern

Marker value used to indicate that no explicit context was passed to a proxy invocation.

Sentinel value indicating that no explicit context argument was passed to a remote invocation.

Protocol_1_0

const ProtocolVersion Ice::Protocol_1_0

extern

Identifies protocol version 1.0.

SSLEndpointType

const Short Ice::SSLEndpointType = 2

Uniquely identifies SSL endpoints.

TCPEndpointType

const Short Ice::TCPEndpointType = 1

Uniquely identifies TCP endpoints.

UDPEndpointType

const Short Ice::UDPEndpointType = 3

Uniquely identifies UDP endpoints.

WSEndpointType

const Short Ice::WSEndpointType = 4

Uniquely identifies TCP-based WebSocket endpoints.

WSSEndpointType

const Short Ice::WSSEndpointType = 5

Uniquely identifies SSL-based WebSocket endpoints.