Added support for C+11 marshaled results

10 files changed, 274 insertions, 34 deletions

diff --git a/cpp/test/Ice/objects/TestI.cpp b/cpp/test/Ice/objects/TestI.cpp
index 08f0ce760f2..b46797912c3 100644
--- a/cpp/test/Ice/objects/TestI.cpp
+++ b/cpp/test/Ice/objects/TestI.cpp
@@ -161,21 +161,28 @@ InitialI::getF(const Ice::Current&)
     return _f;
 }
 
-Test::BPtr
-InitialI::getMB(const Ice::Current&)
+#ifdef ICE_CPP11_MAPPING
+InitialI::GetMBMarshaledResult
+InitialI::getMB(const Ice::Current& current)
 {
-    return _b1;
+    return GetMBMarshaledResult(_b1, current);
 }
 
 void
-#ifdef ICE_CPP11_MAPPING
-InitialI::getAMDMBAsync(function<void(const shared_ptr<B>&)> response,
+InitialI::getAMDMBAsync(function<void(const GetAMDMBMarshaledResult&)> response,
                         function<void(exception_ptr)>,
-                        const Ice::Current&)
+                        const Ice::Current& current)
 {
-    response(_b1);
+    response(GetAMDMBMarshaledResult(_b1, current));
 }
 #else
+Test::BPtr
+InitialI::getMB(const Ice::Current&)
+{
+    return _b1;
+}
+
+void
 InitialI::getAMDMB_async(const Test::AMD_Initial_getAMDMBPtr& cb, const Ice::Current&)
 {
     cb->ice_response(_b1);
diff --git a/cpp/test/Ice/objects/TestI.h b/cpp/test/Ice/objects/TestI.h
index 5212856f533..177d2b01864 100644
--- a/cpp/test/Ice/objects/TestI.h
+++ b/cpp/test/Ice/objects/TestI.h
@@ -97,12 +97,13 @@ public:
     virtual Test::EPtr getE(const Ice::Current&);
     virtual Test::FPtr getF(const Ice::Current&);
 
-    virtual Test::BPtr getMB(const Ice::Current&);
 #ifdef ICE_CPP11_MAPPING
-    virtual void getAMDMBAsync(std::function<void(const std::shared_ptr<Test::B>&)>,
+    virtual GetMBMarshaledResult getMB(const Ice::Current&);
+    virtual void getAMDMBAsync(std::function<void(const GetAMDMBMarshaledResult&)>,
                                std::function<void(std::exception_ptr)>,
                                const Ice::Current&);
 #else
+    virtual Test::BPtr getMB(const Ice::Current&);
     virtual void getAMDMB_async(const Test::AMD_Initial_getAMDMBPtr&, const Ice::Current&);
 #endif
 
diff --git a/cpp/test/Ice/operations/TestAMDI.cpp b/cpp/test/Ice/operations/TestAMDI.cpp
index ed02a23f340..baea3211706 100644
--- a/cpp/test/Ice/operations/TestAMDI.cpp
+++ b/cpp/test/Ice/operations/TestAMDI.cpp
@@ -996,56 +996,56 @@ MyDerivedClassI::opWStringLiteralsAsync(function<void(const Test::WStringS&)> re
 }
 
 void
-MyDerivedClassI::opMStruct1Async(function<void(const Test::Structure&)> response,
+MyDerivedClassI::opMStruct1Async(function<void(const OpMStruct1MarshaledResult&)> response,
                                  function<void(std::exception_ptr)>,
-                                 const Ice::Current&)
+                                 const Ice::Current& current)
 {
     Test::Structure s;
     s.e = ICE_ENUM(MyEnum, enum1); // enum must be initialized
-    response(s);
+    response(OpMStruct1MarshaledResult(s, current));
 }
 
 void
 MyDerivedClassI::opMStruct2Async(Test::Structure p1,
-                                 function<void(const Test::Structure&, const Test::Structure&)> response,
+                                 function<void(const OpMStruct2MarshaledResult&)> response,
                                  function<void(std::exception_ptr)>,
-                                 const Ice::Current&)
+                                 const Ice::Current& current)
 {
-    response(p1, p1);
+    response(OpMStruct2MarshaledResult(p1, p1, current));
 }
 
 void
-MyDerivedClassI::opMSeq1Async(function<void(const Test::StringS&)> response,
+MyDerivedClassI::opMSeq1Async(function<void(const OpMSeq1MarshaledResult&)> response,
                               function<void(std::exception_ptr)>,
-                              const Ice::Current&)
+                              const Ice::Current& current)
 {
-    response(Test::StringS());
+    response(OpMSeq1MarshaledResult(Test::StringS(), current));
 }
 
 void
 MyDerivedClassI::opMSeq2Async(Test::StringS p1,
-                              function<void(const Test::StringS&, const Test::StringS&)> response,
+                              function<void(const OpMSeq2MarshaledResult&)> response,
                               function<void(std::exception_ptr)>,
-                              const Ice::Current&)
+                              const Ice::Current& current)
 {
-    response(p1, p1);
+    response(OpMSeq2MarshaledResult(p1, p1, current));
 }
 
 void
