diff options
Diffstat (limited to 'cpp/include/Ice/Proxy.h')
| -rw-r--r-- | cpp/include/Ice/Proxy.h | 2342 |
1 files changed, 2153 insertions, 189 deletions
diff --git a/cpp/include/Ice/Proxy.h b/cpp/include/Ice/Proxy.h index ae42ca8d382..58287e0aecc 100644 --- a/cpp/include/Ice/Proxy.h +++ b/cpp/include/Ice/Proxy.h @@ -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,318 @@ 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 compression. + * @param b True enables compression for the new proxy, false disables compression. + * @return A proxy with the specified compression setting. + */ + ::std::shared_ptr<::Ice::ObjectPrx> ice_compress(bool b) const; + + /** + * Obtains a proxy that is identical to this proxy, except for its connection timeout setting. + * @param timeout The connection timeout for the proxy (in milliseconds). + * @return A proxy with the specified timeout. + */ + ::std::shared_ptr<::Ice::ObjectPrx> ice_timeout(int timeout) 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 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 +1003,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 +1017,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 +1053,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 +1066,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 +1086,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 +1111,7 @@ protected: virtual ::std::shared_ptr<ObjectPrx> _newInstance() const; ObjectPrx() = default; friend ::std::shared_ptr<ObjectPrx> IceInternal::createProxy<ObjectPrx>(); + /// \endcond private: @@ -718,111 +1148,220 @@ 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 compression. + * @param b True enables compression for the new proxy, false disables compression. + * @return A proxy with the specified compression 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. + * @param timeout The connection timeout for the proxy (in milliseconds). + * @return A proxy with the specified timeout. + */ ::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 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,17 +1369,54 @@ 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 + */ struct ProxyIdentityLess : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&> { bool operator()(const ::std::shared_ptr<ObjectPrx>& lhs, const ::std::shared_ptr<ObjectPrx>& rhs) const @@ -849,6 +1425,11 @@ 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 + */ struct ProxyIdentityEqual : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&> { bool operator()(const ::std::shared_ptr<ObjectPrx>& lhs, const ::std::shared_ptr<ObjectPrx>& rhs) const @@ -857,6 +1438,11 @@ 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 + */ struct ProxyIdentityAndFacetLess : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&> { bool operator()(const ::std::shared_ptr<ObjectPrx>& lhs, const ::std::shared_ptr<ObjectPrx>& rhs) const @@ -865,6 +1451,11 @@ 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 + */ struct ProxyIdentityAndFacetEqual : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&> { bool operator()(const ::std::shared_ptr<ObjectPrx>& lhs, const ::std::shared_ptr<ObjectPrx>& rhs) const @@ -873,6 +1464,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 +1488,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 +1509,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 +1534,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 +1579,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 +1602,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 +1670,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 +1681,1023 @@ 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 compression. + * @param b True enables compression for the new proxy, false disables compression. + * @return A proxy with the specified compression setting. + */ + ::Ice::ObjectPrx ice_compress(bool b) const; + + /** + * Obtains a proxy that is identical to this proxy, except for its connection timeout setting. + * @param timeout The connection timeout for the proxy (in milliseconds). + * @return A proxy with the specified timeout. + */ + ::Ice::ObjectPrx ice_timeout(int timeout) 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 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 +2717,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 +2786,220 @@ 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 compression. + * @param b True enables compression for the new proxy, false disables compression. + * @return A proxy with the specified compression 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. + * @param timeout The connection timeout for the proxy (in milliseconds). + * @return A proxy with the specified timeout. + */ 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 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 +3007,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 +3059,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 +3072,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 +3085,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 +3268,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 +3282,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 +3294,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 +3562,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 +3584,7 @@ public: { } + /// \cond INTERNAL virtual void completed(const ::Ice::AsyncResultPtr& result) const { bool ret; @@ -2127,12 +3602,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 +3631,7 @@ public: { } + /// \cond INTERNAL virtual void completed(const ::Ice::AsyncResultPtr& result) const { bool ret; @@ -2167,12 +3650,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 +3680,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 +3703,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 +3725,7 @@ public: { } + /// \cond INTERNAL virtual void completed(const ::Ice::AsyncResultPtr& result) const { ::std::vector< ::std::string> ret; @@ -2240,12 +3743,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 +3772,7 @@ public: { } + /// \cond INTERNAL virtual void completed(const ::Ice::AsyncResultPtr& result) const { ::std::vector< ::std::string> ret; @@ -2280,12 +3791,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 +3820,7 @@ public: { } + /// \cond INTERNAL virtual void completed(const ::Ice::AsyncResultPtr& result) const { ::std::string ret; @@ -2319,12 +3838,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 +3867,7 @@ public: { } + /// \cond INTERNAL virtual void completed(const ::Ice::AsyncResultPtr& result) const { ::std::string ret; @@ -2359,12 +3886,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 +3921,7 @@ public: { } + /// \cond INTERNAL virtual void completed(const ::Ice::AsyncResultPtr& result) const { if(_response) @@ -2423,6 +3958,7 @@ public: } } } + /// \endcond private: @@ -2430,6 +3966,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 +3994,7 @@ public: { } + /// \cond INTERNAL virtual void completed(const ::Ice::AsyncResultPtr& result) const { if(_response) @@ -2493,6 +4036,7 @@ public: } } } + /// \endcond private: @@ -2500,6 +4044,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 +4067,7 @@ public: { } + /// \cond INTERNAL virtual void completed(const ::Ice::AsyncResultPtr& result) const { ::Ice::ConnectionPtr ret; @@ -2534,12 +4085,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 +4115,7 @@ public: { } + /// \cond INTERNAL virtual void completed(const ::Ice::AsyncResultPtr& result) const { ::Ice::ConnectionPtr ret; @@ -2575,12 +4134,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 +4164,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 +4187,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 +4204,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 +4221,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 +4236,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 +4251,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 +4268,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 +4285,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 +4300,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 +4315,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 +4332,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 +4349,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 +4364,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 +4379,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 +4396,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 +4413,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 +4428,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 +4443,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 +4460,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 +4477,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 +4492,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 +4507,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 +4524,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 +4541,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 +4556,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 +4571,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 +4588,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 +4605,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 +4620,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 +4635,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 +4652,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 +4669,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 +4684,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 +4699,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 +4716,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 +4733,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 +4750,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 +4768,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 +4783,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 +4798,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 +4815,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 +4832,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 +4849,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 +4866,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 +4882,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 +4898,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 +4913,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 +4928,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 +4943,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 +4958,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 +4974,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 +4990,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 +5006,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&), |