Imrpoved support for using array mapping in async responses and Blobject.

24 files changed, 312 insertions, 124 deletions

diff --git a/cpp/include/Ice/IncomingAsync.h b/cpp/include/Ice/IncomingAsync.h
index b0a9097f42c..429d1eca97e 100644
--- a/cpp/include/Ice/IncomingAsync.h
+++ b/cpp/include/Ice/IncomingAsync.h
@@ -66,6 +66,16 @@ public:
     virtual void ice_exception() = 0;
 };
 
+class ICE_API AMD_Array_Object_ice_invoke : virtual public IceUtil::Shared
+{
+public:
+    
+    virtual void ice_response(bool, const std::pair<const Ice::Byte*, const Ice::Byte*>&) = 0;
+    virtual void ice_exception(const IceUtil::Exception&) = 0;
+    virtual void ice_exception(const std::exception&) = 0;
+    virtual void ice_exception() = 0;
+};
+
 }
 
 namespace IceAsync
@@ -86,6 +96,19 @@ public:
     virtual void ice_exception();
 };
 
+class ICE_API AMD_Array_Object_ice_invoke : public ::Ice::AMD_Array_Object_ice_invoke, 
+					    public IceInternal::IncomingAsync
+{
+public:
+    
+    AMD_Array_Object_ice_invoke(IceInternal::Incoming&);
+    
+    virtual void ice_response(bool, const std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&);
+    virtual void ice_exception(const IceUtil::Exception&);
+    virtual void ice_exception(const std::exception&);
+    virtual void ice_exception();
+};
+
 }
 
 }
diff --git a/cpp/include/Ice/IncomingAsyncF.h b/cpp/include/Ice/IncomingAsyncF.h
index db6b478ef4b..29389f1a0d8 100644
--- a/cpp/include/Ice/IncomingAsyncF.h
+++ b/cpp/include/Ice/IncomingAsyncF.h
@@ -26,6 +26,7 @@ namespace Ice
 {
 
 class AMD_Object_ice_invoke;
+class AMD_Array_Object_ice_invoke;
 
 }
 
@@ -34,6 +35,8 @@ namespace IceInternal
 
 ICE_API void incRef(::Ice::AMD_Object_ice_invoke*);
 ICE_API void decRef(::Ice::AMD_Object_ice_invoke*);
+ICE_API void incRef(::Ice::AMD_Array_Object_ice_invoke*);
+ICE_API void decRef(::Ice::AMD_Array_Object_ice_invoke*);
 
 }
 
@@ -41,6 +44,7 @@ namespace Ice
 {
 
 typedef IceInternal::Handle<AMD_Object_ice_invoke> AMD_Object_ice_invokePtr;
+typedef IceInternal::Handle<AMD_Array_Object_ice_invoke> AMD_Array_Object_ice_invokePtr;
 
 }
 
diff --git a/cpp/include/Ice/Object.h b/cpp/include/Ice/Object.h
index c991c896e23..cb9bd66fd23 100644
--- a/cpp/include/Ice/Object.h
+++ b/cpp/include/Ice/Object.h
@@ -116,22 +116,22 @@ public:
     virtual IceInternal::DispatchStatus __dispatch(IceInternal::Incoming&, const Current&);
 };
 
-class ICE_API BlobjectArrayAsync : virtual public Object
+class ICE_API BlobjectAsync : virtual public Object
 {
 public:
 
     // Returns true if ok, false if user exception.
-    virtual void ice_invoke_async(const AMD_Object_ice_invokePtr&, const std::pair<const Byte*, const Byte*>&,
-    				  const Current&) = 0;
+    virtual void ice_invoke_async(const AMD_Object_ice_invokePtr&, const std::vector<Byte>&, const Current&) = 0;
     virtual IceInternal::DispatchStatus __dispatch(IceInternal::Incoming&, const Current&);
 };
 
-class ICE_API BlobjectAsync : virtual public Object
+class ICE_API BlobjectArrayAsync : virtual public Object
 {
 public:
 
     // Returns true if ok, false if user exception.
-    virtual void ice_invoke_async(const AMD_Object_ice_invokePtr&, const std::vector<Byte>&, const Current&) = 0;
+    virtual void ice_invoke_async(const AMD_Array_Object_ice_invokePtr&, const std::pair<const Byte*, const Byte*>&,
+    				  const Current&) = 0;
     virtual IceInternal::DispatchStatus __dispatch(IceInternal::Incoming&, const Current&);
 };
 
diff --git a/cpp/include/Ice/OutgoingAsync.h b/cpp/include/Ice/OutgoingAsync.h
index ef12d8e1b52..6fa3e254be9 100644
--- a/cpp/include/Ice/OutgoingAsync.h
+++ b/cpp/include/Ice/OutgoingAsync.h
@@ -76,6 +76,21 @@ public:
     virtual void ice_exception(const Ice::Exception&) = 0;
 
     void __invoke(const Ice::ObjectPrx&, const std::string& operation, OperationMode,
+		  const std::vector<Ice::Byte>&, const Context&);
+
+protected:
+
+    virtual void __response(bool);
+};
+
+class ICE_API AMI_Array_Object_ice_invoke : public IceInternal::OutgoingAsync
+{
+public:
+
+    virtual void ice_response(bool, const std::pair<const Byte*, const Byte*>&) = 0;
+    virtual void ice_exception(const Ice::Exception&) = 0;
+
+    void __invoke(const Ice::ObjectPrx&, const std::string& operation, OperationMode,
 		  const std::pair<const Byte*, const Byte*>&, const Context&);
 
 protected:
diff --git a/cpp/include/Ice/OutgoingAsyncF.h b/cpp/include/Ice/OutgoingAsyncF.h
index 7bdebb65fad..1db83083202 100644
--- a/cpp/include/Ice/OutgoingAsyncF.h
+++ b/cpp/include/Ice/OutgoingAsyncF.h
@@ -26,6 +26,7 @@ namespace Ice
 {
 
 class AMI_Object_ice_invoke;
+class AMI_Array_Object_ice_invoke;
 
 }
 
@@ -34,6 +35,8 @@ namespace IceInternal
 
 ICE_API void incRef(::Ice::AMI_Object_ice_invoke*);
 ICE_API void decRef(::Ice::AMI_Object_ice_invoke*);
+ICE_API void incRef(::Ice::AMI_Array_Object_ice_invoke*);
+ICE_API void decRef(::Ice::AMI_Array_Object_ice_invoke*);
 
 }
 
