zeroc-ice 3.7.0 → 3.7.1

data/ext/ice/cpp/include/Ice/Protocol.h

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -116,34 +116,64 @@ const ::Ice::Byte FLAG_IS_LAST_SLICE         = (1<<5);
 namespace Ice
 {
 
+/** Identifies protocol version 1.0. */
 ICE_API extern const ProtocolVersion Protocol_1_0;
 
+/** Identifies encoding version 1.0. */
 ICE_API extern const EncodingVersion Encoding_1_0;
+
+/** Identifies encoding version 1.1. */
 ICE_API extern const EncodingVersion Encoding_1_1;
 
+/** Identifies the latest protocol version. */
 ICE_API extern const ProtocolVersion currentProtocol;
+
+/** Identifies the latest protocol encoding version. */
 ICE_API extern const EncodingVersion currentProtocolEncoding;
 
+/** Identifies the latest encoding version. */
 ICE_API extern const EncodingVersion currentEncoding;
 
+/**
+ * Converts a protocol version into a string.
+ * @param v The protocol version.
+ * @return A string representing the protocol version.
+ */
 inline ::std::string
 protocolVersionToString(const Ice::ProtocolVersion& v)
 {
     return IceInternal::versionToString<ProtocolVersion>(v);
 }
 
+/**
+ * Converts a string into a protocol version.
+ * @param v The string containing a stringified protocol version.
+ * @return The protocol version.
+ * @throws VersionParseException If the given string is not in the X.Y format.
+ */
 inline ::Ice::ProtocolVersion
 stringToProtocolVersion(const ::std::string& v)
 {
     return IceInternal::stringToVersion<ProtocolVersion>(v);
 }
 
+/**
+ * Converts an encoding version into a string.
+ * @param v The encoding version.
+ * @return A string representing the encoding version.
+ */
 inline ::std::string
 encodingVersionToString(const Ice::EncodingVersion& v)
 {
     return IceInternal::versionToString<EncodingVersion>(v);
 }
 
+/**
+ * Converts a string into an encoding version.
+ * @param v The string containing a stringified encoding version.
+ * @return The encoding version.
+ * @throws VersionParseException If the given string is not in the X.Y format.
+ */
 inline ::Ice::EncodingVersion
 stringToEncodingVersion(const ::std::string& v)
 {

data/ext/ice/cpp/include/Ice/Proxy.h

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -34,6 +34,7 @@
 namespace Ice
 {
 
+/** Marker value used to indicate that no explicit context was passed to a proxy invocation. */
 ICE_API extern const Context noExplicitContext;
 
 }
@@ -49,6 +50,7 @@ namespace IceProxy
 namespace Ice
 {
 
+/** Marker value used to indicate that no explicit context was passed to a proxy invocation. */
 ICE_API extern const ::Ice::Context noExplicitContext;
 
 }
@@ -291,14 +293,22 @@ namespace Ice
 {
 
 class RouterPrx;
+/// \cond INTERNAL
 using RouterPrxPtr = ::std::shared_ptr<::Ice::RouterPrx>;
+/// \endcond
 
 class LocatorPrx;
+/// \cond INTERNAL
 using LocatorPrxPtr = ::std::shared_ptr<::Ice::LocatorPrx>;
+/// \endcond
 
 class LocalException;
 class OutputStream;
 
+/**
+ * Base class of all object proxies.
+ * \headerfile Ice/Ice.h
+ */
 class ICE_API ObjectPrx : public ::std::enable_shared_from_this<ObjectPrx>
 {
 public:
@@ -308,16 +318,40 @@ public:
     friend ICE_API bool operator<(const ObjectPrx&, const ObjectPrx&);
     friend ICE_API bool operator==(const ObjectPrx&, const ObjectPrx&);
 
+    /**
+     * Obtains the communicator that created this proxy.
+     * @return The communicator that created this proxy.
+     */
     ::std::shared_ptr<::Ice::Communicator> ice_getCommunicator() const;
 
+    /**
+     * Obtains a stringified version of this proxy.
+     * @return A stringified proxy.
+     */
     ::std::string ice_toString() const;
 
+    /**
+     * Tests whether this object supports a specific Slice interface.
+     * @param typeId The type ID of the Slice interface to test against.
+     * @param context The context map for the invocation.
+     * @return true if the target object has the interface
+     * specified by id or derives from the interface specified by id.
+     */
     bool
     ice_isA(const ::std::string& typeId, const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
         return _makePromiseOutgoing<bool>(true, this, &ObjectPrx::_iceI_isA, typeId, context).get();
     }
 
+    /**
+     * Tests whether this object supports a specific Slice interface.
+     * @param typeId The type ID of the Slice interface to test against.
+     * @param response The response callback.
+     * @param ex The exception callback.
+     * @param sent The sent callback.
+     * @param context The context map for the invocation.
+     * @return A function that can be called to cancel the invocation locally.
+     */
     ::std::function<void()>
     ice_isAAsync(const ::std::string& typeId,
                  ::std::function<void(bool)> response,
@@ -328,6 +362,12 @@ public:
         return _makeLamdaOutgoing<bool>(response, ex, sent, this, &ObjectPrx::_iceI_isA, typeId, context);
     }
 
+    /**
+     * Tests whether this object supports a specific Slice interface.
+     * @param typeId The type ID of the Slice interface to test against.
+     * @param context The context map for the invocation.
+     * @return The future object for the invocation.
+     */
     template<template<typename> class P = std::promise> auto
     ice_isAAsync(const ::std::string& typeId, const ::Ice::Context& context = ::Ice::noExplicitContext)
         -> decltype(std::declval<P<bool>>().get_future())
@@ -335,15 +375,29 @@ public:
         return _makePromiseOutgoing<bool, P>(false, this, &ObjectPrx::_iceI_isA, typeId, context);
     }
 
+    /// \cond INTERNAL
     void
     _iceI_isA(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<bool>>&, const ::std::string&, const ::Ice::Context&);
+    /// \endcond
 
+    /**
+     * Tests whether the target object of this proxy can be reached.
+     * @param context The context map for the invocation.
+     */
     void
     ice_ping(const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
         _makePromiseOutgoing<void>(true, this, &ObjectPrx::_iceI_ping, context).get();
     }
 
+    /**
+     * Tests whether the target object of this proxy can be reached.
+     * @param response The response callback.
+     * @param ex The exception callback.
+     * @param sent The sent callback.
+     * @param context The context map for the invocation.
+     * @return A function that can be called to cancel the invocation locally.
+     */
     ::std::function<void()>
     ice_pingAsync(::std::function<void()> response,
                   ::std::function<void(::std::exception_ptr)> ex = nullptr,
@@ -353,6 +407,11 @@ public:
         return _makeLamdaOutgoing<void>(response, ex, sent, this, &ObjectPrx::_iceI_ping, context);
     }
 
+    /**
+     * Tests whether the target object of this proxy can be reached.
+     * @param context The context map for the invocation.
+     * @return The future object for the invocation.
+     */
     template<template<typename> class P = std::promise>
     auto ice_pingAsync(const ::Ice::Context& context = ::Ice::noExplicitContext)
         -> decltype(std::declval<P<void>>().get_future())
@@ -360,15 +419,31 @@ public:
         return _makePromiseOutgoing<void, P>(false, this, &ObjectPrx::_iceI_ping, context);
     }
 
+    /// \cond INTERNAL
     void
     _iceI_ping(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::Ice::Context&);
-
+    /// \endcond
+
+    /**
+     * Returns the Slice type IDs of the interfaces supported by the target object of this proxy.
+     * @param context The context map for the invocation.
+     * @return The Slice type IDs of the interfaces supported by the target object, in base-to-derived
+     * order. The first element of the returned array is always "::Ice::Object".
+     */
     ::std::vector<::std::string>
     ice_ids(const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
         return _makePromiseOutgoing<::std::vector<::std::string>>(true, this, &ObjectPrx::_iceI_ids, context).get();
     }
 
+    /**
+     * Returns the Slice type IDs of the interfaces supported by the target object of this proxy.
+     * @param response The response callback.
+     * @param ex The exception callback.
+     * @param sent The sent callback.
+     * @param context The context map for the invocation.
+     * @return A function that can be called to cancel the invocation locally.
+     */
     ::std::function<void()>
     ice_idsAsync(::std::function<void(::std::vector<::std::string>)> response,
                  ::std::function<void(::std::exception_ptr)> ex = nullptr,
@@ -378,6 +453,11 @@ public:
         return _makeLamdaOutgoing<::std::vector<::std::string>>(response, ex, sent, this, &ObjectPrx::_iceI_ids, context);
     }
 
+    /**
+     * Returns the Slice type IDs of the interfaces supported by the target object of this proxy.
+     * @param context The context map for the invocation.
+     * @return The future object for the invocation.
+     */
     template<template<typename> class P = std::promise> auto
     ice_idsAsync(const ::Ice::Context& context = ::Ice::noExplicitContext)
         -> decltype(std::declval<P<::std::vector<::std::string>>>().get_future())
@@ -385,15 +465,30 @@ public:
         return _makePromiseOutgoing<::std::vector<::std::string>, P>(false, this, &ObjectPrx::_iceI_ids, context);
     }
 
+    /// \cond INTERNAL
     void
     _iceI_ids(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::vector<::std::string>>>&, const ::Ice::Context&);
+    /// \endcond
 
+    /**
+     * Returns the Slice type ID of the most-derived interface supported by the target object of this proxy.
+     * @param context The context map for the invocation.
+     * @return The Slice type ID of the most-derived interface.
+     */
     ::std::string
     ice_id(const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
         return _makePromiseOutgoing<::std::string>(true, this, &ObjectPrx::_iceI_id, context).get();
     }
 
+    /**
+     * Returns the Slice type ID of the most-derived interface supported by the target object of this proxy.
+     * @param response The response callback.
+     * @param ex The exception callback.
+     * @param sent The sent callback.
+     * @param context The context map for the invocation.
+     * @return A function that can be called to cancel the invocation locally.
+     */
     ::std::function<void()>
     ice_idAsync(::std::function<void(::std::string)> response,
                 ::std::function<void(::std::exception_ptr)> ex = nullptr,
@@ -403,6 +498,11 @@ public:
         return _makeLamdaOutgoing<::std::string>(response, ex, sent, this, &ObjectPrx::_iceI_id, context);
     }
 
+    /**
+     * Returns the Slice type ID of the most-derived interface supported by the target object of this proxy.
+     * @param context The context map for the invocation.
+     * @return The future object for the invocation.
+     */
     template<template<typename> class P = std::promise>
     auto ice_idAsync(const ::Ice::Context& context = ::Ice::noExplicitContext)
         -> decltype(std::declval<P<::std::string>>().get_future())
@@ -410,42 +510,75 @@ public:
         return _makePromiseOutgoing<::std::string, P>(false, this, &ObjectPrx::_iceI_id, context);
     }
 
+    /// \cond INTERNAL
     void
     _iceI_id(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::string>>&, const ::Ice::Context&);
+    /// \endcond
 
+    /**
+     * Returns the Slice type ID associated with this type.
+     * @return The Slice type ID.
+     */
     static const ::std::string& ice_staticId()
     {
         return ::Ice::Object::ice_staticId();
     }
 
-    //
-    // ice_invoke with default vector mapping for byte-sequence parameters
-    //
-
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @param outParams An encapsulation containing the encoded results.
+     * @param context The context map for the invocation.
+     * @return True if the operation completed successfully, in which case outParams contains
+     * the encoded out parameters. False if the operation raised a user exception, in which
+     * case outParams contains the encoded user exception. If the operation raises a run-time
+     * exception, it throws it directly.
+     */
     bool
     ice_invoke(const ::std::string& operation,
                ::Ice::OperationMode mode,
-               const ::std::vector<Byte>& inP,
+               const ::std::vector<Byte>& inParams,
                ::std::vector<::Ice::Byte>& outParams,
                const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
-        return ice_invoke(operation, mode, ::IceInternal::makePair(inP), outParams, context);
+        return ice_invoke(operation, mode, ::IceInternal::makePair(inParams), outParams, context);
     }
 
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @param context The context map for the invocation.
+     * @return The future object for the invocation.
+     */
     template<template<typename> class P = std::promise> auto
     ice_invokeAsync(const ::std::string& operation,
                     ::Ice::OperationMode mode,
-                    const ::std::vector<Byte>& inP,
+                    const ::std::vector<Byte>& inParams,
                     const ::Ice::Context& context = ::Ice::noExplicitContext)
         -> decltype(std::declval<P<::Ice::Object::Ice_invokeResult>>().get_future())
     {
-        return ice_invokeAsync<P>(operation, mode, ::IceInternal::makePair(inP), context);
+        return ice_invokeAsync<P>(operation, mode, ::IceInternal::makePair(inParams), context);
     }
 
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @param response The response callback.
+     * @param ex The exception callback.
+     * @param sent The sent callback.
+     * @param context The context map for the invocation.
+     * @return A function that can be called to cancel the invocation locally.
+     */
     ::std::function<void()>
     ice_invokeAsync(const ::std::string& operation,
                     ::Ice::OperationMode mode,
-                    const ::std::vector<::Ice::Byte>& inP,
+                    const ::std::vector<::Ice::Byte>& inParams,
                     ::std::function<void(bool, ::std::vector<::Ice::Byte>)> response,
                     ::std::function<void(::std::exception_ptr)> ex = nullptr,
                     ::std::function<void(bool)> sent = nullptr,
@@ -461,48 +594,75 @@ public:
             };
         }
         auto outAsync = ::std::make_shared<Outgoing>(shared_from_this(), r, ex, sent);
-        outAsync->invoke(operation, mode, ::IceInternal::makePair(inP), context);
+        outAsync->invoke(operation, mode, ::IceInternal::makePair(inParams), context);
         return [outAsync]() { outAsync->cancel(); };
     }
 
-    //
-    // ice_invoke with cpp:array mapping for byte sequence parameters
-    //
-
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @param outParams An encapsulation containing the encoded results.
+     * @param context The context map for the invocation.
+     * @return True if the operation completed successfully, in which case outParams contains
+     * the encoded out parameters. False if the operation raised a user exception, in which
+     * case outParams contains the encoded user exception. If the operation raises a run-time
+     * exception, it throws it directly.
+     */
     bool
     ice_invoke(const ::std::string& operation,
                ::Ice::OperationMode mode,
-               const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inP,
+               const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
                ::std::vector<::Ice::Byte>& outParams,
                const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
         using Outgoing = ::IceInternal::InvokePromiseOutgoing<
             ::std::promise<::Ice::Object::Ice_invokeResult>, ::Ice::Object::Ice_invokeResult>;
         auto outAsync = ::std::make_shared<Outgoing>(shared_from_this(), true);
-        outAsync->invoke(operation, mode, inP, context);
+        outAsync->invoke(operation, mode, inParams, context);
         auto result = outAsync->getFuture().get();
         outParams.swap(result.outParams);
         return result.returnValue;
     }
 
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @param context The context map for the invocation.
+     * @return The future object for the invocation.
+     */
     template<template<typename> class P = std::promise> auto
     ice_invokeAsync(const ::std::string& operation,
                     ::Ice::OperationMode mode,
-                    const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inP,
+                    const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
                     const ::Ice::Context& context = ::Ice::noExplicitContext)
         -> decltype(std::declval<P<::Ice::Object::Ice_invokeResult>>().get_future())
     {
         using Outgoing =
             ::IceInternal::InvokePromiseOutgoing<P<::Ice::Object::Ice_invokeResult>, ::Ice::Object::Ice_invokeResult>;
         auto outAsync = ::std::make_shared<Outgoing>(shared_from_this(), false);
-        outAsync->invoke(operation, mode, inP, context);
+        outAsync->invoke(operation, mode, inParams, context);
         return outAsync->getFuture();
     }
 
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @param response The response callback.
+     * @param ex The exception callback.
+     * @param sent The sent callback.
+     * @param context The context map for the invocation.
+     * @return A function that can be called to cancel the invocation locally.
+     */
     ::std::function<void()>
     ice_invokeAsync(const ::std::string& operation,
                     ::Ice::OperationMode mode,
-                    const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inP,
+                    const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
                     ::std::function<void(bool, ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>)> response,
                     ::std::function<void(::std::exception_ptr)> ex = nullptr,
                     ::std::function<void(bool)> sent = nullptr,
@@ -520,78 +680,342 @@ public:
             };
         }
         auto outAsync = ::std::make_shared<Outgoing>(shared_from_this(), r, ex, sent);
