Fixed #2 of ICE-5594: code style for CallbackBase class

9 files changed, 211 insertions, 180 deletions

diff --git a/cpp/include/Ice/CommunicatorAsync.h b/cpp/include/Ice/CommunicatorAsync.h
index 5258a2e1a55..70fa3682eff 100644
--- a/cpp/include/Ice/CommunicatorAsync.h
+++ b/cpp/include/Ice/CommunicatorAsync.h
@@ -31,7 +31,7 @@ public:
     {
     }
 
-    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
         ::Ice::CommunicatorPtr __com = __result->getCommunicator();
         assert(__com);
@@ -42,7 +42,7 @@ public:
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
+            ::IceInternal::CallbackNC<T>::exception(__result, ex);
         }
     }
 };
@@ -79,7 +79,7 @@ public:
     {
     }
 
-    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
         ::Ice::CommunicatorPtr __com = __result->getCommunicator();
         assert(__com);
@@ -90,7 +90,7 @@ public:
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
+            ::IceInternal::Callback<T, CT>::exception(__result, ex);
         }
     }
 };
diff --git a/cpp/include/Ice/ConnectionAsync.h b/cpp/include/Ice/ConnectionAsync.h
index 4275bdf9aa8..dbaea54374a 100644
--- a/cpp/include/Ice/ConnectionAsync.h
+++ b/cpp/include/Ice/ConnectionAsync.h
@@ -32,7 +32,7 @@ public:
     {
     }
 
-    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
         ::Ice::ConnectionPtr __con = __result->getConnection();
         assert(__con);
@@ -43,7 +43,7 @@ public:
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
+            ::IceInternal::CallbackNC<T>::exception(__result, ex);
         }
     }
 };
@@ -79,7 +79,7 @@ public:
     {
     }
 
-    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
         ::Ice::ConnectionPtr __con = __result->getConnection();
         assert(__con);
@@ -90,7 +90,7 @@ public:
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
+            ::IceInternal::Callback<T, CT>::exception(__result, ex);
         }
     }
 };
diff --git a/cpp/include/Ice/OutgoingAsync.h b/cpp/include/Ice/OutgoingAsync.h
index 4d44549e604..8ffb59ee9bc 100644
--- a/cpp/include/Ice/OutgoingAsync.h
+++ b/cpp/include/Ice/OutgoingAsync.h
@@ -396,10 +396,10 @@ public:
         }
     }
 
-    virtual void __completed(const ::Ice::AsyncResultPtr&) const = 0;
-    virtual CallbackBasePtr __verify(const ::Ice::LocalObjectPtr&) = 0;
-    virtual void __sent(const ::Ice::AsyncResultPtr&) const = 0;
-    virtual bool __hasSentCallback() const = 0;
+    virtual void completed(const ::Ice::AsyncResultPtr&) const = 0;
+    virtual CallbackBasePtr verify(const ::Ice::LocalObjectPtr&) = 0;
+    virtual void sent(const ::Ice::AsyncResultPtr&) const = 0;
+    virtual bool hasSentCallback() const = 0;
 };
 
 //
@@ -424,37 +424,39 @@ public:
     typedef void (T::*Callback)(const ::Ice::AsyncResultPtr&);
 
     AsyncCallback(const TPtr& instance, Callback cb, Callback sentcb = 0) :
-        callback(instance), completed(cb), sent(sentcb)
+        _callback(instance), _completed(cb), _sent(sentcb)
     {
         checkCallback(instance, cb != 0);
     }
 
-    virtual void __completed(const ::Ice::AsyncResultPtr& result) const
+    virtual void completed(const ::Ice::AsyncResultPtr& result) const
     {
-        (callback.get()->*completed)(result);
+        (_callback.get()->*_completed)(result);
     }
 
-    virtual CallbackBasePtr __verify(const ::Ice::LocalObjectPtr&)
+    virtual CallbackBasePtr verify(const ::Ice::LocalObjectPtr&)
     {
         return this; // Nothing to do, the cookie is not type-safe.
     }
 
-    virtual void __sent(const ::Ice::AsyncResultPtr& result) const
+    virtual void sent(const ::Ice::AsyncResultPtr& result) const
     {
-        if(sent)
+        if(_sent)
         {
-            (callback.get()->*sent)(result);
+            (_callback.get()->*_sent)(result);
         }
     }
 
-    virtual bool __hasSentCallback() const
+    virtual bool hasSentCallback() const
     {
-        return sent != 0;
+        return _sent != 0;
     }
 
-    TPtr callback;
-    Callback completed;
-    Callback sent;
+private:
+
+    TPtr _callback;
+    Callback _completed;
+    Callback _sent;
 };
 
 #ifdef ICE_CPP11
diff --git a/cpp/include/Ice/Proxy.h b/cpp/include/Ice/Proxy.h
index c889003cc1b..610d095fbb9 100644
--- a/cpp/include/Ice/Proxy.h
+++ b/cpp/include/Ice/Proxy.h
@@ -161,15 +161,15 @@ public:
     Cpp11FnCallbackNC(const ::std::function<void (const ::Ice::Exception&)>&,
                       const ::std::function<void (bool)>&);
 