@@ -41,6 +44,7 @@ namespace Ice
 {
 
 typedef IceInternal::Handle<AMI_Object_ice_invoke> AMI_Object_ice_invokePtr;
+typedef IceInternal::Handle<AMI_Array_Object_ice_invoke> AMI_Array_Object_ice_invokePtr;
 
 }
 
diff --git a/cpp/include/Ice/Proxy.h b/cpp/include/Ice/Proxy.h
index 2e93a2f764e..5babc03e9cf 100644
--- a/cpp/include/Ice/Proxy.h
+++ b/cpp/include/Ice/Proxy.h
@@ -111,9 +111,9 @@ public:
     			  const ::std::vector< ::Ice::Byte>&);
     void ice_invoke_async(const ::Ice::AMI_Object_ice_invokePtr&, const ::std::string&, ::Ice::OperationMode,
     			  const ::std::vector< ::Ice::Byte>&, const ::Ice::Context&);
-    void ice_invoke_async(const ::Ice::AMI_Object_ice_invokePtr&, const ::std::string&, ::Ice::OperationMode,
+    void ice_invoke_async(const ::Ice::AMI_Array_Object_ice_invokePtr&, const ::std::string&, ::Ice::OperationMode,
 			  const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&);
-    void ice_invoke_async(const ::Ice::AMI_Object_ice_invokePtr&, const ::std::string&, ::Ice::OperationMode, 
+    void ice_invoke_async(const ::Ice::AMI_Array_Object_ice_invokePtr&, const ::std::string&, ::Ice::OperationMode, 
 			  const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&, const ::Ice::Context&);
 
     ::Ice::Identity ice_getIdentity() const;
diff --git a/cpp/include/Slice/CPlusPlusUtil.h b/cpp/include/Slice/CPlusPlusUtil.h
index 36a0066bd29..279cdd3319b 100644
--- a/cpp/include/Slice/CPlusPlusUtil.h
+++ b/cpp/include/Slice/CPlusPlusUtil.h
@@ -29,7 +29,7 @@ SLICE_API void printDllExportStuff(::IceUtil::Output&, const std::string&);
 
 SLICE_API std::string typeToString(const TypePtr&, const StringList& = StringList(), bool = true);
 SLICE_API std::string returnTypeToString(const TypePtr&, const StringList& = StringList());
-SLICE_API std::string inputTypeToString(const TypePtr&, const StringList& = StringList());
+SLICE_API std::string inputTypeToString(const TypePtr&, const StringList& = StringList(), bool = true);
 SLICE_API std::string outputTypeToString(const TypePtr&, const StringList& = StringList());
 SLICE_API std::string operationModeToString(Operation::Mode);
 
diff --git a/cpp/src/Glacier2/Blobject.cpp b/cpp/src/Glacier2/Blobject.cpp
index 044ab52f9d5..3e7fa8ba5f1 100644
--- a/cpp/src/Glacier2/Blobject.cpp
+++ b/cpp/src/Glacier2/Blobject.cpp
@@ -101,7 +101,7 @@ Glacier2::Blobject::destroy()
 }
 
 void
-Glacier2::Blobject::invoke(ObjectPrx& proxy, const AMD_Object_ice_invokePtr& amdCB, 
+Glacier2::Blobject::invoke(ObjectPrx& proxy, const AMD_Array_Object_ice_invokePtr& amdCB, 
 			   const std::pair<const Ice::Byte*, const Ice::Byte*>& inParams, const Current& current)
 {
     //
@@ -300,7 +300,17 @@ Glacier2::Blobject::invoke(ObjectPrx& proxy, const AMD_Object_ice_invokePtr& amd
 		ok = proxy->ice_invoke(current.operation, current.mode, inParams, outParams);
 	    }
 
-	    amdCB->ice_response(ok, outParams);
+	    pair<const Byte*, const Byte*> outPair;
+	    if(outParams.size() == 0)
+	    {
+	        outPair.first = outPair.second = 0;
+	    }
+	    else
+	    {
+	        outPair.first = &outParams[0];
+		outPair.second = outPair.first + outParams.size();
+	    }
+	    amdCB->ice_response(ok, outPair);
 	}
 	catch(const LocalException& ex)
 	{
diff --git a/cpp/src/Glacier2/Blobject.h b/cpp/src/Glacier2/Blobject.h
index adf9cd086da..6031fc940f1 100644
--- a/cpp/src/Glacier2/Blobject.h
+++ b/cpp/src/Glacier2/Blobject.h
@@ -27,7 +27,7 @@ public:
 
 protected:
 
-    void invoke(Ice::ObjectPrx&, const Ice::AMD_Object_ice_invokePtr&, 
+    void invoke(Ice::ObjectPrx&, const Ice::AMD_Array_Object_ice_invokePtr&, 
     		const std::pair<const Ice::Byte*, const Ice::Byte*>&, const Ice::Current&);
 
     const Ice::CommunicatorPtr _communicator;
diff --git a/cpp/src/Glacier2/ClientBlobject.cpp b/cpp/src/Glacier2/ClientBlobject.cpp
index d02864882ac..62d0ad63b26 100644
--- a/cpp/src/Glacier2/ClientBlobject.cpp
+++ b/cpp/src/Glacier2/ClientBlobject.cpp
@@ -38,7 +38,7 @@ Glacier2::ClientBlobject::destroy()
 }
 
 void
-Glacier2::ClientBlobject::ice_invoke_async(const Ice::AMD_Object_ice_invokePtr& amdCB, 
+Glacier2::ClientBlobject::ice_invoke_async(const Ice::AMD_Array_Object_ice_invokePtr& amdCB, 
 					   const std::pair<const Byte*, const Byte*>& inParams,
 					   const Current& current)
 {
diff --git a/cpp/src/Glacier2/ClientBlobject.h b/cpp/src/Glacier2/ClientBlobject.h
index d4afcdc5f71..4d5ca99b69e 100644
--- a/cpp/src/Glacier2/ClientBlobject.h
+++ b/cpp/src/Glacier2/ClientBlobject.h
@@ -28,7 +28,7 @@ public:
 
     virtual void destroy();
 
-    virtual void ice_invoke_async(const Ice::AMD_Object_ice_invokePtr&,
+    virtual void ice_invoke_async(const Ice::AMD_Array_Object_ice_invokePtr&,
     				  const std::pair<const Ice::Byte*, const Ice::Byte*>&, const Ice::Current&);
 
 private:
diff --git a/cpp/src/Glacier2/RequestQueue.cpp b/cpp/src/Glacier2/RequestQueue.cpp
index 96ee3c3ac32..1b2cc9c005b 100644
--- a/cpp/src/Glacier2/RequestQueue.cpp
+++ b/cpp/src/Glacier2/RequestQueue.cpp
@@ -25,11 +25,11 @@ namespace Glacier2
 // responsible for sending back the response. It's necessary because
 // sending back the response might block.
 //
-class AMI_Object_ice_invokeI : public AMI_Object_ice_invoke
+class AMI_Array_Object_ice_invokeI : public AMI_Array_Object_ice_invoke
 {
 public:
 
-    AMI_Object_ice_invokeI(const RequestQueuePtr& requestQueue, const AMD_Object_ice_invokePtr& amdCB) :
+    AMI_Array_Object_ice_invokeI(const RequestQueuePtr& requestQueue, const AMD_Array_Object_ice_invokePtr& amdCB) :
 	_requestQueue(requestQueue),
 	_amdCB(amdCB)
     {
@@ -37,7 +37,7 @@ public:
     }
 
     virtual void
-    ice_response(bool ok, const std::vector<Byte>& outParams)
+    ice_response(bool ok, const pair<const Byte*, const Byte*>& outParams)
     {
 	_requestQueue->addResponse(new Response(_amdCB, ok, outParams));
     }
@@ -51,13 +51,13 @@ public:
 private:
 
     const RequestQueuePtr _requestQueue;
-    const AMD_Object_ice_invokePtr _amdCB;
+    const AMD_Array_Object_ice_invokePtr _amdCB;
 };
 
 }
 
 Glacier2::Request::Request(const ObjectPrx& proxy, const std::pair<const Byte*, const Byte*>& inParams,
-			   const Current& current, bool forwardContext, const AMD_Object_ice_invokePtr& amdCB) :
+			   const Current& current, bool forwardContext, const AMD_Array_Object_ice_invokePtr& amdCB) :
     _proxy(proxy),
     _inParams(inParams.first, inParams.second),
     _current(current),
@@ -71,7 +71,7 @@ Glacier2::Request::Request(const ObjectPrx& proxy, const std::pair<const Byte*,
     if(!_proxy->ice_isTwoway())
     {
 	bool ok = true;
-	ByteSeq outParams;
+	pair<const Byte*, const Byte*> outParams(0, 0);
 	_amdCB->ice_response(ok, outParams);
     }
 
@@ -86,16 +86,26 @@ Glacier2::Request::Request(const ObjectPrx& proxy, const std::pair<const Byte*,
 bool
 Glacier2::Request::invoke(const RequestQueuePtr& requestQueue)
 {
+    pair<const Byte*, const Byte*> inPair;
+    if(_inParams.size() == 0)
+    {
+        inPair.first = inPair.second = 0;
+    }
+    else
+    {
+        inPair.first = &_inParams[0];
+	inPair.second = inPair.first + _inParams.size();
+    }
     if(_proxy->ice_isTwoway())
     {
-	AMI_Object_ice_invokePtr cb = new AMI_Object_ice_invokeI(requestQueue, _amdCB);
+	AMI_Array_Object_ice_invokePtr cb = new AMI_Array_Object_ice_invokeI(requestQueue, _amdCB);
 	if(_forwardContext)
 	{
-	    _proxy->ice_invoke_async(cb, _current.operation, _current.mode, _inParams, _current.ctx);
+	    _proxy->ice_invoke_async(cb, _current.operation, _current.mode, inPair, _current.ctx);
 	}
 	else
 	{
-	    _proxy->ice_invoke_async(cb, _current.operation, _current.mode, _inParams);
+	    _proxy->ice_invoke_async(cb, _current.operation, _current.mode, inPair);
 	}
 	return true; // A twoway method is being dispatched.
     }
@@ -106,11 +116,11 @@ Glacier2::Request::invoke(const RequestQueuePtr& requestQueue)
 	    ByteSeq outParams;
 	    if(_forwardContext)
 	    {
-		_proxy->ice_invoke(_current.operation, _current.mode, _inParams, outParams, _current.ctx);
+		_proxy->ice_invoke(_current.operation, _current.mode, inPair, outParams, _current.ctx);
 	    }
 	    else
 	    {
-		_proxy->ice_invoke(_current.operation, _current.mode, _inParams, outParams);
+		_proxy->ice_invoke(_current.operation, _current.mode, inPair, outParams);
 	    }
 	}
 	catch(const LocalException&)
@@ -163,14 +173,15 @@ Glacier2::Request::getConnection() const
     return _proxy->ice_connection();
 }
 
-Glacier2::Response::Response(const AMD_Object_ice_invokePtr& amdCB, bool ok, const ByteSeq& outParams) : 
+Glacier2::Response::Response(const AMD_Array_Object_ice_invokePtr& amdCB, bool ok, 
+			     const pair<const Byte*, const Byte*>& outParams) : 
     _amdCB(amdCB),
     _ok(ok),
-    _outParams(outParams)
+    _outParams(outParams.first, outParams.second)
 {
 }
 
-Glacier2::Response::Response(const AMD_Object_ice_invokePtr& amdCB, const Exception& ex) : 
+Glacier2::Response::Response(const AMD_Array_Object_ice_invokePtr& amdCB, const Exception& ex) : 
     _amdCB(amdCB),
     _ok(false),
     _exception(ex.ice_clone())
@@ -186,7 +197,17 @@ Glacier2::Response::invoke()
     }
     else
     {
-	_amdCB->ice_response(_ok, _outParams);
+        pair<const Byte*, const Byte*> outPair;
+	if(_outParams.size() == 0)
+	{
+	    outPair.first = outPair.second = 0;
+	}
+	else
+	{
+	    outPair.first = &_outParams[0];
+	    outPair.second = outPair.first + _outParams.size();
+	}
+	_amdCB->ice_response(_ok, outPair);
     }
 }
 
diff --git a/cpp/src/Glacier2/RequestQueue.h b/cpp/src/Glacier2/RequestQueue.h
index 68e32ae95ec..2404ef61689 100644
--- a/cpp/src/Glacier2/RequestQueue.h
+++ b/cpp/src/Glacier2/RequestQueue.h
@@ -28,7 +28,7 @@ class Request : public IceUtil::Shared
 public:
 
     Request(const Ice::ObjectPrx&, const std::pair<const Ice::Byte*, const Ice::Byte*>&, const Ice::Current&, bool,
-	    const Ice::AMD_Object_ice_invokePtr&);
+	    const Ice::AMD_Array_Object_ice_invokePtr&);
     
     bool invoke(const RequestQueuePtr&);
     bool override(const RequestPtr&) const;
@@ -42,21 +42,21 @@ private:
     const Ice::Current _current;
     const bool _forwardContext;
     const std::string _override;
-    const Ice::AMD_Object_ice_invokePtr _amdCB;
+    const Ice::AMD_Array_Object_ice_invokePtr _amdCB;
 };
 
 class Response : public IceUtil::Shared
 {
 public:
 
-    Response(const Ice::AMD_Object_ice_invokePtr&, bool, const Ice::ByteSeq&);
-    Response(const Ice::AMD_Object_ice_invokePtr&, const Ice::Exception&);
+    Response(const Ice::AMD_Array_Object_ice_invokePtr&, bool, const std::pair<const Ice::Byte*, const Ice::Byte*>&);
+    Response(const Ice::AMD_Array_Object_ice_invokePtr&, const Ice::Exception&);
 
     void invoke();
     
 private:
 
-    const Ice::AMD_Object_ice_invokePtr _amdCB;
+    const Ice::AMD_Array_Object_ice_invokePtr _amdCB;
     const bool _ok;
     const Ice::ByteSeq _outParams;
     const std::auto_ptr<Ice::Exception> _exception;
diff --git a/cpp/src/Glacier2/ServerBlobject.cpp b/cpp/src/Glacier2/ServerBlobject.cpp
index 9a90f6822f5..9ab9dd0e61a 100644
--- a/cpp/src/Glacier2/ServerBlobject.cpp
+++ b/cpp/src/Glacier2/ServerBlobject.cpp
@@ -33,7 +33,7 @@ Glacier2::ServerBlobject::destroy()
 }
 
 void
-Glacier2::ServerBlobject::ice_invoke_async(const Ice::AMD_Object_ice_invokePtr& amdCB,
+Glacier2::ServerBlobject::ice_invoke_async(const Ice::AMD_Array_Object_ice_invokePtr& amdCB,
 					   const std::pair<const Byte*, const Byte*>& inParams,
 					   const Current& current)
 {
diff --git a/cpp/src/Glacier2/ServerBlobject.h b/cpp/src/Glacier2/ServerBlobject.h
index 3f8e175a4af..9f6fe6b656a 100644
--- a/cpp/src/Glacier2/ServerBlobject.h
+++ b/cpp/src/Glacier2/ServerBlobject.h
@@ -27,7 +27,7 @@ public:
 
     virtual void destroy();
 
-    virtual void ice_invoke_async(const Ice::AMD_Object_ice_invokePtr&,
+    virtual void ice_invoke_async(const Ice::AMD_Array_Object_ice_invokePtr&,
     				  const std::pair<const Ice::Byte*, const Ice::Byte*>&, const Ice::Current&);
 
 private:
diff --git a/cpp/src/Ice/IncomingAsync.cpp b/cpp/src/Ice/IncomingAsync.cpp
index 42d8cb9cf54..1874e71bd57 100644
--- a/cpp/src/Ice/IncomingAsync.cpp
+++ b/cpp/src/Ice/IncomingAsync.cpp
@@ -26,6 +26,9 @@ void IceInternal::decRef(IncomingAsync* p) { p->__decRef(); }
 void IceInternal::incRef(AMD_Object_ice_invoke* p) { p->__incRef(); }
 void IceInternal::decRef(AMD_Object_ice_invoke* p) { p->__decRef(); }
 
+void IceInternal::incRef(AMD_Array_Object_ice_invoke* p) { p->__incRef(); }
+void IceInternal::decRef(AMD_Array_Object_ice_invoke* p) { p->__decRef(); }
+
 IceInternal::IncomingAsync::IncomingAsync(Incoming& in) :
     IncomingBase(in),
     _instanceCopy(_os.instance()),
@@ -428,3 +431,41 @@ IceAsync::Ice::AMD_Object_ice_invoke::ice_exception()
 {
     __exception();
 }
+
+IceAsync::Ice::AMD_Array_Object_ice_invoke::AMD_Array_Object_ice_invoke(Incoming& in) :
+    IncomingAsync(in)
+{
+}
+
+void
+IceAsync::Ice::AMD_Array_Object_ice_invoke::ice_response(bool ok, const pair<const Byte*, const Byte*>& outParams)
+{
+    try
+    {
+	__os()->writeBlob(outParams.first, static_cast<Int>(outParams.second - outParams.first));
+    }
+    catch(const LocalException& ex)
+    {
+	__exception(ex);
+	return;
+    }
+    __response(ok);
+}
+
+void
+IceAsync::Ice::AMD_Array_Object_ice_invoke::ice_exception(const Exception& ex)
+{
+    __exception(ex);
+}
+
+void
+IceAsync::Ice::AMD_Array_Object_ice_invoke::ice_exception(const std::exception& ex)
+{
+    __exception(ex);
+}
+
+void
+IceAsync::Ice::AMD_Array_Object_ice_invoke::ice_exception()
+{
+    __exception();
+}
diff --git a/cpp/src/Ice/Object.cpp b/cpp/src/Ice/Object.cpp
index 0b5ce8a9ff2..29b178d352d 100644
--- a/cpp/src/Ice/Object.cpp
+++ b/cpp/src/Ice/Object.cpp
@@ -351,7 +351,7 @@ Ice::BlobjectArrayAsync::__dispatch(Incoming& in, const Current& current)
     Int sz = in.is()->getReadEncapsSize();
     in.is()->readBlob(inParams.first, sz);
     inParams.second = inParams.first + sz;
-    AMD_Object_ice_invokePtr cb = new ::IceAsync::Ice::AMD_Object_ice_invoke(in);
+    AMD_Array_Object_ice_invokePtr cb = new ::IceAsync::Ice::AMD_Array_Object_ice_invoke(in);
     try
     {
 	ice_invoke_async(cb, inParams, current);
diff --git a/cpp/src/Ice/OutgoingAsync.cpp b/cpp/src/Ice/OutgoingAsync.cpp
index 784cc6ca356..024c1f13764 100644
--- a/cpp/src/Ice/OutgoingAsync.cpp
+++ b/cpp/src/Ice/OutgoingAsync.cpp
@@ -31,6 +31,9 @@ void IceInternal::decRef(OutgoingAsync* p) { p->__decRef(); }
 void IceInternal::incRef(AMI_Object_ice_invoke* p) { p->__incRef(); }
 void IceInternal::decRef(AMI_Object_ice_invoke* p) { p->__decRef(); }
 
+void IceInternal::incRef(AMI_Array_Object_ice_invoke* p) { p->__incRef(); }
+void IceInternal::decRef(AMI_Array_Object_ice_invoke* p) { p->__decRef(); }
+
 IceInternal::OutgoingAsync::OutgoingAsync() :
     __is(0),
     __os(0)
@@ -417,12 +420,12 @@ IceInternal::OutgoingAsync::cleanup()
 
 void
 Ice::AMI_Object_ice_invoke::__invoke(const ObjectPrx& prx, const string& operation, OperationMode mode,
-				     const pair<const Byte*, const Byte*>& inParams, const Context& context)
+				     const vector<Byte>& inParams, const Context& context)
 {
     try
     {
 	__prepare(prx, operation, mode, context);
-	__os->writeBlob(inParams.first, static_cast<Int>(inParams.second - inParams.first));
+	__os->writeBlob(inParams);
 	__os->endWriteEncaps();
     }
     catch(const LocalException& ex)
@@ -449,3 +452,39 @@ Ice::AMI_Object_ice_invoke::__response(bool ok) // ok == true means no user exce
     }
     ice_response(ok, outParams);
 }
+
+void
+Ice::AMI_Array_Object_ice_invoke::__invoke(const ObjectPrx& prx, const string& operation, OperationMode mode,
+				           const pair<const Byte*, const Byte*>& inParams, const Context& context)
+{
+    try
+    {
+	__prepare(prx, operation, mode, context);
+	__os->writeBlob(inParams.first, static_cast<Int>(inParams.second - inParams.first));
+	__os->endWriteEncaps();
+    }
+    catch(const LocalException& ex)
+    {
+	__finished(ex);
+	return;
+    }
+    __send();
+}
+
+void
+Ice::AMI_Array_Object_ice_invoke::__response(bool ok) // ok == true means no user exception.
+{
+    pair<const Byte*, const Byte*> outParams;
+    try
+    {
+	Int sz = __is->getReadEncapsSize();
+	__is->readBlob(outParams.first, sz);
+	outParams.second = outParams.first + sz;
+    }
+    catch(const LocalException& ex)
+    {
+	__finished(ex);
+	return;
+    }
+    ice_response(ok, outParams);
+}
diff --git a/cpp/src/Ice/Proxy.cpp b/cpp/src/Ice/Proxy.cpp
index 37951c6a898..571058bc2dc 100644
--- a/cpp/src/Ice/Proxy.cpp
+++ b/cpp/src/Ice/Proxy.cpp
@@ -349,21 +349,11 @@ IceProxy::Ice::Object::ice_invoke_async(const AMI_Object_ice_invokePtr& cb,
 					const vector<Byte>& inParams,
 					const Context& context)
 {
-    pair<const Byte*, const Byte*> inPair;
-    if(inParams.size() == 0)
-    {
-        inPair.first = inPair.second = 0;
-    }
-    else
-    {
-        inPair.first = &inParams[0];
-	inPair.second = inPair.first + inParams.size();
-    }
-    ice_invoke_async(cb, operation, mode, inPair, context);
+    cb->__invoke(this, operation, mode, inParams, context);
 }
 
 void
-IceProxy::Ice::Object::ice_invoke_async(const AMI_Object_ice_invokePtr& cb,
+IceProxy::Ice::Object::ice_invoke_async(const AMI_Array_Object_ice_invokePtr& cb,
 					const string& operation,
 					OperationMode mode,
 					const pair<const Byte*, const Byte*>& inParams)
@@ -372,7 +362,7 @@ IceProxy::Ice::Object::ice_invoke_async(const AMI_Object_ice_invokePtr& cb,
 }
 
 void
-IceProxy::Ice::Object::ice_invoke_async(const AMI_Object_ice_invokePtr& cb,
+IceProxy::Ice::Object::ice_invoke_async(const AMI_Array_Object_ice_invokePtr& cb,
 					const string& operation,
 					OperationMode mode,
 					const pair<const Byte*, const Byte*>& inParams,
diff --git a/cpp/src/Slice/CPlusPlusUtil.cpp b/cpp/src/Slice/CPlusPlusUtil.cpp
index 66cead140c3..d3f368c6817 100644
--- a/cpp/src/Slice/CPlusPlusUtil.cpp
+++ b/cpp/src/Slice/CPlusPlusUtil.cpp
@@ -236,7 +236,7 @@ Slice::returnTypeToString(const TypePtr& type, const StringList& metaData)
 }
 
 string
-Slice::inputTypeToString(const TypePtr& type, const StringList& metaData)
+Slice::inputTypeToString(const TypePtr& type, const StringList& metaData, bool allowArray)
 {
     static const char* inputBuiltinTable[] =
     {
@@ -283,28 +283,43 @@ Slice::inputTypeToString(const TypePtr& type, const StringList& metaData)
         string seqType = findMetaData(metaData, true);
         if(!seqType.empty())
         {
+	    
             if(seqType == "array" || seqType == "range:array")
             {
-                TypePtr elemType = seq->type();
-                string s = typeToString(elemType);
-                return "const ::std::pair<const " + s + "*, const " + s + "*>&";
+	        if(allowArray)
+		{
+                    TypePtr elemType = seq->type();
+                    string s = typeToString(elemType);
+                    return "const ::std::pair<const " + s + "*, const " + s + "*>&";
+		}
+		else
+		{
+            	    return "const " + fixKwd(seq->scoped()) + "&";
+		}
             }
 	    else if(seqType.find("range") == 0)
 	    {
-	        string s;
-	        if(seqType.find("range:") == 0)
+	        if(allowArray)
 		{
-		    s = seqType.substr(strlen("range:"));
+	            string s;
+	            if(seqType.find("range:") == 0)
+		    {
+		        s = seqType.substr(strlen("range:"));
+		    }
+		    else
+		    {
+	                s = fixKwd(seq->scoped());
+		    }
+		    if(s[0] == ':')
+		    {
+		        s = " " + s;
+		    }
+		    return "const ::std::pair<" + s + "::const_iterator, " + s + "::const_iterator>&";
 		}
 		else
 		{
-	            s = fixKwd(seq->scoped());
-		}
-		if(s[0] == ':')
-		{
-		    s = " " + s;
+		    return "const " + fixKwd(seq->scoped()) + "&";
 		}
-		return "const ::std::pair<" + s + "::const_iterator, " + s + "::const_iterator>&";
 	    }
             else
             {
diff --git a/cpp/src/slice2cpp/Gen.cpp b/cpp/src/slice2cpp/Gen.cpp
index d4a7f5394e7..2b7ea158304 100644
--- a/cpp/src/slice2cpp/Gen.cpp
+++ b/cpp/src/slice2cpp/Gen.cpp
@@ -4327,6 +4327,7 @@ Slice::Gen::AsyncVisitor::visitOperation(const OperationPtr& p)
     string proxyName = classScope + className + "Prx";
     
     vector<string> params;
+    vector<string> paramsAMD;
     vector<string> paramsDecl;
     vector<string> args;
     
@@ -4342,6 +4343,7 @@ Slice::Gen::AsyncVisitor::visitOperation(const OperationPtr& p)
     if(ret)
     {
 	params.push_back(retS);
+	paramsAMD.push_back(inputTypeToString(ret, p->getMetaData(), false));
 	paramsDecl.push_back(retS + " __ret");
 	args.push_back("__ret");
     }
@@ -4358,6 +4360,7 @@ Slice::Gen::AsyncVisitor::visitOperation(const OperationPtr& p)
 	if((*q)->isOutParam())
 	{
 	    params.push_back(typeString);
+	    paramsAMD.push_back(inputTypeToString(type, (*q)->getMetaData(), false));
 	    paramsDecl.push_back(typeString + ' ' + paramName);
 	    args.push_back(paramName);
 
@@ -4425,7 +4428,7 @@ Slice::Gen::AsyncVisitor::visitOperation(const OperationPtr& p)
 
 	C << sp << nl << "void" << nl << classScopedAMI.substr(2) << '_' << name << "::__response(bool __ok)";
 	C << sb;
-	writeAllocateCode(C, outParams, ret, p->getMetaData());
+	writeAllocateCode(C, outParams, ret, p->getMetaData(), true);
 	C << nl << "try";
 	C << sb;
 	C << nl << "if(!__ok)";
@@ -4461,7 +4464,11 @@ Slice::Gen::AsyncVisitor::visitOperation(const OperationPtr& p)
 	C << eb;
 	C << eb;
 
-	writeUnmarshalCode(C, outParams, ret, p->getMetaData());
+	writeUnmarshalCode(C, outParams, 0, StringList(), true);
+	if(ret)
+	{
+	    writeMarshalUnmarshalCode(C, ret, "__ret", false, "", true, p->getMetaData(), true);
+	}
 	if(p->returnsClasses())
 	{
 	    C << nl << "__is->readPendingObjects();";
@@ -4485,7 +4492,7 @@ Slice::Gen::AsyncVisitor::visitOperation(const OperationPtr& p)
 	H << nl << "public:";
 	H.inc();
 	H << sp;
-	H << nl << "virtual void ice_response" << spar << params << epar << " = 0;";
+	H << nl << "virtual void ice_response" << spar << paramsAMD << epar << " = 0;";
 	H << nl << "virtual void ice_exception(const ::Ice::Exception&) = 0;";
 	H << nl << "virtual void ice_exception(const ::std::exception&) = 0;";
 	H << nl << "virtual void ice_exception() = 0;";
@@ -4578,7 +4585,7 @@ Slice::Gen::AsyncImplVisitor::visitOperation(const OperationPtr& p)
 #endif
 
     TypePtr ret = p->returnType();
-    string retS = inputTypeToString(ret, p->getMetaData());
+    string retS = inputTypeToString(ret, p->getMetaData(), false);
     
     if(ret)
     {
@@ -4597,7 +4604,7 @@ Slice::Gen::AsyncImplVisitor::visitOperation(const OperationPtr& p)
 	{
 	    string paramName = fixKwd((*q)->name());
 	    TypePtr type = (*q)->type();
-	    string typeString = inputTypeToString(type, (*q)->getMetaData());
+	    string typeString = inputTypeToString(type, (*q)->getMetaData(), false);
 	    
 	    if(ret || !outParams.empty())
 	    {
@@ -4800,6 +4807,12 @@ Slice::Gen::MetaDataVisitor::visitStructEnd(const StructPtr&)
 void
 Slice::Gen::MetaDataVisitor::visitOperation(const OperationPtr& p)
 {
+    bool ami = false;
+    ClassDefPtr cl = ClassDefPtr::dynamicCast(p->container());
+    if(cl->hasMetaData("ami") || p->hasMetaData("ami"))
+    {
+        ami = true;
+    }
     StringList metaData = p->getMetaData();
     TypePtr returnType = p->returnType();
     if(!metaData.empty())
@@ -4818,7 +4831,7 @@ Slice::Gen::MetaDataVisitor::visitOperation(const OperationPtr& p)
         }
         else
         {
-            validate(returnType, metaData, p->definitionContext()->filename(), p->line(), false);
+            validate(returnType, metaData, p->definitionContext()->filename(), p->line(), ami);
         }
     }
 
@@ -4826,7 +4839,7 @@ Slice::Gen::MetaDataVisitor::visitOperation(const OperationPtr& p)
     for(ParamDeclList::iterator q = params.begin(); q != params.end(); ++q)
     {
         validate((*q)->type(), (*q)->getMetaData(), p->definitionContext()->filename(), (*q)->line(),
-                 !(*q)->isOutParam());
+                 ami || !(*q)->isOutParam());
     }
 }
 
diff --git a/cpp/test/Ice/custom/AllTests.cpp b/cpp/test/Ice/custom/AllTests.cpp
index 7d34d2d7afa..22232ab460c 100644
--- a/cpp/test/Ice/custom/AllTests.cpp
+++ b/cpp/test/Ice/custom/AllTests.cpp
@@ -8,6 +8,7 @@
 // **********************************************************************
 
 #include <Ice/Ice.h>
+#include <IceUtil/Iterator.h>
 #include <TestCommon.h>
 #include <Test.h>
 
@@ -64,7 +65,7 @@ public:
     {
     }
 
-    virtual void ice_response(const Test::BoolSeq& out, const Test::BoolSeq& ret)
+    virtual void ice_response(const Test::BoolSeq& ret, const Test::BoolSeq& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -87,15 +88,24 @@ class AMI_TestIntf_opByteArrayI : public Test::AMI_TestIntf_opByteArray, public
 {
 public:
 
-    AMI_TestIntf_opByteArrayI(Test::ByteList in)
+    AMI_TestIntf_opByteArrayI(const pair<const Ice::Byte*, const Ice::Byte*>& in)
         : _in(in)
     {
     }
 
-    virtual void ice_response(const Test::ByteList& out, const Test::ByteList& ret)
+    virtual void ice_response(const pair<const Ice::Byte*, const Ice::Byte*>& ret,
+    			      const pair<const Ice::Byte*, const Ice::Byte*>& out)
     {
-        test(out == _in);
-	test(ret == _in);
+        test(_in.second - _in.first == out.second - out.first);
+        test(_in.second - _in.first == ret.second - ret.first);
+    	Ice::Byte* b = const_cast<Ice::Byte*>(_in.first);
+    	Ice::Byte* r = const_cast<Ice::Byte*>(ret.first);
+    	Ice::Byte* o = const_cast<Ice::Byte*>(out.first);
+	while(b != _in.second)
+	{
+	    test(*r++ == *b);
+	    test(*o++ == *b++);
+	}
         called();
     }
 
@@ -106,7 +116,7 @@ public:
 
 private:
 
-    Test::ByteList _in;
+    pair<const Ice::Byte*, const Ice::Byte*> _in;
 };
 
 typedef IceUtil::Handle<AMI_TestIntf_opByteArrayI> AMI_TestIntf_opByteArrayIPtr;
@@ -120,7 +130,7 @@ public:
     {
     }
 
-    virtual void ice_response(const Test::VariableList& out, const Test::VariableList& ret)
+    virtual void ice_response(const Test::VariableList& ret, const Test::VariableList& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -148,7 +158,7 @@ public:
     {
     }
 
-    virtual void ice_response(const Test::BoolSeq& out, const Test::BoolSeq& ret)
+    virtual void ice_response(const Test::BoolSeq& ret, const Test::BoolSeq& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -176,10 +186,19 @@ public:
     {
     }
 
-    virtual void ice_response(const Test::ByteList& out, const Test::ByteList& ret)
+    virtual void ice_response(const pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator>& ret,
+    			      const pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator>& out)
     {
-        test(out == _in);
-	test(ret == _in);
+        test(ice_distance(out.first, out.second) == static_cast<Ice::Int>(_in.size()));
+        test(ice_distance(ret.first, ret.second) == static_cast<Ice::Int>(_in.size()));
+	Test::ByteList::const_iterator b;
+	Test::ByteList::const_iterator o = out.first;
+	Test::ByteList::const_iterator r = ret.first;
+	for(b = _in.begin(); b != _in.end(); ++b)
+	{
+	    test(*b == *o++);
+	    test(*b == *r++);
+	}
         called();
     }
 
@@ -204,7 +223,7 @@ public:
     {
     }
 
-    virtual void ice_response(const Test::VariableList& out, const Test::VariableList& ret)
+    virtual void ice_response(const Test::VariableList& ret, const Test::VariableList& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -232,7 +251,7 @@ public:
     {
     }
 
-    virtual void ice_response(const Test::BoolSeq& out, const Test::BoolSeq& ret)
+    virtual void ice_response(const Test::BoolSeq& ret, const Test::BoolSeq& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -260,7 +279,7 @@ public:
     {
     }
 
-    virtual void ice_response(const Test::ByteList& out, const Test::ByteList& ret)
+    virtual void ice_response(const Test::ByteList& ret, const Test::ByteList& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -288,7 +307,7 @@ public:
     {
     }
 
-    virtual void ice_response(const Test::VariableList& out, const Test::VariableList& ret)
+    virtual void ice_response(const Test::VariableList& ret, const Test::VariableList& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -316,7 +335,7 @@ public:
     {
     }
 
-    virtual void ice_response(const deque<bool>& out, const deque<bool>& ret)
+    virtual void ice_response(const deque<bool>& ret, const deque<bool>& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -344,7 +363,7 @@ public:
     {
     }
 
-    virtual void ice_response(const list<bool>& out, const list<bool>& ret)
+    virtual void ice_response(const list<bool>& ret, const list<bool>& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -372,7 +391,7 @@ public:
     {
     }
 
-    virtual void ice_response(const deque<Ice::Byte>& out, const deque<Ice::Byte>& ret)
+    virtual void ice_response(const deque<Ice::Byte>& ret, const deque<Ice::Byte>& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -400,7 +419,7 @@ public:
     {
     }
 
-    virtual void ice_response(const list<Ice::Byte>& out, const list<Ice::Byte>& ret)
+    virtual void ice_response(const list<Ice::Byte>& ret, const list<Ice::Byte>& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -428,7 +447,7 @@ public:
     {
     }
 
-    virtual void ice_response(const MyByteSeq& out, const MyByteSeq& ret)
+    virtual void ice_response(const MyByteSeq& ret, const MyByteSeq& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -456,7 +475,7 @@ public:
     {
     }
 
-    virtual void ice_response(const deque<string>& out, const deque<string>& ret)
+    virtual void ice_response(const deque<string>& ret, const deque<string>& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -484,7 +503,7 @@ public:
     {
     }
 
-    virtual void ice_response(const list<string>& out, const list<string>& ret)
+    virtual void ice_response(const list<string>& ret, const list<string>& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -512,7 +531,7 @@ public:
     {
     }
 
-    virtual void ice_response(const deque<Test::Fixed>& out, const deque<Test::Fixed>& ret)
+    virtual void ice_response(const deque<Test::Fixed>& ret, const deque<Test::Fixed>& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -540,7 +559,7 @@ public:
     {
     }
 
-    virtual void ice_response(const list<Test::Fixed>& out, const list<Test::Fixed>& ret)
+    virtual void ice_response(const list<Test::Fixed>& ret, const list<Test::Fixed>& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -568,7 +587,7 @@ public:
     {
     }
 
-    virtual void ice_response(const deque<Test::Variable>& out, const deque<Test::Variable>& ret)
+    virtual void ice_response(const deque<Test::Variable>& ret, const deque<Test::Variable>& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -596,7 +615,7 @@ public:
     {
     }
 
-    virtual void ice_response(const list<Test::Variable>& out, const list<Test::Variable>& ret)
+    virtual void ice_response(const list<Test::Variable>& ret, const list<Test::Variable>& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -624,7 +643,7 @@ public:
     {
     }
 
-    virtual void ice_response(const deque<Test::StringStringDict>& out, const deque<Test::StringStringDict>& ret)
+    virtual void ice_response(const deque<Test::StringStringDict>& ret, const deque<Test::StringStringDict>& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -652,7 +671,7 @@ public:
     {
     }
 
-    virtual void ice_response(const list<Test::StringStringDict>& out, const list<Test::StringStringDict>& ret)
+    virtual void ice_response(const list<Test::StringStringDict>& ret, const list<Test::StringStringDict>& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -680,7 +699,7 @@ public:
     {
     }
 
-    virtual void ice_response(const deque<Test::E>& out, const deque<Test::E>& ret)
+    virtual void ice_response(const deque<Test::E>& ret, const deque<Test::E>& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -708,7 +727,7 @@ public:
     {
     }
 
-    virtual void ice_response(const list<Test::E>& out, const list<Test::E>& ret)
+    virtual void ice_response(const list<Test::E>& ret, const list<Test::E>& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -736,7 +755,7 @@ public:
     {
     }
 
-    virtual void ice_response(const deque<Test::CPrx>& out, const deque<Test::CPrx>& ret)
+    virtual void ice_response(const deque<Test::CPrx>& ret, const deque<Test::CPrx>& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -764,7 +783,7 @@ public:
     {
     }
 
-    virtual void ice_response(const list<Test::CPrx>& out, const list<Test::CPrx>& ret)
+    virtual void ice_response(const list<Test::CPrx>& ret, const list<Test::CPrx>& out)
     {
         test(out == _in);
 	test(ret == _in);
@@ -792,7 +811,7 @@ public:
     {
     }
 
-    virtual void ice_response(const deque<Test::CPtr>& out, const deque<Test::CPtr>& ret)
+    virtual void ice_response(const deque<Test::CPtr>& ret, const deque<Test::CPtr>& out)
     {
 	test(out.size() == _in.size());
 	test(ret.size() == _in.size());
@@ -825,7 +844,7 @@ public:
     {
     }
 
-    virtual void ice_response(const list<Test::CPtr>& out, const list<Test::CPtr>& ret)
+    virtual void ice_response(const list<Test::CPtr>& ret, const list<Test::CPtr>& out)
     {
 	test(out.size() == _in.size());
 	test(ret.size() == _in.size());
@@ -1379,21 +1398,15 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
         }
 
         {
-            Test::ByteList in;
-	    Ice::Byte inArray[5];
-	    inArray[0] = '1';
-	    in.push_back(inArray[0]);
-	    inArray[1] = '2';
-	    in.push_back(inArray[1]);
-	    inArray[2] = '3';
-	    in.push_back(inArray[2]);
-	    inArray[3] = '4';
-	    in.push_back(inArray[3]);
-	    inArray[4] = '5';
-	    in.push_back(inArray[4]);
-	    pair<const Ice::Byte*, const Ice::Byte*> inPair(inArray, inArray + 5);
+	    Ice::Byte in[5];
+	    in[0] = '1';
+	    in[1] = '2';
+	    in[2] = '3';
+	    in[3] = '4';
+	    in[4] = '5';
+	    pair<const Ice::Byte*, const Ice::Byte*> inPair(in, in + 5);
 
-	    AMI_TestIntf_opByteArrayIPtr cb = new AMI_TestIntf_opByteArrayI(in);
+	    AMI_TestIntf_opByteArrayIPtr cb = new AMI_TestIntf_opByteArrayI(inPair);
 	    t->opByteArray_async(cb, inPair);
 	    test(cb->check());
         }
diff --git a/cpp/test/Ice/custom/Test.ice b/cpp/test/Ice/custom/Test.ice
index 4cef600cfce..3fc5a736741 100644
--- a/cpp/test/Ice/custom/Test.ice
+++ b/cpp/test/Ice/custom/Test.ice
@@ -101,13 +101,13 @@ sequence<double> DoubleSeq;
 
     BoolSeq opBoolArray(["cpp:array"] BoolSeq inSeq, out BoolSeq outSeq);
 
-    ByteList opByteArray(["cpp:array"] ByteList inSeq, out ByteList outSeq);
+    ["cpp:array"] ByteList opByteArray(["cpp:array"] ByteList inSeq, out ["cpp:array"] ByteList outSeq);
 
     VariableList opVariableArray(["cpp:array"] VariableList inSeq, out VariableList outSeq);
 
     BoolSeq opBoolRange(["cpp:range"] BoolSeq inSeq, out BoolSeq outSeq);
 
-    ByteList opByteRange(["cpp:range"] ByteList inSeq, out ByteList outSeq);
+    ["cpp:range"] ByteList opByteRange(["cpp:range"] ByteList inSeq, out ["cpp:range"] ByteList outSeq);
 
     VariableList opVariableRange(["cpp:range"] VariableList inSeq, out VariableList outSeq);
 
@@ -167,7 +167,7 @@ sequence<double> DoubleSeq;
 
     CPrxList opCPrxList(CPrxList inSeq, out CPrxList outSeq);
 
-    ["cpp:type:std::deque< ::Test::CPtr>"] CSeq 
+    ["cpp:type:std::deque< ::Test::CPtr>"] CSeq
     opCSeq(["cpp:type:std::deque< ::Test::CPtr>"] CSeq inSeq, out ["cpp:type:std::deque< ::Test::CPtr>"] CSeq outSeq);
 
     CList opCList(CList inSeq, out CList outSeq);
diff --git a/cpp/test/Ice/custom/TestAMD.ice b/cpp/test/Ice/custom/TestAMD.ice
index 66a1396f6f5..390fb16ecf2 100644
--- a/cpp/test/Ice/custom/TestAMD.ice
+++ b/cpp/test/Ice/custom/TestAMD.ice
@@ -101,13 +101,13 @@ sequence<double> DoubleSeq;
 
     BoolSeq opBoolArray(["cpp:array"] BoolSeq inSeq, out BoolSeq outSeq);
 
-    ByteList opByteArray(["cpp:array"] ByteList inSeq, out ByteList outSeq);
+    ["cpp:array"] ByteList opByteArray(["cpp:array"] ByteList inSeq, out ["cpp:array"] ByteList outSeq);
 
     VariableList opVariableArray(["cpp:array"] VariableList inSeq, out VariableList outSeq);
 
     BoolSeq opBoolRange(["cpp:range"] BoolSeq inSeq, out BoolSeq outSeq);
 
-    ByteList opByteRange(["cpp:range"] ByteList inSeq, out ByteList outSeq);
+    ["cpp:range"] ByteList opByteRange(["cpp:range"] ByteList inSeq, out ["cpp:range"] ByteList outSeq);
 
     VariableList opVariableRange(["cpp:range"] VariableList inSeq, out VariableList outSeq);