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	Application
	Singleton helper class that simplifies Ice initialization, finalization and signal handling. 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	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	CFNetworkException
	This exception indicates CFNetwork errors. More...
class	CloneNotImplementedException
	An attempt was made to clone a class that does not support cloning. 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	DispatchInterceptor
	Base class for a dispatch interceptor, which is a servant that dispatches requests to another servant. 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	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	InterfaceByValue
	Represents an instance of a Slice interface that was marshaled by value. 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	LocalExceptionHelper
	Helper template for the implementation of Ice::LocalException. More...
class	Locator
	The Ice locator interface. More...
class	LocatorFinder
	This interface should be implemented by services implementing the Ice::Locator interface. More...
class	LocatorFinderPrx
	This interface should be implemented by services implementing the Ice::Locator interface. More...
class	LocatorPrx
	The Ice locator interface. More...
class	LocatorRegistry
	The Ice locator registry interface. More...
class	LocatorRegistryPrx
	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	LoggerAdminPrx
	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	MarshaledResult
	Base class for marshaled result structures, which are generated for operations having the marshaled-result metadata tag. 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	ObjectPrx
	Base class of all object proxies. 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	ProcessPrx
	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	PropertiesAdminPrx
	The PropertiesAdmin interface provides remote access to the properties of a communicator. 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	RemoteLoggerPrx
	The Ice remote logger interface. 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	RouterFinderPrx
	This interface should be implemented by services implementing the Ice::Router interface. More...
class	RouterPrx
	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...
struct	TargetCompare
	Functor class that compares the contents of two smart pointers of the given type using the given comparator. 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	UserExceptionHelper
	Helper template for the implementation of Ice::UserException. More...
class	Value
	The base class for instances of Slice classes. 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
using	bad_optional_access = std::experimental::Ice::bad_optional_access
	Raised when accessing an optional that doesn't contain a value.
template<typename charT>
using	BasicStringConverter = IceUtil::BasicStringConverter<charT>
	Base class for a string converter.
using	BoolSeq = ::std::vector<bool>
	A sequence of bools.
typedef unsigned char	Byte
	The mapping for the Slice byte type.
using	ByteSeq = ::std::vector<Byte>
	A sequence of bytes.
using	CloseCallback = ::std::function<void(const ::std::shared_ptr<Connection>& con)>
	This method is called by the connection when the connection is closed.
typedef IceUtil::Handle< CompactIdResolver >	CompactIdResolverPtr
using	Context = ::std::map<::std::string, ::std::string>
	A request context.
using	CtrlCHandlerCallback
	Invoked when a signal occurs.
using	DispatchInterceptorPtr = ::std::shared_ptr<DispatchInterceptor>
typedef double	Double
	The mapping for the Slice double type.
using	DoubleSeq = ::std::vector<double>
	A sequence of doubles.
using	EndpointSeq = ::std::vector<::std::shared_ptr<Endpoint>>
	A sequence of endpoints.
typedef LoggerOutput< Logger, LoggerPtr, &Logger::error >	Error
	Flushes output to Logger::error.
typedef IceUtil::Exception	Exception
using	FacetMap = ::std::map<::std::string, ::std::shared_ptr<Object>>
	A mapping from facet name to servant.
typedef float	Float
	The mapping for the Slice float type.
using	FloatSeq = ::std::vector<float>
	A sequence of floats.
using	HeaderDict = ::std::map<::std::string, ::std::string>
	A collection of HTTP headers.
using	HeartbeatCallback = ::std::function<void(const ::std::shared_ptr<Connection>& con)>
	This method is called by the connection when a heartbeat is received from the peer.
using	IdentitySeq = ::std::vector<Identity>
	A sequence of identities.
typedef IceUtil::IllegalConversionException	IllegalConversionException
	Indicates an error occurred during string conversion.
using	in_place_t = std::experimental::Ice::in_place_t
	This type indicates that an optional value should be constructed in place.
typedef int	Int
	The mapping for the Slice int type.
using	IntSeq = ::std::vector<int>
	A sequence of ints.
typedef IceInternal::Handle< LocalObject >	LocalObjectPtr
using	LogMessageSeq = std::list<LogMessage>
	A sequence of LogMessage.
using	LogMessageTypeSeq = ::std::vector<LogMessageType>
	A sequence of LogMessageType.