-        outAsync->invoke(operation, mode, inP, context);
+        outAsync->invoke(operation, mode, inParams, context);
         return [outAsync]() { outAsync->cancel(); };
     }
 
+    /**
+     * Obtains the identity embedded in this proxy.
+     * @return The identity of the target object.
+     */
     ::Ice::Identity ice_getIdentity() const;
-    ::std::shared_ptr<::Ice::ObjectPrx> ice_identity(const ::Ice::Identity&) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the identity.
+     * @param id The identity for the new proxy.
+     * @return A proxy with the new identity.
+     */
+    ::std::shared_ptr<::Ice::ObjectPrx> ice_identity(const ::Ice::Identity& id) const;
+
+    /**
+     * Obtains the per-proxy context for this proxy.
+     * @return The per-proxy context.
+     */
     ::Ice::Context ice_getContext() const;
-    ::std::shared_ptr<::Ice::ObjectPrx> ice_context(const ::Ice::Context&) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the per-proxy context.
+     * @param context The context for the new proxy.
+     * @return A proxy with the new per-proxy context.
+     */
+    ::std::shared_ptr<::Ice::ObjectPrx> ice_context(const ::Ice::Context& context) const;
+
+    /**
+     * Obtains the facet for this proxy.
+     * @return The facet for this proxy. If the proxy uses the default facet, the return value is the empty string.
+     */
     const ::std::string& ice_getFacet() const;
-    ::std::shared_ptr<::Ice::ObjectPrx> ice_facet(const ::std::string&) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the facet.
+     * @param facet The facet for the new proxy.
+     * @return A proxy with the new facet.
+     */
+    ::std::shared_ptr<::Ice::ObjectPrx> ice_facet(const ::std::string& facet) const;
+
+    /**
+     * Obtains the adapter ID for this proxy.
+     * @return The adapter ID. If the proxy does not have an adapter ID, the return value is the empty string.
+     */
     ::std::string ice_getAdapterId() const;
-    ::std::shared_ptr<::Ice::ObjectPrx> ice_adapterId(const ::std::string&) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the adapter ID.
+     * @param id The adapter ID for the new proxy.
+     * @return A proxy with the new adapter ID.
+     */
+    ::std::shared_ptr<::Ice::ObjectPrx> ice_adapterId(const ::std::string& id) const;
+
+    /**
+     * Obtains the endpoints used by this proxy.
+     * @return The endpoints used by this proxy.
+     */
     ::Ice::EndpointSeq ice_getEndpoints() const;
-    ::std::shared_ptr<::Ice::ObjectPrx> ice_endpoints(const ::Ice::EndpointSeq&) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the endpoints.
+     * @param endpoints The endpoints for the new proxy.
+     * @return A proxy with the new endpoints.
+     */
+    ::std::shared_ptr<::Ice::ObjectPrx> ice_endpoints(const ::Ice::EndpointSeq& endpoints) const;
+
+    /**
+     * Obtains the locator cache timeout of this proxy.
+     * @return The locator cache timeout value (in seconds).
+     */
     ::Ice::Int ice_getLocatorCacheTimeout() const;
-    ::std::shared_ptr<::Ice::ObjectPrx> ice_locatorCacheTimeout(::Ice::Int) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the locator cache timeout.
+     * @param timeout The new locator cache timeout (in seconds).
+     * @return A proxy with the new timeout.
+     */
+    ::std::shared_ptr<::Ice::ObjectPrx> ice_locatorCacheTimeout(::Ice::Int timeout) const;
+
+    /**
+     * Determines whether this proxy caches connections.
+     * @return True if this proxy caches connections, false otherwise.
+     */
     bool ice_isConnectionCached() const;
-    ::std::shared_ptr<::Ice::ObjectPrx> ice_connectionCached(bool) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for connection caching.
+     * @param b True if the new proxy should cache connections, false otherwise.
+     * @return A proxy with the specified caching policy.
+     */
+    ::std::shared_ptr<::Ice::ObjectPrx> ice_connectionCached(bool b) const;
+
+    /**
+     * Obtains the endpoint selection policy for this proxy (randomly or ordered).
+     * @return The endpoint selection policy.
+     */
     ::Ice::EndpointSelectionType ice_getEndpointSelection() const;
-    ::std::shared_ptr<::Ice::ObjectPrx> ice_endpointSelection(::Ice::EndpointSelectionType) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the endpoint selection policy.
+     * @param type The new endpoint selection policy.
+     * @return A proxy with the specified endpoint selection policy.
+     */
+    ::std::shared_ptr<::Ice::ObjectPrx> ice_endpointSelection(::Ice::EndpointSelectionType type) const;
+
+    /**
+     * Determines whether this proxy uses only secure endpoints.
+     * @return True if this proxy communicates only via secure endpoints, false otherwise.
+     */
     bool ice_isSecure() const;
-    ::std::shared_ptr<::Ice::ObjectPrx> ice_secure(bool) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for how it selects endpoints.
+     * @param b If true, only endpoints that use a secure transport are used by the new proxy.
+     * If false, the returned proxy uses both secure and insecure endpoints.
+     * @return A proxy with the specified security policy.
+     */
+    ::std::shared_ptr<::Ice::ObjectPrx> ice_secure(bool b) const;
+
+    /**
+     * Obtains the encoding version used to marshal request parameters.
+     * @return The encoding version.
+     */
     ::Ice::EncodingVersion ice_getEncodingVersion() const;
-    ::std::shared_ptr<::Ice::ObjectPrx> ice_encodingVersion(const ::Ice::EncodingVersion&) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the encoding used to marshal
+     * parameters.
+     * @param version The encoding version to use to marshal request parameters.
+     * @return A proxy with the specified encoding version.
+     */
+    ::std::shared_ptr<::Ice::ObjectPrx> ice_encodingVersion(const ::Ice::EncodingVersion& version) const;
+
+    /**
+     * Determines whether this proxy prefers secure endpoints.
+     * @return True if the proxy always attempts to invoke via secure endpoints before it
+     * attempts to use insecure endpoints, false otherwise.
+     */
     bool ice_isPreferSecure() const;
-    ::std::shared_ptr<::Ice::ObjectPrx> ice_preferSecure(bool) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for its endpoint selection policy.
+     * @param b If true, the new proxy will use secure endpoints for invocations and only use
+     * insecure endpoints if an invocation cannot be made via secure endpoints. If false, the
+     * proxy prefers insecure endpoints to secure ones.
+     * @return A proxy with the specified selection policy.
+     */
+    ::std::shared_ptr<::Ice::ObjectPrx> ice_preferSecure(bool b) const;
+
+    /**
+     * Obtains the router for this proxy.
+     * @return The router for the proxy. If no router is configured for the proxy, the return value
+     * is nil.
+     */
     ::std::shared_ptr<::Ice::RouterPrx> ice_getRouter() const;
-    ::std::shared_ptr<::Ice::ObjectPrx> ice_router(const ::std::shared_ptr<::Ice::RouterPrx>&) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the router.
+     * @param router The router for the new proxy.
+     * @return A proxy with the specified router.
+     */
+    ::std::shared_ptr<::Ice::ObjectPrx> ice_router(const ::std::shared_ptr<::Ice::RouterPrx>& router) const;
+
+    /**
+     * Obtains the locator for this proxy.
+     * @return The locator for this proxy. If no locator is configured, the return value is nil.
+     */
     ::std::shared_ptr<::Ice::LocatorPrx> ice_getLocator() const;
-    ::std::shared_ptr<::Ice::ObjectPrx> ice_locator(const ::std::shared_ptr<::Ice::LocatorPrx>&) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the locator.
+     * @param locator The locator for the new proxy.
+     * @return A proxy with the specified locator.
+     */
+    ::std::shared_ptr<::Ice::ObjectPrx> ice_locator(const ::std::shared_ptr<::Ice::LocatorPrx>& locator) const;
+
+    /**
+     * Determines whether this proxy uses collocation optimization.
+     * @return True if the proxy uses collocation optimization, false otherwise.
+     */
     bool ice_isCollocationOptimized() const;
-    ::std::shared_ptr<::Ice::ObjectPrx> ice_collocationOptimized(bool) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for collocation optimization.
+     * @param b True if the new proxy enables collocation optimization, false otherwise.
+     * @return A proxy with the specified collocation optimization.
+     */
+    ::std::shared_ptr<::Ice::ObjectPrx> ice_collocationOptimized(bool b) const;
+
+    /**
+     * Obtains the invocation timeout of this proxy.
+     * @return The invocation timeout value (in milliseconds).
+     */
     ::Ice::Int ice_getInvocationTimeout() const;
-    ::std::shared_ptr<::Ice::ObjectPrx> ice_invocationTimeout(::Ice::Int) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the invocation timeout.
+     * @param timeout The new invocation timeout (in milliseconds).
+     * @return A proxy with the new timeout.
+     */
+    ::std::shared_ptr<::Ice::ObjectPrx> ice_invocationTimeout(::Ice::Int timeout) const;
+
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses twoway invocations.
+     * @return A proxy that uses twoway invocations.
+     */
     ::std::shared_ptr<::Ice::ObjectPrx> ice_twoway() const;
+
+    /**
+     * Determines whether this proxy uses twoway invocations.
+     * @return True if this proxy uses twoway invocations, false otherwise.
+     */
     bool ice_isTwoway() const;
+
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses oneway invocations.
+     * @return A proxy that uses oneway invocations.
+     */
     ::std::shared_ptr<::Ice::ObjectPrx> ice_oneway() const;
+
+    /**
+     * Determines whether this proxy uses oneway invocations.
+     * @return True if this proxy uses oneway invocations, false otherwise.
+     */
     bool ice_isOneway() const;
+
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses batch oneway invocations.
+     * @return A proxy that uses batch oneway invocations.
+     */
     ::std::shared_ptr<::Ice::ObjectPrx> ice_batchOneway() const;
+
+    /**
+     * Determines whether this proxy uses batch oneway invocations.
+     * @return True if this proxy uses batch oneway invocations, false otherwise.
+     */
     bool ice_isBatchOneway() const;
+
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses datagram invocations.
+     * @return A proxy that uses datagram invocations.
+     */
     ::std::shared_ptr<::Ice::ObjectPrx> ice_datagram() const;
+
+    /**
+     * Determines whether this proxy uses datagram invocations.
+     * @return True if this proxy uses datagram invocations, false otherwise.
+     */
     bool ice_isDatagram() const;
+
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses batch datagram invocations.
+     * @return A proxy that uses batch datagram invocations.
+     */
     ::std::shared_ptr<::Ice::ObjectPrx> ice_batchDatagram() const;
-    bool ice_isBatchDatagram() const;
 
-    ::std::shared_ptr<::Ice::ObjectPrx> ice_compress(bool) const;
-    ::std::shared_ptr<::Ice::ObjectPrx> ice_timeout(int) const;
+    /**
+     * Determines whether this proxy uses batch datagram invocations.
+     * @return True if this proxy uses batch datagram invocations, false otherwise.
+     */
+    bool ice_isBatchDatagram() const;
 
-    ::std::shared_ptr<::Ice::ObjectPrx> ice_connectionId(const ::std::string&) const;
+    /**
+     * Obtains a proxy that is identical to this proxy, except for its compression setting which
+     * overrides the compression setting from the proxy endpoints.
+     * @param b True enables compression for the new proxy, false disables compression.
+     * @return A proxy with the specified compression override setting.
+     */
+    ::std::shared_ptr<::Ice::ObjectPrx> ice_compress(bool b) const;
+
+    /**
+     * Obtains the compression override setting of this proxy.
+     * @return The compression override setting. If nullopt is returned, no override is set. Otherwise, true
+     * if compression is enabled, false otherwise.
+     */
+    ::Ice::optional<bool> ice_getCompress() const;
+
+    /**
+     * Obtains a proxy that is identical to this proxy, except for its connection timeout setting
+     * which overrides the timeot setting from the proxy endpoints.
+     * @param timeout The connection timeout override for the proxy (in milliseconds).
+     * @return A proxy with the specified timeout override.
+     */
+    ::std::shared_ptr<::Ice::ObjectPrx> ice_timeout(int timeout) const;
+
+    /**
+     * Obtains the timeout override of this proxy.
+     * @return The timeout override. If nullopt is returned, no override is set. Otherwise, returns
+     * the timeout override value.
+     */
+    ::Ice::optional<int> ice_getTimeout() const;
+
+    /**
+     * Obtains a proxy that is identical to this proxy, except for its connection ID.
+     * @param id The connection ID for the new proxy. An empty string removes the
+     * connection ID.
+     * @return A proxy with the specified connection ID.
+     */
+    ::std::shared_ptr<::Ice::ObjectPrx> ice_connectionId(const ::std::string& id) const;
+
+    /**
+     * Obtains the connection ID of this proxy.
+     * @return The connection ID.
+     */
     ::std::string ice_getConnectionId() const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except it's a fixed proxy bound
+     * the given connection.
+     * @param connection The fixed proxy connection.
+     * @return A fixed proxy bound to the given connection.
+     */
+    ::std::shared_ptr<::Ice::ObjectPrx> ice_fixed(const ::std::shared_ptr<::Ice::Connection>& connection) const;
+
+    /**
+     * Obtains the Connection for this proxy. If the proxy does not yet have an established connection,
+     * it first attempts to create a connection.
+     * @return The connection for this proxy.
+     */
     ::std::shared_ptr<::Ice::Connection>
     ice_getConnection()
     {
         return ice_getConnectionAsync().get();
     }
 
+    /**
+     * Obtains the Connection for this proxy. If the proxy does not yet have an established connection,
+     * it first attempts to create a connection.
+     * @param response The response callback.
+     * @param ex The exception callback.
+     * @param sent The sent callback.
+     * @return A function that can be called to cancel the invocation locally.
+     */
     ::std::function<void()>
     ice_getConnectionAsync(::std::function<void(::std::shared_ptr<::Ice::Connection>)> response,
                            ::std::function<void(::std::exception_ptr)> ex = nullptr,
@@ -603,6 +1027,11 @@ public:
         return [outAsync]() { outAsync->cancel(); };
     }
 
+    /**
+     * Obtains the Connection for this proxy. If the proxy does not yet have an established connection,
+     * it first attempts to create a connection.
+     * @return The future object for the invocation.
+     */
     template<template<typename> class P = std::promise> auto
     ice_getConnectionAsync() -> decltype(std::declval<P<::std::shared_ptr<::Ice::Connection>>>().get_future())
     {
@@ -612,15 +1041,32 @@ public:
         return outAsync->getFuture();
     }
 
+    /// \cond INTERNAL
     void _iceI_getConnection(const ::std::shared_ptr<::IceInternal::ProxyGetConnection>&);
-
+    /// \endcond
+
+    /**
+     * Obtains the cached Connection for this proxy. If the proxy does not yet have an established
+     * connection, it does not attempt to create a connection.
+     * @return The cached connection for this proxy, or nil if the proxy does not have
+     * an established connection.
+     */
     ::std::shared_ptr<::Ice::Connection> ice_getCachedConnection() const;
 
+    /**
+     * Flushes any pending batched requests for this communicator. The call blocks until the flush is complete.
+     */
     void ice_flushBatchRequests()
     {
         return ice_flushBatchRequestsAsync().get();
     }
 
+    /**
+     * Flushes any pending batched requests for this communicator. The call blocks until the flush is complete.
+     * @param ex The exception callback.
+     * @param sent The sent callback.
+     * @return A function that can be called to cancel the invocation locally.
+     */
     std::function<void()>
     ice_flushBatchRequestsAsync(::std::function<void(::std::exception_ptr)> ex,
                                 ::std::function<void(bool)> sent = nullptr)
@@ -631,6 +1077,10 @@ public:
         return [outAsync]() { outAsync->cancel(); };
     }
 
+    /**
+     * Flushes any pending batched requests for this communicator. The call blocks until the flush is complete.
+     * @return The future object for the invocation.
+     */
     template<template<typename> class P = std::promise> auto
     ice_flushBatchRequestsAsync() -> decltype(std::declval<P<void>>().get_future())
     {
@@ -640,6 +1090,7 @@ public:
         return outAsync->getFuture();
     }
 
+    /// \cond INTERNAL
     void _iceI_flushBatchRequests(const ::std::shared_ptr<::IceInternal::ProxyFlushBatchAsync>&);
 
     const ::IceInternal::ReferencePtr& _getReference() const { return _reference; }