-    virtual CallbackBasePtr __verify(const ::Ice::LocalObjectPtr&);
+    virtual CallbackBasePtr verify(const ::Ice::LocalObjectPtr&);
 
-    virtual void __sent(const ::Ice::AsyncResultPtr&) const;
+    virtual void sent(const ::Ice::AsyncResultPtr&) const;
  
-    virtual bool __hasSentCallback() const;
+    virtual bool hasSentCallback() const;
 
 protected:
 
-    void __exception(const ::Ice::AsyncResultPtr&, const ::Ice::Exception& ex) const;
+    void exception(const ::Ice::AsyncResultPtr&, const ::Ice::Exception& ex) const;
 
     ::std::function<void (const ::Ice::Exception&)> _exception;
     ::std::function<void (bool)> _sent;
@@ -184,7 +184,7 @@ public:
                             const ::std::function<void (bool)>&);
 
     virtual void
-    __completed(const ::Ice::AsyncResultPtr&) const;
+    completed(const ::Ice::AsyncResultPtr&) const;
     
 private:
     
@@ -1296,11 +1296,11 @@ public:
     typedef void (T::*Exception)(const ::Ice::Exception&);
     typedef void (T::*Sent)(bool);
 
-    CallbackNC(const TPtr& instance, Exception excb, Sent sentcb) : callback(instance), exception(excb), sent(sentcb)
+    CallbackNC(const TPtr& instance, Exception excb, Sent sentcb) : _callback(instance), _exception(excb), _sent(sentcb)
     {
     }
 
-    virtual CallbackBasePtr __verify(const ::Ice::LocalObjectPtr& cookie)
+    virtual CallbackBasePtr verify(const ::Ice::LocalObjectPtr& cookie)
     {
         if(cookie != 0) // Makes sure begin_ was called without a cookie
         {
@@ -1309,32 +1309,35 @@ public:
         return this;
     }
 
-    virtual void __sent(const ::Ice::AsyncResultPtr& result) const
+    virtual void sent(const ::Ice::AsyncResultPtr& result) const
     {
-        if(sent)
+        if(_sent)
         {
-            (callback.get()->*sent)(result->sentSynchronously());
+            (_callback.get()->*_sent)(result->sentSynchronously());
         }
     }
 
-    virtual bool __hasSentCallback() const
+    virtual bool hasSentCallback() const
     {
-        return sent != 0;
+        return _sent != 0;
     }
 
-    TPtr callback;
-    Exception exception;
-    Sent sent;
-
 protected:
 
-    void __exception(const ::Ice::AsyncResultPtr&, const ::Ice::Exception& ex) const
+    void exception(const ::Ice::AsyncResultPtr&, const ::Ice::Exception& ex) const
     {
-        if(exception)
+        if(_exception)
         {
-            (callback.get()->*exception)(ex);
+            (_callback.get()->*_exception)(ex);
         }
     }
+
+    TPtr _callback;
+
+private:
+
+    Exception _exception;
+    Sent _sent;
 };
 
 template<class T, typename CT>
@@ -1350,11 +1353,11 @@ public:
     typedef void (T::*Exception)(const ::Ice::Exception&, const CT&);
     typedef void (T::*Sent)(bool, const CT&);
 
-    Callback(const TPtr& instance, Exception excb, Sent sentcb) : callback(instance), exception(excb), sent(sentcb)
+    Callback(const TPtr& instance, Exception excb, Sent sentcb) : _callback(instance), _exception(excb), _sent(sentcb)
     {
     }
 
-    virtual CallbackBasePtr __verify(const ::Ice::LocalObjectPtr& cookie)
+    virtual CallbackBasePtr verify(const ::Ice::LocalObjectPtr& cookie)
     {
         if(cookie && !CT::dynamicCast(cookie))
         {
@@ -1363,32 +1366,35 @@ public:
         return this;
     }
 
-    virtual void __sent(const ::Ice::AsyncResultPtr& result) const
+    virtual void sent(const ::Ice::AsyncResultPtr& result) const
     {
-        if(sent)
+        if(_sent)
         {
-            (callback.get()->*sent)(result->sentSynchronously(), CT::dynamicCast(result->getCookie()));
+            (_callback.get()->*_sent)(result->sentSynchronously(), CT::dynamicCast(result->getCookie()));
         }
     }
 
-    virtual bool __hasSentCallback() const
+    virtual bool hasSentCallback() const
     {
-        return sent != 0;
+        return _sent != 0;
     }
 
-    TPtr callback;
-    Exception exception;
-    Sent sent;
-
 protected:
 
-    void __exception(const ::Ice::AsyncResultPtr& result, const ::Ice::Exception& ex) const
+    void exception(const ::Ice::AsyncResultPtr& result, const ::Ice::Exception& ex) const
     {
-        if(exception)
+        if(_exception)
         {
-            (callback.get()->*exception)(ex, CT::dynamicCast(result->getCookie()));
+            (_callback.get()->*_exception)(ex, CT::dynamicCast(result->getCookie()));
         }
     }
+
+    TPtr _callback;
+
+private:
+
+    Exception _exception;
+    Sent _sent;
 };
 
 //