typedef long long int	Long
	The mapping for the Slice long type.
using	LongSeq = ::std::vector<long long int>
	A sequence of longs.
using	nullopt_t = std::experimental::Ice::nullopt_t
	This type indicates that no value is provided.
using	ObjectDict = ::std::map<Identity, ::std::shared_ptr<Object>>
	A mapping between identities and Ice objects.
using	ObjectProxySeq = ::std::vector<::std::shared_ptr<ObjectPrx>>
	A sequence of object proxies.
using	ObjectSeq = ::std::vector<::std::shared_ptr<Value>>
	A sequence of objects.
template<class T>
using	optional = std::experimental::Ice::optional<T>
	Ice::optional is a placeholder for std::optional.
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 LoggerOutput< Logger, LoggerPtr, &Logger::print >	Print
	Flushes output to Logger::print.
using	PropertyDict = ::std::map<::std::string, ::std::string>
	A simple collection of properties, represented as a dictionary of key/value pairs.
typedef short	Short
	The mapping for the Slice short type.
using	ShortSeq = ::std::vector<short>
	A sequence of shorts.
using	SliceChecksumDict = ::std::map<::std::string, ::std::string>
	A mapping from type IDs to Slice checksums.
typedef ::std::vector< SliceInfoPtr >	SliceInfoSeq
	The slices of unknown types.
typedef IceUtil::StringConverter	StringConverter
	Narrow string converter.
typedef IceUtil::StringConverterPtr	StringConverterPtr
using	StringSeq = ::std::vector<::std::string>
	A sequence of strings.
typedef IceUtil::Handle< ThreadNotification >	ThreadNotificationPtr
using	UserExceptionFactory = std::function<void(const std::string&)>
	Creates and throws a user exception.
typedef IceUtil::UTF8Buffer	UTF8Buffer
	Encapsulates bytes in the UTF-8 encoding.
using	ValueFactory = ::std::function<::std::shared_ptr<Value>(const ::std::string& type)>
	Create a new value for a given value type.
typedef LoggerOutput< Logger, LoggerPtr, &Logger::warning >	Warning
	Flushes output to Logger::warning.
typedef IceUtil::WstringConverter	WstringConverter
	Wide string converter.
typedef IceUtil::WstringConverterPtr	WstringConverterPtr

Enumerations
enum class	ACMClose : unsigned char {   CloseOff , CloseOnIdle , CloseOnInvocation , CloseOnInvocationAndIdle ,   CloseOnIdleForceful }
	Specifies the close semantics for Active Connection Management. More...
enum class	ACMHeartbeat : unsigned char { HeartbeatOff , HeartbeatOnDispatch , HeartbeatOnIdle , HeartbeatAlways }
	Specifies the heartbeat semantics for Active Connection Management. More...
enum class	CompressBatch : unsigned char { Yes , No , BasedOnProxy }
	The batch compression option when flushing queued batch requests. More...
enum class	ConnectionClose : unsigned char { Forcefully , Gracefully , GracefullyWithWait }
	Determines the behavior when manually closing a connection. More...
enum class	EndpointSelectionType : unsigned char { Random , Ordered }
	Determines the order in which the Ice run time uses the endpoints in a proxy when establishing a connection. More...
enum class	FormatType : unsigned char { DefaultFormat , CompactFormat , SlicedFormat }
	Describes the possible formats for classes and exceptions. More...
enum class	LogMessageType : unsigned char { PrintMessage , TraceMessage , WarningMessage , ErrorMessage }
	An enumeration representing the different types of log messages. More...
enum class	OperationMode : unsigned char { Normal , Nonmutating , Idempotent }
	Determines the retry behavior an invocation in case of a (potentially) recoverable error. More...
enum class	SignalPolicy : unsigned char { HandleSignals , NoSignalHandling }
	Determines how the Application class handles signals. More...