@@ -659,9 +1110,11 @@ public:
     int _hash() const;
 
     void _write(OutputStream&) const;
+    /// \endcond
 
 protected:
 
+    /// \cond INTERNAL
     template<typename R, template<typename> class P = ::std::promise, typename Obj, typename Fn, typename... Args>
     auto _makePromiseOutgoing(bool sync, Obj obj, Fn fn, Args&&... args)
         -> decltype(std::declval<P<R>>().get_future())
@@ -682,6 +1135,7 @@ protected:
     virtual ::std::shared_ptr<ObjectPrx> _newInstance() const;
     ObjectPrx() = default;
     friend ::std::shared_ptr<ObjectPrx> IceInternal::createProxy<ObjectPrx>();
+    /// \endcond
 
 private:
 
@@ -718,111 +1172,233 @@ operator!=(const ObjectPrx& lhs, const ObjectPrx& rhs)
     return !(lhs == rhs);
 }
 
+/**
+ * Helper template that supplies proxy factory functions.
+ * \headerfile Ice/Ice.h
+ */
 template<typename Prx, typename... Bases>
 class Proxy : public virtual Bases...
 {
 public:
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the per-proxy context.
+     * @param context The context for the new proxy.
+     * @return A proxy with the new per-proxy context.
+     */
     ::std::shared_ptr<Prx> ice_context(const ::Ice::Context& context) const
     {
         return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_context(context));
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the adapter ID.
+     * @param id The adapter ID for the new proxy.
+     * @return A proxy with the new adapter ID.
+     */
     ::std::shared_ptr<Prx> ice_adapterId(const ::std::string& id) const
     {
         return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_adapterId(id));
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the endpoints.
+     * @param endpoints The endpoints for the new proxy.
+     * @return A proxy with the new endpoints.
+     */
     ::std::shared_ptr<Prx> ice_endpoints(const ::Ice::EndpointSeq& endpoints) const
     {
         return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_endpoints(endpoints));
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the locator cache timeout.
+     * @param timeout The new locator cache timeout (in seconds).
+     * @return A proxy with the new timeout.
+     */
     ::std::shared_ptr<Prx> ice_locatorCacheTimeout(int timeout) const
     {
         return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_locatorCacheTimeout(timeout));
     }
 
-    ::std::shared_ptr<Prx> ice_connectionCached(bool cached) const
+    /**
+     * Obtains a proxy that is identical to this proxy, except for connection caching.
+     * @param b True if the new proxy should cache connections, false otherwise.
+     * @return A proxy with the specified caching policy.
+     */
+    ::std::shared_ptr<Prx> ice_connectionCached(bool b) const
     {
-        return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_connectionCached(cached));
+        return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_connectionCached(b));
     }
 
-    ::std::shared_ptr<Prx> ice_endpointSelection(::Ice::EndpointSelectionType selection) const
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the endpoint selection policy.
+     * @param type The new endpoint selection policy.
+     * @return A proxy with the specified endpoint selection policy.
+     */
+    ::std::shared_ptr<Prx> ice_endpointSelection(::Ice::EndpointSelectionType type) const
     {
-        return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_endpointSelection(selection));
+        return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_endpointSelection(type));
     }
 
-    ::std::shared_ptr<Prx> ice_secure(bool secure) const
+    /**
+     * Obtains a proxy that is identical to this proxy, except for how it selects endpoints.
+     * @param b If true, only endpoints that use a secure transport are used by the new proxy.
+     * If false, the returned proxy uses both secure and insecure endpoints.
+     * @return A proxy with the specified security policy.
+     */
+    ::std::shared_ptr<Prx> ice_secure(bool b) const
     {
-        return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_secure(secure));
+        return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_secure(b));
     }
 
-    ::std::shared_ptr<Prx> ice_preferSecure(bool preferSecure) const
+    /**
+     * Obtains a proxy that is identical to this proxy, except for its endpoint selection policy.
+     * @param b If true, the new proxy will use secure endpoints for invocations and only use
+     * insecure endpoints if an invocation cannot be made via secure endpoints. If false, the
+     * proxy prefers insecure endpoints to secure ones.
+     * @return A proxy with the specified selection policy.
+     */
+    ::std::shared_ptr<Prx> ice_preferSecure(bool b) const
     {
-        return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_preferSecure(preferSecure));
+        return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_preferSecure(b));
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the router.
+     * @param router The router for the new proxy.
+     * @return A proxy with the specified router.
+     */
     ::std::shared_ptr<Prx> ice_router(const ::std::shared_ptr<::Ice::RouterPrx>& router) const
     {
         return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_router(router));
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the locator.
+     * @param locator The locator for the new proxy.
+     * @return A proxy with the specified locator.
+     */
     ::std::shared_ptr<Prx> ice_locator(const ::std::shared_ptr<::Ice::LocatorPrx>& locator) const
     {
         return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_locator(locator));
     }
 
-    ::std::shared_ptr<Prx> ice_collocationOptimized(bool collocated) const
+    /**
+     * Obtains a proxy that is identical to this proxy, except for collocation optimization.
+     * @param b True if the new proxy enables collocation optimization, false otherwise.
+     * @return A proxy with the specified collocation optimization.
+     */
+    ::std::shared_ptr<Prx> ice_collocationOptimized(bool b) const
     {
-        return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_collocationOptimized(collocated));
+        return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_collocationOptimized(b));
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the invocation timeout.
+     * @param timeout The new invocation timeout (in milliseconds).
+     * @return A proxy with the new timeout.
+     */
     ::std::shared_ptr<Prx> ice_invocationTimeout(int timeout) const
     {
         return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_invocationTimeout(timeout));
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses twoway invocations.
+     * @return A proxy that uses twoway invocations.
+     */
     ::std::shared_ptr<Prx> ice_twoway() const
     {
         return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_twoway());
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses oneway invocations.
+     * @return A proxy that uses oneway invocations.
+     */
     ::std::shared_ptr<Prx> ice_oneway() const
     {
         return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_oneway());
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses batch oneway invocations.
+     * @return A proxy that uses batch oneway invocations.
+     */
     ::std::shared_ptr<Prx> ice_batchOneway() const
     {
         return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_batchOneway());
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses datagram invocations.
+     * @return A proxy that uses datagram invocations.
+     */
     ::std::shared_ptr<Prx> ice_datagram() const
     {
         return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_datagram());
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses batch datagram invocations.
+     * @return A proxy that uses batch datagram invocations.
+     */
     ::std::shared_ptr<Prx> ice_batchDatagram() const
     {
         return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_batchDatagram());
     }
 
-    ::std::shared_ptr<Prx> ice_compress(bool compress) const
+    /**
+     * Obtains a proxy that is identical to this proxy, except for its compression setting which
+     * overrides the compression setting from the proxy endpoints.
+     * @param b True enables compression for the new proxy, false disables compression.
+     * @return A proxy with the specified compression override setting.
+     */
+    ::std::shared_ptr<Prx> ice_compress(bool b) const
     {
-        return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_compress(compress));
+        return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_compress(b));
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for its connection timeout setting
+     * which overrides the timeot setting from the proxy endpoints.
+     * @param timeout The connection timeout override for the proxy (in milliseconds).
+     * @return A proxy with the specified timeout override.
+     */
     ::std::shared_ptr<Prx> ice_timeout(int timeout) const
     {
         return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_timeout(timeout));
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for its connection ID.
+     * @param id The connection ID for the new proxy. An empty string removes the
+     * connection ID.
+     * @return A proxy with the specified connection ID.
+     */
     ::std::shared_ptr<Prx> ice_connectionId(const ::std::string& id) const
     {
         return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_connectionId(id));
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except it's a fixed proxy bound
+     * the given connection.
+     * @param connection The fixed proxy connection.
+     * @return A fixed proxy bound to the given connection.
+     */
+    ::std::shared_ptr<Prx> ice_fixed(const ::std::shared_ptr<::Ice::Connection>& connection) const
+    {
+        return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_fixed(connection));
+    }
+
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the encoding used to marshal
+     * parameters.
+     * @param version The encoding version to use to marshal request parameters.
+     * @return A proxy with the specified encoding version.
+     */
     ::std::shared_ptr<Prx> ice_encodingVersion(const ::Ice::EncodingVersion& version) const
     {
         return ::std::dynamic_pointer_cast<Prx>(ObjectPrx::ice_encodingVersion(version));
@@ -830,18 +1406,59 @@ public:
 
 protected:
 
+    /// \cond INTERNAL
     virtual ::std::shared_ptr<ObjectPrx> _newInstance() const = 0;
+    /// \endcond
 };
 
 ICE_API ::std::ostream& operator<<(::std::ostream&, const ::Ice::ObjectPrx&);
 
-ICE_API bool proxyIdentityLess(const ::std::shared_ptr<ObjectPrx>&, const ::std::shared_ptr<ObjectPrx>&);
-ICE_API bool proxyIdentityEqual(const ::std::shared_ptr<ObjectPrx>&, const ::std::shared_ptr<ObjectPrx>&);
-
-ICE_API bool proxyIdentityAndFacetLess(const ::std::shared_ptr<ObjectPrx>&, const ::std::shared_ptr<ObjectPrx>&);
-ICE_API bool proxyIdentityAndFacetEqual(const ::std::shared_ptr<ObjectPrx>&, const ::std::shared_ptr<ObjectPrx>&);
-
+/**
+ * Compares the object identities of two proxies.
+ * @param lhs A proxy.
+ * @param rhs A proxy.
+ * @return True if the identity in lhs compares less than the identity in rhs, false otherwise.
+ */
+ICE_API bool proxyIdentityLess(const ::std::shared_ptr<ObjectPrx>& lhs, const ::std::shared_ptr<ObjectPrx>& rhs);
+
+/**
+ * Compares the object identities of two proxies.
+ * @param lhs A proxy.
+ * @param rhs A proxy.
+ * @return True if the identity in lhs compares equal to the identity in rhs, false otherwise.
+ */
+ICE_API bool proxyIdentityEqual(const ::std::shared_ptr<ObjectPrx>& lhs, const ::std::shared_ptr<ObjectPrx>& rhs);
+
+/**
+ * Compares the object identities and facets of two proxies.
+ * @param lhs A proxy.
+ * @param rhs A proxy.
+ * @return True if the identity and facet in lhs compare less than the identity and facet
+ * in rhs, false otherwise.
+ */
+ICE_API bool proxyIdentityAndFacetLess(const ::std::shared_ptr<ObjectPrx>& lhs,
+                                       const ::std::shared_ptr<ObjectPrx>& rhs);
+
+/**
+ * Compares the object identities and facets of two proxies.
+ * @param lhs A proxy.
+ * @param rhs A proxy.
+ * @return True if the identity and facet in lhs compare equal to the identity and facet
+ * in rhs, false otherwise.
+ */
+ICE_API bool proxyIdentityAndFacetEqual(const ::std::shared_ptr<ObjectPrx>& lhs,
+                                        const ::std::shared_ptr<ObjectPrx>& rhs);
+
+/**
+ * A functor that compares the object identities of two proxies. Evaluates true if the identity in lhs
+ * compares less than the identity in rhs, false otherwise.
+ * \headerfile Ice/Ice.h
+ */
+#if (ICE_CPLUSPLUS >= 201703L)
+struct ProxyIdentityLess
+#else
 struct ProxyIdentityLess : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&>
+#endif
 {
     bool operator()(const ::std::shared_ptr<ObjectPrx>& lhs, const ::std::shared_ptr<ObjectPrx>& rhs) const
     {
@@ -849,7 +1466,16 @@ struct ProxyIdentityLess : std::binary_function<bool, ::std::shared_ptr<ObjectPr
     }
 };
 
+/**
+ * A functor that compares the object identities of two proxies. Evaluates true if the identity in lhs
+ * compares equal to the identity in rhs, false otherwise.
+ * \headerfile Ice/Ice.h
+ */
+#if (ICE_CPLUSPLUS >= 201703L)
+struct ProxyIdentityEqual
+#else
 struct ProxyIdentityEqual : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&>
+#endif
 {
     bool operator()(const ::std::shared_ptr<ObjectPrx>& lhs, const ::std::shared_ptr<ObjectPrx>& rhs) const
     {
@@ -857,7 +1483,16 @@ struct ProxyIdentityEqual : std::binary_function<bool, ::std::shared_ptr<ObjectP
     }
 };
 
+/**
+ * A functor that compares the object identities and facets of two proxies. Evaluates true if the identity
+ * and facet in lhs compare less than the identity and facet in rhs, false otherwise.
+ * \headerfile Ice/Ice.h
+ */
+#if (ICE_CPLUSPLUS >= 201703L)
+struct ProxyIdentityAndFacetLess
+#else
 struct ProxyIdentityAndFacetLess : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&>
+#endif
 {
     bool operator()(const ::std::shared_ptr<ObjectPrx>& lhs, const ::std::shared_ptr<ObjectPrx>& rhs) const
     {
@@ -865,7 +1500,16 @@ struct ProxyIdentityAndFacetLess : std::binary_function<bool, ::std::shared_ptr<
     }
 };
 
+/**
+ * A functor that compares the object identities and facets of two proxies. Evaluates true if the identity
+ * and facet in lhs compare equal to the identity and facet in rhs, false otherwise.
+ * \headerfile Ice/Ice.h
+ */
+#if (ICE_CPLUSPLUS >= 201703L)
+struct ProxyIdentityAndFacetEqual
+#else
 struct ProxyIdentityAndFacetEqual : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&>
+#endif
 {
     bool operator()(const ::std::shared_ptr<ObjectPrx>& lhs, const ::std::shared_ptr<ObjectPrx>& rhs) const
     {
@@ -873,6 +1517,11 @@ struct ProxyIdentityAndFacetEqual : std::binary_function<bool, ::std::shared_ptr
     }
 };
 
+/**
+ * Downcasts a proxy without confirming the target object's type via a remote invocation.
+ * @param b The target proxy.
+ * @return A proxy with the requested type.
+ */
 template<typename P,
          typename T,
          typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, P>::value>::type* = nullptr,
@@ -892,6 +1541,12 @@ uncheckedCast(const ::std::shared_ptr<T>& b)
     return r;
 }
 
+/**
+ * Downcasts a proxy without confirming the target object's type via a remote invocation.
+ * @param b The target proxy.
+ * @param f A facet name.
+ * @return A proxy with the requested type and facet.
+ */
 template<typename P,
          typename T,
          typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, P>::value>::type* = nullptr,
@@ -907,6 +1562,13 @@ uncheckedCast(const ::std::shared_ptr<T>& b, const std::string& f)
     return r;
 }
 
+/**
+ * Downcasts a proxy after confirming the target object's type via a remote invocation.
+ * @param b The target proxy.
+ * @param context The context map for the invocation.
+ * @return A proxy with the requested type, or nil if the target proxy is nil or the target
+ * object does not support the requested type.
+ */
 template<typename P,
          typename T,
          typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, P>::value>::type* = nullptr,
@@ -925,6 +1587,14 @@ checkedCast(const ::std::shared_ptr<T>& b, const ::Ice::Context& context = Ice::
     return r;
 }
 
+/**
+ * Downcasts a proxy after confirming the target object's type via a remote invocation.
+ * @param b The target proxy.
+ * @param f A facet name.
+ * @param context The context map for the invocation.
+ * @return 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.
+ */
 template<typename P,
          typename T,
          typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, P>::value>::type* = nullptr,
@@ -962,11 +1632,13 @@ namespace IceProxy
 namespace Ice
 {
 
+/// \cond INTERNAL
 class Locator;
 ICE_API ::IceProxy::Ice::Object* upCast(::IceProxy::Ice::Locator*);
 
 class Router;
 ICE_API ::IceProxy::Ice::Object* upCast(::IceProxy::Ice::Router*);
+/// \endcond
 
 }
 
@@ -983,24 +1655,66 @@ typedef LocatorPrx LocatorPrxPtr;
 class LocalException;
 class OutputStream;
 
+/**
+ * Base class for asynchronous callback wrapper classes used for calls to
+ * IceProxy::Ice::Object::begin_ice_isA.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_isA.
+ * \headerfile Ice/Ice.h
+ */
 class Callback_Object_ice_isA_Base : public virtual ::IceInternal::CallbackBase { };
 typedef ::IceUtil::Handle< Callback_Object_ice_isA_Base> Callback_Object_ice_isAPtr;
 