@@ -1443,12 +1449,12 @@ public:
     typedef void (T::*Response)();
 
     OnewayCallbackNC(const TPtr& instance, Response cb, Exception excb, Sent sentcb) : 
-        CallbackNC<T>(instance, excb, sentcb), response(cb)
+        CallbackNC<T>(instance, excb, sentcb), _response(cb)
     {
         CallbackBase::checkCallback(instance, cb != 0 || excb != 0);
     }
 
-    virtual void __completed(const ::Ice::AsyncResultPtr& result) const
+    virtual void completed(const ::Ice::AsyncResultPtr& result) const
     {
         try
         {
@@ -1456,16 +1462,18 @@ public:
         }
         catch(const ::Ice::Exception& ex)
         {
-            CallbackNC<T>::__exception(result, ex);
+            CallbackNC<T>::exception(result, ex);
             return;
         }
-        if(response)
+        if(_response)
         {
-            (CallbackNC<T>::callback.get()->*response)();
+            (CallbackNC<T>::_callback.get()->*_response)();
         }
     }
 
-    Response response;
+private:
+
+    Response _response;
 };
 
 template<class T, typename CT>
@@ -1480,12 +1488,12 @@ public:
     typedef void (T::*Response)(const CT&);
 
     OnewayCallback(const TPtr& instance, Response cb, Exception excb, Sent sentcb) : 
-        Callback<T, CT>(instance, excb, sentcb),  response(cb)
+        Callback<T, CT>(instance, excb, sentcb), _response(cb)
     {
         CallbackBase::checkCallback(instance, cb != 0 || excb != 0);
     }
 
-    virtual void __completed(const ::Ice::AsyncResultPtr& result) const
+    virtual void completed(const ::Ice::AsyncResultPtr& result) const
     {
         try
         {
@@ -1493,16 +1501,18 @@ public:
         }
         catch(const ::Ice::Exception& ex)
         {
-            Callback<T, CT>::__exception(result, ex);
+            Callback<T, CT>::exception(result, ex);
             return;
         }
-        if(response)
+        if(_response)
         {
-            (Callback<T, CT>::callback.get()->*response)(CT::dynamicCast(result->getCookie()));
+            (Callback<T, CT>::_callback.get()->*_response)(CT::dynamicCast(result->getCookie()));
         }
     }
 
-    Response response;
+private:
+    
+    Response _response;
 };
 
 }
@@ -1522,11 +1532,11 @@ public:
     typedef void (T::*Response)(bool);
 
     CallbackNC_Object_ice_isA(const TPtr& instance, Response cb, Exception excb, Sent sentcb) :
-        ::IceInternal::TwowayCallbackNC<T>(instance, cb != 0, excb, sentcb), response(cb)
+        ::IceInternal::TwowayCallbackNC<T>(instance, cb != 0, excb, sentcb), _response(cb)
     {
     }
 
-    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
         bool __ret;
         try
@@ -1535,16 +1545,18 @@ public:
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
+            ::IceInternal::CallbackNC<T>::exception(__result, ex);
             return;
         }
-        if(response)
+        if(_response)
         {
-            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
+            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret);
         }
     }
 
-    Response response;
+private:
+
+    Response _response;
 };
 
 template<class T, typename CT>
@@ -1559,11 +1571,11 @@ public:
     typedef void (T::*Response)(bool, const CT&);
 
     Callback_Object_ice_isA(const TPtr& instance, Response cb, Exception excb, Sent sentcb) :
-        ::IceInternal::TwowayCallback<T, CT>(instance, cb != 0, excb, sentcb), response(cb)
+        ::IceInternal::TwowayCallback<T, CT>(instance, cb != 0, excb, sentcb), _response(cb)
     {
     }
 
-    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
         bool __ret;
         try
@@ -1572,16 +1584,19 @@ public:
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
+            ::IceInternal::Callback<T, CT>::exception(__result, ex);
             return;
         }
-        if(response)
+        if(_response)
         {
-            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
+            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret,
+                                                                          CT::dynamicCast(__result->getCookie()));
         }
     }
 
-    Response response;
+private:
+
+    Response _response;
 };
 
 template<class T>
@@ -1630,11 +1645,11 @@ public:
     typedef void (T::*Response)(const ::std::vector< ::std::string>&);
 
     CallbackNC_Object_ice_ids(const TPtr& instance, Response cb, Exception excb, Sent sentcb) :
-        ::IceInternal::TwowayCallbackNC<T>(instance, cb != 0, excb, sentcb), response(cb)
+        ::IceInternal::TwowayCallbackNC<T>(instance, cb != 0, excb, sentcb), _response(cb)
     {
     }
 
-    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
         ::std::vector< ::std::string> __ret;
         try 
