Renamed C++11 AMI/AMD suffix: _async to Async

3 files changed, 199 insertions, 199 deletions

diff --git a/cpp/test/Ice/exceptions/AllTests.cpp b/cpp/test/Ice/exceptions/AllTests.cpp
index a000cc34b03..18cd9d7539b 100644
--- a/cpp/test/Ice/exceptions/AllTests.cpp
+++ b/cpp/test/Ice/exceptions/AllTests.cpp
@@ -1151,7 +1151,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
     cout << "catching exact types with new AMI mapping... " << flush;
 #ifdef ICE_CPP11_MAPPING
     {
-        auto f = thrower->throwAasA_async(1);
+        auto f = thrower->throwAasAAsync(1);
         try
         {
             f.get();
@@ -1172,7 +1172,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
     }
     
     {
-        auto f = thrower->throwAorDasAorD_async(1);
+        auto f = thrower->throwAorDasAorDAsync(1);
         try
         {
             f.get();
@@ -1189,7 +1189,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
     }
     
     {
-        auto f = thrower->throwAorDasAorD_async(-1);
+        auto f = thrower->throwAorDasAorDAsync(-1);
         try
         {
             f.get();
@@ -1205,7 +1205,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
         }
     }
     {
-        auto f = thrower->throwBasB_async(1, 2);
+        auto f = thrower->throwBasBAsync(1, 2);
         try
         {
             f.get();
@@ -1222,7 +1222,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
         }
     }
     {
-        auto f = thrower->throwCasC_async(1, 2, 3);
+        auto f = thrower->throwCasCAsync(1, 2, 3);
         try
         {
             f.get();
@@ -1240,7 +1240,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
         }
     }
     {
-        auto f = thrower->throwModA_async(1, 2);
+        auto f = thrower->throwModAAsync(1, 2);
         try
         {
             f.get();
@@ -1266,7 +1266,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
     //
     {
         promise<bool> sent;
-        thrower->throwAasA_async(1,
+        thrower->throwAasAAsync(1,
             []()
             {
                 test(false);
@@ -1281,7 +1281,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
     
     {
         promise<bool> sent;
-        thrower->throwAorDasAorD_async(1,
+        thrower->throwAorDasAorDAsync(1,
             []()
             {
                 test(false);
@@ -1296,7 +1296,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
     
     {
         promise<bool> sent;
-        thrower->throwAorDasAorD_async(-1,
+        thrower->throwAorDasAorDAsync(-1,
             []()
             {
                 test(false);
@@ -1311,7 +1311,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
 
     {
         promise<bool> sent;
-        thrower->throwBasB_async(1, 2,
+        thrower->throwBasBAsync(1, 2,
             []()
             {
                 test(false);
@@ -1326,7 +1326,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
 
     {
         promise<bool> sent;
-        thrower->throwCasC_async(1, 2, 3,
+        thrower->throwCasCAsync(1, 2, 3,
             []()
             {
                 test(false);
@@ -1341,7 +1341,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
 
     {
         promise<bool> sent;
-        thrower->throwModA_async(1, 2,
+        thrower->throwModAAsync(1, 2,
             []()
             {
                 test(false);
@@ -1402,7 +1402,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
     cout << "catching derived types with new AMI mapping... " << flush;
 #ifdef ICE_CPP11_MAPPING
     {
-        auto f = thrower->throwBasA_async(1, 2);
+        auto f = thrower->throwBasAAsync(1, 2);
         try
         {
             f.get();
@@ -1419,7 +1419,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
     }
 
     {
-        auto f = thrower->throwCasA_async(1, 2, 3);
+        auto f = thrower->throwCasAAsync(1, 2, 3);
         try
         {
             f.get();
@@ -1437,7 +1437,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
     }
 
     {
-        auto f = thrower->throwCasB_async(1, 2, 3);
+        auto f = thrower->throwCasBAsync(1, 2, 3);
         try
         {
             f.get();
@@ -1485,7 +1485,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
         cout << "catching unknown user exception with new AMI mapping... " << flush;
 #ifdef ICE_CPP11_MAPPING
         {
-            auto f = thrower->throwUndeclaredA_async(1);
+            auto f = thrower->throwUndeclaredAAsync(1);
             try
             {
                 f.get();
@@ -1507,7 +1507,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
         }
 
         {
-            auto f = thrower->throwUndeclaredB_async(1, 2);
+            auto f = thrower->throwUndeclaredBAsync(1, 2);
             try
             {
                 f.get();
@@ -1523,7 +1523,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
         }
 
         {
-            auto f = thrower->throwUndeclaredC_async(1, 2, 3);
+            auto f = thrower->throwUndeclaredCAsync(1, 2, 3);
             try
             {
                 f.get();
@@ -1570,7 +1570,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
 #ifdef ICE_CPP11_MAPPING
         id = communicator->stringToIdentity("does not exist");
         shared_ptr<ThrowerPrx> thrower2 = Ice::uncheckedCast<ThrowerPrx>(thrower->ice_identity(id));
-        auto f = thrower2->throwAasA_async(1);
+        auto f = thrower2->throwAasAAsync(1);
         try
         {
             f.get();
@@ -1601,7 +1601,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
     {
 #ifdef ICE_CPP11_MAPPING
         shared_ptr<ThrowerPrx> thrower2 = Ice::uncheckedCast<ThrowerPrx>(thrower, "no such facet");
-        auto f = thrower2->throwAasA_async(1);
+        auto f = thrower2->throwAasAAsync(1);
         try
         {
             f.get();
@@ -1627,7 +1627,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
     {
 #ifdef ICE_CPP11_MAPPING
         shared_ptr<WrongOperationPrx> thrower4 = Ice::uncheckedCast<WrongOperationPrx>(thrower);
-        auto f = thrower4->noSuchOperation_async();
+        auto f = thrower4->noSuchOperationAsync();
         try
         {
             f.get();
@@ -1656,7 +1656,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
     cout << "catching unknown local exception with new AMI mapping... " << flush;
 #ifdef ICE_CPP11_MAPPING
     {
-        auto f = thrower->throwLocalException_async();
+        auto f = thrower->throwLocalExceptionAsync();
         try
         {
             f.get();
@@ -1672,7 +1672,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
     }
 
     {
-        auto f = thrower->throwLocalExceptionIdempotent_async();
+        auto f = thrower->throwLocalExceptionIdempotentAsync();
         try
         {
             f.get();
@@ -1713,7 +1713,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
 
     {
 #ifdef ICE_CPP11_MAPPING
-        auto f = thrower->throwNonIceException_async();
+        auto f = thrower->throwNonIceExceptionAsync();
         try
         {
             f.get();
diff --git a/cpp/test/Ice/exceptions/TestAMDI.cpp b/cpp/test/Ice/exceptions/TestAMDI.cpp
index db8039e9c6e..deb949defee 100644
--- a/cpp/test/Ice/exceptions/TestAMDI.cpp
+++ b/cpp/test/Ice/exceptions/TestAMDI.cpp
@@ -30,35 +30,35 @@ ThrowerI::ThrowerI()
 
 #ifdef ICE_CPP11_MAPPING
 void
-ThrowerI::shutdown_async(function<void ()> response,
-                         function<void (exception_ptr)>,
-                         const Ice::Current& current)
+ThrowerI::shutdownAsync(function<void ()> response,
+                        function<void (exception_ptr)>,
+                        const Ice::Current& current)
 {
     current.adapter->getCommunicator()->shutdown();
     response();
 }
 
 void
-ThrowerI::supportsUndeclaredExceptions_async(function<void (bool)> response,
-                                             function<void (exception_ptr)>,
-                                             const Ice::Current&)
+ThrowerI::supportsUndeclaredExceptionsAsync(function<void (bool)> response,
+                                            function<void (exception_ptr)>,
+                                            const Ice::Current&)
 {
     response(true);
 }
 
 void
-ThrowerI::supportsAssertException_async(function<void (bool)> response,
-                                        function<void (exception_ptr)>,
-                                        const Ice::Current&)
+ThrowerI::supportsAssertExceptionAsync(function<void (bool)> response,
+                                       function<void (exception_ptr)>,
+                                       const Ice::Current&)
 {
     response(false);
 }
 
 void
-ThrowerI::throwAasA_async(int a,
-                          function<void ()>,
-                          function<void (exception_ptr)> exception,
-                          const Ice::Current&)
+ThrowerI::throwAasAAsync(int a,
+                         function<void ()>,
+                         function<void (exception_ptr)> exception,
+                         const Ice::Current&)
 {
     try
     {
@@ -73,10 +73,10 @@ ThrowerI::throwAasA_async(int a,
 }
 
 void
-ThrowerI::throwAorDasAorD_async(int a,
-                                function<void ()>,
-                                function<void (exception_ptr)> exception,
-                                const Ice::Current&)
+ThrowerI::throwAorDasAorDAsync(int a,
+                               function<void ()>,
+                               function<void (exception_ptr)> exception,
+                               const Ice::Current&)
 {
     try
     {
@@ -100,10 +100,10 @@ ThrowerI::throwAorDasAorD_async(int a,
 }
 
 void
-ThrowerI::throwBasA_async(int a, int b,
-                          function<void ()>,
-                          function<void (exception_ptr)> exception,
-                          const Ice::Current&)
+ThrowerI::throwBasAAsync(int a, int b,
+                         function<void ()>,
+                         function<void (exception_ptr)> exception,
+                         const Ice::Current&)
 {
     try
     {
@@ -119,10 +119,10 @@ ThrowerI::throwBasA_async(int a, int b,
 }
 
 void
-ThrowerI::throwCasA_async(int a, int b, int c,
-                          function<void ()>,
-                          function<void (exception_ptr)> exception,
-                          const Ice::Current&)
+ThrowerI::throwCasAAsync(int a, int b, int c,
+                         function<void ()>,
+                         function<void (exception_ptr)> exception,
+                         const Ice::Current&)
 {
     try
     {
@@ -139,10 +139,10 @@ ThrowerI::throwCasA_async(int a, int b, int c,
 }
 
 void
-ThrowerI::throwBasB_async(int a, int b,
-                          function<void ()>,
-                          function<void (exception_ptr)> exception,
-                          const Ice::Current&)
+ThrowerI::throwBasBAsync(int a, int b,
+                         function<void ()>,
+                         function<void (exception_ptr)> exception,
+                         const Ice::Current&)
 {
     try
     {
@@ -158,10 +158,10 @@ ThrowerI::throwBasB_async(int a, int b,
 }
 
 void
-ThrowerI::throwCasB_async(int a, int b, int c,
-                          function<void ()>,
-                          function<void (exception_ptr)> exception,
-                          const Ice::Current&)
+ThrowerI::throwCasBAsync(int a, int b, int c,
+                         function<void ()>,
+                         function<void (exception_ptr)> exception,
+                         const Ice::Current&)
 {
     try
     {
@@ -178,10 +178,10 @@ ThrowerI::throwCasB_async(int a, int b, int c,
 }
 
 void
-ThrowerI::throwCasC_async(int a, int b, int c,
-                          function<void ()>,
-                          function<void (exception_ptr)> exception,
-                          const Ice::Current&)
+ThrowerI::throwCasCAsync(int a, int b, int c,
+                         function<void ()>,
+                         function<void (exception_ptr)> exception,
+                         const Ice::Current&)
 {
     try
     {
@@ -198,10 +198,10 @@ ThrowerI::throwCasC_async(int a, int b, int c,
 }
 
 void
-ThrowerI::throwModA_async(int a, int a2,
-                          function<void ()>,
-                          function<void (exception_ptr)> exception,
-                          const Ice::Current&)
+ThrowerI::throwModAAsync(int a, int a2,
+                         function<void ()>,
+                         function<void (exception_ptr)> exception,
+                         const Ice::Current&)
 {
     Mod::A ex;
     ex.aMem = a;
@@ -210,10 +210,10 @@ ThrowerI::throwModA_async(int a, int a2,
 }
 
 void
-ThrowerI::throwUndeclaredA_async(int a,
-                                 function<void ()>,
-                                 function<void (exception_ptr)> exception,
-                                  const Ice::Current&)
+ThrowerI::throwUndeclaredAAsync(int a,
+                                function<void ()>,
+                                function<void (exception_ptr)> exception,
+                                const Ice::Current&)
 {
     try
     {
@@ -228,10 +228,10 @@ ThrowerI::throwUndeclaredA_async(int a,
 }
 
 void
-ThrowerI::throwUndeclaredB_async(int a, int b,
-                                 function<void ()>,
-                                 function<void (exception_ptr)>,
-                                 const Ice::Current&)
+ThrowerI::throwUndeclaredBAsync(int a, int b,
+                                function<void ()>,
+                                function<void (exception_ptr)>,
+                                const Ice::Current&)
 {
     B ex;
     ex.aMem = a;
@@ -240,10 +240,10 @@ ThrowerI::throwUndeclaredB_async(int a, int b,
 }
 
 void
-ThrowerI::throwUndeclaredC_async(int a, int b, int c,
-                                 function<void ()>,
-                                 function<void (exception_ptr)> exception,
-                                 const Ice::Current&)
+ThrowerI::throwUndeclaredCAsync(int a, int b, int c,
+                                function<void ()>,
+                                function<void (exception_ptr)> exception,
+                                const Ice::Current&)
 {
     try
     {
@@ -260,9 +260,9 @@ ThrowerI::throwUndeclaredC_async(int a, int b, int c,
 }
 
 void
-ThrowerI::throwLocalException_async(function<void ()>,
-                                    function<void (exception_ptr)> exception,
-                                    const Ice::Current&)
+ThrowerI::throwLocalExceptionAsync(function<void ()>,
+                                   function<void (exception_ptr)> exception,
+                                   const Ice::Current&)
 {
     try
     {
@@ -275,9 +275,9 @@ ThrowerI::throwLocalException_async(function<void ()>,
 }
 
 void
-ThrowerI::throwNonIceException_async(function<void ()>,
-                                     function<void (exception_ptr)> exception,
-                                     const Ice::Current&)
+ThrowerI::throwNonIceExceptionAsync(function<void ()>,
+                                    function<void (exception_ptr)> exception,
+                                    const Ice::Current&)
 {
     try
     {
@@ -290,26 +290,26 @@ ThrowerI::throwNonIceException_async(function<void ()>,
 }
 
 void
-ThrowerI::throwAssertException_async(function<void ()>,
-                                     function<void (exception_ptr)>,
-                                     const Ice::Current&)
+ThrowerI::throwAssertExceptionAsync(function<void ()>,
+                                    function<void (exception_ptr)>,
+                                    const Ice::Current&)
 {
     assert(false); // No supported in C++
 }
 
 void
-ThrowerI::throwMemoryLimitException_async(ICE_IN(Ice::ByteSeq),
-                                          function<void (const Ice::ByteSeq&)> response,
-                                          function<void (exception_ptr)>,
-                                          const Ice::Current&)
+ThrowerI::throwMemoryLimitExceptionAsync(ICE_IN(Ice::ByteSeq),
+                                         function<void (const Ice::ByteSeq&)> response,
+                                         function<void (exception_ptr)>,
+                                         const Ice::Current&)
 {
     response(Ice::ByteSeq(1024 * 20)); // 20 KB.
 }
 
 void
-ThrowerI::throwLocalExceptionIdempotent_async(function<void ()>,
-                                              function<void (exception_ptr)> exception,
-                                              const Ice::Current&)
+ThrowerI::throwLocalExceptionIdempotentAsync(function<void ()>,
+                                             function<void (exception_ptr)> exception,
+                                             const Ice::Current&)
 {
     try
     {
@@ -323,9 +323,9 @@ ThrowerI::throwLocalExceptionIdempotent_async(function<void ()>,
 }
 
 void
-ThrowerI::throwAfterResponse_async(function<void ()> response,
-                                   function<void (exception_ptr)>,
-                                   const Ice::Current&)
+ThrowerI::throwAfterResponseAsync(function<void ()> response,
+                                  function<void (exception_ptr)>,
+                                  const Ice::Current&)
 {
     response();
 
@@ -333,9 +333,9 @@ ThrowerI::throwAfterResponse_async(function<void ()> response,
 }
 
 void
-ThrowerI::throwAfterException_async(function<void ()>,
-                                    function<void (exception_ptr)> exception,
-                                    const Ice::Current&)
+ThrowerI::throwAfterExceptionAsync(function<void ()>,
+                                   function<void (exception_ptr)> exception,
+                                   const Ice::Current&)
 {
     try
     {
@@ -349,9 +349,9 @@ ThrowerI::throwAfterException_async(function<void ()>,
 }
 
 void
-ThrowerI::throwE_async(function<void ()>,
-                       function<void (exception_ptr)> exception,
-                       const Ice::Current&)
+ThrowerI::throwEAsync(function<void ()>,
+                      function<void (exception_ptr)> exception,
+                      const Ice::Current&)
 {
     try
     {
@@ -364,9 +364,9 @@ ThrowerI::throwE_async(function<void ()>,
 }
 
 void
-ThrowerI::throwF_async(function<void ()>,
-                       function<void (exception_ptr)> exception,
-                       const Ice::Current&)
+ThrowerI::throwFAsync(function<void ()>,
+                      function<void (exception_ptr)> exception,
+                      const Ice::Current&)
 {
     try
     {
@@ -379,9 +379,9 @@ ThrowerI::throwF_async(function<void ()>,
 }
 
 void
-ThrowerI::throwG_async(function<void ()>,
-                       function<void (exception_ptr)> exception,
-                       const Ice::Current&)
+ThrowerI::throwGAsync(function<void ()>,
+                      function<void (exception_ptr)> exception,
+                      const Ice::Current&)
 {
     try
     {
@@ -398,9 +398,9 @@ ThrowerI::throwG_async(function<void ()>,
 }
 
 void
-ThrowerI::throwH_async(function<void ()>,
-                       function<void (exception_ptr)> exception,
-                       const Ice::Current&)
+ThrowerI::throwHAsync(function<void ()>,
+                      function<void (exception_ptr)> exception,
+                      const Ice::Current&)
 {
     try
     {
diff --git a/cpp/test/Ice/exceptions/TestAMDI.h b/cpp/test/Ice/exceptions/TestAMDI.h
index 4db8fe0b079..182fe8f6de6 100644
--- a/cpp/test/Ice/exceptions/TestAMDI.h
+++ b/cpp/test/Ice/exceptions/TestAMDI.h
@@ -23,117 +23,117 @@ public:
     ThrowerI();
 
 #ifdef ICE_CPP11_MAPPING
-    virtual void shutdown_async(std::function<void ()>,
+    virtual void shutdownAsync(std::function<void ()>,
+                               std::function<void (std::exception_ptr)>,
+                               const Ice::Current&);
+
+    virtual void supportsUndeclaredExceptionsAsync(std::function<void (bool)>,
+                                                   std::function<void (std::exception_ptr)>,
+                                                   const Ice::Current&);
+
+    virtual void supportsAssertExceptionAsync(std::function<void (bool)>,
+                                              std::function<void (std::exception_ptr)>,
+                                              const Ice::Current&);
+
+    virtual void throwAasAAsync(int,
+                                std::function<void ()>,
                                 std::function<void (std::exception_ptr)>,
                                 const Ice::Current&);
 
-    virtual void supportsUndeclaredExceptions_async(std::function<void (bool)>,
-                                                    std::function<void (std::exception_ptr)>,
-                                                    const Ice::Current&);
+    virtual void throwAorDasAorDAsync(int,
+                                      std::function<void ()>,
+                                      std::function<void (std::exception_ptr)>,
+                                      const Ice::Current&);
 
-    virtual void supportsAssertException_async(std::function<void (bool)>,
-                                               std::function<void (std::exception_ptr)>,
-                                               const Ice::Current&);
+    virtual void throwBasAAsync(int, int,
+                                std::function<void ()>,
+                                std::function<void (std::exception_ptr)>,
+                                const Ice::Current&);
+
+    virtual void throwCasAAsync(int, int, int,
+                                std::function<void ()>,
+                                std::function<void (std::exception_ptr)>,
+                                const Ice::Current&);
 
-    virtual void throwAasA_async(int,
-                                 std::function<void ()>,
-                                 std::function<void (std::exception_ptr)>,
-                                 const Ice::Current&);
+    virtual void throwBasBAsync(int, int,
+                                std::function<void ()>,
+                                std::function<void (std::exception_ptr)>,
+                                const Ice::Current&);
+
+    virtual void throwCasBAsync(int, int, int,
+                                std::function<void ()>,
+                                std::function<void (std::exception_ptr)>,
+                                const Ice::Current&);
+
+    virtual void throwCasCAsync(int, int, int,
+                                std::function<void ()>,
+                                std::function<void (std::exception_ptr)>,
+                                const Ice::Current&);
+
+    virtual void throwModAAsync(int, int,
+                                std::function<void ()>,
+                                std::function<void (std::exception_ptr)>,
+                                const Ice::Current&);
 
-    virtual void throwAorDasAorD_async(int,
+    virtual void throwUndeclaredAAsync(int,
                                        std::function<void ()>,
                                        std::function<void (std::exception_ptr)>,
                                        const Ice::Current&);
 
-    virtual void throwBasA_async(int, int,
-                                 std::function<void ()>,
-                                 std::function<void (std::exception_ptr)>,
-                                 const Ice::Current&);
-
-    virtual void throwCasA_async(int, int, int,
-                                 std::function<void ()>,
-                                 std::function<void (std::exception_ptr)>,
-                                 const Ice::Current&);
-
-    virtual void throwBasB_async(int, int,
-                                 std::function<void ()>,
-                                 std::function<void (std::exception_ptr)>,
-                                 const Ice::Current&);
-
-    virtual void throwCasB_async(int, int, int,
-                                 std::function<void ()>,
-                                 std::function<void (std::exception_ptr)>,
-                                 const Ice::Current&);
-
-    virtual void throwCasC_async(int, int, int,
-                                 std::function<void ()>,
-                                 std::function<void (std::exception_ptr)>,
-                                 const Ice::Current&);
-
-    virtual void throwModA_async(int, int,
-                                 std::function<void ()>,
-                                 std::function<void (std::exception_ptr)>,
-                                 const Ice::Current&);
-
-    virtual void throwUndeclaredA_async(int,
-                                        std::function<void ()>,
-                                        std::function<void (std::exception_ptr)>,
-                                        const Ice::Current&);
-
-    virtual void throwUndeclaredB_async(int, int,
-                                        std::function<void ()>,
-                                        std::function<void (std::exception_ptr)>,
-                                        const Ice::Current&);
-
-    virtual void throwUndeclaredC_async(int, int, int,
-                                        std::function<void ()>,
-                                        std::function<void (std::exception_ptr)>,
-                                        const Ice::Current&);
-
-    virtual void throwLocalException_async(std::function<void ()>,
+    virtual void throwUndeclaredBAsync(int, int,
+                                       std::function<void ()>,
+                                       std::function<void (std::exception_ptr)>,
+                                       const Ice::Current&);
+
+    virtual void throwUndeclaredCAsync(int, int, int,
+                                       std::function<void ()>,
+                                       std::function<void (std::exception_ptr)>,
+                                       const Ice::Current&);
+
+    virtual void throwLocalExceptionAsync(std::function<void ()>,
+                                          std::function<void (std::exception_ptr)>,
+                                          const Ice::Current&);
+
+    virtual void throwNonIceExceptionAsync(std::function<void ()>,
                                            std::function<void (std::exception_ptr)>,
                                            const Ice::Current&);
 
-    virtual void throwNonIceException_async(std::function<void ()>,
-                                            std::function<void (std::exception_ptr)>,
-                                            const Ice::Current&);
+    virtual void throwAssertExceptionAsync(std::function<void ()>,
+                                           std::function<void (std::exception_ptr)>,
+                                           const Ice::Current&);
 
-    virtual void throwAssertException_async(std::function<void ()>,
-                                            std::function<void (std::exception_ptr)>,
-                                            const Ice::Current&);
+    virtual void throwMemoryLimitExceptionAsync(ICE_IN(Ice::ByteSeq),
+                                                std::function<void (const Ice::ByteSeq&)>,
+                                                std::function<void (std::exception_ptr)>,
+                                                const Ice::Current&);
 
-    virtual void throwMemoryLimitException_async(ICE_IN(Ice::ByteSeq),
-                                                 std::function<void (const Ice::ByteSeq&)>,
-                                                 std::function<void (std::exception_ptr)>,
-                                                 const Ice::Current&);
+    virtual void throwLocalExceptionIdempotentAsync(std::function<void ()>,
+                                                    std::function<void (std::exception_ptr)>,
+                                                    const Ice::Current&);
 
-    virtual void throwLocalExceptionIdempotent_async(std::function<void ()>,
-                                                     std::function<void (std::exception_ptr)>,
-                                                     const Ice::Current&);
+    virtual void throwAfterResponseAsync(std::function<void ()>,
+                                         std::function<void (std::exception_ptr)>,
+                                         const Ice::Current&);
 
-    virtual void throwAfterResponse_async(std::function<void ()>,
+    virtual void throwAfterExceptionAsync(std::function<void ()>,
                                           std::function<void (std::exception_ptr)>,
                                           const Ice::Current&);
-
-    virtual void throwAfterException_async(std::function<void ()>,
-                                           std::function<void (std::exception_ptr)>,
-                                           const Ice::Current&);
     
-    virtual void throwE_async(std::function<void ()>,
-                              std::function<void (std::exception_ptr)>,
-                              const Ice::Current&);
+    virtual void throwEAsync(std::function<void ()>,
+                             std::function<void (std::exception_ptr)>,
+                             const Ice::Current&);
 
-    virtual void throwF_async(std::function<void ()>,
-                              std::function<void (std::exception_ptr)>,
-                              const Ice::Current&);
+    virtual void throwFAsync(std::function<void ()>,
+                             std::function<void (std::exception_ptr)>,
+                             const Ice::Current&);
 
-    virtual void throwG_async(std::function<void ()>,
-                              std::function<void (std::exception_ptr)>,
-                              const Ice::Current&);
+    virtual void throwGAsync(std::function<void ()>,
+                             std::function<void (std::exception_ptr)>,
+                             const Ice::Current&);
 
-    virtual void throwH_async(std::function<void ()>,
-                              std::function<void (std::exception_ptr)>,
-                              const Ice::Current&);
+    virtual void throwHAsync(std::function<void ()>,
+                             std::function<void (std::exception_ptr)>,
+                             const Ice::Current&);
 #else
     virtual void shutdown_async(const Test::AMD_Thrower_shutdownPtr&,
                                 const Ice::Current&);