+/**
+ * Base class for asynchronous callback wrapper classes used for calls to
+ * IceProxy::Ice::Object::begin_ice_ping.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_ping.
+ * \headerfile Ice/Ice.h
+ */
 class Callback_Object_ice_ping_Base : public virtual ::IceInternal::CallbackBase { };
 typedef ::IceUtil::Handle< Callback_Object_ice_ping_Base> Callback_Object_ice_pingPtr;
 
+/**
+ * Base class for asynchronous callback wrapper classes used for calls to
+ * IceProxy::Ice::Object::begin_ice_ids.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_ids.
+ * \headerfile Ice/Ice.h
+ */
 class Callback_Object_ice_ids_Base : public virtual ::IceInternal::CallbackBase { };
 typedef ::IceUtil::Handle< Callback_Object_ice_ids_Base> Callback_Object_ice_idsPtr;
 
+/**
+ * Base class for asynchronous callback wrapper classes used for calls to
+ * IceProxy::Ice::Object::begin_ice_id.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_id.
+ * \headerfile Ice/Ice.h
+ */
 class Callback_Object_ice_id_Base : public virtual ::IceInternal::CallbackBase { };
 typedef ::IceUtil::Handle< Callback_Object_ice_id_Base> Callback_Object_ice_idPtr;
 
+/**
+ * Base class for asynchronous callback wrapper classes used for calls to
+ * IceProxy::Ice::Object::begin_ice_invoke.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_invoke.
+ * \headerfile Ice/Ice.h
+ */
 class Callback_Object_ice_invoke_Base : public virtual ::IceInternal::CallbackBase { };
 typedef ::IceUtil::Handle< Callback_Object_ice_invoke_Base> Callback_Object_ice_invokePtr;
 
+/**
+ * Base class for asynchronous callback wrapper classes used for calls to
+ * IceProxy::Ice::Object::begin_ice_flushBatchRequests.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_flushBatchRequests.
+ * \headerfile Ice/Ice.h
+ */
 class Callback_Object_ice_flushBatchRequests_Base : public virtual ::IceInternal::CallbackBase { };
 typedef ::IceUtil::Handle< Callback_Object_ice_flushBatchRequests_Base> Callback_Object_ice_flushBatchRequestsPtr;
 
+/**
+ * Base class for asynchronous callback wrapper classes used for calls to
+ * IceProxy::Ice::Object::begin_ice_getConnection.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_getConnection.
+ * \headerfile Ice/Ice.h
+ */
 class Callback_Object_ice_getConnection_Base : public virtual ::IceInternal::CallbackBase { };
 typedef ::IceUtil::Handle< Callback_Object_ice_getConnection_Base> Callback_Object_ice_getConnectionPtr;
 