-MyDerivedClassI::opMDict1Async(function<void(const Test::StringStringD&)> response,
+MyDerivedClassI::opMDict1Async(function<void(const OpMDict1MarshaledResult&)> response,
                                function<void(std::exception_ptr)>,
-                               const Ice::Current&)
+                               const Ice::Current& current)
 {
-    response(Test::StringStringD());
+    response(OpMDict1MarshaledResult(Test::StringStringD(), current));
 }
 
 void
 MyDerivedClassI::opMDict2Async(Test::StringStringD p1,
-                               function<void(const Test::StringStringD&, const Test::StringStringD&)> response,
+                               function<void(const OpMDict2MarshaledResult&)> response,
                                function<void(std::exception_ptr)>,
-                               const Ice::Current&)
+                               const Ice::Current& current)
 {
-    response(p1, p1);
+    response(OpMDict2MarshaledResult(p1, p1, current));
 }
 
 #else
diff --git a/cpp/test/Ice/operations/TestAMDI.h b/cpp/test/Ice/operations/TestAMDI.h
index 06603bb38d6..38cea8022f9 100644
--- a/cpp/test/Ice/operations/TestAMDI.h
+++ b/cpp/test/Ice/operations/TestAMDI.h
@@ -383,30 +383,30 @@ public:
                                         ::std::function<void(std::exception_ptr)>,
                                         const Ice::Current&);
 