@@ -1643,16 +1658,18 @@ public:
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
+            ::IceInternal::CallbackNC<T>::exception(__result, ex);
             return;
         }
-        if(response)
+        if(_response)
         {
-            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
+            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret);
         }
     }
 
-    Response response;
+private:
+
+    Response _response;
 };
 
 template<class T, typename CT>
@@ -1667,11 +1684,11 @@ public:
     typedef void (T::*Response)(const ::std::vector< ::std::string>&, const CT&);
 
     Callback_Object_ice_ids(const TPtr& instance, Response cb, Exception excb, Sent sentcb) :
-        ::IceInternal::TwowayCallback<T, CT>(instance, cb != 0, excb, sentcb), response(cb)
+        ::IceInternal::TwowayCallback<T, CT>(instance, cb != 0, excb, sentcb), _response(cb)
     {
     }
 
-    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
         ::std::vector< ::std::string> __ret;
         try 
@@ -1680,16 +1697,19 @@ public:
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
+            ::IceInternal::Callback<T, CT>::exception(__result, ex);
             return;
         }
-        if(response)
+        if(_response)
         {
-            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
+            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret, 
+                                                                          CT::dynamicCast(__result->getCookie()));
         }
     }
 
-    Response response;
+private:
+
+    Response _response;
 };
 
 template<class T>
@@ -1704,11 +1724,11 @@ public:
     typedef void (T::*Response)(const ::std::string&);
 
     CallbackNC_Object_ice_id(const TPtr& instance, Response cb, Exception excb, Sent sentcb) :
-        ::IceInternal::TwowayCallbackNC<T>(instance, cb != 0, excb, sentcb), response(cb)
+        ::IceInternal::TwowayCallbackNC<T>(instance, cb != 0, excb, sentcb), _response(cb)
     {
     }
 
-    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
         ::std::string __ret;
         try
@@ -1717,16 +1737,18 @@ public:
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::CallbackNC<T>::__exception(__result, ex);
+            ::IceInternal::CallbackNC<T>::exception(__result, ex);
             return;
         }
-        if(response)
+        if(_response)
         {
-            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret);
+            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ret);
         }
     }
 
-    Response response;
+private:
+
+    Response _response;
 };
 
 template<class T, typename CT>
@@ -1741,11 +1763,11 @@ public:
     typedef void (T::*Response)(const ::std::string&, const CT&);
 
     Callback_Object_ice_id(const TPtr& instance, Response cb, Exception excb, Sent sentcb) :
-        ::IceInternal::TwowayCallback<T, CT>(instance, cb != 0, excb, sentcb), response(cb)
+        ::IceInternal::TwowayCallback<T, CT>(instance, cb != 0, excb, sentcb), _response(cb)
     {
     }
 
-    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
         ::std::string __ret;
         try
@@ -1754,16 +1776,19 @@ public:
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::Callback<T, CT>::__exception(__result, ex);
+            ::IceInternal::Callback<T, CT>::exception(__result, ex);
             return;
         }
-        if(response)
+        if(_response)
         {
-            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, CT::dynamicCast(__result->getCookie()));
+            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ret,
+                                                                          CT::dynamicCast(__result->getCookie()));
         }
     }
 
-    Response response;
+private:
+
+    Response _response;
 };
 
 template<class T>
@@ -1779,18 +1804,18 @@ public:
     typedef void (T::*ResponseArray)(bool, const std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&);
 
     CallbackNC_Object_ice_invoke(const TPtr& instance, Response cb, Exception excb, Sent sentcb) :
-        ::IceInternal::TwowayCallbackNC<T>(instance, cb != 0, excb, sentcb), response(cb), responseArray(0)
+        ::IceInternal::TwowayCallbackNC<T>(instance, cb != 0, excb, sentcb), _response(cb), _responseArray(0)
     {
     }
 
     CallbackNC_Object_ice_invoke(const TPtr& instance, ResponseArray cb, Exception excb, Sent sentcb) :
-        ::IceInternal::TwowayCallbackNC<T>(instance, cb != 0, excb, sentcb), response(0), responseArray(cb)
+        ::IceInternal::TwowayCallbackNC<T>(instance, cb != 0, excb, sentcb), _response(0), _responseArray(cb)
     {
     }
 
-    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
-        if(response)
+        if(_response)
         {
             bool __ok;
             std::vector< ::Ice::Byte> outParams;
@@ -1800,10 +1825,10 @@ public:
             }
             catch(const ::Ice::Exception& ex)
             {
-                ::IceInternal::CallbackNC<T>::__exception(__result, ex);
+                ::IceInternal::CallbackNC<T>::exception(__result, ex);
                 return;
             }
-            (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ok, outParams);
+            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(__ok, outParams);
         }
         else
         {
@@ -1815,18 +1840,20 @@ public:
             }
             catch(const ::Ice::Exception& ex)
             {
-                ::IceInternal::CallbackNC<T>::__exception(__result, ex);
+                ::IceInternal::CallbackNC<T>::exception(__result, ex);
                 return;
             }