@@ -1009,6 +1723,10 @@ typedef ::IceUtil::Handle< Callback_Object_ice_getConnection_Base> Callback_Obje
 namespace IceProxy { namespace Ice
 {
 
+/**
+ * Base class of all object proxies.
+ * \headerfile Ice/Ice.h
+ */
 class ICE_API Object : public ::IceUtil::Shared
 {
 public:
@@ -1016,408 +1734,1047 @@ public:
     bool operator==(const Object&) const;
     bool operator<(const Object&) const;
 
+    /**
+     * Obtains the communicator that created this proxy.
+     * @return The communicator that created this proxy.
+     */
     ::Ice::CommunicatorPtr ice_getCommunicator() const;
 
+    /**
+     * Obtains a stringified version of this proxy.
+     * @return A stringified proxy.
+     */
     ::std::string ice_toString() const;
 
+    /**
+     * Tests whether this object supports a specific Slice interface.
+     * @param typeId The type ID of the Slice interface to test against.
+     * @param context The context map for the invocation.
+     * @return True if the target object has the interface
+     * specified by id or derives from the interface specified by id.
+     */
     bool ice_isA(const ::std::string& typeId, const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
         return end_ice_isA(_iceI_begin_ice_isA(typeId, context, ::IceInternal::dummyCallback, 0, true));
     }
 
+    /**
+     * Tests whether this object supports a specific Slice interface.
+     * @param typeId The type ID of the Slice interface to test against.
+     * @param context The context map for the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
     ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId,
                                         const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
         return _iceI_begin_ice_isA(typeId, context, ::IceInternal::dummyCallback, 0);
     }
 
+    /**
+     * Tests whether this object supports a specific Slice interface.
+     * @param typeId The type ID of the Slice interface to test against.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
     ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId,
-                                        const ::Ice::CallbackPtr& del,
+                                        const ::Ice::CallbackPtr& cb,
                                         const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_isA(typeId, ::Ice::noExplicitContext, del, cookie);
+        return _iceI_begin_ice_isA(typeId, ::Ice::noExplicitContext, cb, cookie);
     }
 
+    /**
+     * Tests whether this object supports a specific Slice interface.
+     * @param typeId The type ID of the Slice interface to test against.
+     * @param context The context map for the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
     ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId,
                                         const ::Ice::Context& context,
-                                        const ::Ice::CallbackPtr& del,
+                                        const ::Ice::CallbackPtr& cb,
                                         const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_isA(typeId, context, del, cookie);
+        return _iceI_begin_ice_isA(typeId, context, cb, cookie);
     }
 
+    /**
+     * Tests whether this object supports a specific Slice interface.
+     * @param typeId The type ID of the Slice interface to test against.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
     ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId,
-                                        const ::Ice::Callback_Object_ice_isAPtr& del,
+                                        const ::Ice::Callback_Object_ice_isAPtr& cb,
                                         const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_isA(typeId, ::Ice::noExplicitContext, del, cookie);
+        return _iceI_begin_ice_isA(typeId, ::Ice::noExplicitContext, cb, cookie);
     }
 
+    /**
+     * Tests whether this object supports a specific Slice interface.
+     * @param typeId The type ID of the Slice interface to test against.
+     * @param context The context map for the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
     ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId,
                                         const ::Ice::Context& context,
-                                        const ::Ice::Callback_Object_ice_isAPtr& del,
+                                        const ::Ice::Callback_Object_ice_isAPtr& cb,
                                         const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_isA(typeId, context, del, cookie);
+        return _iceI_begin_ice_isA(typeId, context, cb, cookie);
     }
 
-    bool end_ice_isA(const ::Ice::AsyncResultPtr&);
+    /**
+     * Completes an invocation of begin_ice_isA.
+     * @param result The asynchronous result object for the invocation.
+     * @return True if the target object has the interface
+     * specified by id or derives from the interface specified by id.
+     */
+    bool end_ice_isA(const ::Ice::AsyncResultPtr& result);
 
+    /**
+     * Tests whether the target object of this proxy can be reached.
+     * @param context The context map for the invocation.
+     */
     void ice_ping(const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
         end_ice_ping(_iceI_begin_ice_ping(context, ::IceInternal::dummyCallback, 0, true));
     }
 
+    /**
+     * Tests whether the target object of this proxy can be reached.
+     * @param context The context map for the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
     ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
         return _iceI_begin_ice_ping(context, ::IceInternal::dummyCallback, 0);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
+    /**
+     * Tests whether the target object of this proxy can be reached.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_ping(::Ice::noExplicitContext, del, cookie);
+        return _iceI_begin_ice_ping(::Ice::noExplicitContext, cb, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Context& context, const ::Ice::CallbackPtr& del,
+    /**
+     * Tests whether the target object of this proxy can be reached.
+     * @param context The context map for the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Context& context, const ::Ice::CallbackPtr& cb,
                                          const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_ping(context, del, cookie);
+        return _iceI_begin_ice_ping(context, cb, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Callback_Object_ice_pingPtr& del,
+    /**
+     * Tests whether the target object of this proxy can be reached.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Callback_Object_ice_pingPtr& cb,
                                          const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_ping(::Ice::noExplicitContext, del, cookie);
+        return _iceI_begin_ice_ping(::Ice::noExplicitContext, cb, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Context& context, const ::Ice::Callback_Object_ice_pingPtr& del,
+    /**
+     * Tests whether the target object of this proxy can be reached.
+     * @param context The context map for the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Context& context, const ::Ice::Callback_Object_ice_pingPtr& cb,
                                          const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_ping(context, del, cookie);
+        return _iceI_begin_ice_ping(context, cb, cookie);
     }
 
-    void end_ice_ping(const ::Ice::AsyncResultPtr&);
+    /**
+     * Completes an invocation of begin_ice_ping.
+     * @param result The asynchronous result object for the invocation.
+     */
+    void end_ice_ping(const ::Ice::AsyncResultPtr& result);
 
+    /**
+     * Returns the Slice type IDs of the interfaces supported by the target object of this proxy.
+     * @param context The context map for the invocation.
+     * @return The Slice type IDs of the interfaces supported by the target object, in base-to-derived
+     * order. The first element of the returned array is always "::Ice::Object".
+     */
     ::std::vector< ::std::string> ice_ids(const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
         return end_ice_ids(_iceI_begin_ice_ids(context, ::IceInternal::dummyCallback, 0, true));
     }
 
+    /**
+     * Returns the Slice type IDs of the interfaces supported by the target object of this proxy.
+     * @param context The context map for the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
     ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
         return _iceI_begin_ice_ids(context, ::IceInternal::dummyCallback, 0);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::CallbackPtr& del,
+    /**
+     * Returns the Slice type IDs of the interfaces supported by the target object of this proxy.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::CallbackPtr& cb,
                                         const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_ids(::Ice::noExplicitContext, del, cookie);
+        return _iceI_begin_ice_ids(::Ice::noExplicitContext, cb, cookie);
     }
 
+    /**
+     * Returns the Slice type IDs of the interfaces supported by the target object of this proxy.
+     * @param context The context map for the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
     ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Context& context,
-                                        const ::Ice::CallbackPtr& del,
+                                        const ::Ice::CallbackPtr& cb,
                                         const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_ids(context, del, cookie);
+        return _iceI_begin_ice_ids(context, cb, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Callback_Object_ice_idsPtr& del,
+    /**
+     * Returns the Slice type IDs of the interfaces supported by the target object of this proxy.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Callback_Object_ice_idsPtr& cb,
                                         const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_ids(::Ice::noExplicitContext, del, cookie);
+        return _iceI_begin_ice_ids(::Ice::noExplicitContext, cb, cookie);
     }
 
+    /**
+     * Returns the Slice type IDs of the interfaces supported by the target object of this proxy.
+     * @param context The context map for the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
     ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Context& context,
-                                        const ::Ice::Callback_Object_ice_idsPtr& del,
+                                        const ::Ice::Callback_Object_ice_idsPtr& cb,
                                         const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_ids(context, del, cookie);
+        return _iceI_begin_ice_ids(context, cb, cookie);
     }
 
-    ::std::vector< ::std::string> end_ice_ids(const ::Ice::AsyncResultPtr&);
+    /**
+     * Completes an invocation of begin_ice_ids.
+     * @param result The asynchronous result object for the invocation.
+     * @return The Slice type IDs of the interfaces supported by the target object, in base-to-derived
+     * order. The first element of the returned array is always "::Ice::Object".
+     */
+    ::std::vector< ::std::string> end_ice_ids(const ::Ice::AsyncResultPtr& result);
 
+    /**
+     * Returns the Slice type ID of the most-derived interface supported by the target object of this proxy.
+     * @param context The context map for the invocation.
+     * @return The Slice type ID of the most-derived interface.
+     */
     ::std::string ice_id(const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
         return end_ice_id(_iceI_begin_ice_id(context, ::IceInternal::dummyCallback, 0, true));
     }
 
+    /**
+     * Returns the Slice type ID of the most-derived interface supported by the target object of this proxy.
+     * @param context The context map for the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
     ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
         return _iceI_begin_ice_id(context, ::IceInternal::dummyCallback, 0);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::CallbackPtr& del,
+    /**
+     * Returns the Slice type ID of the most-derived interface supported by the target object of this proxy.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::CallbackPtr& cb,
                                        const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_id(::Ice::noExplicitContext, del, cookie);
+        return _iceI_begin_ice_id(::Ice::noExplicitContext, cb, cookie);
     }
 
+    /**
+     * Returns the Slice type ID of the most-derived interface supported by the target object of this proxy.
+     * @param context The context map for the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
     ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Context& context,
-                                       const ::Ice::CallbackPtr& del,
+                                       const ::Ice::CallbackPtr& cb,
                                        const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_id(context, del, cookie);
+        return _iceI_begin_ice_id(context, cb, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Callback_Object_ice_idPtr& del,
+    /**
+     * Returns the Slice type ID of the most-derived interface supported by the target object of this proxy.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Callback_Object_ice_idPtr& cb,
                                        const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_id(::Ice::noExplicitContext, del, cookie);
+        return _iceI_begin_ice_id(::Ice::noExplicitContext, cb, cookie);
     }
 
+    /**
+     * Returns the Slice type ID of the most-derived interface supported by the target object of this proxy.
+     * @param context The context map for the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
     ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Context& context,
-                                       const ::Ice::Callback_Object_ice_idPtr& del,
+                                       const ::Ice::Callback_Object_ice_idPtr& cb,
                                        const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_id(context, del, cookie);
+        return _iceI_begin_ice_id(context, cb, cookie);
     }
 
-    ::std::string end_ice_id(const ::Ice::AsyncResultPtr&);
+    /**
+     * Completes an invocation of begin_ice_id.
+     * @param result The asynchronous result object for the invocation.
+     * @return The Slice type ID of the most-derived interface.
+     */
+    ::std::string end_ice_id(const ::Ice::AsyncResultPtr& result);
 
+    /**
+     * Returns the Slice type ID associated with this type.
+     * @return The Slice type ID.
+     */
     static const ::std::string& ice_staticId()
     {
         return ::Ice::Object::ice_staticId();
     }
 
-    // Returns true if ok, false if user exception.
-    bool ice_invoke(const ::std::string&,
-                    ::Ice::OperationMode,
-                    const ::std::vector< ::Ice::Byte>&,
-                    ::std::vector< ::Ice::Byte>&,
-                    const ::Ice::Context& = ::Ice::noExplicitContext);
-
-    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @param outParams An encapsulation containing the encoded results.
+     * @param context The context map for the invocation.
+     * @return True if the operation completed successfully, in which case outParams contains
+     * the encoded out parameters. False if the operation raised a user exception, in which
+     * case outParams contains the encoded user exception. If the operation raises a run-time
+     * exception, it throws it directly.
+     */
+    bool ice_invoke(const ::std::string& operation,
+                    ::Ice::OperationMode mode,
+                    const ::std::vector< ::Ice::Byte>& inParams,
+                    ::std::vector< ::Ice::Byte>& outParams,
+                    const ::Ice::Context& context = ::Ice::noExplicitContext);
+
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
                                            ::Ice::OperationMode mode,
                                            const ::std::vector< ::Ice::Byte>& inParams)
     {
-        return _iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, ::IceInternal::dummyCallback, 0);
+        return _iceI_begin_ice_invoke(operation, mode, inParams, ::Ice::noExplicitContext,
+                                      ::IceInternal::dummyCallback, 0);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @param context The context map for the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
                                            ::Ice::OperationMode mode,
                                            const ::std::vector< ::Ice::Byte>& inParams,
                                            const ::Ice::Context& context)
     {
-        return _iceI_begin_ice_invoke(op, mode, inParams, context, ::IceInternal::dummyCallback, 0);
+        return _iceI_begin_ice_invoke(operation, mode, inParams, context, ::IceInternal::dummyCallback, 0);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
                                            ::Ice::OperationMode mode,
                                            const ::std::vector< ::Ice::Byte>& inParams,
-                                           const ::Ice::CallbackPtr& del,
+                                           const ::Ice::CallbackPtr& cb,
                                            const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie);
+        return _iceI_begin_ice_invoke(operation, mode, inParams, ::Ice::noExplicitContext, cb, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @param context The context map for the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
                                            ::Ice::OperationMode mode,
                                            const ::std::vector< ::Ice::Byte>& inParams,
                                            const ::Ice::Context& context,
-                                           const ::Ice::CallbackPtr& del,
+                                           const ::Ice::CallbackPtr& cb,
                                            const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_invoke(op, mode, inParams, context, del, cookie);
+        return _iceI_begin_ice_invoke(operation, mode, inParams, context, cb, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
                                            ::Ice::OperationMode mode,
                                            const ::std::vector< ::Ice::Byte>& inParams,
-                                           const ::Ice::Callback_Object_ice_invokePtr& del,
+                                           const ::Ice::Callback_Object_ice_invokePtr& cb,
                                            const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie);
+        return _iceI_begin_ice_invoke(operation, mode, inParams, ::Ice::noExplicitContext, cb, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @param context The context map for the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
                                            ::Ice::OperationMode mode,
                                            const ::std::vector< ::Ice::Byte>& inParams,
                                            const ::Ice::Context& context,
-                                           const ::Ice::Callback_Object_ice_invokePtr& del,
+                                           const ::Ice::Callback_Object_ice_invokePtr& cb,
                                            const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_invoke(op, mode, inParams, context, del, cookie);
-    }
-
-    bool end_ice_invoke(::std::vector< ::Ice::Byte>&, const ::Ice::AsyncResultPtr&);
-
-    bool ice_invoke(const ::std::string& op,
+        return _iceI_begin_ice_invoke(operation, mode, inParams, context, cb, cookie);
+    }
+
+    /**
+     * Invokes an operation dynamically.
+     * @param outParams An encapsulation containing the encoded results.
+     * @param result The asynchronous result object for the invocation.
+     * @return True if the operation completed successfully, in which case outParams contains
+     * the encoded out parameters. False if the operation raised a user exception, in which
+     * case outParams contains the encoded user exception. If the operation raises a run-time
+     * exception, it throws it directly.
+     */
+    bool end_ice_invoke(::std::vector< ::Ice::Byte>& outParams, const ::Ice::AsyncResultPtr& result);
+
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @param outParams An encapsulation containing the encoded results.
+     * @param context The context map for the invocation.
+     * @return True if the operation completed successfully, in which case outParams contains
+     * the encoded out parameters. False if the operation raised a user exception, in which
+     * case outParams contains the encoded user exception. If the operation raises a run-time
+     * exception, it throws it directly.
+     */
+    bool ice_invoke(const ::std::string& operation,
                     ::Ice::OperationMode mode,
-                    const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inP,
-                    ::std::vector< ::Ice::Byte>& outP,
+                    const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
+                    ::std::vector< ::Ice::Byte>& outParams,
                     const ::Ice::Context& context = ::Ice::noExplicitContext)
     {
-        return end_ice_invoke(outP, _iceI_begin_ice_invoke(op, mode, inP, context, ::IceInternal::dummyCallback, 0, true));
+        return end_ice_invoke(outParams, _iceI_begin_ice_invoke(operation, mode, inParams, context,
+                                                                ::IceInternal::dummyCallback, 0, true));
     }
 
-    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
                                            ::Ice::OperationMode mode,
                                            const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams)
     {
-        return _iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, ::IceInternal::dummyCallback, 0);
+        return _iceI_begin_ice_invoke(operation, mode, inParams, ::Ice::noExplicitContext,
+                                      ::IceInternal::dummyCallback, 0);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @param context The context map for the invocation.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
                                            ::Ice::OperationMode mode,
                                            const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
                                            const ::Ice::Context& context,
                                            const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_invoke(op, mode, inParams, context, ::IceInternal::dummyCallback, cookie);
+        return _iceI_begin_ice_invoke(operation, mode, inParams, context, ::IceInternal::dummyCallback, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
                                            ::Ice::OperationMode mode,
                                            const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
-                                           const ::Ice::CallbackPtr& del,
+                                           const ::Ice::CallbackPtr& cb,
                                            const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie);
+        return _iceI_begin_ice_invoke(operation, mode, inParams, ::Ice::noExplicitContext, cb, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @param context The context map for the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
                                            ::Ice::OperationMode mode,
                                            const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
                                            const ::Ice::Context& context,
-                                           const ::Ice::CallbackPtr& del,
+                                           const ::Ice::CallbackPtr& cb,
                                            const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_invoke(op, mode, inParams, context, del, cookie);
+        return _iceI_begin_ice_invoke(operation, mode, inParams, context, cb, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
                                            ::Ice::OperationMode mode,
                                            const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
-                                           const ::Ice::Callback_Object_ice_invokePtr& del,
+                                           const ::Ice::Callback_Object_ice_invokePtr& cb,
                                            const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_invoke(op, mode, inParams, ::Ice::noExplicitContext, del, cookie);
+        return _iceI_begin_ice_invoke(operation, mode, inParams, ::Ice::noExplicitContext, cb, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& op,
+    /**
+     * Invokes an operation dynamically.
+     * @param operation The name of the operation to invoke.
+     * @param mode The operation mode (normal or idempotent).
+     * @param inParams An encapsulation containing the encoded in-parameters for the operation.
+     * @param context The context map for the invocation.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
                                            ::Ice::OperationMode mode,
                                            const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
                                            const ::Ice::Context& context,
-                                           const ::Ice::Callback_Object_ice_invokePtr& del,
+                                           const ::Ice::Callback_Object_ice_invokePtr& cb,
                                            const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_invoke(op, mode, inParams, context, del, cookie);
+        return _iceI_begin_ice_invoke(operation, mode, inParams, context, cb, cookie);
     }
 
+    /// \cond INTERNAL
     bool _iceI_end_ice_invoke(::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&, const ::Ice::AsyncResultPtr&);
+    /// \endcond
 
+    /**
+     * Obtains the identity embedded in this proxy.
+     * @return The identity of the target object.
+     */
     ::Ice::Identity ice_getIdentity() const;
-    ::Ice::ObjectPrx ice_identity(const ::Ice::Identity&) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the identity.
+     * @param id The identity for the new proxy.
+     * @return A proxy with the new identity.
+     */
+    ::Ice::ObjectPrx ice_identity(const ::Ice::Identity& id) const;
+
+    /**
+     * Obtains the per-proxy context for this proxy.
+     * @return The per-proxy context.
+     */
     ::Ice::Context ice_getContext() const;
-    ::Ice::ObjectPrx ice_context(const ::Ice::Context&) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the per-proxy context.
+     * @param context The context for the new proxy.
+     * @return A proxy with the new per-proxy context.
+     */
+    ::Ice::ObjectPrx ice_context(const ::Ice::Context& context) const;
+
+    /**
+     * Obtains the facet for this proxy.
+     * @return The facet for this proxy. If the proxy uses the default facet, the return value is the empty string.
+     */
     const ::std::string& ice_getFacet() const;
-    ::Ice::ObjectPrx ice_facet(const ::std::string&) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the facet.
+     * @param facet The facet for the new proxy.
+     * @return A proxy with the new facet.
+     */
+    ::Ice::ObjectPrx ice_facet(const ::std::string& facet) const;
+
+    /**
+     * Obtains the adapter ID for this proxy.
+     * @return The adapter ID. If the proxy does not have an adapter ID, the return value is the empty string.
+     */
     ::std::string ice_getAdapterId() const;
-    ::Ice::ObjectPrx ice_adapterId(const ::std::string&) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the adapter ID.
+     * @param id The adapter ID for the new proxy.
+     * @return A proxy with the new adapter ID.
+     */
+    ::Ice::ObjectPrx ice_adapterId(const ::std::string& id) const;
+
+    /**
+     * Obtains the endpoints used by this proxy.
+     * @return The endpoints used by this proxy.
+     */
     ::Ice::EndpointSeq ice_getEndpoints() const;
-    ::Ice::ObjectPrx ice_endpoints(const ::Ice::EndpointSeq&) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the endpoints.
+     * @param endpoints The endpoints for the new proxy.
+     * @return A proxy with the new endpoints.
+     */
+    ::Ice::ObjectPrx ice_endpoints(const ::Ice::EndpointSeq& endpoints) const;
+
+    /**
+     * Obtains the locator cache timeout of this proxy.
+     * @return The locator cache timeout value (in seconds).
+     */
     ::Ice::Int ice_getLocatorCacheTimeout() const;
-    ::Ice::ObjectPrx ice_locatorCacheTimeout(::Ice::Int) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the locator cache timeout.
+     * @param timeout The new locator cache timeout (in seconds).
+     * @return A proxy with the new timeout.
+     */
+    ::Ice::ObjectPrx ice_locatorCacheTimeout(::Ice::Int timeout) const;
+
+    /**
+     * Determines whether this proxy caches connections.
+     * @return True if this proxy caches connections, false otherwise.
+     */
     bool ice_isConnectionCached() const;
-    ::Ice::ObjectPrx ice_connectionCached(bool) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for connection caching.
+     * @param b True if the new proxy should cache connections, false otherwise.
+     * @return A proxy with the specified caching policy.
+     */
+    ::Ice::ObjectPrx ice_connectionCached(bool b) const;
+
+    /**
+     * Obtains the endpoint selection policy for this proxy (randomly or ordered).
+     * @return The endpoint selection policy.
+     */
     ::Ice::EndpointSelectionType ice_getEndpointSelection() const;
-    ::Ice::ObjectPrx ice_endpointSelection(::Ice::EndpointSelectionType) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the endpoint selection policy.
+     * @param type The new endpoint selection policy.
+     * @return A proxy with the specified endpoint selection policy.
+     */
+    ::Ice::ObjectPrx ice_endpointSelection(::Ice::EndpointSelectionType type) const;
+
+    /**
+     * Determines whether this proxy uses only secure endpoints.
+     * @return True if this proxy communicates only via secure endpoints, false otherwise.
+     */
     bool ice_isSecure() const;
-    ::Ice::ObjectPrx ice_secure(bool) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for how it selects endpoints.
+     * @param b If true, only endpoints that use a secure transport are used by the new proxy.
+     * If false, the returned proxy uses both secure and insecure endpoints.
+     * @return A proxy with the specified security policy.
+     */
+    ::Ice::ObjectPrx ice_secure(bool b) const;
+
+    /**
+     * Obtains the encoding version used to marshal request parameters.
+     * @return The encoding version.
+     */
     ::Ice::EncodingVersion ice_getEncodingVersion() const;
-    ::Ice::ObjectPrx ice_encodingVersion(const ::Ice::EncodingVersion&) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the encoding used to marshal
+     * parameters.
+     * @param version The encoding version to use to marshal request parameters.
+     * @return A proxy with the specified encoding version.
+     */
+    ::Ice::ObjectPrx ice_encodingVersion(const ::Ice::EncodingVersion& version) const;
+
+    /**
+     * Determines whether this proxy prefers secure endpoints.
+     * @return True if the proxy always attempts to invoke via secure endpoints before it
+     * attempts to use insecure endpoints, false otherwise.
+     */
     bool ice_isPreferSecure() const;
-    ::Ice::ObjectPrx ice_preferSecure(bool) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for its endpoint selection policy.
+     * @param b If true, the new proxy will use secure endpoints for invocations and only use
+     * insecure endpoints if an invocation cannot be made via secure endpoints. If false, the
+     * proxy prefers insecure endpoints to secure ones.
+     * @return A proxy with the specified selection policy.
+     */
+    ::Ice::ObjectPrx ice_preferSecure(bool b) const;
+
+    /**
+     * Obtains the router for this proxy.
+     * @return The router for the proxy. If no router is configured for the proxy, the return value
+     * is nil.
+     */
     ::Ice::RouterPrx ice_getRouter() const;
-    ::Ice::ObjectPrx ice_router(const ::Ice::RouterPrx&) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the router.
+     * @param router The router for the new proxy.
+     * @return A proxy with the specified router.
+     */
+    ::Ice::ObjectPrx ice_router(const ::Ice::RouterPrx& router) const;
+
+    /**
+     * Obtains the locator for this proxy.
+     * @return The locator for this proxy. If no locator is configured, the return value is nil.
+     */
     ::Ice::LocatorPrx ice_getLocator() const;
-    ::Ice::ObjectPrx ice_locator(const ::Ice::LocatorPrx&) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the locator.
+     * @param locator The locator for the new proxy.
+     * @return A proxy with the specified locator.
+     */
+    ::Ice::ObjectPrx ice_locator(const ::Ice::LocatorPrx& locator) const;
+
+    /**
+     * Determines whether this proxy uses collocation optimization.
+     * @return True if the proxy uses collocation optimization, false otherwise.
+     */
     bool ice_isCollocationOptimized() const;
-    ::Ice::ObjectPrx ice_collocationOptimized(bool) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for collocation optimization.
+     * @param b True if the new proxy enables collocation optimization, false otherwise.
+     * @return A proxy with the specified collocation optimization.
+     */
+    ::Ice::ObjectPrx ice_collocationOptimized(bool b) const;
+
+    /**
+     * Obtains the invocation timeout of this proxy.
+     * @return The invocation timeout value (in milliseconds).
+     */
     ::Ice::Int ice_getInvocationTimeout() const;
-    ::Ice::ObjectPrx ice_invocationTimeout(::Ice::Int) const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the invocation timeout.
+     * @param timeout The new invocation timeout (in milliseconds).
+     * @return A proxy with the new timeout.
+     */
+    ::Ice::ObjectPrx ice_invocationTimeout(::Ice::Int timeout) const;
+
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses twoway invocations.
+     * @return A proxy that uses twoway invocations.
+     */
     ::Ice::ObjectPrx ice_twoway() const;
+
+    /**
+     * Determines whether this proxy uses twoway invocations.
+     * @return True if this proxy uses twoway invocations, false otherwise.
+     */
     bool ice_isTwoway() const;
+
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses oneway invocations.
+     * @return A proxy that uses oneway invocations.
+     */
     ::Ice::ObjectPrx ice_oneway() const;
+
+    /**
+     * Determines whether this proxy uses oneway invocations.
+     * @return True if this proxy uses oneway invocations, false otherwise.
+     */
     bool ice_isOneway() const;
+
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses batch oneway invocations.
+     * @return A proxy that uses batch oneway invocations.
+     */
     ::Ice::ObjectPrx ice_batchOneway() const;
+
+    /**
+     * Determines whether this proxy uses batch oneway invocations.
+     * @return True if this proxy uses batch oneway invocations, false otherwise.
+     */
     bool ice_isBatchOneway() const;
+
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses datagram invocations.
+     * @return A proxy that uses datagram invocations.
+     */
     ::Ice::ObjectPrx ice_datagram() const;
+
+    /**
+     * Determines whether this proxy uses datagram invocations.
+     * @return True if this proxy uses datagram invocations, false otherwise.
+     */
     bool ice_isDatagram() const;
+
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses batch datagram invocations.
+     * @return A proxy that uses batch datagram invocations.
+     */
     ::Ice::ObjectPrx ice_batchDatagram() const;
-    bool ice_isBatchDatagram() const;
 
-    ::Ice::ObjectPrx ice_compress(bool) const;
-    ::Ice::ObjectPrx ice_timeout(int) const;
+    /**
+     * Determines whether this proxy uses batch datagram invocations.
+     * @return True if this proxy uses batch datagram invocations, false otherwise.
+     */
+    bool ice_isBatchDatagram() const;
 
-    ::Ice::ObjectPrx ice_connectionId(const ::std::string&) const;
+    /**
+     * Obtains a proxy that is identical to this proxy, except for its compression setting which
+     * overrides the compression setting from the proxy endpoints.
+     * @param b True enables compression for the new proxy, false disables compression.
+     * @return A proxy with the specified compression override setting.
+     */
+    ::Ice::ObjectPrx ice_compress(bool b) const;
+
+    /**
+     * Obtains the compression override setting of this proxy.
+     * @return The compression override setting. If nullopt is returned, no override is set. Otherwise, true
+     * if compression is enabled, false otherwise.
+     */
+    ::IceUtil::Optional<bool> ice_getCompress() const;
+
+    /**
+     * Obtains a proxy that is identical to this proxy, except for its connection timeout setting
+     * which overrides the timeot setting from the proxy endpoints.
+     * @param timeout The connection timeout override for the proxy (in milliseconds).
+     * @return A proxy with the specified timeout override.
+     */
+    ::Ice::ObjectPrx ice_timeout(int timeout) const;
+
+    /**
+     * Obtains the timeout override of this proxy.
+     * @return The timeout override. If nullopt is returned, no override is set. Otherwise, returns
+     * the timeout override value.
+     */
+    ::IceUtil::Optional<int> ice_getTimeout() const;
+
+    /**
+     * Obtains a proxy that is identical to this proxy, except for its connection ID.
+     * @param id The connection ID for the new proxy. An empty string removes the
+     * connection ID.
+     * @return A proxy with the specified connection ID.
+     */
+    ::Ice::ObjectPrx ice_connectionId(const ::std::string& id) const;
+
+    /**
+     * Obtains the connection ID of this proxy.
+     * @return The connection ID.
+     */
     ::std::string ice_getConnectionId() const;
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except it's a fixed proxy bound
+     * the given connection.
+     * @param connection The fixed proxy connection.
+     * @return A fixed proxy bound to the given connection.
+     */
+    ::Ice::ObjectPrx ice_fixed(const ::Ice::ConnectionPtr& connection) const;
+
+    /**
+     * Obtains the Connection for this proxy. If the proxy does not yet have an established connection,
+     * it first attempts to create a connection.
+     * @return The connection for this proxy.
+     */
     ::Ice::ConnectionPtr ice_getConnection()
     {
         return end_ice_getConnection(begin_ice_getConnection());
     }
 
+    /**
+     * Obtains the Connection for this proxy. If the proxy does not yet have an established connection,
+     * it first attempts to create a connection.
+     * @return The asynchronous result object for the invocation.
+     */
     ::Ice::AsyncResultPtr begin_ice_getConnection()
     {
         return _iceI_begin_ice_getConnection(::IceInternal::dummyCallback, 0);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_getConnection(const ::Ice::CallbackPtr& del,
+    /**
+     * Obtains the Connection for this proxy. If the proxy does not yet have an established connection,
+     * it first attempts to create a connection.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_getConnection(const ::Ice::CallbackPtr& cb,
                                                   const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_getConnection(del, cookie);
+        return _iceI_begin_ice_getConnection(cb, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_getConnection(const ::Ice::Callback_Object_ice_getConnectionPtr& del,
+    /**
+     * Obtains the Connection for this proxy. If the proxy does not yet have an established connection,
+     * it first attempts to create a connection.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_getConnection(const ::Ice::Callback_Object_ice_getConnectionPtr& cb,
                                                   const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_getConnection(del, cookie);
+        return _iceI_begin_ice_getConnection(cb, cookie);
     }
 
-    ::Ice::ConnectionPtr end_ice_getConnection(const ::Ice::AsyncResultPtr&);
+    /**
+     * Completes an invocation of begin_ice_getConnection.
+     * @param result The asynchronous result object for the invocation.
+     * @return The connection for this proxy.
+     */
+    ::Ice::ConnectionPtr end_ice_getConnection(const ::Ice::AsyncResultPtr& result);
 
+    /**
+     * Returns the cached connection for this proxy. If the proxy does not yet have an established
+     * connection, it does not attempt to create a connection.
+     *
+     * @return The cached connection for this proxy, or nil if the proxy does not have
+     * an established connection.
+     */
     ::Ice::ConnectionPtr ice_getCachedConnection() const;
 
+    /**
+     * Flushes any pending batched requests for this proxy. The call blocks until the flush is complete.
+     */
     void ice_flushBatchRequests()
     {
         return end_ice_flushBatchRequests(begin_ice_flushBatchRequests());
     }
 
+    /**
+     * Flushes any pending batched requests for this proxy. The call blocks until the flush is complete.
+     * @return The asynchronous result object for the invocation.
+     */
     ::Ice::AsyncResultPtr begin_ice_flushBatchRequests()
     {
         return _iceI_begin_ice_flushBatchRequests(::IceInternal::dummyCallback, 0);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_flushBatchRequests(const ::Ice::CallbackPtr& del,
+    /**
+     * Flushes any pending batched requests for this proxy. The call blocks until the flush is complete.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_flushBatchRequests(const ::Ice::CallbackPtr& cb,
                                                        const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_flushBatchRequests(del, cookie);
+        return _iceI_begin_ice_flushBatchRequests(cb, cookie);
     }
 
-    ::Ice::AsyncResultPtr begin_ice_flushBatchRequests(const ::Ice::Callback_Object_ice_flushBatchRequestsPtr& del,
+    /**
+     * Flushes any pending batched requests for this proxy. The call blocks until the flush is complete.
+     * @param cb Asynchronous callback object.
+     * @param cookie User-defined data to associate with the invocation.
+     * @return The asynchronous result object for the invocation.
+     */
+    ::Ice::AsyncResultPtr begin_ice_flushBatchRequests(const ::Ice::Callback_Object_ice_flushBatchRequestsPtr& cb,
                                                        const ::Ice::LocalObjectPtr& cookie = 0)
     {
-        return _iceI_begin_ice_flushBatchRequests(del, cookie);
+        return _iceI_begin_ice_flushBatchRequests(cb, cookie);
     }
 
-    void end_ice_flushBatchRequests(const ::Ice::AsyncResultPtr&);
+    /**
+     * Completes an invocation of begin_ice_flushBatchRequests.
+     * @param result The asynchronous result object for the invocation.
+     */
+    void end_ice_flushBatchRequests(const ::Ice::AsyncResultPtr& result);
 
+    /// \cond INTERNAL
     const ::IceInternal::ReferencePtr& _getReference() const { return _reference; }
 
     ::Ice::Int _hash() const;
@@ -1437,10 +2794,13 @@ public:
     void _updateRequestHandler(const ::IceInternal::RequestHandlerPtr&, const ::IceInternal::RequestHandlerPtr&);
 
     void _write(::Ice::OutputStream&) const;
+    /// \endcond
 
 protected:
 
+    /// \cond INTERNAL
     virtual Object* _newInstance() const;
+    /// \endcond
 
 private:
 
@@ -1503,111 +2863,233 @@ ICE_API ::std::ostream& operator<<(::std::ostream&, const ::IceProxy::Ice::Objec
 namespace Ice
 {
 
+/**
+ * Helper template that supplies proxy factory functions.
+ * \headerfile Ice/Ice.h
+ */
 template<typename Prx, typename Base>
 class Proxy : public virtual Base
 {
 public:
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the per-proxy context.
+     * @param context The context for the new proxy.
+     * @return A proxy with the new per-proxy context.
+     */
     IceInternal::ProxyHandle<Prx> ice_context(const ::Ice::Context& context) const
     {
         return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_context(context).get());
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the adapter ID.
+     * @param id The adapter ID for the new proxy.
+     * @return A proxy with the new adapter ID.
+     */
     IceInternal::ProxyHandle<Prx> ice_adapterId(const ::std::string& id) const
     {
         return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_adapterId(id).get());
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the endpoints.
+     * @param endpoints The endpoints for the new proxy.
+     * @return A proxy with the new endpoints.
+     */
     IceInternal::ProxyHandle<Prx> ice_endpoints(const ::Ice::EndpointSeq& endpoints) const
     {
         return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_endpoints(endpoints).get());
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the locator cache timeout.
+     * @param timeout The new locator cache timeout (in seconds).
+     * @return A proxy with the new timeout.
+     */
     IceInternal::ProxyHandle<Prx> ice_locatorCacheTimeout(int timeout) const
     {
         return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(timeout).get());
     }
 
-    IceInternal::ProxyHandle<Prx> ice_connectionCached(bool cached) const
+    /**
+     * Obtains a proxy that is identical to this proxy, except for connection caching.
+     * @param b True if the new proxy should cache connections, false otherwise.
+     * @return A proxy with the specified caching policy.
+     */
+    IceInternal::ProxyHandle<Prx> ice_connectionCached(bool b) const
     {
-        return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_connectionCached(cached).get());
+        return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_connectionCached(b).get());
     }
 
-    IceInternal::ProxyHandle<Prx> ice_endpointSelection(::Ice::EndpointSelectionType selection) const
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the endpoint selection policy.
+     * @param type The new endpoint selection policy.
+     * @return A proxy with the specified endpoint selection policy.
+     */
+    IceInternal::ProxyHandle<Prx> ice_endpointSelection(::Ice::EndpointSelectionType type) const
     {
-        return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_endpointSelection(selection).get());
+        return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_endpointSelection(type).get());
     }
 
-    IceInternal::ProxyHandle<Prx> ice_secure(bool secure) const
+    /**
+     * Obtains a proxy that is identical to this proxy, except for how it selects endpoints.
+     * @param b If true, only endpoints that use a secure transport are used by the new proxy.
+     * If false, the returned proxy uses both secure and insecure endpoints.
+     * @return A proxy with the specified security policy.
+     */
+    IceInternal::ProxyHandle<Prx> ice_secure(bool b) const
     {
-        return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_secure(secure).get());
+        return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_secure(b).get());
     }
 
-    IceInternal::ProxyHandle<Prx> ice_preferSecure(bool preferSecure) const
+    /**
+     * Obtains a proxy that is identical to this proxy, except for its endpoint selection policy.
+     * @param b If true, the new proxy will use secure endpoints for invocations and only use
+     * insecure endpoints if an invocation cannot be made via secure endpoints. If false, the
+     * proxy prefers insecure endpoints to secure ones.
+     * @return A proxy with the specified selection policy.
+     */
+    IceInternal::ProxyHandle<Prx> ice_preferSecure(bool b) const
     {
-        return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_preferSecure(preferSecure).get());
+        return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_preferSecure(b).get());
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the router.
+     * @param router The router for the new proxy.
+     * @return A proxy with the specified router.
+     */
     IceInternal::ProxyHandle<Prx> ice_router(const ::Ice::RouterPrx& router) const
     {
         return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_router(router).get());
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the locator.
+     * @param locator The locator for the new proxy.
+     * @return A proxy with the specified locator.
+     */
     IceInternal::ProxyHandle<Prx> ice_locator(const ::Ice::LocatorPrx& locator) const
     {
         return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_locator(locator).get());
     }
 
-    IceInternal::ProxyHandle<Prx> ice_collocationOptimized(bool collocated) const
+    /**
+     * Obtains a proxy that is identical to this proxy, except for collocation optimization.
+     * @param b True if the new proxy enables collocation optimization, false otherwise.
+     * @return A proxy with the specified collocation optimization.
+     */
+    IceInternal::ProxyHandle<Prx> ice_collocationOptimized(bool b) const
     {
-        return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_collocationOptimized(collocated).get());
+        return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_collocationOptimized(b).get());
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the invocation timeout.
+     * @param timeout The new invocation timeout (in milliseconds).
+     * @return A proxy with the new timeout.
+     */
     IceInternal::ProxyHandle<Prx> ice_invocationTimeout(int timeout) const
     {
         return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_invocationTimeout(timeout).get());
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses twoway invocations.
+     * @return A proxy that uses twoway invocations.
+     */
     IceInternal::ProxyHandle<Prx> ice_twoway() const
     {
         return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_twoway().get());
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses oneway invocations.
+     * @return A proxy that uses oneway invocations.
+     */
     IceInternal::ProxyHandle<Prx> ice_oneway() const
     {
         return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_oneway().get());
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses batch oneway invocations.
+     * @return A proxy that uses batch oneway invocations.
+     */
     IceInternal::ProxyHandle<Prx> ice_batchOneway() const
     {
         return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_batchOneway().get());
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses datagram invocations.
+     * @return A proxy that uses datagram invocations.
+     */
     IceInternal::ProxyHandle<Prx> ice_datagram() const
     {
         return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_datagram().get());
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, but uses batch datagram invocations.
+     * @return A proxy that uses batch datagram invocations.
+     */
     IceInternal::ProxyHandle<Prx> ice_batchDatagram() const
     {
         return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
     }
 
-    IceInternal::ProxyHandle<Prx> ice_compress(bool compress) const
+    /**
+     * Obtains a proxy that is identical to this proxy, except for its compression setting which
+     * overrides the compression setting from the proxy endpoints.
+     * @param b True enables compression for the new proxy, false disables compression.
+     * @return A proxy with the specified compression override setting.
+     */
+    IceInternal::ProxyHandle<Prx> ice_compress(bool b) const
     {
-        return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_compress(compress).get());
+        return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_compress(b).get());
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for its connection timeout setting
+     * which overrides the timeot setting from the proxy endpoints.
+     * @param timeout The connection timeout override for the proxy (in milliseconds).
+     * @return A proxy with the specified timeout override.
+     */
     IceInternal::ProxyHandle<Prx> ice_timeout(int timeout) const
     {
         return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_timeout(timeout).get());
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except for its connection ID.
+     * @param id The connection ID for the new proxy. An empty string removes the
+     * connection ID.
+     * @return A proxy with the specified connection ID.
+     */
     IceInternal::ProxyHandle<Prx> ice_connectionId(const ::std::string& id) const
     {
         return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_connectionId(id).get());
     }
 
