More fixes for ICE-4841 - changed createInputStream with bool parameter to wrapInputStream

13 files changed, 62 insertions, 61 deletions

diff --git a/CHANGES b/CHANGES
index 723e89887da..39d340d7d0f 100644
--- a/CHANGES
+++ b/CHANGES
@@ -27,6 +27,12 @@ Changes since version 3.5b
 General Changes
 ===============
 
+- Added support for wrapInputStream function. Unlike the
+  createInputStream function, the returned input stream wraps the
+  provided encoded data rather than copying it. While it avoids
+  copying the data, care must be taken to not modify the data while
+  the input stream is being used.
+
 - The IceBox server no longer configures a service's logger if the
   service defines Ice.LogFile or Ice.UseSyslog.
 
diff --git a/cpp/include/Ice/Initialize.h b/cpp/include/Ice/Initialize.h
index 753ac5dddb2..49644abb20f 100644
--- a/cpp/include/Ice/Initialize.h
+++ b/cpp/include/Ice/Initialize.h
@@ -108,19 +108,18 @@ ICE_API CommunicatorPtr initialize(const InitializationData& = InitializationDat
 ICE_API InputStreamPtr createInputStream(const CommunicatorPtr&, const ::std::vector< Byte >&);
 ICE_API InputStreamPtr createInputStream(const CommunicatorPtr&, const ::std::vector< Byte >&,
                                          const EncodingVersion&);
-ICE_API InputStreamPtr createInputStream(const CommunicatorPtr&, const ::std::vector< Byte >&, bool);
-ICE_API InputStreamPtr createInputStream(const CommunicatorPtr&, const ::std::vector< Byte >&,
-                                         const EncodingVersion&, bool);
+ICE_API InputStreamPtr wrapInputStream(const CommunicatorPtr&, const ::std::vector< Byte >&);
+ICE_API InputStreamPtr wrapInputStream(const CommunicatorPtr&, const ::std::vector< Byte >&, const EncodingVersion&);
 ICE_API InputStreamPtr createInputStream(const CommunicatorPtr&,
                                          const ::std::pair< const Ice::Byte*, const Ice::Byte*>&);
 ICE_API InputStreamPtr createInputStream(const CommunicatorPtr&,
                                          const ::std::pair< const Ice::Byte*, const Ice::Byte*>&,
                                          const EncodingVersion&);
-ICE_API InputStreamPtr createInputStream(const CommunicatorPtr&,
-                                         const ::std::pair< const Ice::Byte*, const Ice::Byte*>&, bool);
-ICE_API InputStreamPtr createInputStream(const CommunicatorPtr&,
-                                         const ::std::pair< const Ice::Byte*, const Ice::Byte*>&,
-                                         const EncodingVersion&, bool);
+ICE_API InputStreamPtr wrapInputStream(const CommunicatorPtr&,
+                                       const ::std::pair< const Ice::Byte*, const Ice::Byte*>&);
+ICE_API InputStreamPtr wrapInputStream(const CommunicatorPtr&,
+                                       const ::std::pair< const Ice::Byte*, const Ice::Byte*>&, 
+                                       const EncodingVersion&);
 
 ICE_API OutputStreamPtr createOutputStream(const CommunicatorPtr&);
 ICE_API OutputStreamPtr createOutputStream(const CommunicatorPtr&, const EncodingVersion&);
diff --git a/cpp/src/FreezeScript/DumpDescriptors.cpp b/cpp/src/FreezeScript/DumpDescriptors.cpp
index 4661cc5a9fb..76ff447279a 100644
--- a/cpp/src/FreezeScript/DumpDescriptors.cpp
+++ b/cpp/src/FreezeScript/DumpDescriptors.cpp
@@ -1269,12 +1269,12 @@ FreezeScript::RecordDescriptor::execute(const SymbolTablePtr& /*sym*/, ExecuteIn
             Ice::ByteSeq keyBytes;
             keyBytes.resize(dbKey.get_size());
             memcpy(&keyBytes[0], dbKey.get_data(), dbKey.get_size());
-            Ice::InputStreamPtr inKey = Ice::createInputStream(info->communicator, keyBytes, false);
+            Ice::InputStreamPtr inKey = Ice::wrapInputStream(info->communicator, keyBytes);
 
             Ice::ByteSeq valueBytes;
             valueBytes.resize(dbValue.get_size());
             memcpy(&valueBytes[0], dbValue.get_data(), dbValue.get_size());
-            Ice::InputStreamPtr inValue = Ice::createInputStream(info->communicator, valueBytes, false);
+            Ice::InputStreamPtr inValue = Ice::wrapInputStream(info->communicator, valueBytes);
             inValue->startEncapsulation();
 
             //
diff --git a/cpp/src/FreezeScript/Transformer.cpp b/cpp/src/FreezeScript/Transformer.cpp
index c10c13e37a9..56c1f433ddd 100644
--- a/cpp/src/FreezeScript/Transformer.cpp
+++ b/cpp/src/FreezeScript/Transformer.cpp
@@ -1960,8 +1960,8 @@ FreezeScript::RecordDescriptor::transformRecord(const Ice::ByteSeq& inKeyBytes,
                                                 Ice::ByteSeq& outKeyBytes,
                                                 Ice::ByteSeq& outValueBytes)
 {
-    Ice::InputStreamPtr inKey = Ice::createInputStream(_info->communicator, inKeyBytes, false);
-    Ice::InputStreamPtr inValue = Ice::createInputStream(_info->communicator, inValueBytes, false);
+    Ice::InputStreamPtr inKey = Ice::wrapInputStream(_info->communicator, inKeyBytes);
+    Ice::InputStreamPtr inValue = Ice::wrapInputStream(_info->communicator, inValueBytes);
     inValue->startEncapsulation();
 
     Ice::OutputStreamPtr outKey = Ice::createOutputStream(_info->communicator);
diff --git a/cpp/src/Ice/Initialize.cpp b/cpp/src/Ice/Initialize.cpp
index 60adb309571..bfc155630d2 100644
--- a/cpp/src/Ice/Initialize.cpp
+++ b/cpp/src/Ice/Initialize.cpp
@@ -271,53 +271,51 @@ Ice::initialize(const InitializationData& initData, Int version)
 InputStreamPtr
 Ice::createInputStream(const CommunicatorPtr& communicator, const vector<Byte>& bytes)
 {
-    return createInputStream(communicator, makePair(bytes));
+    return new InputStreamI(communicator, makePair(bytes), true);
 }
 
 InputStreamPtr
 Ice::createInputStream(const CommunicatorPtr& communicator, const vector<Byte>& bytes, const EncodingVersion& v)
 {
-    return createInputStream(communicator, makePair(bytes), v);
+    return new InputStreamI(communicator, makePair(bytes), v, true);
 }
 
 InputStreamPtr
-Ice::createInputStream(const CommunicatorPtr& communicator, const vector<Byte>& bytes, bool copyBytes)
+Ice::wrapInputStream(const CommunicatorPtr& communicator, const vector<Byte>& bytes)
 {
-    return createInputStream(communicator, makePair(bytes), copyBytes);
+    return new InputStreamI(communicator, makePair(bytes), false);
 }
 
 InputStreamPtr
-Ice::createInputStream(const CommunicatorPtr& communicator, const vector<Byte>& bytes, const EncodingVersion& v,
-                       bool copyBytes)
+Ice::wrapInputStream(const CommunicatorPtr& communicator, const vector<Byte>& bytes, const EncodingVersion& v)
 {
-    return createInputStream(communicator, makePair(bytes), v, copyBytes);
+    return new InputStreamI(communicator, makePair(bytes), v, false);
 }
 
 InputStreamPtr
 Ice::createInputStream(const CommunicatorPtr& communicator, const pair<const Ice::Byte*, const Ice::Byte*>& bytes)
 {
-    return createInputStream(communicator, bytes, true);
+    return new InputStreamI(communicator, bytes, true);
 }
 
 InputStreamPtr
 Ice::createInputStream(const CommunicatorPtr& communicator, const pair<const Ice::Byte*, const Ice::Byte*>& bytes,
                        const EncodingVersion& v)
 {
-    return createInputStream(communicator, bytes, v, true);
+    return new InputStreamI(communicator, bytes, v, true);
 }
 
 InputStreamPtr
-Ice::createInputStream(const CommunicatorPtr& communicator, const pair<const Ice::Byte*, const Ice::Byte*>& bytes,
-                       bool copyBytes)
+Ice::wrapInputStream(const CommunicatorPtr& communicator, const pair<const Ice::Byte*, const Ice::Byte*>& bytes)
 {
-    return new InputStreamI(communicator, bytes, copyBytes);
+    return new InputStreamI(communicator, bytes, false);
 }
 
 InputStreamPtr
-Ice::createInputStream(const CommunicatorPtr& communicator, const pair<const Ice::Byte*, const Ice::Byte*>& bytes,
-                       const EncodingVersion& v, bool copyBytes)
+Ice::wrapInputStream(const CommunicatorPtr& communicator, const pair<const Ice::Byte*, const Ice::Byte*>& bytes,
+                     const EncodingVersion& v)
 {
-    return new InputStreamI(communicator, bytes, v, copyBytes);
+    return new InputStreamI(communicator, bytes, v, false);
 }
 
 OutputStreamPtr
diff --git a/cpp/test/Ice/stream/Client.cpp b/cpp/test/Ice/stream/Client.cpp
index 6d581bc6c6b..f8c72f07ebe 100644
--- a/cpp/test/Ice/stream/Client.cpp
+++ b/cpp/test/Ice/stream/Client.cpp
@@ -184,7 +184,7 @@ run(int, char**, const Ice::CommunicatorPtr& communicator)
         test(v);
         in->endEncapsulation();
 
-        in = Ice::createInputStream(communicator, data, false);
+        in = Ice::wrapInputStream(communicator, data);
         in->startEncapsulation();
         in->read(v);
         test(v);
diff --git a/cs/src/Ice/Util.cs b/cs/src/Ice/Util.cs
index eb88832610d..87bfb6e2996 100644
--- a/cs/src/Ice/Util.cs
+++ b/cs/src/Ice/Util.cs
@@ -438,14 +438,14 @@ namespace Ice
 
         /// <summary>
         /// Creates an input stream for dynamic invocation and dispatch. The stream uses
-        /// the communicator's default encoding version.
+        /// the communicator's default encoding version. The given data is copied.
         /// </summary>
         /// <param name="communicator">The communicator for the stream.</param>
         /// <param name="bytes">An encoded request or reply.</param>
         /// <returns>The input stream.</returns>
         public static InputStream createInputStream(Communicator communicator, byte[] bytes)
         {
-            return createInputStream(communicator, bytes, true);
+            return new InputStreamI(communicator, bytes, true);
         }
 
         /// <summary>
@@ -458,35 +458,32 @@ namespace Ice
         /// <returns>The input stream.</returns>
         public static InputStream createInputStream(Communicator communicator, byte[] bytes, EncodingVersion v)
         {
-            return createInputStream(communicator, bytes, v, true);
+            return new InputStreamI(communicator, bytes, v, true);
         }
 
         /// <summary>
-        /// Creates an input stream for dynamic invocation and dispatch. The stream uses
-        /// the communicator's default encoding version.
+        /// Wraps encoded data with an input stream for dynamic invocation and dispatch. 
+        /// The stream uses the communicator's default encoding version.
         /// </summary>
         /// <param name="communicator">The communicator for the stream.</param>
         /// <param name="bytes">An encoded request or reply.</param>
-        /// <param name="copyBytes">True if the given bytes should be copied, false otherwise.</param>
         /// <returns>The input stream.</returns>
-        public static InputStream createInputStream(Communicator communicator, byte[] bytes, bool copyBytes)
+        public static InputStream wrapInputStream(Communicator communicator, byte[] bytes)
         {
-            return new InputStreamI(communicator, bytes, copyBytes);
+            return new InputStreamI(communicator, bytes, false);
         }
 
         /// <summary>
-        /// Creates an input stream for dynamic invocation and dispatch. The stream uses
-        /// the given encoding version.
+        /// Wraps encoded data with an input stream for dynamic invocation and dispatch. 
+        /// The stream uses the given encoding version.
         /// </summary>
         /// <param name="communicator">The communicator for the stream.</param>
         /// <param name="bytes">An encoded request or reply.</param>
         /// <param name="v">The desired encoding version.</param>
-        /// <param name="copyBytes">True if the given bytes should be copied, false otherwise.</param>
         /// <returns>The input stream.</returns>
-        public static InputStream createInputStream(Communicator communicator, byte[] bytes, EncodingVersion v, 
-                                                    bool copyBytes)
+        public static InputStream wrapInputStream(Communicator communicator, byte[] bytes, EncodingVersion v)
         {
-            return new InputStreamI(communicator, bytes, v, copyBytes);
+            return new InputStreamI(communicator, bytes, v, false);
         }
 
         /// <summary>
diff --git a/cs/test/Ice/stream/AllTests.cs b/cs/test/Ice/stream/AllTests.cs
index 0d35bc427f0..dde94d139db 100644
--- a/cs/test/Ice/stream/AllTests.cs
+++ b/cs/test/Ice/stream/AllTests.cs
@@ -208,7 +208,7 @@ public class AllTests : TestCommon.TestApp
             @in.endEncapsulation();
             @in.destroy();
 
-            @in = Ice.Util.createInputStream(communicator, data, false);
+            @in = Ice.Util.wrapInputStream(communicator, data);
             @in.startEncapsulation();
             test(@in.readBool());
             @in.endEncapsulation();
diff --git a/java/src/Ice/Util.java b/java/src/Ice/Util.java
index 049d82f0e7f..94e3c6a55a6 100644
--- a/java/src/Ice/Util.java
+++ b/java/src/Ice/Util.java
@@ -440,7 +440,7 @@ public final class Util
     public static InputStream
     createInputStream(Communicator communicator, byte[] bytes)
     {
-        return createInputStream(communicator, bytes, true);
+        return new InputStreamI(communicator, bytes, true);
     }
 
     /**
@@ -455,12 +455,13 @@ public final class Util
     public static InputStream
     createInputStream(Communicator communicator, byte[] bytes, EncodingVersion v)
     {
-        return createInputStream(communicator, bytes, v, true);
+        return new InputStreamI(communicator, bytes, v, true);
     }
 
     /**
-     * Creates an input stream for dynamic invocation and dispatch. The stream uses
-     * the communicator's default encoding version.
+     * Wraps encoded data with an input stream for dynamic invocation
+     * and dispatch. The stream uses the communicator's default
+     * encoding version.
      *
      * @param communicator The communicator for the stream.
      * @param bytes An encoded request or reply.
@@ -469,14 +470,14 @@ public final class Util
      * @return The input stream.
      **/
     public static InputStream
-    createInputStream(Communicator communicator, byte[] bytes, boolean copyBytes)
+    wrapInputStream(Communicator communicator, byte[] bytes)
     {
-        return new InputStreamI(communicator, bytes, copyBytes);
+        return new InputStreamI(communicator, bytes, false);
     }
 
     /**
-     * Creates an input stream for dynamic invocation and dispatch. The stream uses
-     * the given encoding version.
+     * Wraps encoded data with an input stream for dynamic invocation
+     * and dispatch. The stream uses the given encoding version.
      *
      * @param communicator The communicator for the stream.
      * @param bytes An encoded request or reply.
@@ -486,9 +487,9 @@ public final class Util
      * @return The input stream.
      **/
     public static InputStream
-    createInputStream(Communicator communicator, byte[] bytes, EncodingVersion v, boolean copyBytes)
+    wrapInputStream(Communicator communicator, byte[] bytes, EncodingVersion v)
     {
-        return new InputStreamI(communicator, bytes, v, copyBytes);
+        return new InputStreamI(communicator, bytes, v, false);
     }
 
     /**
diff --git a/java/test/Ice/stream/Client.java b/java/test/Ice/stream/Client.java
index 1c43cc75435..c9ccc3ca6e2 100644
--- a/java/test/Ice/stream/Client.java
+++ b/java/test/Ice/stream/Client.java
@@ -180,7 +180,7 @@ public class Client extends test.Util.Application
             in.endEncapsulation();
             in.destroy();
 
-            in = Ice.Util.createInputStream(comm, data, false);
+            in = Ice.Util.wrapInputStream(comm, data);
             in.startEncapsulation();
             test(in.readBool());
             in.endEncapsulation();
diff --git a/php/src/IcePHP/Operation.cpp b/php/src/IcePHP/Operation.cpp
index bfeaeff4075..412de85e9b5 100644
--- a/php/src/IcePHP/Operation.cpp
+++ b/php/src/IcePHP/Operation.cpp
@@ -560,7 +560,7 @@ void
 IcePHP::TypedInvocation::unmarshalResults(int argc, zval** args, zval* ret,
                                           const pair<const Ice::Byte*, const Ice::Byte*>& bytes TSRMLS_DC)
 {
-    Ice::InputStreamPtr is = Ice::createInputStream(_communicator->getCommunicator(), bytes, false);
+    Ice::InputStreamPtr is = Ice::wrapInputStream(_communicator->getCommunicator(), bytes);
 
     //
     // Store a pointer to a local SlicedDataUtil object as the stream's closure.
@@ -667,7 +667,7 @@ IcePHP::TypedInvocation::unmarshalResults(int argc, zval** args, zval* ret,
 zval*
 IcePHP::TypedInvocation::unmarshalException(const pair<const Ice::Byte*, const Ice::Byte*>& bytes TSRMLS_DC)
 {
-    Ice::InputStreamPtr is = Ice::createInputStream(_communicator->getCommunicator(), bytes, false);
+    Ice::InputStreamPtr is = Ice::wrapInputStream(_communicator->getCommunicator(), bytes);
 
     //
     // Store a pointer to a local SlicedDataUtil object as the stream's closure.
diff --git a/py/modules/IcePy/Operation.cpp b/py/modules/IcePy/Operation.cpp
index b575cce2626..b30d70c0e5f 100644
--- a/py/modules/IcePy/Operation.cpp
+++ b/py/modules/IcePy/Operation.cpp
@@ -1602,7 +1602,7 @@ IcePy::TypedInvocation::unmarshalResults(const pair<const Ice::Byte*, const Ice:
     PyObjectHandle results = PyTuple_New(numResults);
     if(results.get() && numResults > 0)
     {
-        Ice::InputStreamPtr is = Ice::createInputStream(_communicator, bytes, false);
+        Ice::InputStreamPtr is = Ice::wrapInputStream(_communicator, bytes);
 
         //
         // Store a pointer to a local SlicedDataUtil object as the stream's closure.
@@ -1676,7 +1676,7 @@ IcePy::TypedInvocation::unmarshalResults(const pair<const Ice::Byte*, const Ice:
 PyObject*
 IcePy::TypedInvocation::unmarshalException(const pair<const Ice::Byte*, const Ice::Byte*>& bytes)
 {
-    Ice::InputStreamPtr is = Ice::createInputStream(_communicator, bytes, false);
+    Ice::InputStreamPtr is = Ice::wrapInputStream(_communicator, bytes);
 
     //
     // Store a pointer to a local SlicedDataUtil object as the stream's closure.
@@ -3227,7 +3227,7 @@ IcePy::TypedUpcall::dispatch(PyObject* servant, const pair<const Ice::Byte*, con
 
     if(!_op->inParams.empty())
     {
-        Ice::InputStreamPtr is = Ice::createInputStream(_communicator, inBytes, false);
+        Ice::InputStreamPtr is = Ice::wrapInputStream(_communicator, inBytes);
 
         //
         // Store a pointer to a local SlicedDataUtil object as the stream's closure.
diff --git a/rb/src/IceRuby/Operation.cpp b/rb/src/IceRuby/Operation.cpp
index a6871da2f5e..d9a0327b020 100644
--- a/rb/src/IceRuby/Operation.cpp
+++ b/rb/src/IceRuby/Operation.cpp
@@ -495,7 +495,7 @@ IceRuby::OperationI::unmarshalResults(const vector<Ice::Byte>& bytes, const Ice:
     // Unmarshal the results. If there is more than one value to be returned, then return them
     // in a tuple of the form (result, outParam1, ...). Otherwise just return the value.
     //
-    Ice::InputStreamPtr is = Ice::createInputStream(communicator, bytes, false);
+    Ice::InputStreamPtr is = Ice::wrapInputStream(communicator, bytes);
 
     //
     // Store a pointer to a local SlicedDataUtil object as the stream's closure.
@@ -564,7 +564,7 @@ IceRuby::OperationI::unmarshalResults(const vector<Ice::Byte>& bytes, const Ice:
 VALUE
 IceRuby::OperationI::unmarshalException(const vector<Ice::Byte>& bytes, const Ice::CommunicatorPtr& communicator)
 {
-    Ice::InputStreamPtr is = Ice::createInputStream(communicator, bytes, false);
+    Ice::InputStreamPtr is = Ice::wrapInputStream(communicator, bytes);
 
     //
     // Store a pointer to a local SlicedDataUtil object as the stream's closure.