-            if(responseArray)
+            if(_responseArray)
             {
-                (::IceInternal::CallbackNC<T>::callback.get()->*responseArray)(__ok, outParams);
+                (::IceInternal::CallbackNC<T>::_callback.get()->*_responseArray)(__ok, outParams);
             }
         }
     }
 
-    Response response;
-    ResponseArray responseArray;
+private:
+
+    Response _response;
+    ResponseArray _responseArray;
 };
 
 template<class T, typename CT>
@@ -1842,18 +1869,18 @@ public:
     typedef void (T::*ResponseArray)(bool, const std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&, const CT&);
 
     Callback_Object_ice_invoke(const TPtr& instance, Response cb, Exception excb, Sent sentcb) :
-        ::IceInternal::TwowayCallback<T, CT>(instance, cb != 0, excb, sentcb), response(cb), responseArray(0)
+        ::IceInternal::TwowayCallback<T, CT>(instance, cb != 0, excb, sentcb), _response(cb), _responseArray(0)
     {
     }
 
     Callback_Object_ice_invoke(const TPtr& instance, ResponseArray cb, Exception excb, Sent sentcb) :
-        ::IceInternal::TwowayCallback<T, CT>(instance, cb != 0, excb, sentcb), response(0), responseArray(cb)
+        ::IceInternal::TwowayCallback<T, CT>(instance, cb != 0, excb, sentcb), _response(0), _responseArray(cb)
     {
     }
 
-    virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
     {
-        if(response)
+        if(_response)
         {
             bool __ok;
             std::vector< ::Ice::Byte> outParams;
@@ -1863,12 +1890,12 @@ public:
             }
             catch(const ::Ice::Exception& ex)
             {
-                ::IceInternal::Callback<T, CT>::__exception(__result, ex);
+                ::IceInternal::Callback<T, CT>::exception(__result, ex);
                 return;
             }
-            (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ok, 
-                                                                        outParams, 
-                                                                        CT::dynamicCast(__result->getCookie()));
+            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(__ok, 
+                                                                          outParams, 
+                                                                          CT::dynamicCast(__result->getCookie()));
         }
         else
         {
@@ -1880,21 +1907,23 @@ public:
             }
             catch(const ::Ice::Exception& ex)
             {
-                ::IceInternal::Callback<T, CT>::__exception(__result, ex);
+                ::IceInternal::Callback<T, CT>::exception(__result, ex);
                 return;
             }
-            if(responseArray)
+            if(_responseArray)
             {
-                (::IceInternal::Callback<T, CT>::callback.get()->*responseArray)(__ok,
-                                                                                 outParams, 
-                                                                                 CT::dynamicCast(
-                                                                                     __result->getCookie()));
+                (::IceInternal::Callback<T, CT>::_callback.get()->*_responseArray)(__ok,
+                                                                                   outParams, 
+                                                                                   CT::dynamicCast(
+                                                                                       __result->getCookie()));
             }
         }
     }
 
-    Response response;
-    ResponseArray responseArray;
+private:
+
+    Response _response;
+    ResponseArray _responseArray;
 };
 
 template<class T>
diff --git a/cpp/src/Ice/CommunicatorI.cpp b/cpp/src/Ice/CommunicatorI.cpp
index 8bc80d47363..57a04cc9435 100644
--- a/cpp/src/Ice/CommunicatorI.cpp
+++ b/cpp/src/Ice/CommunicatorI.cpp
@@ -241,7 +241,7 @@ Ice::CommunicatorI::begin_flushBatchRequests(
         }
         
         virtual void
-        __completed(const AsyncResultPtr& __result) const
+        completed(const AsyncResultPtr& __result) const
         {
             CommunicatorPtr __com = __result->getCommunicator();
             assert(__com);
@@ -252,7 +252,7 @@ Ice::CommunicatorI::begin_flushBatchRequests(
             }
             catch(const Exception& ex)
             {
-                IceInternal::Cpp11FnCallbackNC::__exception(__result, ex);
+                IceInternal::Cpp11FnCallbackNC::exception(__result, ex);
             }
         }
     };
diff --git a/cpp/src/Ice/ConnectionI.cpp b/cpp/src/Ice/ConnectionI.cpp
index 01f18e6e91f..22cc069ef08 100644
--- a/cpp/src/Ice/ConnectionI.cpp
+++ b/cpp/src/Ice/ConnectionI.cpp
@@ -1002,7 +1002,7 @@ Ice::ConnectionI::begin_flushBatchRequests(
         }
         
         virtual void
-        __completed(const AsyncResultPtr& __result) const
+        completed(const AsyncResultPtr& __result) const
         {
             ConnectionPtr __con = __result->getConnection();
             assert(__con);
@@ -1013,7 +1013,7 @@ Ice::ConnectionI::begin_flushBatchRequests(
             }
             catch(const Exception& ex)
             {
-                IceInternal::Cpp11FnCallbackNC::__exception(__result, ex);
+                IceInternal::Cpp11FnCallbackNC::exception(__result, ex);
             }
         }
     };