+    /**
+     * Obtains a proxy that is identical to this proxy, except it's a fixed proxy bound
+     * the given connection.
+     * @param connection The fixed proxy connection.
+     * @return A fixed proxy bound to the given connection.
+     */
+    IceInternal::ProxyHandle<Prx> ice_fixed(const ::Ice::ConnectionPtr& connection) const
+    {
+        return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_fixed(connection).get());
+    }
+
+    /**
+     * Obtains a proxy that is identical to this proxy, except for the encoding used to marshal
+     * parameters.
+     * @param version The encoding version to use to marshal request parameters.
+     * @return A proxy with the specified encoding version.
+     */
     IceInternal::ProxyHandle<Prx> ice_encodingVersion(const ::Ice::EncodingVersion& version) const
     {
         return dynamic_cast<Prx*>(::IceProxy::Ice::Object::ice_encodingVersion(version).get());
@@ -1615,15 +3097,50 @@ public:
 
 protected:
 
+    /// \cond INTERNAL
     virtual ::IceProxy::Ice::Object* _newInstance() const = 0;
+    /// \endcond
 };
 
-ICE_API bool proxyIdentityLess(const ObjectPrx&, const ObjectPrx&);
-ICE_API bool proxyIdentityEqual(const ObjectPrx&, const ObjectPrx&);
-
-ICE_API bool proxyIdentityAndFacetLess(const ObjectPrx&, const ObjectPrx&);
-ICE_API bool proxyIdentityAndFacetEqual(const ObjectPrx&, const ObjectPrx&);
-
+/**
+ * Compares the object identities of two proxies.
+ * @param lhs A proxy.
+ * @param rhs A proxy.
+ * @return True if the identity in lhs compares less than the identity in rhs, false otherwise.
+ */
+ICE_API bool proxyIdentityLess(const ObjectPrx& lhs, const ObjectPrx& rhs);
+
+/**
+ * Compares the object identities of two proxies.
+ * @param lhs A proxy.
+ * @param rhs A proxy.
+ * @return True if the identity in lhs compares equal to the identity in rhs, false otherwise.
+ */
+ICE_API bool proxyIdentityEqual(const ObjectPrx& lhs, const ObjectPrx& rhs);
+
+/**
+ * Compares the object identities and facets of two proxies.
+ * @param lhs A proxy.
+ * @param rhs A proxy.
+ * @return True if the identity and facet in lhs compare less than the identity and facet
+ * in rhs, false otherwise.
+ */
+ICE_API bool proxyIdentityAndFacetLess(const ObjectPrx& lhs, const ObjectPrx& rhs);
+
+/**
+ * Compares the object identities and facets of two proxies.
+ * @param lhs A proxy.
+ * @param rhs A proxy.
+ * @return True if the identity and facet in lhs compare equal to the identity and facet
+ * in rhs, false otherwise.
+ */
+ICE_API bool proxyIdentityAndFacetEqual(const ObjectPrx& lhs, const ObjectPrx& rhs);
+
+/**
+ * A functor that compares the object identities of two proxies. Evaluates true if the identity in lhs
+ * compares less than the identity in rhs, false otherwise.
+ * \headerfile Ice/Ice.h
+ */
 struct ProxyIdentityLess : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
 {
     bool operator()(const ObjectPrx& lhs, const ObjectPrx& rhs) const
@@ -1632,6 +3149,11 @@ struct ProxyIdentityLess : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
     }
 };
 
+/**
+ * A functor that compares the object identities of two proxies. Evaluates true if the identity in lhs
+ * compares equal to the identity in rhs, false otherwise.
+ * \headerfile Ice/Ice.h
+ */
 struct ProxyIdentityEqual : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
 {
     bool operator()(const ObjectPrx& lhs, const ObjectPrx& rhs) const
@@ -1640,6 +3162,11 @@ struct ProxyIdentityEqual : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
     }
 };
 
+/**
+ * A functor that compares the object identities and facets of two proxies. Evaluates true if the identity
+ * and facet in lhs compare less than the identity and facet in rhs, false otherwise.
+ * \headerfile Ice/Ice.h
+ */
 struct ProxyIdentityAndFacetLess : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
 {
     bool operator()(const ObjectPrx& lhs, const ObjectPrx& rhs) const
@@ -1648,6 +3175,11 @@ struct ProxyIdentityAndFacetLess : std::binary_function<bool, ObjectPrx&, Object
     }
 };
 