enum class	ToStringMode : unsigned char { 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, typename T, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, P >::value >::type * = nullptr, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, T >::value >::type * = nullptr>
::std::shared_ptr< P >	checkedCast (const ::std::shared_ptr< T > &b, const ::Ice::Context &context=Ice::noExplicitContext)
	Downcasts a proxy after confirming the target object's type via a remote invocation.
template<typename P, typename T, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, P >::value >::type * = nullptr, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, T >::value >::type * = nullptr>
::std::shared_ptr< P >	checkedCast (const ::std::shared_ptr< T > &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 charT>
::std::shared_ptr< 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=ToStringMode::Unicode)
	Converts an Identity structure into a string using the specified mode.
CommunicatorPtr	initialize (const InitializationData &initData=InitializationData(), int version=30711)
	Initializes a new communicator.
CommunicatorPtr	initialize (const std::string &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, char *argv[], const std::string &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 (int &argc, const char *argv[], const std::string &configFile, int version=30711)
	Initializes a new communicator.
CommunicatorPtr	initialize (StringSeq &seq, const InitializationData &initData=InitializationData(), int version=30711)
	Initializes a new communicator.
CommunicatorPtr	initialize (StringSeq &seq, const std::string &configFile, int version=30711)
	Initializes a new communicator.
template<class T>
constexpr optional< typename decay< T >::type >	make_optional (T &&v)
	Creates an optional object.
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 C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator!= (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator!= (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator!= (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator!= (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator!= (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator!= (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
bool	operator!= (const ObjectPrx &lhs, const ObjectPrx &rhs)
template<class T>
constexpr bool	operator!= (const optional< T > &x, const optional< T > &y)
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator< (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator< (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator< (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator< (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator< (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator< (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class T>
constexpr bool	operator< (const optional< T > &x, const optional< T > &y)
::std::ostream &	operator<< (::std::ostream &, const ::Ice::ObjectPrx &)
std::ostream &	operator<< (std::ostream &out, const EncodingVersion &version)
std::ostream &	operator<< (std::ostream &out, const ProtocolVersion &version)
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator<= (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator<= (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator<= (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator<= (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator<= (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator<= (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
bool	operator<= (const ObjectPrx &lhs, const ObjectPrx &rhs)
template<class T>
constexpr bool	operator<= (const optional< T > &x, const optional< T > &y)
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator== (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator== (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator== (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator== (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator== (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator== (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class T>
constexpr bool	operator== (const optional< T > &x, const optional< T > &y)
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator> (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator> (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator> (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator> (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator> (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator> (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
bool	operator> (const ObjectPrx &lhs, const ObjectPrx &rhs)
template<class T>
constexpr bool	operator> (const optional< T > &x, const optional< T > &y)
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator>= (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator>= (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator>= (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator>= (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator>= (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
bool	operator>= (const C &lhs, const C &rhs)
	Relational operator for generated structs and classes.
bool	operator>= (const ObjectPrx &lhs, const ObjectPrx &rhs)
template<class T>
constexpr bool	operator>= (const optional< T > &x, const optional< T > &y)
inline ::std::string	protocolVersionToString (const Ice::ProtocolVersion &v)
	Converts a protocol version into a string.
bool	proxyIdentityAndFacetEqual (const ::std::shared_ptr< ObjectPrx > &lhs, const ::std::shared_ptr< ObjectPrx > &rhs)
	Compares the object identities and facets of two proxies.
bool	proxyIdentityAndFacetLess (const ::std::shared_ptr< ObjectPrx > &lhs, const ::std::shared_ptr< ObjectPrx > &rhs)
	Compares the object identities and facets of two proxies.
bool	proxyIdentityEqual (const ::std::shared_ptr< ObjectPrx > &lhs, const ::std::shared_ptr< ObjectPrx > &rhs)
	Compares the object identities of two proxies.
bool	proxyIdentityLess (const ::std::shared_ptr< ObjectPrx > &lhs, const ::std::shared_ptr< 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<class T>
void	swap (optional< T > &x, optional< T > &y) noexcept(noexcept(x.swap(y)))
	Exchanges the state of an optional object with another one.
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, typename T, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, P >::value >::type * = nullptr, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, T >::value >::type * = nullptr>
::std::shared_ptr< P >	uncheckedCast (const ::std::shared_ptr< T > &b)
	Downcasts a proxy without confirming the target object's type via a remote invocation.
template<typename P, typename T, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, P >::value >::type * = nullptr, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, T >::value >::type * = nullptr>
::std::shared_ptr< P >	uncheckedCast (const ::std::shared_ptr< T > &b, const std::string &f)
	Downcasts a proxy without confirming the target object's type via a remote invocation.
IceUtil::Shared *	upCast (::Ice::LocalObject *)
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
constexpr short	BTEndpointType = 6
	Uniquely identifies Bluetooth endpoints.
constexpr 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.
constexpr short	iAPEndpointType = 8
	Uniquely identifies iAP-based endpoints.
constexpr short	iAPSEndpointType = 9
	Uniquely identifies SSL iAP-based endpoints.
constexpr struct std::experimental::Ice::in_place_t	in_place
	An instance of in_place_t that indicates that an optional value should be constructed in place.
const Context	noExplicitContext
	Marker value used to indicate that no explicit context was passed to a proxy invocation.
constexpr nullopt_t	nullopt
	An instance of nullopt_t used as a marker value to indicate that no value is provided.
const ProtocolVersion	Protocol_1_0
	Identifies protocol version 1.0.
constexpr short	SSLEndpointType = 2
	Uniquely identifies SSL endpoints.
constexpr short	TCPEndpointType = 1
	Uniquely identifies TCP endpoints.
constexpr short	UDPEndpointType = 3
	Uniquely identifies UDP endpoints.
constexpr short	WSEndpointType = 4
	Uniquely identifies TCP-based WebSocket endpoints.
constexpr short	WSSEndpointType = 5
	Uniquely identifies SSL-based WebSocket endpoints.

Typedef Documentation

bad_optional_access

using Ice::bad_optional_access = std::experimental::Ice::bad_optional_access

Raised when accessing an optional that doesn't contain a value.

BasicStringConverter

template<typename charT>

using Ice::BasicStringConverter = IceUtil::BasicStringConverter<charT>

Base class for a string converter.

BoolSeq

using Ice::BoolSeq = ::std::vector<bool>

A sequence of bools.

Byte

typedef unsigned char Ice::Byte

The mapping for the Slice byte type.

ByteSeq

using Ice::ByteSeq = ::std::vector<Byte>

A sequence of bytes.

CloseCallback

using Ice::CloseCallback = ::std::function<void(const ::std::shared_ptr<Connection>& con)>

This method is called by the connection when the connection is closed.

If the callback needs more information about the closure, it can call Connection#throwException.

Parameters

con	The connection that closed.

CompactIdResolverPtr

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

Context

using Ice::Context = ::std::map<::std::string, ::std::string>

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.

CtrlCHandlerCallback

using IceUtil::CtrlCHandlerCallback

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.

DispatchInterceptorPtr

using Ice::DispatchInterceptorPtr = ::std::shared_ptr<DispatchInterceptor>

Double

typedef double Ice::Double

The mapping for the Slice double type.

DoubleSeq

using Ice::DoubleSeq = ::std::vector<double>

A sequence of doubles.

EndpointSeq

using Ice::EndpointSeq = ::std::vector<::std::shared_ptr<Endpoint>>

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

using Ice::FacetMap = ::std::map<::std::string, ::std::shared_ptr<Object>>

A mapping from facet name to servant.

Float

typedef float Ice::Float

The mapping for the Slice float type.

FloatSeq

using Ice::FloatSeq = ::std::vector<float>

A sequence of floats.

HeaderDict

using Ice::HeaderDict = ::std::map<::std::string, ::std::string>

A collection of HTTP headers.

HeartbeatCallback

using Ice::HeartbeatCallback = ::std::function<void(const ::std::shared_ptr<Connection>& con)>

This method is called by the connection when a heartbeat is received from the peer.

Parameters

con	The connection on which a heartbeat was received.

IdentitySeq

using Ice::IdentitySeq = ::std::vector<Identity>

A sequence of identities.

IllegalConversionException

typedef IceUtil::IllegalConversionException Ice::IllegalConversionException

Indicates an error occurred during string conversion.

in_place_t

using Ice::in_place_t = std::experimental::Ice::in_place_t

This type indicates that an optional value should be constructed in place.

Int

typedef int Ice::Int

The mapping for the Slice int type.

IntSeq

using Ice::IntSeq = ::std::vector<int>

A sequence of ints.

LocalObjectPtr

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

LogMessageSeq

using Ice::LogMessageSeq = std::list<LogMessage>

A sequence of LogMessage.

LogMessageTypeSeq

using Ice::LogMessageTypeSeq = ::std::vector<LogMessageType>

A sequence of LogMessageType.

Long

typedef long long int Ice::Long

The mapping for the Slice long type.

LongSeq

using Ice::LongSeq = ::std::vector<long long int>

A sequence of longs.

nullopt_t

using Ice::nullopt_t = std::experimental::Ice::nullopt_t

This type indicates that no value is provided.

ObjectDict

using Ice::ObjectDict = ::std::map<Identity, ::std::shared_ptr<Object>>

A mapping between identities and Ice objects.

ObjectProxySeq

using Ice::ObjectProxySeq = ::std::vector<::std::shared_ptr<ObjectPrx>>

A sequence of object proxies.

ObjectSeq

using Ice::ObjectSeq = ::std::vector<::std::shared_ptr<Value>>

A sequence of objects.

optional

template<class T>

using Ice::optional = std::experimental::Ice::optional<T>

Ice::optional is a placeholder for std::optional.

Refer to http://en.cppreference.com/w/cpp/utility/optional for more information.

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.

Print

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

Flushes output to Logger::print.

PropertyDict

using Ice::PropertyDict = ::std::map<::std::string, ::std::string>

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

Both key and value are strings.

See also

Properties::getPropertiesForPrefix

Short

typedef short Ice::Short

The mapping for the Slice short type.

ShortSeq

using Ice::ShortSeq = ::std::vector<short>

A sequence of shorts.

SliceChecksumDict

using Ice::SliceChecksumDict = ::std::map<::std::string, ::std::string>

A mapping from type IDs to Slice checksums.

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

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

using Ice::StringSeq = ::std::vector<::std::string>

A sequence of strings.

ThreadNotificationPtr

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

UserExceptionFactory

using Ice::UserExceptionFactory = std::function<void(const std::string&)>

Creates and throws a user exception.

UTF8Buffer

typedef IceUtil::UTF8Buffer Ice::UTF8Buffer

Encapsulates bytes in the UTF-8 encoding.

ValueFactory

using Ice::ValueFactory = ::std::function<::std::shared_ptr<Value>(const ::std::string& type)>

Create a new value for a given value type.

The type is the absolute Slice type id, i.e., the id relative to the unnamed top-level Slice module. For example, the absolute Slice type id for an interface Bar in the module Foo is "::Foo::Bar".

Note that the leading "<code>::</code>" is required.

Parameters

type	The value type.

Returns

The value created for the given type, or nil if the factory is unable to create the value.

Warning

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

Flushes output to Logger::warning.

WstringConverter

typedef IceUtil::WstringConverter Ice::WstringConverter

Wide string converter.

WstringConverterPtr

typedef IceUtil::WstringConverterPtr Ice::WstringConverterPtr

Enumeration Type Documentation

ACMClose

enum class Ice::ACMClose : unsigned char

strong

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 class Ice::ACMHeartbeat : unsigned char

strong

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 class Ice::CompressBatch : unsigned char

strong

The batch compression option when flushing queued batch requests.

Enumerator
Yes	Compress the batch requests.
No	Don't compress the batch requests.
BasedOnProxy	Compress the batch requests if at least one request was made on a compressed proxy.

ConnectionClose

enum class Ice::ConnectionClose : unsigned char

strong

Determines the behavior when manually closing a connection.

Enumerator
Forcefully	Close the connection immediately without sending a close connection protocol message to the peer and waiting for the peer to acknowledge it.
Gracefully	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.
GracefullyWithWait	Wait for all pending invocations to complete before closing the connection.

EndpointSelectionType

enum class Ice::EndpointSelectionType : unsigned char

strong

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 class Ice::FormatType : unsigned char

strong

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 class Ice::LogMessageType : unsigned char

strong

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 class Ice::OperationMode : unsigned char

strong

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 class Ice::SignalPolicy : unsigned char

strong

Determines how the Application class handles signals.

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

ToStringMode

enum class Ice::ToStringMode : unsigned char

strong

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, typename T, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, P >::value >::type * = nullptr, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, T >::value >::type * = nullptr>

::std::shared_ptr< P > Ice::checkedCast	(	const ::std::shared_ptr< T > &	b,
		const ::Ice::Context &	context = Ice::noExplicitContext )

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.

checkedCast() [2/2]

template<typename P, typename T, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, P >::value >::type * = nullptr, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, T >::value >::type * = nullptr>

::std::shared_ptr< P > Ice::checkedCast	(	const ::std::shared_ptr< T > &	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.

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.

createIconvStringConverter()

template<typename charT>

::std::shared_ptr< 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 = ToStringMode::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 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() [2/8]

CommunicatorPtr Ice::initialize	(	const std::string &	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() [3/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() [4/8]

CommunicatorPtr Ice::initialize ( int & argc, char * argv[], const std::string & 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() [5/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() [6/8]

CommunicatorPtr Ice::initialize	(	int &	argc,
		const char *	argv[],
		const std::string &	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() [7/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.

initialize() [8/8]

CommunicatorPtr Ice::initialize	(	StringSeq &	seq,
		const std::string &	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.

make_optional()

template<class T>

optional< typename decay< T >::type > std::experimental::Ice::make_optional ( T && v )

constexpr

Creates an optional object.

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.

operator!=() [1/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator!=	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

Parameters

lhs	The left-hand side.
rhs	The right-hand side.

Returns

True if the left-hand side is not equal to the right-hand side, false otherwise.

operator!=() [2/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator!=	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

Parameters

lhs	The left-hand side.
rhs	The right-hand side.

Returns

True if the left-hand side is not equal to the right-hand side, false otherwise.

operator!=() [3/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator!=	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

Parameters

lhs	The left-hand side.
rhs	The right-hand side.

Returns

True if the left-hand side is not equal to the right-hand side, false otherwise.

operator!=() [4/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator!=	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

Parameters

lhs	The left-hand side.
rhs	The right-hand side.

Returns

True if the left-hand side is not equal to the right-hand side, false otherwise.

operator!=() [5/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator!=	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

Parameters

lhs	The left-hand side.
rhs	The right-hand side.

Returns

True if the left-hand side is not equal to the right-hand side, false otherwise.

operator!=() [6/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator!=	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

Parameters

lhs	The left-hand side.
rhs	The right-hand side.

Returns

True if the left-hand side is not equal to the right-hand side, false otherwise.

operator!=() [7/8]

bool Ice::operator!= ( const ObjectPrx & lhs, const ObjectPrx & rhs )

inline

operator!=() [8/8]

template<class T>

bool std::experimental::Ice::operator!= ( const optional< T > & x, const optional< T > & y )

constexpr

operator<() [1/7]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator<	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator<() [2/7]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator<	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator<() [3/7]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator<	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator<() [4/7]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator<	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator<() [5/7]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator<	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator<() [6/7]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator<	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator<() [7/7]

template<class T>

bool std::experimental::Ice::operator< ( const optional< T > & x, const optional< T > & y )

constexpr

operator<<() [1/3]

::std::ostream & Ice::operator<<	(	::std::ostream &	,
		const ::Ice::ObjectPrx &	)

operator<<() [2/3]

std::ostream & Ice::operator<< ( std::ostream & out, const EncodingVersion & version )

inline

operator<<() [3/3]

std::ostream & Ice::operator<< ( std::ostream & out, const ProtocolVersion & version )

inline

operator<=() [1/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator<=	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator<=() [2/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator<=	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator<=() [3/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator<=	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator<=() [4/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator<=	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator<=() [5/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator<=	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator<=() [6/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator<=	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator<=() [7/8]

bool Ice::operator<= ( const ObjectPrx & lhs, const ObjectPrx & rhs )

inline

operator<=() [8/8]

template<class T>

bool std::experimental::Ice::operator<= ( const optional< T > & x, const optional< T > & y )

constexpr

operator==() [1/7]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator==	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

Parameters

lhs	The left-hand side.
rhs	The right-hand side.

Returns

True if the left-hand side compares equal to the right-hand side, false otherwise.

operator==() [2/7]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator==	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

Parameters

lhs	The left-hand side.
rhs	The right-hand side.

Returns

True if the left-hand side compares equal to the right-hand side, false otherwise.

operator==() [3/7]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator==	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

Parameters

lhs	The left-hand side.
rhs	The right-hand side.

Returns

True if the left-hand side compares equal to the right-hand side, false otherwise.

operator==() [4/7]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator==	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

Parameters

lhs	The left-hand side.
rhs	The right-hand side.

Returns

True if the left-hand side compares equal to the right-hand side, false otherwise.

operator==() [5/7]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator==	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

Parameters

lhs	The left-hand side.
rhs	The right-hand side.

Returns

True if the left-hand side compares equal to the right-hand side, false otherwise.

operator==() [6/7]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator==	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

Parameters

lhs	The left-hand side.
rhs	The right-hand side.

Returns

True if the left-hand side compares equal to the right-hand side, false otherwise.

operator==() [7/7]

template<class T>

bool std::experimental::Ice::operator== ( const optional< T > & x, const optional< T > & y )

constexpr

operator>() [1/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator>	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator>() [2/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator>	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator>() [3/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator>	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator>() [4/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator>	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator>() [5/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator>	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator>() [6/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator>	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator>() [7/8]

bool Ice::operator> ( const ObjectPrx & lhs, const ObjectPrx & rhs )

inline

operator>() [8/8]

template<class T>

bool std::experimental::Ice::operator> ( const optional< T > & x, const optional< T > & y )

constexpr

operator>=() [1/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator>=	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator>=() [2/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator>=	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator>=() [3/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator>=	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator>=() [4/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator>=	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator>=() [5/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator>=	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator>=() [6/8]

template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>

bool Ice::operator>=	(	const C &	lhs,
		const C &	rhs )

Relational operator for generated structs and classes.

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.

operator>=() [7/8]

bool Ice::operator>= ( const ObjectPrx & lhs, const ObjectPrx & rhs )

inline

operator>=() [8/8]

template<class T>

bool std::experimental::Ice::operator>= ( const optional< T > & x, const optional< T > & y )

constexpr

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 ::std::shared_ptr< ObjectPrx > &	lhs,
		const ::std::shared_ptr< 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 ::std::shared_ptr< ObjectPrx > &	lhs,
		const ::std::shared_ptr< 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 ::std::shared_ptr< ObjectPrx > &	lhs,
		const ::std::shared_ptr< 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 ::std::shared_ptr< ObjectPrx > &	lhs,
		const ::std::shared_ptr< 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.

swap()

template<class T>

void std::experimental::Ice::swap ( optional< T > & x, optional< T > & y )

noexcept

Exchanges the state of an optional object with another one.

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, typename T, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, P >::value >::type * = nullptr, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, T >::value >::type * = nullptr>

::std::shared_ptr< P > Ice::uncheckedCast

(

const ::std::shared_ptr< T > &

b

)

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.

uncheckedCast() [2/2]

template<typename P, typename T, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, P >::value >::type * = nullptr, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, T >::value >::type * = nullptr>

::std::shared_ptr< P > Ice::uncheckedCast	(	const ::std::shared_ptr< T > &	b,
		const std::string &	f )

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.

upCast()

IceUtil::Shared * Ice::upCast

(

::Ice::LocalObject *

)

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

short Ice::BTEndpointType = 6

constexpr

Uniquely identifies Bluetooth endpoints.

BTSEndpointType

short Ice::BTSEndpointType = 7

constexpr

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

short Ice::iAPEndpointType = 8

constexpr

Uniquely identifies iAP-based endpoints.

iAPSEndpointType

short Ice::iAPSEndpointType = 9

constexpr

Uniquely identifies SSL iAP-based endpoints.

in_place

struct std::experimental::Ice::in_place_t std::experimental::Ice::in_place

An instance of in_place_t that indicates that an optional value should be constructed in place.

noExplicitContext

const Context Ice::noExplicitContext

extern

Marker value used to indicate that no explicit context was passed to a proxy invocation.

nullopt

nullopt_t std::experimental::Ice::nullopt

constexpr

An instance of nullopt_t used as a marker value to indicate that no value is provided.

Protocol_1_0

const ProtocolVersion Ice::Protocol_1_0

extern

Identifies protocol version 1.0.

SSLEndpointType

short Ice::SSLEndpointType = 2

constexpr

Uniquely identifies SSL endpoints.

TCPEndpointType

short Ice::TCPEndpointType = 1

constexpr

Uniquely identifies TCP endpoints.

UDPEndpointType

short Ice::UDPEndpointType = 3

constexpr

Uniquely identifies UDP endpoints.

WSEndpointType

short Ice::WSEndpointType = 4

constexpr

Uniquely identifies TCP-based WebSocket endpoints.

WSSEndpointType

short Ice::WSSEndpointType = 5

constexpr

Uniquely identifies SSL-based WebSocket endpoints.