diff --git a/cpp/src/Ice/OutgoingAsync.cpp b/cpp/src/Ice/OutgoingAsync.cpp
index 905b3196a5f..39252dbcadc 100644
--- a/cpp/src/Ice/OutgoingAsync.cpp
+++ b/cpp/src/Ice/OutgoingAsync.cpp
@@ -111,7 +111,7 @@ Ice::AsyncResult::AsyncResult(const CommunicatorPtr& communicator,
     {
         throw IceUtil::IllegalArgumentException(__FILE__, __LINE__);
     }
-    const_cast<CallbackBasePtr&>(_callback) = _callback->__verify(_cookie);
+    const_cast<CallbackBasePtr&>(_callback) = _callback->verify(_cookie);
 }
 
 Ice::AsyncResult::~AsyncResult()
@@ -216,7 +216,7 @@ Ice::AsyncResult::__invokeSent()
         try
         {
             AsyncResultPtr self(this);
-            _callback->__sent(self);
+            _callback->sent(self);
         }
         catch(const std::exception& ex)
         {
@@ -296,7 +296,7 @@ Ice::AsyncResult::__invokeCompleted()
         try
         {
             AsyncResultPtr self(this);
-            _callback->__completed(self);
+            _callback->completed(self);
         }
         catch(const std::exception& ex)
         {
@@ -538,7 +538,7 @@ IceInternal::OutgoingAsync::__sent()
     if(_proxy->__reference()->getMode() != Reference::ModeTwoway)
     {
         _childObserver.detach();
-        if(!_callback || !_callback->__hasSentCallback())
+        if(!_callback || !_callback->hasSentCallback())
         {
             _observer.detach();
         }
@@ -551,7 +551,7 @@ IceInternal::OutgoingAsync::__sent()
         //_os.resize(0); // Don't clear the buffer now, it's needed for collocation optimization.
     }
     _monitor.notifyAll();
-    return !alreadySent && _callback && _callback->__hasSentCallback();
+    return !alreadySent && _callback && _callback->hasSentCallback();
 }
 
 void
@@ -873,7 +873,7 @@ IceInternal::BatchOutgoingAsync::__sent()
         _timeoutRequestHandler = 0;
     }
     _monitor.notifyAll();
-    if(!_callback || !_callback->__hasSentCallback())
+    if(!_callback || !_callback->hasSentCallback())
     {
         _observer.detach();
         return false;
@@ -1105,7 +1105,7 @@ IceInternal::CommunicatorBatchOutgoingAsync::check(bool userThread)
         _monitor.notifyAll();
     }
 
-    if(!_callback || !_callback->__hasSentCallback())
+    if(!_callback || !_callback->hasSentCallback())
     {
         _observer.detach();
     }
@@ -1145,12 +1145,12 @@ public:
     {
     }
 
-    virtual void __completed(const Ice::AsyncResultPtr&) const
+    virtual void completed(const Ice::AsyncResultPtr&) const
     {
          assert(false);
     }
 
-    virtual CallbackBasePtr __verify(const Ice::LocalObjectPtr&)
+    virtual CallbackBasePtr verify(const Ice::LocalObjectPtr&)
     {
         //
         // Called by the AsyncResult constructor to verify the delegate. The dummy
@@ -1161,12 +1161,12 @@ public:
         return 0;
     }
 
-    virtual void __sent(const AsyncResultPtr&) const
+    virtual void sent(const AsyncResultPtr&) const
     {
          assert(false);
     }
 