+/**
+ * A functor that compares the object identities and facets of two proxies. Evaluates true if the identity
+ * and facet in lhs compare equal to the identity and facet in rhs, false otherwise.
+ * \headerfile Ice/Ice.h
+ */
 struct ProxyIdentityAndFacetEqual : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
 {
     bool operator()(const ObjectPrx& lhs, const ObjectPrx& rhs) const
@@ -1826,6 +3358,13 @@ uncheckedCastImpl(const ::Ice::ObjectPrx& b, const std::string& f)
 namespace Ice
 {
 
+/**
+ * Downcasts a proxy after confirming the target object's type via a remote invocation.
+ * @param b The target proxy.
+ * @param context The context map for the invocation.
+ * @return A proxy with the requested type, or nil if the target proxy is nil or the target
+ * object does not support the requested type.
+ */
 template<typename P, typename Y> inline P
 checkedCast(const ::IceInternal::ProxyHandle<Y>& b, const ::Ice::Context& context = ::Ice::noExplicitContext)
 {
@@ -1833,6 +3372,11 @@ checkedCast(const ::IceInternal::ProxyHandle<Y>& b, const ::Ice::Context& contex
     return ::IceInternal::checkedCastHelper<typename P::element_type>(b, tag, context);
 }
 
+/**
+ * Downcasts a proxy without confirming the target object's type via a remote invocation.
+ * @param b The target proxy.
+ * @return A proxy with the requested type.
+ */
 template<typename P, typename Y> inline P
 uncheckedCast(const ::IceInternal::ProxyHandle<Y>& b)
 {
@@ -1840,12 +3384,26 @@ uncheckedCast(const ::IceInternal::ProxyHandle<Y>& b)
     return ::IceInternal::uncheckedCastHelper<typename P::element_type>(b, tag);
 }
 
+/**
+ * Downcasts a proxy after confirming the target object's type via a remote invocation.
+ * @param b The target proxy.
+ * @param f A facet name.
+ * @param context The context map for the invocation.
+ * @return 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.
+ */
 template<typename P> inline P
 checkedCast(const ::Ice::ObjectPrx& b, const std::string& f, const ::Ice::Context& context = ::Ice::noExplicitContext)
 {
     return ::IceInternal::checkedCastImpl<P>(b, f, context);
 }
 
+/**
+ * Downcasts a proxy without confirming the target object's type via a remote invocation.
+ * @param b The target proxy.
+ * @param f A facet name.
+ * @return A proxy with the requested type and facet.
+ */
 template<typename P> inline P
 uncheckedCast(const ::Ice::ObjectPrx& b, const std::string& f)
 {
@@ -2094,6 +3652,12 @@ private:
 namespace Ice
 {
 
+/**
+ * Type-safe asynchronous callback wrapper class used for calls to
+ * IceProxy::Ice::Object::begin_ice_isA.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_isA.
+ * \headerfile Ice/Ice.h
+ */
 template<class T>
 class CallbackNC_Object_ice_isA : public Callback_Object_ice_isA_Base, public ::IceInternal::TwowayCallbackNC<T>
 {
@@ -2110,6 +3674,7 @@ public:
     {
     }
 
+    /// \cond INTERNAL
     virtual void completed(const ::Ice::AsyncResultPtr& result) const
     {
         bool ret;
@@ -2127,12 +3692,19 @@ public:
             (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
         }
     }
+    /// \endcond
 
 private:
 
     Response _response;
 };
 
+/**
+ * Type-safe asynchronous callback wrapper class with cookie support used for calls to
+ * IceProxy::Ice::Object::begin_ice_isA.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_isA.
+ * \headerfile Ice/Ice.h
+ */
 template<class T, typename CT>
 class Callback_Object_ice_isA : public Callback_Object_ice_isA_Base, public ::IceInternal::TwowayCallback<T, CT>
 {
@@ -2149,6 +3721,7 @@ public:
     {
     }
 
+    /// \cond INTERNAL
     virtual void completed(const ::Ice::AsyncResultPtr& result) const
     {
         bool ret;
@@ -2167,12 +3740,19 @@ public:
                                                                           CT::dynamicCast(result->getCookie()));
         }
     }
+    /// \endcond
 
 private:
 
     Response _response;
 };
 
+/**
+ * Type-safe asynchronous callback wrapper class used for calls to
+ * IceProxy::Ice::Object::begin_ice_ping.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_ping.
+ * \headerfile Ice/Ice.h
+ */
 template<class T>
 class CallbackNC_Object_ice_ping : public Callback_Object_ice_ping_Base, public ::IceInternal::OnewayCallbackNC<T>
 {
@@ -2190,6 +3770,12 @@ public:
     }
 };
 
+/**
+ * Type-safe asynchronous callback wrapper class with cookie support used for calls to
+ * IceProxy::Ice::Object::begin_ice_ping.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_ping.
+ * \headerfile Ice/Ice.h
+ */
 template<class T, typename CT>
 class Callback_Object_ice_ping : public Callback_Object_ice_ping_Base, public ::IceInternal::OnewayCallback<T, CT>
 {
@@ -2207,6 +3793,12 @@ public:
     }
 };
 
+/**
+ * Type-safe asynchronous callback wrapper class used for calls to
+ * IceProxy::Ice::Object::begin_ice_ids.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_ids.
+ * \headerfile Ice/Ice.h
+ */
 template<class T>
 class CallbackNC_Object_ice_ids : public Callback_Object_ice_ids_Base, public ::IceInternal::TwowayCallbackNC<T>
 {
@@ -2223,6 +3815,7 @@ public:
     {
     }
 
+    /// \cond INTERNAL
     virtual void completed(const ::Ice::AsyncResultPtr& result) const
     {
         ::std::vector< ::std::string> ret;
@@ -2240,12 +3833,19 @@ public:
             (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
         }
     }
+    /// \endcond
 
 private:
 
     Response _response;
 };
 
+/**
+ * Type-safe asynchronous callback wrapper class with cookie support used for calls to
+ * IceProxy::Ice::Object::begin_ice_ids.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_ids.
+ * \headerfile Ice/Ice.h
+ */
 template<class T, typename CT>
 class Callback_Object_ice_ids : public Callback_Object_ice_ids_Base, public ::IceInternal::TwowayCallback<T, CT>
 {
@@ -2262,6 +3862,7 @@ public:
     {
     }
 
+    /// \cond INTERNAL
     virtual void completed(const ::Ice::AsyncResultPtr& result) const
     {
         ::std::vector< ::std::string> ret;
@@ -2280,12 +3881,19 @@ public:
                                                                           CT::dynamicCast(result->getCookie()));
         }
     }
+    /// \endcond
 
 private:
 
     Response _response;
 };
 
+/**
+ * Type-safe asynchronous callback wrapper class used for calls to
+ * IceProxy::Ice::Object::begin_ice_id.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_id.
+ * \headerfile Ice/Ice.h
+ */
 template<class T>
 class CallbackNC_Object_ice_id : public Callback_Object_ice_id_Base, public ::IceInternal::TwowayCallbackNC<T>
 {
@@ -2302,6 +3910,7 @@ public:
     {
     }
 
+    /// \cond INTERNAL
     virtual void completed(const ::Ice::AsyncResultPtr& result) const
     {
         ::std::string ret;
@@ -2319,12 +3928,19 @@ public:
             (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
         }
     }
+    /// \endcond
 
 private:
 
     Response _response;
 };
 
+/**
+ * Type-safe asynchronous callback wrapper class with cookie support used for calls to
+ * IceProxy::Ice::Object::begin_ice_id.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_id.
+ * \headerfile Ice/Ice.h
+ */
 template<class T, typename CT>
 class Callback_Object_ice_id : public Callback_Object_ice_id_Base, public ::IceInternal::TwowayCallback<T, CT>
 {
@@ -2341,6 +3957,7 @@ public:
     {
     }
 
+    /// \cond INTERNAL
     virtual void completed(const ::Ice::AsyncResultPtr& result) const
     {
         ::std::string ret;
@@ -2359,12 +3976,19 @@ public:
                                                                           CT::dynamicCast(result->getCookie()));
         }
     }
+    /// \endcond
 
 private:
 
     Response _response;
 };
 
+/**
+ * Type-safe asynchronous callback wrapper class used for calls to
+ * IceProxy::Ice::Object::begin_ice_invoke.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_invoke.
+ * \headerfile Ice/Ice.h
+ */
 template<class T>
 class CallbackNC_Object_ice_invoke : public Callback_Object_ice_invoke_Base, public ::IceInternal::TwowayCallbackNC<T>
 {
@@ -2387,6 +4011,7 @@ public:
     {
     }
 
+    /// \cond INTERNAL
     virtual void completed(const ::Ice::AsyncResultPtr& result) const
     {
         if(_response)
@@ -2423,6 +4048,7 @@ public:
             }
         }
     }
+    /// \endcond
 
 private:
 
@@ -2430,6 +4056,12 @@ private:
     ResponseArray _responseArray;
 };
 
+/**
+ * Type-safe asynchronous callback wrapper class with cookie support used for calls to
+ * IceProxy::Ice::Object::begin_ice_invoke.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_invoke.
+ * \headerfile Ice/Ice.h
+ */
 template<class T, typename CT>
 class Callback_Object_ice_invoke : public Callback_Object_ice_invoke_Base, public ::IceInternal::TwowayCallback<T, CT>
 {
@@ -2452,6 +4084,7 @@ public:
     {
     }
 
+    /// \cond INTERNAL
     virtual void completed(const ::Ice::AsyncResultPtr& result) const
     {
         if(_response)
@@ -2493,6 +4126,7 @@ public:
             }
         }
     }
+    /// \endcond
 
 private:
 
@@ -2500,6 +4134,12 @@ private:
     ResponseArray _responseArray;
 };
 
+/**
+ * Type-safe asynchronous callback wrapper class used for calls to
+ * IceProxy::Ice::Object::begin_ice_getConnection.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_getConnection.
+ * \headerfile Ice/Ice.h
+ */
 template<class T>
 class CallbackNC_Object_ice_getConnection : public Callback_Object_ice_getConnection_Base,
                                             public ::IceInternal::CallbackNC<T>
@@ -2517,6 +4157,7 @@ public:
     {
     }
 
+    /// \cond INTERNAL
     virtual void completed(const ::Ice::AsyncResultPtr& result) const
     {
         ::Ice::ConnectionPtr ret;
@@ -2534,12 +4175,19 @@ public:
             (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
         }
     }
+    /// \endcond
 
 private:
 
     Response _response;
 };
 
+/**
+ * Type-safe asynchronous callback wrapper class with cookie support used for calls to
+ * IceProxy::Ice::Object::begin_ice_getConnection.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_getConnection.
+ * \headerfile Ice/Ice.h
+ */
 template<class T, typename CT>
 class Callback_Object_ice_getConnection : public Callback_Object_ice_getConnection_Base,
                                           public ::IceInternal::Callback<T, CT>
@@ -2557,6 +4205,7 @@ public:
     {
     }
 
+    /// \cond INTERNAL
     virtual void completed(const ::Ice::AsyncResultPtr& result) const
     {
         ::Ice::ConnectionPtr ret;
@@ -2575,12 +4224,19 @@ public:
                                                                           CT::dynamicCast(result->getCookie()));
         }
     }
+    /// \endcond
 
 private:
 
     Response _response;
 };
 
+/**
+ * Type-safe asynchronous callback wrapper class used for calls to
+ * IceProxy::Ice::Object::begin_ice_flushBatchRequests.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_flushBatchRequests.
+ * \headerfile Ice/Ice.h
+ */
 template<class T>
 class CallbackNC_Object_ice_flushBatchRequests : public Callback_Object_ice_flushBatchRequests_Base,
                                                  public ::IceInternal::OnewayCallbackNC<T>
@@ -2598,6 +4254,12 @@ public:
     }
 };
 
+/**
+ * Type-safe asynchronous callback wrapper class with cookie support used for calls to
+ * IceProxy::Ice::Object::begin_ice_flushBatchRequests.
+ * Create a wrapper instance by calling ::Ice::newCallback_Object_ice_flushBatchRequests.
+ * \headerfile Ice/Ice.h
+ */
 template<class T, typename CT>
 class Callback_Object_ice_flushBatchRequests : public Callback_Object_ice_flushBatchRequests_Base,
                                                public ::IceInternal::OnewayCallback<T, CT>
