Fixed ICE-7941 - scheduleCallback now provides the connection to the dispatcher work item, fixed naming of AsyncResult private methods

1 files changed, 57 insertions, 57 deletions

diff --git a/cpp/src/Ice/Proxy.cpp b/cpp/src/Ice/Proxy.cpp
index 7b7a7311fa6..f5d6551edf1 100644
--- a/cpp/src/Ice/Proxy.cpp
+++ b/cpp/src/Ice/Proxy.cpp
@@ -323,13 +323,13 @@ IceProxy::Ice::Object::_iceI_begin_ice_isA(const string& typeId,
 bool
 IceProxy::Ice::Object::end_ice_isA(const AsyncResultPtr& result)
 {
-    AsyncResult::check(result, this, ice_isA_name);
-    bool ok = result->waitForResponse();
+    AsyncResult::_check(result, this, ice_isA_name);
+    bool ok = result->_waitForResponse();
     if(!ok)
     {
         try
         {
-            result->throwUserException();
+            result->_throwUserException();
         }
         catch(const UserException& ex)
         {
@@ -337,17 +337,17 @@ IceProxy::Ice::Object::end_ice_isA(const AsyncResultPtr& result)
         }
     }
     bool ret;
-    ::Ice::InputStream* istr = result->startReadParams();
+    ::Ice::InputStream* istr = result->_startReadParams();
     istr->read(ret);
-    result->endReadParams();
+    result->_endReadParams();
     return ret;
 }
 
 AsyncResultPtr
 IceProxy::Ice::Object::_iceI_begin_ice_ping(const Context& ctx,
-                                        const ::IceInternal::CallbackBasePtr& del,
-                                        const ::Ice::LocalObjectPtr& cookie,
-                                        bool sync)
+                                            const ::IceInternal::CallbackBasePtr& del,
+                                            const ::Ice::LocalObjectPtr& cookie,
+                                            bool sync)
 {
     OutgoingAsyncPtr result = new CallbackOutgoing(this, ice_ping_name, del, cookie, sync);
     try
@@ -371,9 +371,9 @@ IceProxy::Ice::Object::end_ice_ping(const AsyncResultPtr& result)
 
 AsyncResultPtr
 IceProxy::Ice::Object::_iceI_begin_ice_ids(const Context& ctx,
-                                       const ::IceInternal::CallbackBasePtr& del,
-                                       const ::Ice::LocalObjectPtr& cookie,
-                                       bool sync)
+                                           const ::IceInternal::CallbackBasePtr& del,
+                                           const ::Ice::LocalObjectPtr& cookie,
+                                           bool sync)
 {
     _checkTwowayOnly(ice_ids_name, sync);
     OutgoingAsyncPtr result = new CallbackOutgoing(this, ice_ids_name, del, cookie, sync);
@@ -393,13 +393,13 @@ IceProxy::Ice::Object::_iceI_begin_ice_ids(const Context& ctx,
 vector<string>
 IceProxy::Ice::Object::end_ice_ids(const AsyncResultPtr& result)
 {
-    AsyncResult::check(result, this, ice_ids_name);
-    bool ok = result->waitForResponse();
+    AsyncResult::_check(result, this, ice_ids_name);
+    bool ok = result->_waitForResponse();
     if(!ok)
     {
         try
         {
-            result->throwUserException();
+            result->_throwUserException();
         }
         catch(const UserException& ex)
         {
@@ -407,17 +407,17 @@ IceProxy::Ice::Object::end_ice_ids(const AsyncResultPtr& result)
         }
     }
     vector<string> ret;
-    ::Ice::InputStream* istr = result->startReadParams();
+    ::Ice::InputStream* istr = result->_startReadParams();
     istr->read(ret, false);
-    result->endReadParams();
+    result->_endReadParams();
     return ret;
 }
 
 AsyncResultPtr
 IceProxy::Ice::Object::_iceI_begin_ice_id(const Context& ctx,
-                                      const ::IceInternal::CallbackBasePtr& del,
-                                      const ::Ice::LocalObjectPtr& cookie,
-                                      bool sync)
+                                          const ::IceInternal::CallbackBasePtr& del,
+                                          const ::Ice::LocalObjectPtr& cookie,
+                                          bool sync)
 {
     _checkTwowayOnly(ice_id_name, sync);
     OutgoingAsyncPtr result = new CallbackOutgoing(this, ice_id_name, del, cookie, sync);
@@ -437,13 +437,13 @@ IceProxy::Ice::Object::_iceI_begin_ice_id(const Context& ctx,
 string
 IceProxy::Ice::Object::end_ice_id(const AsyncResultPtr& result)
 {
-    AsyncResult::check(result, this, ice_id_name);
-    bool ok = result->waitForResponse();
+    AsyncResult::_check(result, this, ice_id_name);
+    bool ok = result->_waitForResponse();
     if(!ok)
     {
         try
         {
-            result->throwUserException();
+            result->_throwUserException();
         }
         catch(const UserException& ex)
         {
@@ -451,9 +451,9 @@ IceProxy::Ice::Object::end_ice_id(const AsyncResultPtr& result)
         }
     }
     string ret;
-    ::Ice::InputStream* istr = result->startReadParams();
+    ::Ice::InputStream* istr = result->_startReadParams();
     istr->read(ret, false);
-    result->endReadParams();
+    result->_endReadParams();
     return ret;
 }
 
@@ -479,12 +479,12 @@ IceProxy::Ice::Object::ice_invoke(const string& operation,
 
 AsyncResultPtr
 IceProxy::Ice::Object::_iceI_begin_ice_invoke(const string& operation,
-                                          OperationMode mode,
-                                          const vector<Byte>& inEncaps,
-                                          const Context& ctx,
-                                          const ::IceInternal::CallbackBasePtr& del,
-                                          const ::Ice::LocalObjectPtr& cookie,
-                                          bool sync)
+                                              OperationMode mode,
+                                              const vector<Byte>& inEncaps,
+                                              const Context& ctx,
+                                              const ::IceInternal::CallbackBasePtr& del,
+                                              const ::Ice::LocalObjectPtr& cookie,
+                                              bool sync)
 {
     pair<const Byte*, const Byte*> inPair;
     if(inEncaps.empty())
@@ -502,13 +502,13 @@ IceProxy::Ice::Object::_iceI_begin_ice_invoke(const string& operation,
 bool
 IceProxy::Ice::Object::end_ice_invoke(vector<Byte>& outEncaps, const AsyncResultPtr& result)
 {
-    AsyncResult::check(result, this, ice_invoke_name);
-    bool ok = result->waitForResponse();
+    AsyncResult::_check(result, this, ice_invoke_name);
+    bool ok = result->_waitForResponse();
     if(_reference->getMode() == Reference::ModeTwoway)
     {
         const Byte* v;
         Int sz;
-        result->readParamEncaps(v, sz);
+        result->_readParamEncaps(v, sz);
         vector<Byte>(v, v + sz).swap(outEncaps);
     }
     return ok;
@@ -516,12 +516,12 @@ IceProxy::Ice::Object::end_ice_invoke(vector<Byte>& outEncaps, const AsyncResult
 
 AsyncResultPtr
 IceProxy::Ice::Object::_iceI_begin_ice_invoke(const string& operation,
-                                          OperationMode mode,
-                                          const pair<const Byte*, const Byte*>& inEncaps,
-                                          const Context& ctx,
-                                          const ::IceInternal::CallbackBasePtr& del,
-                                          const ::Ice::LocalObjectPtr& cookie,
-                                          bool sync)
+                                              OperationMode mode,
+                                              const pair<const Byte*, const Byte*>& inEncaps,
+                                              const Context& ctx,
+                                              const ::IceInternal::CallbackBasePtr& del,
+                                              const ::Ice::LocalObjectPtr& cookie,
+                                              bool sync)
 {
     OutgoingAsyncPtr result = new CallbackOutgoing(this, ice_invoke_name, del, cookie, sync);
     try
@@ -540,12 +540,12 @@ IceProxy::Ice::Object::_iceI_begin_ice_invoke(const string& operation,
 bool
 IceProxy::Ice::Object::_iceI_end_ice_invoke(pair<const Byte*, const Byte*>& outEncaps, const AsyncResultPtr& result)
 {
-    AsyncResult::check(result, this, ice_invoke_name);
-    bool ok = result->waitForResponse();
+    AsyncResult::_check(result, this, ice_invoke_name);
+    bool ok = result->_waitForResponse();
     if(_reference->getMode() == Reference::ModeTwoway)
     {
         Int sz;
-        result->readParamEncaps(outEncaps.first, sz);
+        result->_readParamEncaps(outEncaps.first, sz);
         outEncaps.second = outEncaps.first + sz;
     }
     return ok;
@@ -553,7 +553,7 @@ IceProxy::Ice::Object::_iceI_end_ice_invoke(pair<const Byte*, const Byte*>& outE
 
 ::Ice::AsyncResultPtr
 IceProxy::Ice::Object::_iceI_begin_ice_flushBatchRequests(const ::IceInternal::CallbackBasePtr& del,
-                                                      const ::Ice::LocalObjectPtr& cookie)
+                                                          const ::Ice::LocalObjectPtr& cookie)
 {
     class ProxyFlushBatchAsyncWithCallback : public ProxyFlushBatchAsync, public CallbackCompletion
     {
@@ -589,29 +589,29 @@ IceProxy::Ice::Object::_iceI_begin_ice_flushBatchRequests(const ::IceInternal::C
 void
 IceProxy::Ice::Object::end_ice_flushBatchRequests(const AsyncResultPtr& result)
 {
-    AsyncResult::check(result, this, ice_flushBatchRequests_name);
-    result->waitForResponse();
+    AsyncResult::_check(result, this, ice_flushBatchRequests_name);
+    result->_waitForResponse();
 }
 
 void
 IceProxy::Ice::Object::_end(const ::Ice::AsyncResultPtr& result, const std::string& operation) const
 {
-    AsyncResult::check(result, this, operation);
-    bool ok = result->waitForResponse();
+    AsyncResult::_check(result, this, operation);
+    bool ok = result->_waitForResponse();
     if(_reference->getMode() == Reference::ModeTwoway)
     {
         if(!ok)
         {
             try
             {
-                result->throwUserException();
+                result->_throwUserException();
             }
             catch(const UserException& ex)
             {
                 throw UnknownUserException(__FILE__, __LINE__, ex.ice_id());
             }
         }
-        result->readEmptyParams();
+        result->_readEmptyParams();
     }
 }
 
@@ -639,7 +639,7 @@ IceProxy::Ice::Object::_newInstance() const
 
 AsyncResultPtr
 IceProxy::Ice::Object::_iceI_begin_ice_getConnection(const ::IceInternal::CallbackBasePtr& del,
-                                                 const ::Ice::LocalObjectPtr& cookie)
+                                                     const ::Ice::LocalObjectPtr& cookie)
 {
     class ProxyGetConnectionWithCallback :  public ProxyGetConnection, public CallbackCompletion
     {
@@ -675,8 +675,8 @@ IceProxy::Ice::Object::_iceI_begin_ice_getConnection(const ::IceInternal::Callba
 ConnectionPtr
 IceProxy::Ice::Object::end_ice_getConnection(const AsyncResultPtr& result)
 {
-    AsyncResult::check(result, this, ice_getConnection_name);
-    result->waitForResponse();
+    AsyncResult::_check(result, this, ice_getConnection_name);
+    result->_waitForResponse();
     return result->getConnection();
 }
 
@@ -1286,10 +1286,10 @@ ICE_OBJECT_PRX::setup(const ReferencePtr& ref)
 
 int
 ICE_OBJECT_PRX::_handleException(const Exception& ex,
-                                         const RequestHandlerPtr& handler,
-                                         OperationMode mode,
-                                         bool sent,
-                                         int& cnt)
+                                 const RequestHandlerPtr& handler,
+                                 OperationMode mode,
+                                 bool sent,
+                                 int& cnt)
 {
     _updateRequestHandler(handler, 0); // Clear the request handler
 
@@ -1376,7 +1376,7 @@ ICE_OBJECT_PRX::_setRequestHandler(const ::IceInternal::RequestHandlerPtr& handl
 
 void
 ICE_OBJECT_PRX::_updateRequestHandler(const ::IceInternal::RequestHandlerPtr& previous,
-                                              const ::IceInternal::RequestHandlerPtr& handler)
+                                      const ::IceInternal::RequestHandlerPtr& handler)
 {
     if(_reference->getCacheConnection() && previous)
     {