1 files changed, 76 insertions, 0 deletions

diff --git a/cpp/include/Ice/AsyncResult.h b/cpp/include/Ice/AsyncResult.h
index 56e53e65213..53cca7775a4 100644
--- a/cpp/include/Ice/AsyncResult.h
+++ b/cpp/include/Ice/AsyncResult.h
@@ -23,34 +23,107 @@
 namespace Ice
 {
 
+/**
+ * Represents the result of an asynchronous invocation using the C++98 mapping.
+ * \headerfile Ice/Ice.h
+ */
 class ICE_API AsyncResult : private IceUtil::noncopyable, public Ice::LocalObject
 {
 public:
 
     virtual ~AsyncResult();
 
+    /**
+     * Prevents a queued invocation from being sent or, if the invocation has already been sent,
+     * ignores a reply if the server sends one. cancel is a local operation and has no effect
+     * on the server. A canceled invocation is considered to be completed, meaning isCompleted
+     * returns true, and the result of the invocation is an InvocationCanceledException.
+     */
     virtual void cancel() = 0;
 
+    /**
+     * Allows you to create ordered or hashed collections of pending asynchronous invocations.
+     * @return A unique hash code for this object.
+     */
     virtual Int getHash() const = 0;
 
+    /**
+     * Obtains the communicator that sent the invocation.
+     * @return A reference to the communicator.
+     */
     virtual CommunicatorPtr getCommunicator() const = 0;
+
+    /**
+     * Obtains the connection that was used for the invocation. Note that, for typical asynchronous
+     * proxy invocations, this method returns a nil value because the possibility of automatic retries
+     * means the connection that is currently in use could change unexpectedly. The getConnection
+     * method only returns a non-nil value when the AsyncResult object is obtained by calling
+     * Connection::begin_flushBatchRequests.
+     * @return A reference to the connection.
+     */
     virtual ConnectionPtr getConnection() const = 0;
+
+    /**
+     * Obtains the proxy that was used to call the begin_ method, or nil if the AsyncResult object was
+     * not obtained via an asynchronous proxy invocation.
+     * @return A reference to the proxy.
+     */
     virtual ObjectPrxPtr getProxy() const = 0;
 
+    /**
+     * Obtains the completion status of the invocation.
+     * @return True if, at the time it is called, the result of an invocation is available, indicating
+     * that a call to the end_ method will not block the caller. Otherwise, if the result is not yet
+     * available, the method returns false.
+     */
     virtual bool isCompleted() const = 0;
+
+    /**
+     * Blocks the caller until the result of an invocation becomes available.
+     */
     virtual void waitForCompleted() = 0;
 
+    /**
+     * Obtains the sent status of the invocation.
+     * @return True if, at the time it is called, the request has been written to the local transport
+     * (whether it was initially queued or not). Otherwise, if the request is still queued or an
+     * exception occurred before the request could be sent, this method returns false.
+     */
     virtual bool isSent() const = 0;
+
+    /**
+     * Blocks the calling thread until a request has been written to the client-side transport,
+     * or an exception occurs.
+     */
     virtual void waitForSent() = 0;
 
+    /**
+     * Throws the local exception that caused the invocation to fail. If no exception has occurred yet,
+     * this method does nothing.
+     */
     virtual void throwLocalException() const = 0;
 
+    /**
+     * Determines whether the request was sent synchronously.
+     * @return True if a request was written to the client-side transport without first being queued.
+     * If the request was initially queued, sentSynchronously returns false (independent of whether
+     * the request is still in the queue or has since been written to the client-side transport).
+     */
     virtual bool sentSynchronously() const = 0;
 
+    /**
+     * Obtains the cookie that was passed to the begin_ method.
+     * @return The cookie, or nil if you did not pass a cookie to the begin_ method.
+     */
     virtual LocalObjectPtr getCookie() const = 0;
 
+    /**
+     * Obtains the name of the operation.
+     * @return The operation name.
+     */
     virtual const std::string& getOperation() const = 0;
 
+    /// \cond INTERNAL
     virtual bool _waitForResponse() = 0;
     virtual Ice::InputStream* _startReadParams() = 0;
     virtual void _endReadParams() = 0;
@@ -71,10 +144,13 @@ public:
     typedef IceUtil::Handle<Callback> CallbackPtr;
 
     virtual void _scheduleCallback(const CallbackPtr&) = 0;
+    /// \endcond
 
 protected:
 
+    /// \cond INTERNAL
     static void check(const AsyncResultPtr&, const ::std::string&);
+    /// \endcond
 };
 
 }