@@ -2615,6 +4277,14 @@ public:
     }
 };
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_isA.
+ */
 template<class T> Callback_Object_ice_isAPtr
 newCallback_Object_ice_isA(const IceUtil::Handle<T>& instance,
                            void (T::*cb)(bool),
@@ -2624,6 +4294,14 @@ newCallback_Object_ice_isA(const IceUtil::Handle<T>& instance,
     return new CallbackNC_Object_ice_isA<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_isA.
+ */
 template<class T, typename CT> Callback_Object_ice_isAPtr
 newCallback_Object_ice_isA(const IceUtil::Handle<T>& instance,
                            void (T::*cb)(bool, const CT&),
@@ -2633,6 +4311,13 @@ newCallback_Object_ice_isA(const IceUtil::Handle<T>& instance,
     return new Callback_Object_ice_isA<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_isA.
+ */
 template<class T> Callback_Object_ice_isAPtr
 newCallback_Object_ice_isA(const IceUtil::Handle<T>& instance,
                            void (T::*excb)(const ::Ice::Exception&),
@@ -2641,6 +4326,13 @@ newCallback_Object_ice_isA(const IceUtil::Handle<T>& instance,
     return new CallbackNC_Object_ice_isA<T>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_isA.
+ */
 template<class T, typename CT> Callback_Object_ice_isAPtr
 newCallback_Object_ice_isA(const IceUtil::Handle<T>& instance,
                            void (T::*excb)(const ::Ice::Exception&, const CT&),
@@ -2649,6 +4341,14 @@ newCallback_Object_ice_isA(const IceUtil::Handle<T>& instance,
     return new Callback_Object_ice_isA<T, CT>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_isA.
+ */
 template<class T> Callback_Object_ice_isAPtr
 newCallback_Object_ice_isA(T* instance,
                            void (T::*cb)(bool),
@@ -2658,6 +4358,14 @@ newCallback_Object_ice_isA(T* instance,
     return new CallbackNC_Object_ice_isA<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_isA.
+ */
 template<class T, typename CT> Callback_Object_ice_isAPtr
 newCallback_Object_ice_isA(T* instance,
                            void (T::*cb)(bool, const CT&),
@@ -2667,6 +4375,13 @@ newCallback_Object_ice_isA(T* instance,
     return new Callback_Object_ice_isA<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_isA.
+ */
 template<class T> Callback_Object_ice_isAPtr
 newCallback_Object_ice_isA(T* instance,
                            void (T::*excb)(const ::Ice::Exception&),
@@ -2675,6 +4390,13 @@ newCallback_Object_ice_isA(T* instance,
     return new CallbackNC_Object_ice_isA<T>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_isA.
+ */
 template<class T, typename CT> Callback_Object_ice_isAPtr
 newCallback_Object_ice_isA(T* instance,
                            void (T::*excb)(const ::Ice::Exception&, const CT&),
@@ -2683,6 +4405,14 @@ newCallback_Object_ice_isA(T* instance,
     return new Callback_Object_ice_isA<T, CT>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ping.
+ */
 template<class T> Callback_Object_ice_pingPtr
 newCallback_Object_ice_ping(const IceUtil::Handle<T>& instance,
                             void (T::*cb)(),
@@ -2692,6 +4422,14 @@ newCallback_Object_ice_ping(const IceUtil::Handle<T>& instance,
     return new CallbackNC_Object_ice_ping<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ping.
+ */
 template<class T, typename CT> Callback_Object_ice_pingPtr
 newCallback_Object_ice_ping(const IceUtil::Handle<T>& instance,
                             void (T::*cb)(const CT&),
@@ -2701,6 +4439,13 @@ newCallback_Object_ice_ping(const IceUtil::Handle<T>& instance,
     return new Callback_Object_ice_ping<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ping.
+ */
 template<class T> Callback_Object_ice_pingPtr
 newCallback_Object_ice_ping(const IceUtil::Handle<T>& instance,
                             void (T::*excb)(const ::Ice::Exception&),
@@ -2709,6 +4454,13 @@ newCallback_Object_ice_ping(const IceUtil::Handle<T>& instance,
     return new CallbackNC_Object_ice_ping<T>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ping.
+ */
 template<class T, typename CT> Callback_Object_ice_pingPtr
 newCallback_Object_ice_ping(const IceUtil::Handle<T>& instance,
                             void (T::*excb)(const ::Ice::Exception&, const CT&),
@@ -2717,6 +4469,14 @@ newCallback_Object_ice_ping(const IceUtil::Handle<T>& instance,
     return new Callback_Object_ice_ping<T, CT>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ping.
+ */
 template<class T> Callback_Object_ice_pingPtr
 newCallback_Object_ice_ping(T* instance,
                             void (T::*cb)(),
@@ -2726,6 +4486,14 @@ newCallback_Object_ice_ping(T* instance,
     return new CallbackNC_Object_ice_ping<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ping.
+ */
 template<class T, typename CT> Callback_Object_ice_pingPtr
 newCallback_Object_ice_ping(T* instance,
                             void (T::*cb)(const CT&),
@@ -2735,6 +4503,13 @@ newCallback_Object_ice_ping(T* instance,
     return new Callback_Object_ice_ping<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ping.
+ */
 template<class T> Callback_Object_ice_pingPtr
 newCallback_Object_ice_ping(T* instance,
                             void (T::*excb)(const ::Ice::Exception&),
@@ -2743,6 +4518,13 @@ newCallback_Object_ice_ping(T* instance,
     return new CallbackNC_Object_ice_ping<T>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ping.
+ */
 template<class T, typename CT> Callback_Object_ice_pingPtr
 newCallback_Object_ice_ping(T* instance,
                             void (T::*excb)(const ::Ice::Exception&, const CT&),
@@ -2751,6 +4533,14 @@ newCallback_Object_ice_ping(T* instance,
     return new Callback_Object_ice_ping<T, CT>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ids.
+ */
 template<class T> Callback_Object_ice_idsPtr
 newCallback_Object_ice_ids(const IceUtil::Handle<T>& instance,
                            void (T::*cb)(const ::std::vector< ::std::string>&),
@@ -2760,6 +4550,14 @@ newCallback_Object_ice_ids(const IceUtil::Handle<T>& instance,
     return new CallbackNC_Object_ice_ids<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ids.
+ */
 template<class T, typename CT> Callback_Object_ice_idsPtr
 newCallback_Object_ice_ids(const IceUtil::Handle<T>& instance,
                            void (T::*cb)(const ::std::vector< ::std::string>&, const CT&),
@@ -2769,6 +4567,13 @@ newCallback_Object_ice_ids(const IceUtil::Handle<T>& instance,
     return new Callback_Object_ice_ids<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ids.
+ */
 template<class T> Callback_Object_ice_idsPtr
 newCallback_Object_ice_ids(const IceUtil::Handle<T>& instance,
                            void (T::*excb)(const ::Ice::Exception&),
@@ -2777,6 +4582,13 @@ newCallback_Object_ice_ids(const IceUtil::Handle<T>& instance,
     return new CallbackNC_Object_ice_ids<T>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ids.
+ */
 template<class T, typename CT> Callback_Object_ice_idsPtr
 newCallback_Object_ice_ids(const IceUtil::Handle<T>& instance,
                            void (T::*excb)(const ::Ice::Exception&, const CT&),
@@ -2785,6 +4597,14 @@ newCallback_Object_ice_ids(const IceUtil::Handle<T>& instance,
     return new Callback_Object_ice_ids<T, CT>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ids.
+ */
 template<class T> Callback_Object_ice_idsPtr
 newCallback_Object_ice_ids(T* instance,
                            void (T::*cb)(const ::std::vector< ::std::string>&),
@@ -2794,6 +4614,14 @@ newCallback_Object_ice_ids(T* instance,
     return new CallbackNC_Object_ice_ids<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ids.
+ */
 template<class T, typename CT> Callback_Object_ice_idsPtr
 newCallback_Object_ice_ids(T* instance,
                            void (T::*cb)(const ::std::vector< ::std::string>&, const CT&),
@@ -2803,6 +4631,13 @@ newCallback_Object_ice_ids(T* instance,
     return new Callback_Object_ice_ids<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ids.
+ */
 template<class T> Callback_Object_ice_idsPtr
 newCallback_Object_ice_ids(T* instance,
                            void (T::*excb)(const ::Ice::Exception&),
@@ -2811,6 +4646,13 @@ newCallback_Object_ice_ids(T* instance,
     return new CallbackNC_Object_ice_ids<T>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_ids.
+ */
 template<class T, typename CT> Callback_Object_ice_idsPtr
 newCallback_Object_ice_ids(T* instance,
                            void (T::*excb)(const ::Ice::Exception&, const CT&),
@@ -2819,6 +4661,14 @@ newCallback_Object_ice_ids(T* instance,
     return new Callback_Object_ice_ids<T, CT>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_id.
+ */
 template<class T> Callback_Object_ice_idPtr
 newCallback_Object_ice_id(const IceUtil::Handle<T>& instance,
                           void (T::*cb)(const ::std::string&),
@@ -2828,6 +4678,14 @@ newCallback_Object_ice_id(const IceUtil::Handle<T>& instance,
     return new CallbackNC_Object_ice_id<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_id.
+ */
 template<class T, typename CT> Callback_Object_ice_idPtr
 newCallback_Object_ice_id(const IceUtil::Handle<T>& instance,
                           void (T::*cb)(const ::std::string&, const CT&),
@@ -2837,6 +4695,13 @@ newCallback_Object_ice_id(const IceUtil::Handle<T>& instance,
     return new Callback_Object_ice_id<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_id.
+ */
 template<class T> Callback_Object_ice_idPtr
 newCallback_Object_ice_id(const IceUtil::Handle<T>& instance,
                           void (T::*excb)(const ::Ice::Exception&),
@@ -2845,6 +4710,13 @@ newCallback_Object_ice_id(const IceUtil::Handle<T>& instance,
     return new CallbackNC_Object_ice_id<T>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_id.
+ */
 template<class T, typename CT> Callback_Object_ice_idPtr
 newCallback_Object_ice_id(const IceUtil::Handle<T>& instance,
                           void (T::*excb)(const ::Ice::Exception&, const CT&),
@@ -2853,6 +4725,14 @@ newCallback_Object_ice_id(const IceUtil::Handle<T>& instance,
     return new Callback_Object_ice_id<T, CT>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_id.
+ */
 template<class T> Callback_Object_ice_idPtr
 newCallback_Object_ice_id(T* instance,
                           void (T::*cb)(const ::std::string&),
@@ -2862,6 +4742,14 @@ newCallback_Object_ice_id(T* instance,
     return new CallbackNC_Object_ice_id<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_id.
+ */
 template<class T, typename CT> Callback_Object_ice_idPtr
 newCallback_Object_ice_id(T* instance,
                           void (T::*cb)(const ::std::string&, const CT&),
@@ -2871,6 +4759,13 @@ newCallback_Object_ice_id(T* instance,
     return new Callback_Object_ice_id<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_id.
+ */
 template<class T> Callback_Object_ice_idPtr
 newCallback_Object_ice_id(T* instance,
                           void (T::*excb)(const ::Ice::Exception&),
@@ -2879,6 +4774,13 @@ newCallback_Object_ice_id(T* instance,
     return new CallbackNC_Object_ice_id<T>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_id.
+ */
 template<class T, typename CT> Callback_Object_ice_idPtr
 newCallback_Object_ice_id(T* instance,
                           void (T::*excb)(const ::Ice::Exception&, const CT&),
@@ -2887,6 +4789,14 @@ newCallback_Object_ice_id(T* instance,
     return new Callback_Object_ice_id<T, CT>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.
+ */
 template<class T> Callback_Object_ice_invokePtr
 newCallback_Object_ice_invoke(const IceUtil::Handle<T>& instance,
                               void (T::*cb)(bool, const std::vector<Ice::Byte>&),
@@ -2896,6 +4806,14 @@ newCallback_Object_ice_invoke(const IceUtil::Handle<T>& instance,
     return new CallbackNC_Object_ice_invoke<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.
+ */
 template<class T> Callback_Object_ice_invokePtr
 newCallback_Object_ice_invoke(const IceUtil::Handle<T>& instance,
                               void (T::*cb)(bool, const std::pair<const Byte*, const Byte*>&),
@@ -2905,6 +4823,14 @@ newCallback_Object_ice_invoke(const IceUtil::Handle<T>& instance,
     return new CallbackNC_Object_ice_invoke<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.
+ */
 template<class T, typename CT> Callback_Object_ice_invokePtr
 newCallback_Object_ice_invoke(const IceUtil::Handle<T>& instance,
                               void (T::*cb)(bool, const std::vector<Ice::Byte>&, const CT&),
@@ -2914,6 +4840,14 @@ newCallback_Object_ice_invoke(const IceUtil::Handle<T>& instance,
     return new Callback_Object_ice_invoke<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.
+ */
 template<class T, typename CT> Callback_Object_ice_invokePtr
 newCallback_Object_ice_invoke(const IceUtil::Handle<T>& instance,
                               void (T::*cb)(bool, const std::pair<const Byte*, const Byte*>&,
@@ -2924,6 +4858,13 @@ newCallback_Object_ice_invoke(const IceUtil::Handle<T>& instance,
     return new Callback_Object_ice_invoke<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.
+ */
 template<class T> Callback_Object_ice_invokePtr
 newCallback_Object_ice_invoke(const IceUtil::Handle<T>& instance,
                               void (T::*excb)(const ::Ice::Exception&),
@@ -2932,6 +4873,13 @@ newCallback_Object_ice_invoke(const IceUtil::Handle<T>& instance,
     return new CallbackNC_Object_ice_invoke<T>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.
+ */
 template<class T, typename CT> Callback_Object_ice_invokePtr
 newCallback_Object_ice_invoke(const IceUtil::Handle<T>& instance,
                               void (T::*excb)(const ::Ice::Exception&, const CT&),
@@ -2940,6 +4888,14 @@ newCallback_Object_ice_invoke(const IceUtil::Handle<T>& instance,
     return new Callback_Object_ice_invoke<T, CT>(instance, 0, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.
+ */
 template<class T> Callback_Object_ice_invokePtr
 newCallback_Object_ice_invoke(T* instance,
                               void (T::*cb)(bool, const std::vector<Ice::Byte>&),
@@ -2949,6 +4905,14 @@ newCallback_Object_ice_invoke(T* instance,
     return new CallbackNC_Object_ice_invoke<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.
+ */
 template<class T> Callback_Object_ice_invokePtr
 newCallback_Object_ice_invoke(T* instance,
                               void (T::*cb)(bool, const std::pair<const Byte*, const Byte*>&),
@@ -2958,6 +4922,14 @@ newCallback_Object_ice_invoke(T* instance,
     return new CallbackNC_Object_ice_invoke<T>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.
+ */
 template<class T, typename CT> Callback_Object_ice_invokePtr
 newCallback_Object_ice_invoke(T* instance,
                               void (T::*cb)(bool, const std::vector<Ice::Byte>&, const CT&),
@@ -2967,6 +4939,14 @@ newCallback_Object_ice_invoke(T* instance,
     return new Callback_Object_ice_invoke<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.
+ */
 template<class T, typename CT> Callback_Object_ice_invokePtr
 newCallback_Object_ice_invoke(T* instance,
                               void (T::*cb)(bool, const std::pair<const Byte*, const Byte*>&, const CT&),
@@ -2976,6 +4956,13 @@ newCallback_Object_ice_invoke(T* instance,
     return new Callback_Object_ice_invoke<T, CT>(instance, cb, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.
+ */
 template<class T> Callback_Object_ice_invokePtr
 newCallback_Object_ice_invoke(T* instance,
                               void (T::*excb)(const ::Ice::Exception&),
@@ -2985,6 +4972,13 @@ newCallback_Object_ice_invoke(T* instance,
         instance, static_cast<void (T::*)(bool, const std::vector<Ice::Byte>&)>(0), excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_invoke.
+ */
 template<class T, typename CT> Callback_Object_ice_invokePtr
 newCallback_Object_ice_invoke(T* instance,
                               void (T::*excb)(const ::Ice::Exception&, const CT&),
@@ -2994,6 +4988,13 @@ newCallback_Object_ice_invoke(T* instance,
         instance, static_cast<void (T::*)(bool, const std::vector<Ice::Byte>&, const CT&)>(0), excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_getConnection.
+ */
 template<class T> Callback_Object_ice_getConnectionPtr
 newCallback_Object_ice_getConnection(const IceUtil::Handle<T>& instance,
                                      void (T::*cb)(const ::Ice::ConnectionPtr&),
@@ -3002,6 +5003,13 @@ newCallback_Object_ice_getConnection(const IceUtil::Handle<T>& instance,
     return new CallbackNC_Object_ice_getConnection<T>(instance, cb, excb, 0);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_getConnection.
+ */
 template<class T, typename CT> Callback_Object_ice_getConnectionPtr
 newCallback_Object_ice_getConnection(const IceUtil::Handle<T>& instance,
                                      void (T::*cb)(const ::Ice::ConnectionPtr&, const CT&),
@@ -3010,6 +5018,13 @@ newCallback_Object_ice_getConnection(const IceUtil::Handle<T>& instance,
     return new Callback_Object_ice_getConnection<T, CT>(instance, cb, excb, 0);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_getConnection.
+ */
 template<class T> Callback_Object_ice_getConnectionPtr
 newCallback_Object_ice_getConnection(T* instance,
                                      void (T::*cb)(const ::Ice::ConnectionPtr&),
@@ -3018,6 +5033,13 @@ newCallback_Object_ice_getConnection(T* instance,
     return new CallbackNC_Object_ice_getConnection<T>(instance, cb, excb, 0);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param cb The success method of the callback object.
+ * @param excb The exception method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of IceProxy::Ice::Object::begin_ice_getConnection.
+ */
 template<class T, typename CT> Callback_Object_ice_getConnectionPtr
 newCallback_Object_ice_getConnection(T* instance,
                                      void (T::*cb)(const ::Ice::ConnectionPtr&, const CT&),
@@ -3026,6 +5048,14 @@ newCallback_Object_ice_getConnection(T* instance,
     return new Callback_Object_ice_getConnection<T, CT>(instance, cb, excb, 0);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of
+ * IceProxy::Ice::Object::begin_ice_flushBatchRequests.
+ */
 template<class T> Callback_Object_ice_flushBatchRequestsPtr
 newCallback_Object_ice_flushBatchRequests(const IceUtil::Handle<T>& instance,
                                           void (T::*excb)(const ::Ice::Exception&),
@@ -3034,6 +5064,14 @@ newCallback_Object_ice_flushBatchRequests(const IceUtil::Handle<T>& instance,
     return new CallbackNC_Object_ice_flushBatchRequests<T>(instance, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of
+ * IceProxy::Ice::Object::begin_ice_flushBatchRequests.
+ */
 template<class T, typename CT> Callback_Object_ice_flushBatchRequestsPtr
 newCallback_Object_ice_flushBatchRequests(const IceUtil::Handle<T>& instance,
                                           void (T::*excb)(const ::Ice::Exception&, const CT&),
@@ -3042,6 +5080,14 @@ newCallback_Object_ice_flushBatchRequests(const IceUtil::Handle<T>& instance,
     return new Callback_Object_ice_flushBatchRequests<T, CT>(instance, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of
+ * IceProxy::Ice::Object::begin_ice_flushBatchRequests.
+ */
 template<class T> Callback_Object_ice_flushBatchRequestsPtr
 newCallback_Object_ice_flushBatchRequests(T* instance,
                                           void (T::*excb)(const ::Ice::Exception&),
@@ -3050,6 +5096,14 @@ newCallback_Object_ice_flushBatchRequests(T* instance,
     return new CallbackNC_Object_ice_flushBatchRequests<T>(instance, excb, sentcb);
 }
 
+/**
+ * Creates a callback wrapper instance that delegates to your object.
+ * @param instance The callback object.
+ * @param excb The exception method of the callback object.
+ * @param sentcb The sent method of the callback object.
+ * @return An object that can be passed to an asynchronous invocation of
+ * IceProxy::Ice::Object::begin_ice_flushBatchRequests.
+ */
 template<class T, typename CT> Callback_Object_ice_flushBatchRequestsPtr
 newCallback_Object_ice_flushBatchRequests(T* instance,
                                           void (T::*excb)(const ::Ice::Exception&, const CT&),