-    virtual bool __hasSentCallback() const
+    virtual bool hasSentCallback() const
     {
         assert(false);
         return false;
@@ -1200,17 +1200,17 @@ Ice::newCallback(const ::IceInternal::Function<void (const AsyncResultPtr&)>& co
             checkCallback(true, completed != nullptr);
         }
         
-        virtual void __completed(const AsyncResultPtr& result) const
+        virtual void completed(const AsyncResultPtr& result) const
         {
             _completed(result);
         }
         
-        virtual CallbackBasePtr __verify(const LocalObjectPtr&)
+        virtual CallbackBasePtr verify(const LocalObjectPtr&)
         {
             return this; // Nothing to do, the cookie is not type-safe.
         }
         
-        virtual void __sent(const AsyncResultPtr& result) const
+        virtual void sent(const AsyncResultPtr& result) const
         {
             if(_sent != nullptr)
             {
@@ -1218,7 +1218,7 @@ Ice::newCallback(const ::IceInternal::Function<void (const AsyncResultPtr&)>& co
              }
         }
     
-        virtual bool __hasSentCallback() const
+        virtual bool hasSentCallback() const
         {
             return _sent != nullptr;
         }
diff --git a/cpp/src/Ice/Proxy.cpp b/cpp/src/Ice/Proxy.cpp
index b872b1f0477..41b46165524 100644
--- a/cpp/src/Ice/Proxy.cpp
+++ b/cpp/src/Ice/Proxy.cpp
@@ -80,13 +80,13 @@ IceInternal::Cpp11FnCallbackNC::Cpp11FnCallbackNC(const ::std::function<void (co
 }
 
 IceInternal::CallbackBasePtr 
-IceInternal::Cpp11FnCallbackNC::__verify(const ::Ice::LocalObjectPtr&)
+IceInternal::Cpp11FnCallbackNC::verify(const ::Ice::LocalObjectPtr&)
 {
     return this;
 }
 
 void 
-IceInternal::Cpp11FnCallbackNC::__sent(const ::Ice::AsyncResultPtr& result) const
+IceInternal::Cpp11FnCallbackNC::sent(const ::Ice::AsyncResultPtr& result) const
 {
     if(_sent != nullptr)
     {
@@ -95,13 +95,13 @@ IceInternal::Cpp11FnCallbackNC::__sent(const ::Ice::AsyncResultPtr& result) cons
 }
 
 bool 
-IceInternal::Cpp11FnCallbackNC::__hasSentCallback() const
+IceInternal::Cpp11FnCallbackNC::hasSentCallback() const
 {
     return _sent != nullptr;
 }
 
 void 
-IceInternal::Cpp11FnCallbackNC::__exception(const ::Ice::AsyncResultPtr&, const ::Ice::Exception& ex) const
+IceInternal::Cpp11FnCallbackNC::exception(const ::Ice::AsyncResultPtr&, const ::Ice::Exception& ex) const
 {
     if(_exception != nullptr)
     {
@@ -119,7 +119,7 @@ IceInternal::Cpp11FnOnewayCallbackNC::Cpp11FnOnewayCallbackNC(const ::std::funct
 }
     
 void
-IceInternal::Cpp11FnOnewayCallbackNC::__completed(const ::Ice::AsyncResultPtr& result) const
+IceInternal::Cpp11FnOnewayCallbackNC::completed(const ::Ice::AsyncResultPtr& result) const
 {
     try
     {
@@ -127,7 +127,7 @@ IceInternal::Cpp11FnOnewayCallbackNC::__completed(const ::Ice::AsyncResultPtr& r
     }
     catch(const ::Ice::Exception& ex)
     {
-        Cpp11FnCallbackNC::__exception(result, ex);
+        Cpp11FnCallbackNC::exception(result, ex);
         return;
     }
     if(_cb != nullptr)
@@ -252,7 +252,7 @@ IceProxy::Ice::Object::__begin_ice_isA(
             CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
         }
         
-        virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
         {
             ::Ice::ObjectPrx __proxy = ::Ice::ObjectPrx::uncheckedCast(__result->getProxy());
             bool __ret;
@@ -262,7 +262,7 @@ IceProxy::Ice::Object::__begin_ice_isA(
             }
             catch(const ::Ice::Exception& ex)
             {
-                Cpp11FnCallbackNC::__exception(__result, ex);
+                Cpp11FnCallbackNC::exception(__result, ex);
                 return;
             }
             if(_response != nullptr)
@@ -299,7 +299,7 @@ IceProxy::Ice::Object::__begin_ice_id(
             CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
         }
         
-        virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
         {
             ::Ice::ObjectPrx __proxy = ::Ice::ObjectPrx::uncheckedCast(__result->getProxy());
             ::std::string __ret;
@@ -309,7 +309,7 @@ IceProxy::Ice::Object::__begin_ice_id(
             }
             catch(const ::Ice::Exception& ex)
             {
-                Cpp11FnCallbackNC::__exception(__result, ex);
+                Cpp11FnCallbackNC::exception(__result, ex);
                 return;
             }
             if(_response != nullptr)
@@ -345,7 +345,7 @@ IceProxy::Ice::Object::__begin_ice_ids(
             CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
         }
         
-        virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
         {
             ::Ice::ObjectPrx __proxy = ::Ice::ObjectPrx::uncheckedCast(__result->getProxy());
             ::std::vector< ::std::string> __ret;
@@ -355,7 +355,7 @@ IceProxy::Ice::Object::__begin_ice_ids(
             }
             catch(const ::Ice::Exception& ex)
             {
-                Cpp11FnCallbackNC::__exception(__result, ex);
+                Cpp11FnCallbackNC::exception(__result, ex);
                 return;
             }
             if(_response != nullptr)
@@ -394,7 +394,7 @@ IceProxy::Ice::Object::__begin_ice_invoke(
             CallbackBase::checkCallback(true, responseFunc || exceptionFunc != nullptr);
         }
         
-        virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
         {
             ::Ice::ObjectPrx __proxy = ::Ice::ObjectPrx::uncheckedCast(__result->getProxy());
             bool __ret;
@@ -405,7 +405,7 @@ IceProxy::Ice::Object::__begin_ice_invoke(
             }
             catch(const ::Ice::Exception& ex)
             {
-                Cpp11FnCallbackNC::__exception(__result, ex);
+                Cpp11FnCallbackNC::exception(__result, ex);
                 return;
             }
             if(_response != nullptr)
@@ -446,7 +446,7 @@ IceProxy::Ice::Object::__begin_ice_invoke(
             CallbackBase::checkCallback(true, _response || _exception != nullptr);
         }
         
-        virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
+        virtual void completed(const ::Ice::AsyncResultPtr& __result) const
         {
             bool __ret;
             ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> p1;
@@ -456,7 +456,7 @@ IceProxy::Ice::Object::__begin_ice_invoke(
             }
             catch(const ::Ice::Exception& ex)
             {
-                Cpp11FnCallbackNC::__exception(__result, ex);
+                Cpp11FnCallbackNC::exception(__result, ex);
                 return;
             }
             if(_response != nullptr)
diff --git a/cpp/src/slice2cpp/Gen.cpp b/cpp/src/slice2cpp/Gen.cpp
index 4c1dcbed7da..9342b00d0b5 100644
--- a/cpp/src/slice2cpp/Gen.cpp
+++ b/cpp/src/slice2cpp/Gen.cpp
@@ -516,7 +516,7 @@ Slice::Gen::generate(const UnitPtr& p)
 
     //
     // We need to delay generating the template after the proxy
-    // definition, because __completed calls the begin_ method in the
+    // definition, because completed calls the begin_ method in the
     // proxy.
     //
     AsyncCallbackTemplateVisitor asyncCallbackTemplateVisitor(H, C, _dllExport);
@@ -1779,7 +1779,7 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
     // pointers would be invalid once end_ returns, we still want to allow using this
     // alternate mapping with AMI response callbacks (to allow zero-copy for instance).
     // For this purpose, we generate a special ___end method which is used by the 
-    // __completed implementation of the generated Callback_Inft_opName operation 
+    // completed implementation of the generated Callback_Inft_opName operation 
     // delegate.
     //
     bool generatePrivateEnd = retS != retSEndAMI || outParamsDeclAMI != outParamsDeclEndAMI;
@@ -2267,7 +2267,7 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
         //
         // completed.
         //
-        C << sp << nl << "virtual void __completed(const ::Ice::AsyncResultPtr& __result) const";
+        C << sp << nl << "virtual void completed(const ::Ice::AsyncResultPtr& __result) const";
         C << sb;
         C << nl << clScope << clName << "Prx __proxy = " << clScope << clName 
           << "Prx::uncheckedCast(__result->getProxy());";
@@ -2296,7 +2296,7 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
         C << eb;
         C << nl << "catch(const ::Ice::Exception& ex)";
         C << sb;
-        C << nl << "Cpp11FnCallbackNC::__exception(__result, ex);";
+        C << nl << "Cpp11FnCallbackNC::exception(__result, ex);";
         C << nl << "return;";
         C << eb;
         C << nl << "if(_response != nullptr)";
@@ -2327,8 +2327,8 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
         
         C << eb << ';';
         
-        C << nl << "return begin_" << name << spar << argsAMI << "__ctx" << "new Cpp11CB(__response, __exception, __sent)" 
-          << epar << ';';
+        C << nl << "return begin_" << name << spar << argsAMI << "__ctx" 
+          << "new Cpp11CB(__response, __exception, __sent)" << epar << ';';
         C << eb;
 
         //
@@ -4283,7 +4283,7 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr&
     H.inc();
     if(p->returnsData())
     {
-        H << nl << ": " << inheritD + "(obj, cb != 0, excb, sentcb), response(cb)";
+        H << nl << ": " << inheritD + "(obj, cb != 0, excb, sentcb), _response(cb)";
     }
     else
     {
@@ -4298,7 +4298,7 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr&
         //
         // completed.
         //
-        H << sp << nl << "virtual void __completed(const ::Ice::AsyncResultPtr& __result) const";
+        H << sp << nl << "virtual void completed(const ::Ice::AsyncResultPtr& __result) const";
         H << sb;
         H << nl << clScope << clName << "Prx __proxy = " << clScope << clName
           << "Prx::uncheckedCast(__result->getProxy());";
@@ -4328,12 +4328,12 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr&
         H << nl << "catch(const ::Ice::Exception& ex)";
         H << sb;
 
-        H << nl << "" << baseD << "::__exception(__result, ex);";
+        H << nl << "" << baseD << "::exception(__result, ex);";
         H << nl << "return;";
         H << eb;
-        H << nl << "if(response)";
+        H << nl << "if(_response)";
         H << sb;
-        H << nl << "(" << baseD << "::callback.get()->*response)" << spar;
+        H << nl << "(" << baseD << "::_callback.get()->*_response)" << spar;
         if(ret)
         {
             H << "__ret";
@@ -4346,8 +4346,8 @@ Slice::Gen::AsyncCallbackTemplateVisitor::generateOperation(const OperationPtr&
         H << epar << ';';
         H << eb;
         H << eb;
-        
-        H << sp << nl << "Response response;";
+        H << sp << nl << "private:";
+        H << sp << nl << "Response _response;";
     }
     H << eb << ';';