-    virtual void opMStruct1Async(::std::function<void(const Test::Structure&)>,
+    virtual void opMStruct1Async(::std::function<void(const OpMStruct1MarshaledResult&)>,
                                  ::std::function<void(std::exception_ptr)>,
                                  const Ice::Current&);
 
     virtual void opMStruct2Async(ICE_IN(Test::Structure),
-                                 ::std::function<void(const Test::Structure&, const Test::Structure&)>,
+                                 ::std::function<void(const OpMStruct2MarshaledResult&)>,
                                  ::std::function<void(std::exception_ptr)>,
                                  const Ice::Current&);
 
-    virtual void opMSeq1Async(::std::function<void(const Test::StringS&)>,
+    virtual void opMSeq1Async(::std::function<void(const OpMSeq1MarshaledResult&)>,
                               ::std::function<void(std::exception_ptr)>,
                               const Ice::Current&);
 
     virtual void opMSeq2Async(ICE_IN(Test::StringS),
-                              ::std::function<void(const Test::StringS&, const Test::StringS&)>,
+                              ::std::function<void(const OpMSeq2MarshaledResult&)>,
                               ::std::function<void(std::exception_ptr)>,
                               const Ice::Current&);
 
-    virtual void opMDict1Async(::std::function<void(const Test::StringStringD&)>,
+    virtual void opMDict1Async(::std::function<void(const OpMDict1MarshaledResult&)>,
                                ::std::function<void(std::exception_ptr)>,
                                const Ice::Current&);
 
     virtual void opMDict2Async(ICE_IN(Test::StringStringD),
-                               ::std::function<void(const Test::StringStringD&, const Test::StringStringD&)>,
+                               ::std::function<void(const OpMDict2MarshaledResult&)>,
                                ::std::function<void(std::exception_ptr)>,
                                const Ice::Current&);
 
diff --git a/cpp/test/Ice/operations/TestI.cpp b/cpp/test/Ice/operations/TestI.cpp
index 7b7f4ba6c33..91154cf5769 100644
--- a/cpp/test/Ice/operations/TestI.cpp
+++ b/cpp/test/Ice/operations/TestI.cpp
@@ -843,6 +843,48 @@ MyDerivedClassI::opWStringLiterals(const Ice::Current&)
     return data;
 }
 
+#ifdef ICE_CPP11_MAPPING
+MyDerivedClassI::OpMStruct1MarshaledResult
+MyDerivedClassI::opMStruct1(const Ice::Current& current)
+{
+    Test::Structure s;
+    s.e = ICE_ENUM(MyEnum, enum1); // enum must be initialized
+    return OpMStruct1MarshaledResult(s, current);
+}
+
+
+MyDerivedClassI::OpMStruct2MarshaledResult
+MyDerivedClassI::opMStruct2(ICE_IN(Test::Structure) p1, const Ice::Current& current)
+{
+    return OpMStruct2MarshaledResult(p1, p1, current);
+}
+
+MyDerivedClassI::OpMSeq1MarshaledResult
+MyDerivedClassI::opMSeq1(const Ice::Current& current)
+{
+    return OpMSeq1MarshaledResult(Test::StringS(), current);
+}
+
+MyDerivedClassI::OpMSeq2MarshaledResult
+MyDerivedClassI::opMSeq2(ICE_IN(Test::StringS) p1, const Ice::Current& current)
+{
+    return OpMSeq2MarshaledResult(p1, p1, current);
+}
+
+MyDerivedClassI::OpMDict1MarshaledResult
+MyDerivedClassI::opMDict1(const Ice::Current& current)
+{
+    return OpMDict1MarshaledResult(Test::StringStringD(), current);
+}
+
+MyDerivedClassI::OpMDict2MarshaledResult
+MyDerivedClassI::opMDict2(ICE_IN(Test::StringStringD) p1, const Ice::Current& current)
+{
+    return OpMDict2MarshaledResult(p1, p1, current);
+}
+
+#else
+
 Test::Structure
 MyDerivedClassI::opMStruct1(const Ice::Current&)
 {
@@ -851,7 +893,6 @@ MyDerivedClassI::opMStruct1(const Ice::Current&)
     return s;
 }
 
-
 Test::Structure
 MyDerivedClassI::opMStruct2(ICE_IN(Test::Structure) p1, Test::Structure& p2, const Ice::Current&)
 {
@@ -885,3 +926,4 @@ MyDerivedClassI::opMDict2(ICE_IN(Test::StringStringD) p1, Test::StringStringD& p
     return p1;
 }
 
+#endif
\ No newline at end of file
diff --git a/cpp/test/Ice/operations/TestI.h b/cpp/test/Ice/operations/TestI.h
index 9b85bc09769..83a364fdc69 100644
--- a/cpp/test/Ice/operations/TestI.h
+++ b/cpp/test/Ice/operations/TestI.h
@@ -305,6 +305,19 @@ public:
 
     virtual Test::WStringS opWStringLiterals(const Ice::Current&);
 
+#ifdef ICE_CPP11_MAPPING
+    virtual OpMStruct1MarshaledResult opMStruct1(const Ice::Current&);
+
+    virtual OpMStruct2MarshaledResult opMStruct2(ICE_IN(Test::Structure), const Ice::Current&);
+
+    virtual OpMSeq1MarshaledResult opMSeq1(const Ice::Current&);
+
+    virtual OpMSeq2MarshaledResult opMSeq2(ICE_IN(Test::StringS), const Ice::Current&);
+
+    virtual OpMDict1MarshaledResult opMDict1(const Ice::Current&);
+
+    virtual OpMDict2MarshaledResult opMDict2(ICE_IN(Test::StringStringD), const Ice::Current&);
+#else
     virtual Test::Structure opMStruct1(const Ice::Current&);
 
     virtual Test::Structure opMStruct2(ICE_IN(Test::Structure), Test::Structure&, const Ice::Current&);
@@ -316,6 +329,7 @@ public:
     virtual Test::StringStringD opMDict1(const Ice::Current&);
 
     virtual Test::StringStringD opMDict2(ICE_IN(Test::StringStringD), Test::StringStringD&, const Ice::Current&);
+#endif
 
 private:
 
diff --git a/cpp/test/Ice/optional/TestAMDI.cpp b/cpp/test/Ice/optional/TestAMDI.cpp
index 94c5645d326..817afefb905 100644
--- a/cpp/test/Ice/optional/TestAMDI.cpp
+++ b/cpp/test/Ice/optional/TestAMDI.cpp
@@ -379,6 +379,75 @@ InitialI::opVoidAsync(::std::function<void()> response,
     response();
 }
 
+#ifdef ICE_CPP11_MAPPING
+void
+InitialI::opMStruct1Async(function<void(const OpMStruct1MarshaledResult&)> response,
+                          function<void(exception_ptr)>,
+                          const Ice::Current& current)
+{
+    response(OpMStruct1MarshaledResult(Test::SmallStruct(), current));
+}
+
+void
+InitialI::opMStruct2Async(Ice::optional<SmallStruct> p1,
+                         function<void(const OpMStruct2MarshaledResult&)> response,
+                         function<void(exception_ptr)>,
+                         const Ice::Current& current)
+{
+    response(OpMStruct2MarshaledResult(p1, p1, current));
+}
+
+void
+InitialI::opMSeq1Async(function<void(const OpMSeq1MarshaledResult&)> response,
+                       function<void(exception_ptr)>,
+                       const Ice::Current& current)
+{
+    response(OpMSeq1MarshaledResult(Test::StringSeq(), current));
+}
+
+void
+InitialI::opMSeq2Async(Ice::optional<Test::StringSeq> p1,
+                       function<void(const OpMSeq2MarshaledResult&)> response,
+                       function<void(exception_ptr)>,
+                       const Ice::Current& current)
+{
+    response(OpMSeq2MarshaledResult(p1, p1, current));
+}
+
+void
+InitialI::opMDict1Async(function<void(const OpMDict1MarshaledResult&)> response,
+                        function<void(exception_ptr)>,
+                        const Ice::Current& current)
+{
+    response(OpMDict1MarshaledResult(StringIntDict(), current));
+}
+
+void
+InitialI::opMDict2Async(Ice::optional<StringIntDict> p1,
+                        function<void(const OpMDict2MarshaledResult&)> response,
+                        function<void(exception_ptr)>,
+                        const Ice::Current& current)
+{
+    response(OpMDict2MarshaledResult(p1, p1, current));
+}
+
+void
+InitialI::opMG1Async(function<void(const OpMG1MarshaledResult&)> response,
+                     function<void(exception_ptr)>,
+                     const Ice::Current& current)
+{
+    response(OpMG1MarshaledResult(ICE_MAKE_SHARED(G), current));
+}
+
+void
+InitialI::opMG2Async(Ice::optional<GPtr> p1,
+                     function<void(const OpMG2MarshaledResult&)> response,
+                     function<void(exception_ptr)>,
+                     const Ice::Current& current)
+{
+    response(OpMG2MarshaledResult(p1, p1, current));
+}
+#else
 void
 InitialI::opMStruct1Async(function<void(const Ice::optional<SmallStruct>&)> response,
                           function<void(exception_ptr)>,
@@ -446,6 +515,7 @@ InitialI::opMG2Async(Ice::optional<GPtr> p1,
 {
     response(p1, p1);
 }
+#endif
 
 void
 InitialI::supportsRequiredParamsAsync(::std::function<void(bool)> response,
diff --git a/cpp/test/Ice/optional/TestAMDI.h b/cpp/test/Ice/optional/TestAMDI.h
index 278054f04f5..c38e7301662 100644
--- a/cpp/test/Ice/optional/TestAMDI.h
+++ b/cpp/test/Ice/optional/TestAMDI.h
@@ -202,6 +202,43 @@ public:
     virtual void opVoidAsync(::std::function<void()>,
                              ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
 
+#ifdef ICE_CPP11_MAPPING
+    virtual void opMStruct1Async(::std::function<void(const OpMStruct1MarshaledResult&)>,
+                                 ::std::function<void(::std::exception_ptr)>,
+                                 const Ice::Current&) override;
+
+    virtual void opMStruct2Async(Ice::optional<Test::SmallStruct>,
+                                 ::std::function<void(const OpMStruct2MarshaledResult&)>,
+                                 ::std::function<void(::std::exception_ptr)>,
+                                 const Ice::Current&) override;
+
+    virtual void opMSeq1Async(::std::function<void(const OpMSeq1MarshaledResult&)>,
+                              ::std::function<void(::std::exception_ptr)>,
+                              const Ice::Current&) override;
+
+    virtual void opMSeq2Async(Ice::optional<Test::StringSeq>,
+                              ::std::function<void(const OpMSeq2MarshaledResult&)>,
+                              ::std::function<void(::std::exception_ptr)>,
+                              const Ice::Current&) override;
+
+    virtual void opMDict1Async(::std::function<void(const OpMDict1MarshaledResult&)>,
+                               ::std::function<void(::std::exception_ptr)>,
+                               const Ice::Current&) override;
+
+    virtual void opMDict2Async(Ice::optional<Test::StringIntDict>,
+                               ::std::function<void(const OpMDict2MarshaledResult&)>,
+                               ::std::function<void(::std::exception_ptr)>,
+                               const Ice::Current&) override;
+
+    virtual void opMG1Async(::std::function<void(const OpMG1MarshaledResult&)>,
+                            ::std::function<void(::std::exception_ptr)>,
+                            const Ice::Current&) override;
+
+    virtual void opMG2Async(Ice::optional<Test::GPtr>,
+                            ::std::function<void(const OpMG2MarshaledResult&)>,
+                            ::std::function<void(::std::exception_ptr)>,
+                            const Ice::Current&) override;
+#else
     virtual void opMStruct1Async(::std::function<void(const Ice::optional<Test::SmallStruct>&)>,
                                  ::std::function<void(::std::exception_ptr)>,
                                  const Ice::Current&) override;
@@ -241,6 +278,7 @@ public:
                                                  const Ice::optional<Test::GPtr>&)>,
                             ::std::function<void(::std::exception_ptr)>,
                             const Ice::Current&) override;
+#endif
 
     virtual void supportsRequiredParamsAsync(::std::function<void(bool)>,
                                              ::std::function<void(::std::exception_ptr)>, const Ice::Current&) override;
diff --git a/cpp/test/Ice/optional/TestI.cpp b/cpp/test/Ice/optional/TestI.cpp
index 426082e1abe..1ebaf4afd93 100644
--- a/cpp/test/Ice/optional/TestI.cpp
+++ b/cpp/test/Ice/optional/TestI.cpp
@@ -427,6 +427,55 @@ InitialI::opVoid(const Ice::Current&)
 {
 }
 
+#ifdef ICE_CPP11_MAPPING
+InitialI::OpMStruct1MarshaledResult
+InitialI::opMStruct1(const Ice::Current& current)
+{
+    return OpMStruct1MarshaledResult(Test::SmallStruct(), current);
+}
+
+InitialI::OpMStruct2MarshaledResult
+InitialI::opMStruct2(ICE_IN(IceUtil::Optional<Test::SmallStruct>) p1, const Ice::Current& current)
+{
+    return OpMStruct2MarshaledResult(p1, p1, current);
+}
+
+InitialI::OpMSeq1MarshaledResult
+InitialI::opMSeq1(const Ice::Current& current)
+{
+    return OpMSeq1MarshaledResult(Test::StringSeq(), current);
+}
+
+InitialI::OpMSeq2MarshaledResult
+InitialI::opMSeq2(ICE_IN(IceUtil::Optional<Test::StringSeq>) p1, const Ice::Current& current)
+{
+    return OpMSeq2MarshaledResult(p1, p1, current);
+}
+
+InitialI::OpMDict1MarshaledResult
+InitialI::opMDict1(const Ice::Current& current)
+{
+    return OpMDict1MarshaledResult(Test::StringIntDict(), current);
+}
+
+InitialI::OpMDict2MarshaledResult
+InitialI::opMDict2(ICE_IN(IceUtil::Optional<Test::StringIntDict>) p1, const Ice::Current& current)
+{
+    return OpMDict2MarshaledResult(p1, p1, current);
+}
+
+InitialI::OpMG1MarshaledResult
+InitialI::opMG1(const Ice::Current& current)
+{
+    return OpMG1MarshaledResult(ICE_MAKE_SHARED(G), current);
+}
+
+InitialI::OpMG2MarshaledResult
+InitialI::opMG2(ICE_IN(IceUtil::Optional<Test::GPtr>) p1, const Ice::Current& current)
+{
+    return OpMG2MarshaledResult(p1, p1, current);
+}
+#else
 IceUtil::Optional<Test::SmallStruct>
 InitialI::opMStruct1(const Ice::Current&)
 {
@@ -486,6 +535,7 @@ InitialI::opMG2(ICE_IN(IceUtil::Optional<Test::GPtr>) p1,
     p2 = p1;
     return p1;
 }
+#endif
 
 bool
 InitialI::supportsRequiredParams(const Ice::Current&)
diff --git a/cpp/test/Ice/optional/TestI.h b/cpp/test/Ice/optional/TestI.h
index 461aace5eeb..edd141ce2f5 100644
--- a/cpp/test/Ice/optional/TestI.h
+++ b/cpp/test/Ice/optional/TestI.h
@@ -218,6 +218,23 @@ public:
 
     virtual void opVoid(const Ice::Current&);
 
+#ifdef ICE_CPP11_MAPPING
+    virtual OpMStruct1MarshaledResult opMStruct1(const Ice::Current&);
+
+    virtual OpMStruct2MarshaledResult opMStruct2(ICE_IN(IceUtil::Optional<Test::SmallStruct>), const Ice::Current&);
+
+    virtual OpMSeq1MarshaledResult opMSeq1(const Ice::Current&);
+
+    virtual OpMSeq2MarshaledResult opMSeq2(ICE_IN(IceUtil::Optional<Test::StringSeq>), const Ice::Current&);
+
+    virtual OpMDict1MarshaledResult opMDict1(const Ice::Current&);
+
+    virtual OpMDict2MarshaledResult opMDict2(ICE_IN(IceUtil::Optional<Test::StringIntDict>), const Ice::Current&);
+
+    virtual OpMG1MarshaledResult opMG1(const Ice::Current&);
+
+    virtual OpMG2MarshaledResult opMG2(ICE_IN(IceUtil::Optional<Test::GPtr>), const Ice::Current&);
+#else
     virtual IceUtil::Optional<Test::SmallStruct> opMStruct1(const Ice::Current&);
 
     virtual IceUtil::Optional<Test::SmallStruct> opMStruct2(ICE_IN(IceUtil::Optional<Test::SmallStruct>),
@@ -241,6 +258,7 @@ public:
     virtual IceUtil::Optional<Test::GPtr> opMG2(ICE_IN(IceUtil::Optional<Test::GPtr>),
                                                 IceUtil::Optional<Test::GPtr>&,
                                                 const Ice::Current&);
+#endif
 
     virtual bool supportsRequiredParams(const Ice::Current&);