Improved InputStream and OutputStream in C++11

20 files changed, 898 insertions, 438 deletions

diff --git a/cpp/include/Ice/InputStream.h b/cpp/include/Ice/InputStream.h
index b9525b385e4..062dfc850c0 100644
--- a/cpp/include/Ice/InputStream.h
+++ b/cpp/include/Ice/InputStream.h
@@ -97,6 +97,14 @@ public:
         {
             clear(); // Not inlined.
         }
+
+#ifdef ICE_CPP11_MAPPING
+
+        for(auto d: _deleters)
+        {
+            d();
+        }
+#endif
     }
 
     //
@@ -386,6 +394,52 @@ public:
         }
     }
 
+#ifdef ICE_CPP11_MAPPING
+
+    template<typename T> void read(std::pair<const T*, const T*>& v)
+    {
+        auto holder = new std::vector<T>;
+        _deleters.push_back([holder] { delete holder; });
+        read(*holder);
+        if(holder->size() > 0)
+        {
+            v.first = holder->data();
+            v.second = holder->data() + holder->size();
+        }
+        else
+        {
+            v.first = 0;
+            v.second = 0;
+        }
+    }
+
+    template<typename T> void readAll(T& v)
+    {
+        read(v);
+    }
+
+    template<typename T, typename... Te> void readAll(T& v, Te&... ve)
+    {
+        read(v);
+        readAll(ve...);
+    }
+
+    template<typename T>
+    void readAll(std::initializer_list<int> tags, IceUtil::Optional<T>& v)
+    {
+        read(*(tags.begin() + tags.size() - 1), v);
+    }
+
+    template<typename T, typename... Te>
+    void readAll(std::initializer_list<int> tags, IceUtil::Optional<T>& v, IceUtil::Optional<Te>&... ve)
+    {
+        size_t index = tags.size() - sizeof...(ve) - 1;
+        read(*(tags.begin() + index), v);
+        readAll(tags, ve...);
+    }
+
+#endif
+
     // Read type and tag for optionals
     bool readOptional(Int tag, OptionalFormat expectedFormat)
     {
@@ -412,12 +466,14 @@ public:
     void read(std::vector<Byte>&);
     void read(std::pair<const Byte*, const Byte*>&);
 
+#ifndef ICE_CPP11_MAPPING
     // This method is useful for generic stream helpers
     void read(std::pair<const Byte*, const Byte*>& p, ::IceUtil::ScopedArray<Byte>& result)
     {
         result.reset();
         read(p);
     }
+#endif
 
     // Bool
     void read(bool& v)
@@ -429,12 +485,21 @@ public:
         v = (0 != *i++);
     }
     void read(std::vector<bool>&);
+
+#ifdef ICE_CPP11_MAPPING
+    void read(std::pair<const bool*, const bool*>&);
+#else
     void read(std::pair<const bool*, const bool*>&, ::IceUtil::ScopedArray<bool>&);
+#endif
 
     // Short
     void read(Short&);
     void read(std::vector<Short>&);
+#ifdef ICE_CPP11_MAPPING
+    void read(std::pair<const short*, const short*>&);
+#else
     void read(std::pair<const Short*, const Short*>&, ::IceUtil::ScopedArray<Short>&);
+#endif
 
     // Int
     void read(Int& v) // Inlined for performance reasons.
@@ -461,102 +526,52 @@ public:
     }
 
     void read(std::vector<Int>&);
+#ifdef ICE_CPP11_MAPPING
+    void read(std::pair<const int*, const int*>&);
+#else
     void read(std::pair<const Int*, const Int*>&, ::IceUtil::ScopedArray<Int>&);
+#endif
 
     // Long
 
     void read(Long&);
     void read(std::vector<Long>&);
+#ifdef ICE_CPP11_MAPPING
+    void read(std::pair<const long long*, const long long*>&);
+#else
     void read(std::pair<const Long*, const Long*>&, ::IceUtil::ScopedArray<Long>&);
+#endif
 
     // Float
     void read(Float&);
     void read(std::vector<Float>&);
+#ifdef ICE_CPP11_MAPPING
+    void read(std::pair<const float*, const float*>&);
+#else
     void read(std::pair<const Float*, const Float*>&, ::IceUtil::ScopedArray<Float>&);
+#endif
 
     // Double
     void read(Double&);
     void read(std::vector<Double>&);
+#ifdef ICE_CPP11_MAPPING
+    void read(std::pair<const double*, const double*>&);
+#else
     void read(std::pair<const Double*, const Double*>&, ::IceUtil::ScopedArray<Double>&);
+#endif
 
     // String
-    void read(std::string& v, bool convert = true)
-    {
-        Int sz = readSize();
-        if(sz > 0)
-        {
-            if(b.end() - i < sz)
-            {
-                throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
-            }
-            if(convert && _stringConverter)
-            {
-                readConverted(v, sz);
-            }
-            else
-            {
-                std::string(reinterpret_cast<const char*>(&*i), reinterpret_cast<const char*>(&*i) + sz).swap(v);
-            }
-            i += sz;
-        }
-        else
-        {
-            v.clear();
-        }
-    }
+    void read(std::string& v, bool convert = true);
 
+#ifdef ICE_CPP11_MAPPING
+    void read(const char*& vdata, size_t& vsize, bool convert = true);
+#else
     // For custom strings, convert = false
-    void read(const char*& vdata, size_t& vsize)
-    {
-        Int sz = readSize();
-        if(sz > 0)
-        {
-            if(b.end() - i < sz)
-            {
-                throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
-            }
-
-            vdata = reinterpret_cast<const char*>(&*i);
-            vsize = static_cast<size_t>(sz);
-            i += sz;
-        }
-        else
-        {
-            vdata = 0;
-            vsize = 0;
-        }
-    }
+    void read(const char*& vdata, size_t& vsize);
 
     // For custom strings, convert = true
-    void read(const char*& vdata, size_t& vsize, std::string& holder)
-    {
-        if(!_stringConverter)
-        {
-            holder.clear();
-            read(vdata, vsize);
-        }
-        else
-        {
-            Int sz = readSize();
-            if(sz > 0)
-            {
-                if(b.end() - i < sz)
-                {
-                    throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
-                }
-
-                readConverted(holder, sz);
-                vdata = holder.data();
-                vsize = holder.size();
-            }
-            else
-            {
-                holder.clear();
-                vdata = 0;
-                vsize = 0;
-            }
-        }
-    }
+    void read(const char*& vdata, size_t& vsize, std::string& holder);
+#endif
 
     void read(std::vector<std::string>&, bool = true);
 
@@ -692,12 +707,6 @@ private:
     CompactIdResolverPtr compactIdResolver() const;
 #endif
 
-    //
-    // Optimization. The instance may not be deleted while a
-    // stack-allocated stream still holds it.
-    //
-    IceInternal::Instance* _instance;
-
     typedef std::vector<ValuePtr> ValueList;
 
     class ICE_API EncapsDecoder : private ::IceUtil::noncopyable
@@ -919,6 +928,13 @@ private:
         Encaps* previous;
     };
 
+
+    //
+    // Optimization. The instance may not be deleted while a
+    // stack-allocated stream still holds it.
+    //
+    IceInternal::Instance* _instance;
+
     //
     // The encoding version to use when there's no encapsulation to
     // read from. This is for example used to read message headers.
@@ -953,6 +969,11 @@ private:
 #else
     CompactIdResolverPtr _compactIdResolver;
 #endif
+
+#ifdef ICE_CPP11_MAPPING
+    std::vector<std::function<void()>> _deleters;
+#endif
+
 };
 
 } // End namespace Ice
diff --git a/cpp/include/Ice/OutputStream.h b/cpp/include/Ice/OutputStream.h
index db28f604b77..1a03c2e1737 100644
--- a/cpp/include/Ice/OutputStream.h
+++ b/cpp/include/Ice/OutputStream.h
@@ -289,6 +289,7 @@ public:
             write(&v[0], &v[0] + v.size());
         }
     }
+
     template<typename T> void write(const T* begin, const T* end)
     {
         writeSize(static_cast<Int>(end - begin));
@@ -298,6 +299,35 @@ public:
         }
     }
 
+#ifdef ICE_CPP11_MAPPING
+
+    template<typename T> void writeAll(const T& v)
+    {
+        write(v);
+    }
+
+    template<typename T, typename... Te> void writeAll(const T& v, const Te&... ve)
+    {
+        write(v);
+        writeAll(ve...);
+    }
+
+    template<typename T>
+    void writeAll(std::initializer_list<int> tags, const IceUtil::Optional<T>& v)
+    {
+        write(*(tags.begin() + tags.size() - 1), v);
+    }
+
+    template<typename T, typename... Te>
+    void writeAll(std::initializer_list<int> tags, const IceUtil::Optional<T>& v, const IceUtil::Optional<Te>&... ve)
+    {
+        size_t index = tags.size() - sizeof...(ve) - 1;
+        write(*(tags.begin() + index), v);
+        writeAll(tags, ve...);
+    }
+
+#endif
+
     // Write type and tag for optionals
     bool writeOptional(Int tag, OptionalFormat format)
     {
@@ -358,13 +388,7 @@ public:
     void write(const Int*, const Int*);
 
     // Long
-
-#ifdef ICE_CPP11_MAPPING
-    void write(long long int);
-#else
     void write(Long);
-#endif
-
     void write(const Long*, const Long*);
 
     // Float
@@ -428,7 +452,7 @@ public:
 
     // Proxy
 #ifdef ICE_CPP11_MAPPING
-    void writeProxy(const ObjectPrxPtr&);
+    void writeProxy(const ::std::shared_ptr<ObjectPrx>&);
 
     template<typename T, typename ::std::enable_if<::std::is_base_of<ObjectPrx, T>::value>::type* = nullptr>
     void write(const ::std::shared_ptr<T>& v)
diff --git a/cpp/include/Ice/StreamHelpers.h b/cpp/include/Ice/StreamHelpers.h
index 64023759f0c..9207b428b50 100644
--- a/cpp/include/Ice/StreamHelpers.h
+++ b/cpp/include/Ice/StreamHelpers.h
@@ -136,6 +136,17 @@ struct StreamableTraits<T, typename ::std::enable_if<::std::is_base_of<::Ice::Us
     //
 };
 
+//
+// StreamableTraits specialization for arrays (std::pair<const T*, const T*>).
+//
+template<typename T>
+struct StreamableTraits<std::pair<T*, T*>>
+{
+    static const StreamHelperCategory helper = StreamHelperCategorySequence;
+    static const int minWireSize = 1;
+    static const bool fixedLength = false;
+};
+
 #else
 
 //
@@ -175,7 +186,6 @@ struct StreamableTraits<UserException>
     // and no optional UserException (so no need for fixedLength)
     //
 };
-#endif
 
 //
 // StreamableTraits specialization for array / range mapped sequences
@@ -189,6 +199,7 @@ struct StreamableTraits< ::std::pair<T, U> >
     static const int minWireSize = 1;
     static const bool fixedLength = false;
 };
+#endif
 
 //
 // StreamableTraits specialization for builtins (these are needed for sequence
@@ -438,7 +449,7 @@ struct StreamHelper<T, StreamHelperCategorySequence>
     }
 };
 
-// Helper for array and range:array custom sequence parameters
+// Helper for array custom sequence parameters
 template<typename T>
 struct StreamHelper<std::pair<const T*, const T*>, StreamHelperCategorySequence>
 {
@@ -455,6 +466,8 @@ struct StreamHelper<std::pair<const T*, const T*>, StreamHelperCategorySequence>
     }
 };
 
+#ifndef ICE_CPP11_MAPPING
+
 // Helper for range custom sequence parameters
 template<typename T>
 struct StreamHelper<std::pair<T, T>, StreamHelperCategorySequence>
@@ -490,8 +503,6 @@ struct StreamHelper<std::pair< ::std::vector<bool>::const_iterator,
             stream->write(static_cast<bool>(*p));
         }
     }
-
-    // no read: only used for marshaling
 };
 
 // Helper for zero-copy array sequence parameters
@@ -506,6 +517,8 @@ struct StreamHelper<std::pair<IceUtil::ScopedArray<T>, std::pair<const T*, const
 
     // no write: only used for unmarshaling
 };
+#endif
+
 
 // Helper for dictionaries
 template<typename T>
@@ -861,6 +874,8 @@ struct StreamOptionalHelper<std::pair<const T*, const T*>, StreamHelperCategoryS
     }
 };
 
+#ifndef ICE_CPP11_MAPPING
+
 template<typename T>
 struct StreamOptionalHelper<std::pair<T, T>, StreamHelperCategorySequence, false>
 {
@@ -906,6 +921,7 @@ struct StreamOptionalHelper<std::pair<IceUtil::ScopedArray<T>, std::pair<const T
 
     // no write: only used for unmarshaling
 };
+#endif
 
 //
 // Helper to write dictionaries, delegates to the optional container
diff --git a/cpp/include/IceUtil/ScopedArray.h b/cpp/include/IceUtil/ScopedArray.h
index d3cc8dc59a5..594f9836a2e 100644
--- a/cpp/include/IceUtil/ScopedArray.h
+++ b/cpp/include/IceUtil/ScopedArray.h
@@ -12,15 +12,14 @@
 
 #include <IceUtil/Config.h>
 
-namespace IceUtil
-{
-
-#ifdef ICE_CPP11_MAPPING
+#ifndef ICE_CPP11_MAPPING
 
-template<typename T>
-using ScopedArray = std::unique_ptr<T[]>;
+//
+// Only for the C++98 mapping
+//
 
-#else // C++98 mapping
+namespace IceUtil
+{
 
 template<typename T>
 class ScopedArray
@@ -99,8 +98,7 @@ private:
     T* _ptr;
 };
 
-#endif
-
 } // End of namespace IceUtil
 
 #endif
+#endif
diff --git a/cpp/src/Ice/InputStream.cpp b/cpp/src/Ice/InputStream.cpp
index bfba4b17eec..315de0e6c53 100644
--- a/cpp/src/Ice/InputStream.cpp
+++ b/cpp/src/Ice/InputStream.cpp
@@ -26,6 +26,12 @@
 #include <IceUtil/StringConverter.h>
 #include <iterator>
 
+#ifndef ICE_UNALIGNED
+#   if defined(__i386) || defined(_M_IX86) || defined(__x86_64) || defined(_M_X64)
+#       define ICE_UNALIGNED
+#   endif
+#endif
+
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
@@ -500,6 +506,27 @@ struct ReadBoolHelper<1>
 
 }
 
+#ifdef ICE_CPP11_MAPPING
+void
+Ice::InputStream::read(pair<const bool*, const bool*>& v)
+{
+    Int sz = readAndCheckSeqSize(1);
+    if(sz > 0)
+    {
+        auto boolArray = ReadBoolHelper<sizeof(bool)>::read(v, sz, i);
+        if(boolArray)
+        {
+            _deleters.push_back([boolArray] { delete[] boolArray; });
+        }
+        i += sz;
+    }
+    else
+    {
+        v.first = v.second = reinterpret_cast<bool*>(i);
+    }
+}
+
+#else
 void
 Ice::InputStream::read(pair<const bool*, const bool*>& v, IceUtil::ScopedArray<bool>& result)
 {
@@ -515,6 +542,7 @@ Ice::InputStream::read(pair<const bool*, const bool*>& v, IceUtil::ScopedArray<b
         v.first = v.second = reinterpret_cast<bool*>(i);
     }
 }
+#endif
 
 void
 Ice::InputStream::read(Short& v)
@@ -564,20 +592,32 @@ Ice::InputStream::read(vector<Short>& v)
     }
 }
 
+#ifdef ICE_CPP11_MAPPING
+void
+Ice::InputStream::read(pair<const short*, const short*>& v)
+#else
 void
 Ice::InputStream::read(pair<const Short*, const Short*>& v, IceUtil::ScopedArray<Short>& result)
+#endif
 {
     Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Short)));
     if(sz > 0)
     {
-#if defined(__i386) || defined(_M_IX86) || defined(__x86_64) || defined(_M_X64)
+#ifdef ICE_UNALIGNED
         v.first = reinterpret_cast<Short*>(i);
         i += sz * static_cast<int>(sizeof(Short));
         v.second = reinterpret_cast<Short*>(i);
 #else
+#  ifdef ICE_CPP11_MAPPING
+        auto result = new short[sz];
+        _deleters.push_back([result] { delete[] result; });
+        v.first = result;
+        v.second = result + sz;
+#  else
         result.reset(new Short[sz]);
         v.first = result.get();
         v.second = result.get() + sz;
+#   endif
 
         Container::iterator begin = i;
         i += sz * static_cast<int>(sizeof(Short));
@@ -597,7 +637,9 @@ Ice::InputStream::read(pair<const Short*, const Short*>& v, IceUtil::ScopedArray
     }
     else
     {
+#ifndef ICE_CPP11_MAPPING
         result.reset();
+#endif
         v.first = v.second = 0;
     }
 }
@@ -632,20 +674,33 @@ Ice::InputStream::read(vector<Int>& v)
     }
 }
 
+#ifdef ICE_CPP11_MAPPING
+void
+Ice::InputStream::read(pair<const Int*, const Int*>& v)
+#else
 void
 Ice::InputStream::read(pair<const Int*, const Int*>& v, ::IceUtil::ScopedArray<Int>& result)
+#endif
 {
     Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Int)));
     if(sz > 0)
     {
-#if defined(__i386) || defined(_M_IX86) || defined(__x86_64) || defined(_M_X64)
+#ifdef ICE_UNALIGNED
         v.first = reinterpret_cast<Int*>(i);
         i += sz * static_cast<int>(sizeof(Int));
         v.second = reinterpret_cast<Int*>(i);
 #else
+
+#  ifdef ICE_CPP11_MAPPING
+        auto result = new int[sz];
+        _deleters.push_back([result] { delete[] result; });
+        v.first = result;
+        v.second = result + sz;
+#  else
         result.reset(new Int[sz]);
         v.first = result.get();
         v.second = result.get() + sz;
+#  endif
 
         Container::iterator begin = i;
         i += sz * static_cast<int>(sizeof(Int));
@@ -667,7 +722,9 @@ Ice::InputStream::read(pair<const Int*, const Int*>& v, ::IceUtil::ScopedArray<I
     }
     else
     {
+#ifndef ICE_CPP11_MAPPING
         result.reset();
+#endif
         v.first = v.second = 0;
     }
 }
@@ -738,20 +795,33 @@ Ice::InputStream::read(vector<Long>& v)
     }
 }
 
+#ifdef ICE_CPP11_MAPPING
+void
+Ice::InputStream::read(pair<const Long*, const Long*>& v)
+#else
 void
 Ice::InputStream::read(pair<const Long*, const Long*>& v, IceUtil::ScopedArray<Long>& result)
+#endif
 {
     Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Long)));
     if(sz > 0)
     {
-#if defined(__i386) || defined(_M_IX86) || defined(__x86_64) || defined(_M_X64)
+#ifdef ICE_UNALIGNED
         v.first = reinterpret_cast<Long*>(i);
         i += sz * static_cast<int>(sizeof(Long));
         v.second = reinterpret_cast<Long*>(i);
 #else
+
+#  ifdef ICE_CPP11_MAPPING
+        auto result = new long long[sz];
+        _deleters.push_back([result] { delete[] result; });
+        v.first = result;
+        v.second = result + sz;
+#  else
         result.reset(new Long[sz]);
         v.first = result.get();
         v.second = result.get() + sz;
+#  endif
 
         Container::iterator begin = i;
         i += sz * static_cast<int>(sizeof(Long));
@@ -777,7 +847,9 @@ Ice::InputStream::read(pair<const Long*, const Long*>& v, IceUtil::ScopedArray<L
     }
     else
     {
+#ifndef ICE_CPP11_MAPPING
         result.reset();
+#endif
         v.first = v.second = 0;
     }
 }
@@ -836,20 +908,33 @@ Ice::InputStream::read(vector<Float>& v)
     }
 }
 
+#ifdef ICE_CPP11_MAPPING
+void
+Ice::InputStream::read(pair<const Float*, const Float*>& v)
+#else
 void
 Ice::InputStream::read(pair<const Float*, const Float*>& v, IceUtil::ScopedArray<Float>& result)
+#endif
 {
     Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Float)));
     if(sz > 0)
     {
-#if defined(__i386) || defined(_M_IX86) || defined(__x86_64) || defined(_M_X64)
+#ifdef ICE_UNALIGNED
         v.first = reinterpret_cast<Float*>(i);
         i += sz * static_cast<int>(sizeof(Float));
         v.second = reinterpret_cast<Float*>(i);
 #else
+
+#  ifdef ICE_CPP11_MAPPING
+        auto result = new float[sz];
+        _deleters.push_back([result] { delete[] result; });
+        v.first = result;
+        v.second = result + sz;
+#  else
         result.reset(new Float[sz]);
         v.first = result.get();
         v.second = result.get() + sz;
+#  endif
 
         Container::iterator begin = i;
         i += sz * static_cast<int>(sizeof(Float));
@@ -871,7 +956,9 @@ Ice::InputStream::read(pair<const Float*, const Float*>& v, IceUtil::ScopedArray
     }
     else
     {
+#ifndef ICE_CPP11_MAPPING
         result.reset();
+#endif
         v.first = v.second = 0;
     }
 }
@@ -968,20 +1055,34 @@ Ice::InputStream::read(vector<Double>& v)
     }
 }
 
+
+#ifdef ICE_CPP11_MAPPING
+void
+Ice::InputStream::read(pair<const Double*, const Double*>& v)
+#else
 void
 Ice::InputStream::read(pair<const Double*, const Double*>& v, IceUtil::ScopedArray<Double>& result)
+#endif
 {
     Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Double)));
     if(sz > 0)
     {
-#if defined(__i386) || defined(_M_IX86) || defined(__x86_64) || defined(_M_X64)
+#ifdef ICE_UNALIGNED
         v.first = reinterpret_cast<Double*>(i);
         i += sz * static_cast<int>(sizeof(Double));
         v.second = reinterpret_cast<Double*>(i);
 #else
+
+#  ifdef ICE_CPP11_MAPPING
+        auto result = new double[sz];
+        _deleters.push_back([result] { delete[] result; });
+        v.first = result;
+        v.second = result + sz;
+#  else
         result.reset(new Double[sz]);
         v.first = result.get();
         v.second = result.get() + sz;
+#  endif
 
         Container::iterator begin = i;
         i += sz * static_cast<int>(sizeof(Double));
@@ -1023,12 +1124,145 @@ Ice::InputStream::read(pair<const Double*, const Double*>& v, IceUtil::ScopedArr
     }
     else
     {
+#ifndef ICE_CPP11_MAPPING
         result.reset();
+#endif
         v.first = v.second = 0;
     }
 }
 
 void
+Ice::InputStream::read(std::string& v, bool convert)
+{
+    Int sz = readSize();
+    if(sz > 0)
+    {
+        if(b.end() - i < sz)
+        {
+            throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+        }
+        if(convert && _stringConverter)
+        {
+            readConverted(v, sz);
+        }
+        else
+        {
+            string(reinterpret_cast<const char*>(&*i), reinterpret_cast<const char*>(&*i) + sz).swap(v);
+        }
+        i += sz;
+    }
+    else
+    {
+        v.clear();
+    }
+}
+
+#ifdef ICE_CPP11_MAPPING
+void
+Ice::InputStream::read(const char*& vdata, size_t& vsize, bool convert)
+{
+    int sz = readSize();
+    if(sz > 0)
+    {
+        if(b.end() - i < sz)
+        {
+            throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+        }
+
+        if(convert == false || !_stringConverter)
+        {
+            vdata = reinterpret_cast<const char*>(&*i);
+            vsize = static_cast<size_t>(sz);
+            i += sz;
+        }
+        else
+        {
+            string converted;
+            readConverted(converted, sz);
+            if(converted.size() <= static_cast<size_t>(sz))
+            {
+                //
+                // Write converted string directly into buffer
+                //
+                std::memcpy(i, converted.data(), converted.size());
+                vdata = reinterpret_cast<const char*>(&*i);
+                vsize = converted.size();
+            }
+            else
+            {
+                auto holder = new string(std::move(converted));
+                _deleters.push_back([holder] { delete holder; });
+                vdata = holder->data();
+                vsize = holder->size();
+            }
+            i += sz;
+        }
+    }
+    else
+    {
+        vdata = 0;
+        vsize = 0;
+    }
+}
+
+#else
+
+void
+Ice::InputStream::read(const char*& vdata, size_t& vsize)
+{
+    Int sz = readSize();
+    if(sz > 0)
+    {
+        if(b.end() - i < sz)
+        {
+            throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+        }
+
+        vdata = reinterpret_cast<const char*>(&*i);
+        vsize = static_cast<size_t>(sz);
+        i += sz;
+    }
+    else
+    {
+        vdata = 0;
+        vsize = 0;
+    }
+}
+
+void
+Ice::InputStream::read(const char*& vdata, size_t& vsize, string& holder)
+{
+    if(!_stringConverter)
+    {
+        holder.clear();
+        read(vdata, vsize);
+    }
+    else
+    {
+        Int sz = readSize();
+        if(sz > 0)
+        {
+            if(b.end() - i < sz)
+            {
+                throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+            }
+
+            readConverted(holder, sz);
+            i += sz;
+            vdata = holder.data();
+            vsize = holder.size();
+        }
+        else
+        {
+            holder.clear();
+            vdata = 0;
+            vsize = 0;
+        }
+    }
+}
+#endif
+
+void
 Ice::InputStream::readConverted(string& v, int sz)
 {
     if(!_stringConverter)
diff --git a/cpp/src/Slice/CPlusPlusUtil.cpp b/cpp/src/Slice/CPlusPlusUtil.cpp
index d1688074dcb..9375a4554fc 100644
--- a/cpp/src/Slice/CPlusPlusUtil.cpp
+++ b/cpp/src/Slice/CPlusPlusUtil.cpp
@@ -24,6 +24,12 @@ using namespace IceUtilInternal;
 namespace
 {
 
+string
+condString(bool ok, const string& str)
+{
+    return ok ? str : "";
+}
+
 string toTemplateArg(const string& arg)
 {
     if(arg.empty())
@@ -143,16 +149,16 @@ dictionaryTypeToString(const DictionaryPtr& dict, const StringList& metaData, in
 
 void
 writeParamAllocateCode(Output& out, const TypePtr& type, bool optional, const string& fixedName,
-                       const StringList& metaData, int typeCtx, bool cpp11, bool endArg)
+                       const StringList& metaData, int typeCtx, bool endArg)
 {
-    string s = typeToString(type, metaData, typeCtx, cpp11);
+    string s = typeToString(type, metaData, typeCtx);
     if(optional)
     {
         s = "IceUtil::Optional<" + toTemplateArg(s) + '>';
     }
     out << nl << s << ' ' << fixedName << ';';
 
-    if(!(typeCtx & TypeContextInParam) || !endArg)
+    if((typeCtx & TypeContextCpp11) || !(typeCtx & TypeContextInParam) || !endArg)
     {
         return; // We're done.
     }
@@ -173,7 +179,7 @@ writeParamAllocateCode(Output& out, const TypePtr& type, bool optional, const st
         string s;
         if(seqType == "%array")
         {
-            s = typeToString(seq, metaData, TypeContextAMIPrivateEnd, cpp11);
+            s = typeToString(seq, metaData, TypeContextAMIPrivateEnd);
         }
         else if(seqType.find("%range") == 0)
         {
@@ -182,7 +188,7 @@ writeParamAllocateCode(Output& out, const TypePtr& type, bool optional, const st
             {
                 md.push_back("cpp:type:" + seqType.substr(strlen("%range:")));
             }
-            s = typeToString(seq, md, 0, cpp11);
+            s = typeToString(seq, md, 0);
         }
 
         if(!s.empty())
@@ -296,9 +302,14 @@ writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const Oper
     string prefix = prepend ? paramPrefix : "";
     string returnValueS = retP.empty() ? string("__ret") : retP;
 
+    string objPrefix = obj.empty() ? obj : obj + ".";
+
+    bool cpp11 = (typeCtx & TypeContextCpp11) != 0;
+
     //
     // Marshal non optional parameters.
     //
+    ParamDeclList requiredParams;
     ParamDeclList optionals;
     for(ParamDeclList::const_iterator p = params.begin(); p != params.end(); ++p)
     {
@@ -308,54 +319,158 @@ writeMarshalUnmarshalParams(Output& out, const ParamDeclList& params, const Oper
         }
         else
         {
-            writeMarshalUnmarshalCode(out, (*p)->type(), false, 0, fixKwd(prefix + (*p)->name()), marshal, (*p)->getMetaData(),
-                                      typeCtx, "", true, obj);
+            requiredParams.push_back(*p);
         }
     }
-    if(op && op->returnType())
+
+
+    if(!requiredParams.empty() || (op && op->returnType() && !op->returnIsOptional()))
     {
-        if(!op->returnIsOptional())
+        if(cpp11)
         {
-            writeMarshalUnmarshalCode(out, op->returnType(), false, 0, returnValueS, marshal, op->getMetaData(), typeCtx,
-                                      "", true, obj);
+            out << nl;
+            if(marshal)
+            {
+                out << "__os->writeAll";
+            }
+            else
+            {
+                out << "__is->readAll";
+            }
+            out << spar;
+            for(ParamDeclList::const_iterator p = requiredParams.begin(); p != requiredParams.end(); ++p)
+            {
+                out << objPrefix + fixKwd(prefix + (*p)->name());
+            }
+            if(op && op->returnType() && !op->returnIsOptional())
+            {
+                out << objPrefix + returnValueS;
+            }
+            out << epar << ";";
+        }
+        else
+        {
+            for(ParamDeclList::const_iterator p = requiredParams.begin(); p != requiredParams.end(); ++p)
+            {
+                writeMarshalUnmarshalCode(out, (*p)->type(), false, 0, fixKwd(prefix + (*p)->name()), marshal, (*p)->getMetaData(),
+                                          typeCtx, "", true, obj);
+            }
+
+            if(op && op->returnType())
+            {
+                if(!op->returnIsOptional())
+                {
+                    writeMarshalUnmarshalCode(out, op->returnType(), false, 0, returnValueS, marshal, op->getMetaData(), typeCtx,
+                                              "", true, obj);
+                }
+            }
         }
     }
 
-    //
-    // Sort optional parameters by tag.
-    //
-    class SortFn
+    if(!optionals.empty() || (op && op->returnType() && op->returnIsOptional()))
     {
-    public:
-        static bool compare(const ParamDeclPtr& lhs, const ParamDeclPtr& rhs)
+        //
+        // Sort optional parameters by tag.
+        //
+        class SortFn
         {
-            return lhs->tag() < rhs->tag();
-        }
-    };
-    optionals.sort(SortFn::compare);
+        public:
+            static bool compare(const ParamDeclPtr& lhs, const ParamDeclPtr& rhs)
+            {
+                return lhs->tag() < rhs->tag();
+            }
+        };
+        optionals.sort(SortFn::compare);
 
-    //
-    // Marshal optional parameters.
-    //
-    bool checkReturnType = op && op->returnIsOptional();
-    for(ParamDeclList::const_iterator p = optionals.begin(); p != optionals.end(); ++p)
-    {
-        if(checkReturnType && op->returnTag() < (*p)->tag())
+        if(cpp11)
+        {
+            out << nl;
+            if(marshal)
+            {
+                out << "__os->writeAll";
+            }
+            else
+            {
+                out << "__is->readAll";
+            }
+            out << spar;
+
+            {
+                //
+                // Tags
+                //
+                ostringstream os;
+                os << '{';
+                bool checkReturnType = op && op->returnIsOptional();
+                bool insertComma = false;
+                for(ParamDeclList::const_iterator p = optionals.begin(); p != optionals.end(); ++p)
+                {
+                    if(checkReturnType && op->returnTag() < (*p)->tag())
+                    {
+                        os << condString(insertComma, ", ") << op->returnTag();
+                        checkReturnType = false;
+                        insertComma = true;
+                    }
+                    os << condString(insertComma, ", ") << (*p)->tag();
+                    insertComma = true;
+                }
+                if(checkReturnType)
+                {
+                    os << condString(insertComma, ", ") << op->returnTag();
+                }
+                os << '}';
+                out << os.str();
+            }
+
+            {
+                //
+                // Parameters
+                //
+                bool checkReturnType = op && op->returnIsOptional();
+                for(ParamDeclList::const_iterator p = optionals.begin(); p != optionals.end(); ++p)
+                {
+                    if(checkReturnType && op->returnTag() < (*p)->tag())
+                    {
+                        out << objPrefix + returnValueS;
+                        checkReturnType = false;
+                    }
+                    out << objPrefix + fixKwd(prefix + (*p)->name());
+                }
+                if(checkReturnType)
+                {
+                    out << objPrefix + returnValueS;
+                }
+            }
+            out << epar << ";";
+        }
+        else
         {
-            writeMarshalUnmarshalCode(out, op->returnType(), true, op->returnTag(), returnValueS, marshal,
-                                      op->getMetaData(), typeCtx, "", true, obj);
-            checkReturnType = false;
+
+            //
+            // Marshal optional parameters.
+            //
+
+            bool checkReturnType = op && op->returnIsOptional();
+            for(ParamDeclList::const_iterator p = optionals.begin(); p != optionals.end(); ++p)
+            {
+                if(checkReturnType && op->returnTag() < (*p)->tag())
+                {
+                    writeMarshalUnmarshalCode(out, op->returnType(), true, op->returnTag(), returnValueS, marshal,
+                                              op->getMetaData(), typeCtx, "", true, obj);
+
+                    checkReturnType = false;
+                }
+                writeMarshalUnmarshalCode(out, (*p)->type(), true, (*p)->tag(), fixKwd(prefix + (*p)->name()), marshal,
+                                          (*p)->getMetaData(), typeCtx, "", true, obj);
+            }
+            if(checkReturnType)
+            {
+                writeMarshalUnmarshalCode(out, op->returnType(), true, op->returnTag(), returnValueS, marshal, op->getMetaData(),
+                                          typeCtx, "", true, obj);
+            }
         }
-        writeMarshalUnmarshalCode(out, (*p)->type(), true, (*p)->tag(), fixKwd(prefix + (*p)->name()), marshal,
-                                  (*p)->getMetaData(), typeCtx, "", true, obj);
-    }
-    if(checkReturnType)
-    {
-        writeMarshalUnmarshalCode(out, op->returnType(), true, op->returnTag(), returnValueS, marshal, op->getMetaData(),
-                                  typeCtx, "", true, obj);
     }
 }
-
 }
 
 Slice::FeatureProfile Slice::featureProfile = Slice::Ice;
@@ -474,8 +589,10 @@ Slice::isMovable(const TypePtr& type)
 }
 
 string
-Slice::typeToString(const TypePtr& type, const StringList& metaData, int typeCtx, bool cpp11)
+Slice::typeToString(const TypePtr& type, const StringList& metaData, int typeCtx)
 {
+    bool cpp11 = (typeCtx & TypeContextCpp11) != 0;
+
     static const char* builtinTable[] =
     {
         "::Ice::Byte",
@@ -563,7 +680,7 @@ Slice::typeToString(const TypePtr& type, const StringList& metaData, int typeCtx
     if(st)
     {
         //
-        // C++11 mapping doesn't accept cpp:class metdata
+        // C++11 mapping doesn't accept cpp:class metadata
         //
         if(!cpp11 && findMetaData(st->getMetaData()) == "%class")
         {
@@ -625,20 +742,20 @@ Slice::typeToString(const TypePtr& type, const StringList& metaData, int typeCtx
 }
 
 string
-Slice::typeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx, bool cpp11)
+Slice::typeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx)
 {
     if(optional)
     {
-        return "IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx, cpp11)) + ">";
+        return "IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx)) + ">";
     }
     else
     {
-        return typeToString(type, metaData, typeCtx, cpp11);
+        return typeToString(type, metaData, typeCtx);
     }
 }
 
 string
-Slice::returnTypeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx, bool cpp11)
+Slice::returnTypeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx)
 {
     if(!type)
     {
@@ -647,15 +764,17 @@ Slice::returnTypeToString(const TypePtr& type, bool optional, const StringList&
 
     if(optional)
     {
-        return "IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx, cpp11)) + ">";
+        return "IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx)) + ">";
     }
 
-    return typeToString(type, metaData, typeCtx, cpp11);
+    return typeToString(type, metaData, typeCtx);
 }
 
 string
-Slice::inputTypeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx, bool cpp11)
+Slice::inputTypeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx)
 {
+    bool cpp11 = (typeCtx & TypeContextCpp11) != 0;
+
     static const char* cpp98InputBuiltinTable[] =
     {
         "::Ice::Byte",
@@ -692,7 +811,7 @@ Slice::inputTypeToString(const TypePtr& type, bool optional, const StringList& m
 
     if(optional)
     {
-        return "const IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx, cpp11)) +">&";
+        return "const IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx)) +">&";
     }
 
     BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
@@ -729,7 +848,7 @@ Slice::inputTypeToString(const TypePtr& type, bool optional, const StringList& m
         {
             if(cl->definition() && cl->definition()->isDelegate())
             {
-                return classDefToDelegateString(cl->definition(), typeCtx, cpp11);
+                return classDefToDelegateString(cl->definition(), typeCtx);
             }
             else if(cl->isInterface() && !cl->isLocal())
             {
@@ -815,8 +934,10 @@ Slice::inputTypeToString(const TypePtr& type, bool optional, const StringList& m
 }
 
 string
-Slice::outputTypeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx, bool cpp11)
+Slice::outputTypeToString(const TypePtr& type, bool optional, const StringList& metaData, int typeCtx)
 {
+    bool cpp11 = (typeCtx & TypeContextCpp11) != 0;
+
     static const char* outputBuiltinTable[] =
     {
         "::Ice::Byte&",
@@ -851,7 +972,7 @@ Slice::outputTypeToString(const TypePtr& type, bool optional, const StringList&
 
     if(optional)
     {
-        return "IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx, cpp11)) +">&";
+        return "IceUtil::Optional<" + toTemplateArg(typeToString(type, metaData, typeCtx)) +">&";
     }
 
     BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
@@ -888,7 +1009,7 @@ Slice::outputTypeToString(const TypePtr& type, bool optional, const StringList&
         {
             if(cl->definition() && cl->definition()->isDelegate())
             {
-                return classDefToDelegateString(cl->definition(), typeCtx, cpp11) + "&";
+                return classDefToDelegateString(cl->definition(), typeCtx) + "&";
             }
             else if(cl->isInterface() && !cl->isLocal())
             {
@@ -1191,8 +1312,7 @@ Slice::writeUnmarshalCode(Output& out, const ParamDeclList& params, const Operat
 }
 
 void
-Slice::writeAllocateCode(Output& out, const ParamDeclList& params, const OperationPtr& op, bool prepend, int typeCtx,
-                         bool cpp11)
+Slice::writeAllocateCode(Output& out, const ParamDeclList& params, const OperationPtr& op, bool prepend, int typeCtx)
 {
     string prefix = prepend ? paramPrefix : "";
     string returnValueS = "__ret";
@@ -1200,12 +1320,12 @@ Slice::writeAllocateCode(Output& out, const ParamDeclList& params, const Operati
     for(ParamDeclList::const_iterator p = params.begin(); p != params.end(); ++p)
     {
         writeParamAllocateCode(out, (*p)->type(), (*p)->optional(), fixKwd(prefix + (*p)->name()), (*p)->getMetaData(),
-                               typeCtx, cpp11, getEndArg((*p)->type(),(*p)->getMetaData(), (*p)->name()) != (*p)->name());
+                               typeCtx, getEndArg((*p)->type(), (*p)->getMetaData(), (*p)->name()) != (*p)->name());
     }
 
     if(op && op->returnType())
     {
-        writeParamAllocateCode(out, op->returnType(), op->returnIsOptional(), returnValueS, op->getMetaData(), typeCtx, cpp11,
+        writeParamAllocateCode(out, op->returnType(), op->returnIsOptional(), returnValueS, op->getMetaData(), typeCtx,
                                getEndArg(op->returnType(), op->getMetaData(), returnValueS) != returnValueS);
     }
 
@@ -1379,28 +1499,23 @@ Slice::findMetaData(const StringList& metaData, int typeCtx)
             // the return value is % followed by the string after cpp:.
             //
             // The priority of the metadata is as follows:
-            // 1: protobuf
-            // 2: array, range, view-type for "view" parameters
-            // 3: class
+            // 1: array, range (C++98 only), view-type for "view" parameters
+            // 2: class (C++98 only), unscoped (C++11 only)
+            //
 
             if(pos != string::npos)
             {
                 string ss = str.substr(prefix.size());
 
-                if(ss.find("protobuf:") == 0)
-                {
-                    return str.substr(pos + 1);
-                }
-
                 if(typeCtx & (TypeContextInParam | TypeContextAMIPrivateEnd))
                 {
-                    if(ss.find("range:") == 0)
+                    if(ss.find("view-type:") == 0)
                     {
-                        return string("%") + str.substr(prefix.size());
+                        return str.substr(pos + 1);
                     }
-                    else if(ss.find("view-type:") == 0)
+                    else if(ss.find("range:") == 0 && !(typeCtx & TypeContextCpp11))
                     {
-                        return str.substr(pos + 1);
+                        return string("%") + str.substr(prefix.size());
                     }
                 }
 
@@ -1416,7 +1531,7 @@ Slice::findMetaData(const StringList& metaData, int typeCtx)
                 {
                     return "%array";
                 }
-                else if(ss == "range")
+                else if(ss == "range" && !(typeCtx & TypeContextCpp11))
                 {
                     return "%range";
                 }
@@ -1427,11 +1542,11 @@ Slice::findMetaData(const StringList& metaData, int typeCtx)
             else
             {
                 string ss = str.substr(prefix.size());
-                if(ss == "class")
+                if(ss == "class" && !(typeCtx & TypeContextCpp11))
                 {
                     return "%class";
                 }
-                else if(ss == "unscoped")
+                else if(ss == "unscoped" && (typeCtx & TypeContextCpp11))
                 {
                     return "%unscoped";
                 }
@@ -1488,7 +1603,7 @@ Slice::getDataMemberRef(const DataMemberPtr& p)
 }
 
 string
-Slice::classDefToDelegateString(const ClassDefPtr& cl, int typeCtx, bool cpp11)
+Slice::classDefToDelegateString(const ClassDefPtr& cl, int typeCtx)
 {
     assert(cl->isDelegate());
 
@@ -1496,7 +1611,7 @@ Slice::classDefToDelegateString(const ClassDefPtr& cl, int typeCtx, bool cpp11)
     OperationPtr op = cl->allOperations().front();
 
     TypePtr ret = op->returnType();
-    string retS = returnTypeToString(ret, op->returnIsOptional(), op->getMetaData(), typeCtx, cpp11);
+    string retS = returnTypeToString(ret, op->returnIsOptional(), op->getMetaData(), typeCtx);
 
     string t = "::std::function<" + retS + "(";
 
@@ -1505,11 +1620,11 @@ Slice::classDefToDelegateString(const ClassDefPtr& cl, int typeCtx, bool cpp11)
     {
         if((*q)->isOutParam())
         {
-            t += outputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), typeCtx, cpp11);
+            t += outputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), typeCtx);
         }
         else
         {
-            t += inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), typeCtx, cpp11);
+            t += inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), typeCtx);
         }
 
         t += distance(q, paramList.end()) == 1  ? "" : ", ";
diff --git a/cpp/src/Slice/CPlusPlusUtil.h b/cpp/src/Slice/CPlusPlusUtil.h
index b60d6036c2f..da430845e30 100644
--- a/cpp/src/Slice/CPlusPlusUtil.h
+++ b/cpp/src/Slice/CPlusPlusUtil.h
@@ -34,15 +34,16 @@ const int TypeContextAMIPrivateEnd = 4;
 const int TypeContextAMICallPrivateEnd = 8;
 const int TypeContextUseWstring = 16;
 const int TypeContextLocal = 32;
+const int TypeContextCpp11 = 64;
 
 bool isMovable(const TypePtr&);
 
-std::string typeToString(const TypePtr&, const StringList& = StringList(), int = 0, bool = false);
-std::string typeToString(const TypePtr&, bool, const StringList& = StringList(), int = 0, bool = false);
-std::string returnTypeToString(const TypePtr&, bool, const StringList& = StringList(), int = 0, bool = false);
-std::string inputTypeToString(const TypePtr&, bool, const StringList& = StringList(), int = 0, bool = false);
-std::string outputTypeToString(const TypePtr&, bool, const StringList& = StringList(), int = 0, bool = false);
-std::string operationModeToString(Operation::Mode, bool cpp11 = false);
+std::string typeToString(const TypePtr&, const StringList& = StringList(), int = 0);
+std::string typeToString(const TypePtr&, bool, const StringList& = StringList(), int = 0);
+std::string returnTypeToString(const TypePtr&, bool, const StringList& = StringList(), int = 0);
+std::string inputTypeToString(const TypePtr&, bool, const StringList& = StringList(), int = 0);
+std::string outputTypeToString(const TypePtr&, bool, const StringList& = StringList(), int = 0);
+std::string operationModeToString(Operation::Mode, bool = false);
 std::string opFormatTypeToString(const OperationPtr&);
 
 std::string fixKwd(const std::string&);
@@ -54,8 +55,7 @@ void writeMarshalUnmarshalCode(::IceUtilInternal::Output&, const TypePtr&, bool,
 void writeMarshalCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, bool, int = 0);
 void writeUnmarshalCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, bool, int = 0,
                         const std::string& = "", const std::string& = "");
-void writeAllocateCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, bool, int = 0,
-                       bool = false);
+void writeAllocateCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, bool, int = 0);
 
 std::string getEndArg(const TypePtr&, const StringList&, const std::string&);
 void writeEndCode(::IceUtilInternal::Output&, const ParamDeclList&, const OperationPtr&, bool = false);
@@ -69,7 +69,7 @@ bool inWstringModule(const SequencePtr&);
 
 std::string getDataMemberRef(const DataMemberPtr&);
 
-std::string classDefToDelegateString(const ClassDefPtr&, int = 0, bool = false);
+std::string classDefToDelegateString(const ClassDefPtr&, int = 0);
 }
 
 #endif
diff --git a/cpp/src/slice2cpp/Gen.cpp b/cpp/src/slice2cpp/Gen.cpp
index c7eef696620..645aea8a316 100644
--- a/cpp/src/slice2cpp/Gen.cpp
+++ b/cpp/src/slice2cpp/Gen.cpp
@@ -400,7 +400,7 @@ writeConstantValue(IceUtilInternal::Output& out, const TypePtr& type, const Synt
             EnumPtr ep = EnumPtr::dynamicCast(type);
             if(ep)
             {
-                bool unscoped = findMetaData(ep->getMetaData()) == "%unscoped";
+                bool unscoped = findMetaData(ep->getMetaData(), cpp11 ? TypeContextCpp11 : 0) == "%unscoped";
                 if(!cpp11 || unscoped)
                 {
                     out << fixKwd(value);
@@ -4144,7 +4144,7 @@ Slice::Gen::ImplVisitor::defaultValue(const TypePtr& type, const StringList& met
         SequencePtr seq = SequencePtr::dynamicCast(type);
         if(seq)
         {
-            return typeToString(seq, metaData, _useWstring, true) + "()";
+            return typeToString(seq, metaData, _useWstring | TypeContextCpp11) + "()";
         }
 
         DictionaryPtr dict = DictionaryPtr::dynamicCast(type);
@@ -5665,7 +5665,8 @@ Slice::Gen::Cpp11TypesVisitor::visitExceptionStart(const ExceptionPtr& p)
 
     for(DataMemberList::const_iterator q = allDataMembers.begin(); q != allDataMembers.end(); ++q)
     {
-        string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring, true);
+        string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(),
+                                            _useWstring | TypeContextCpp11);
         allTypes.push_back(typeName);
         allParamDecls.push_back(typeName + " " + fixKwd("__ice_" + (*q)->name()));
     }
@@ -6010,7 +6011,8 @@ void
 Slice::Gen::Cpp11TypesVisitor::visitDataMember(const DataMemberPtr& p)
 {
     string name = fixKwd(p->name());
-    H << nl << typeToString(p->type(), p->optional(), p->getMetaData(), _useWstring, true) << ' ' << name;
+    H << nl << typeToString(p->type(), p->optional(), p->getMetaData(), _useWstring | TypeContextCpp11)
+      << ' ' << name;
 
     string defaultValue = p->defaultValue();
     if(!defaultValue.empty())
@@ -6028,7 +6030,7 @@ Slice::Gen::Cpp11TypesVisitor::visitSequence(const SequencePtr& p)
     string name = fixKwd(p->name());
     TypePtr type = p->type();
     int typeCtx = p->isLocal() ? (_useWstring | TypeContextLocal) : _useWstring;
-    string s = typeToString(type, p->typeMetaData(), typeCtx, true);
+    string s = typeToString(type, p->typeMetaData(), typeCtx | TypeContextCpp11);
     StringList metaData = p->getMetaData();
 
     string seqType = findMetaData(metaData, _useWstring);
@@ -6058,12 +6060,12 @@ Slice::Gen::Cpp11TypesVisitor::visitDictionary(const DictionaryPtr& p)
 
         TypePtr keyType = p->keyType();
         TypePtr valueType = p->valueType();
-        string ks = typeToString(keyType, p->keyMetaData(), typeCtx, true);
+        string ks = typeToString(keyType, p->keyMetaData(), typeCtx | TypeContextCpp11);
         if(ks[0] == ':')
         {
             ks.insert(0, " ");
         }
-        string vs = typeToString(valueType, p->valueMetaData(), typeCtx, true);
+        string vs = typeToString(valueType, p->valueMetaData(), typeCtx | TypeContextCpp11);
 
         H << sp << nl << "typedef ::std::map<" << ks << ", " << vs << "> " << name << ';';
     }
@@ -6198,7 +6200,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
     TypePtr ret = p->returnType();
 
     bool retIsOpt = p->returnIsOptional();
-    string retS = returnTypeToString(ret, retIsOpt, p->getMetaData(), _useWstring, true);
+    string retS = returnTypeToString(ret, retIsOpt, p->getMetaData(), _useWstring | TypeContextCpp11);
 
     ContainerPtr container = p->container();
     ClassDefPtr cl = ClassDefPtr::dynamicCast(container);
@@ -6221,10 +6223,10 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
 
     if(ret)
     {
-        futureOutParams.push_back(typeToString(ret, retIsOpt, p->getMetaData(), _useWstring, true));
+        futureOutParams.push_back(typeToString(ret, retIsOpt, p->getMetaData(), _useWstring | TypeContextCpp11));
 
         lambdaOutParams.push_back(
-            typeToString(ret, retIsOpt, p->getMetaData(), _useWstring | TypeContextInParam, true));
+            typeToString(ret, retIsOpt, p->getMetaData(), _useWstring | TypeContextInParam | TypeContextCpp11));
 
         outParamsHasOpt |= p->returnIsOptional();
     }
@@ -6236,11 +6238,13 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
 
         if((*q)->isOutParam())
         {
-            futureOutParams.push_back(typeToString((*q)->type(), (*q)->optional(), metaData, _useWstring, true));
-            lambdaOutParams.push_back(
-                typeToString((*q)->type(), (*q)->optional(), metaData, _useWstring | TypeContextInParam, true));
+            futureOutParams.push_back(typeToString((*q)->type(), (*q)->optional(), metaData,
+                                                   _useWstring | TypeContextCpp11));
+            lambdaOutParams.push_back(typeToString((*q)->type(), (*q)->optional(), metaData,
+                                                   _useWstring | TypeContextInParam | TypeContextCpp11));
 
-            string outputTypeString = outputTypeToString((*q)->type(), (*q)->optional(), metaData, _useWstring, true);
+            string outputTypeString = outputTypeToString((*q)->type(), (*q)->optional(), metaData,
+                                                         _useWstring | TypeContextCpp11);
 
             params.push_back(outputTypeString);
             paramsDecl.push_back(outputTypeString + ' ' + paramName);
@@ -6255,7 +6259,8 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
         }
         else
         {
-            string typeString = inputTypeToString((*q)->type(), (*q)->optional(), metaData, _useWstring, true);
+            string typeString = inputTypeToString((*q)->type(), (*q)->optional(), metaData,
+                                                  _useWstring | TypeContextCpp11);
 
             params.push_back(typeString);
             paramsDecl.push_back(typeString + ' ' + paramName);
@@ -6427,8 +6432,8 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
         C << nl << "__read = [__response](::Ice::InputStream* __is)";
         C << sb;
         C << nl << "__is->startEncapsulation();";
-        writeAllocateCode(C, outParams, p, true, _useWstring | TypeContextInParam, true);
-        writeUnmarshalCode(C, outParams, p, true, _useWstring | TypeContextInParam);
+        writeAllocateCode(C, outParams, p, true, _useWstring | TypeContextInParam | TypeContextCpp11);
+        writeUnmarshalCode(C, outParams, p, true, _useWstring | TypeContextInParam | TypeContextCpp11);
 
         if(p->returnsClasses(false))
         {
@@ -6471,7 +6476,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
         {
             C << "[&](::Ice::OutputStream* __os)";
             C << sb;
-            writeMarshalCode(C, inParams, 0, true, TypeContextInParam);
+            writeMarshalCode(C, inParams, 0, true, TypeContextInParam | TypeContextCpp11);
             if(p->sendsClasses(false))
             {
                 C << nl << "__os->writePendingValues();";
@@ -6595,7 +6600,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
     {
         C << "[&](::Ice::OutputStream* __os)";
         C << sb;
-        writeMarshalCode(C, inParams, 0, true, TypeContextInParam);
+        writeMarshalCode(C, inParams, 0, true, TypeContextInParam | TypeContextCpp11);
         if(p->sendsClasses(false))
         {
             C << nl << "__os->writePendingValues();";
@@ -6655,7 +6660,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
         C << "," << nl << "[](::Ice::InputStream* __is)";
         C << sb;
         C << nl << futureT << " v;";
-        writeUnmarshalCode(C, outParams, p, false, _useWstring, returnValueS, "v");
+        writeUnmarshalCode(C, outParams, p, false, _useWstring | TypeContextCpp11, returnValueS, "v");
 
         if(p->returnsClasses(false))
         {
@@ -6674,8 +6679,8 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
         C << "," << nl << "[](::Ice::InputStream* __is)";
         C << sb;
 
-        writeAllocateCode(C, outParams, p, true, _useWstring, true);
-        writeUnmarshalCode(C, outParams, p, true, _useWstring);
+        writeAllocateCode(C, outParams, p, true, _useWstring | TypeContextCpp11);
+        writeUnmarshalCode(C, outParams, p, true, _useWstring | TypeContextCpp11);
 
         if(p->returnsClasses(false))
         {
@@ -6700,7 +6705,7 @@ Slice::Gen::Cpp11ProxyVisitor::visitOperation(const OperationPtr& p)
 void
 Slice::Gen::Cpp11TypesVisitor::visitEnum(const EnumPtr& p)
 {
-    bool unscoped = findMetaData(p->getMetaData()) == "%unscoped";
+    bool unscoped = findMetaData(p->getMetaData(), TypeContextCpp11) == "%unscoped";
     H << sp << nl << "enum ";
     if(!unscoped)
     {
@@ -6741,7 +6746,8 @@ void
 Slice::Gen::Cpp11TypesVisitor::visitConst(const ConstPtr& p)
 {
     H << sp;
-    H << nl << (isConstexprType(p->type()) ? "constexpr " : "const ") << typeToString(p->type(), p->typeMetaData(), _useWstring, true) << " " << fixKwd(p->name())
+    H << nl << (isConstexprType(p->type()) ? "constexpr " : "const ")
+      << typeToString(p->type(), p->typeMetaData(), _useWstring | TypeContextCpp11) << " " << fixKwd(p->name())
       << " = ";
     writeConstantValue(H, p->type(), p->valueType(), p->value(), _useWstring, p->typeMetaData(), true);
     H << ';';
@@ -6769,7 +6775,8 @@ void
 Slice::Gen::Cpp11ObjectVisitor::emitDataMember(const DataMemberPtr& p)
 {
     string name = fixKwd(p->name());
-    H << sp << nl << typeToString(p->type(), p->optional(), p->getMetaData(), _useWstring, true) << ' ' << name;
+    H << sp << nl << typeToString(p->type(), p->optional(), p->getMetaData(),
+                                  _useWstring | TypeContextCpp11) << ' ' << name;
 
     string defaultValue = p->defaultValue();
     if(!defaultValue.empty())
@@ -6903,7 +6910,7 @@ Slice::Gen::Cpp11LocalObjectVisitor::visitClassDefStart(const ClassDefPtr& p)
         {
             H << sp << nl << name << "() :";
             H.inc();
-            writeDataMemberInitializers(H, dataMembers, _useWstring, true);
+            writeDataMemberInitializers(H, dataMembers, _useWstring | TypeContextCpp11);
             H.dec();
             H << sb;
             H << eb;
@@ -7005,9 +7012,10 @@ Slice::Gen::Cpp11LocalObjectVisitor::visitOperation(const OperationPtr& p)
     string scoped = fixKwd(p->scoped());
     string scope = fixKwd(p->scope());
 
-    int typeCtx = _useWstring | TypeContextLocal;
+    int typeCtx = _useWstring | TypeContextLocal | TypeContextCpp11;
     TypePtr ret = p->returnType();
-    string retS = returnTypeToString(ret, p->returnIsOptional(), p->getMetaData(), typeCtx, true);
+    string retS = returnTypeToString(ret, p->returnIsOptional(), p->getMetaData(),
+                                     typeCtx | TypeContextCpp11);
 
     string params = "(";
     string paramsDecl = "(";
@@ -7030,12 +7038,12 @@ Slice::Gen::Cpp11LocalObjectVisitor::visitOperation(const OperationPtr& p)
         if(isOutParam)
         {
             outParams.push_back(*q);
-            typeString = outputTypeToString(type, (*q)->optional(), (*q)->getMetaData(), typeCtx, true);
+            typeString = outputTypeToString(type, (*q)->optional(), (*q)->getMetaData(), typeCtx);
         }
         else
         {
             inParams.push_back(*q);
-            typeString = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), typeCtx, true);
+            typeString = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), typeCtx);
         }
 
         if(q != paramList.begin())
@@ -7082,7 +7090,7 @@ Slice::Gen::Cpp11LocalObjectVisitor::visitOperation(const OperationPtr& p)
             string typeString;
             if(!(*r)->isOutParam())
             {
-                typeString = inputTypeToString((*r)->type(), (*r)->optional(), metaData, typeCtx, true);
+                typeString = inputTypeToString((*r)->type(), (*r)->optional(), metaData, typeCtx);
                 paramsDeclAMI.push_back(typeString + ' ' + paramName);
             }
         }
@@ -7364,7 +7372,7 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p)
     string name = p->name();
 
     TypePtr ret = p->returnType();
-    string retS = returnTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring, true);
+    string retS = returnTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring | TypeContextCpp11);
 
     string params = "(";
     string paramsDecl = "(";
@@ -7397,14 +7405,16 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p)
         if(isOutParam)
         {
             outParams.push_back(*q);
-            typeString = outputTypeToString(type, (*q)->optional(), (*q)->getMetaData(), _useWstring, true);
-            outDecls.push_back(inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring, true));
+            typeString = outputTypeToString(type, (*q)->optional(), (*q)->getMetaData(),
+                                            _useWstring | TypeContextCpp11);
+            outDecls.push_back(inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(),
+                                                 _useWstring | TypeContextCpp11));
         }
         else
         {
             inParams.push_back(*q);
             typeString = typeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(),
-                                      _useWstring | TypeContextInParam, true);
+                                      _useWstring | TypeContextInParam | TypeContextCpp11);
         }
 
         if(q != paramList.begin())
@@ -7431,8 +7441,8 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p)
 
         for(ParamDeclList::iterator q = outParams.begin(); q != outParams.end(); ++q)
         {
-            string typeString
-                = typeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring, true);
+            string typeString = typeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(),
+                                             _useWstring | TypeContextCpp11);
 
             dataMembers.push_back(typeString + " " + fixKwd((*q)->name()));
 
@@ -7477,7 +7487,7 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p)
             argsAMD += ", ";
         }
         paramsAMD += typeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(),
-                                  _useWstring | TypeContextInParam, true);
+                                  _useWstring | TypeContextInParam | TypeContextCpp11);
         if(isMovable((*q)->type()))
         {
             argsAMD += "::std::move(" + fixKwd(string(paramPrefix) + (*q)->name()) + ")";
@@ -7490,7 +7500,8 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p)
 
     if(ret)
     {
-        string typeString = inputTypeToString(ret, p->returnIsOptional(), p->getMetaData(), _useWstring, true);
+        string typeString = inputTypeToString(ret, p->returnIsOptional(), p->getMetaData(),
+                                              _useWstring | TypeContextCpp11);
         responseParams = typeString;
         responseParamsDecl = typeString + " __ret";
         if(!outParams.empty())
@@ -7507,7 +7518,8 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p)
             responseParams += ", ";
             responseParamsDecl += ", ";
         }
-        string typeString = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring, true);
+        string typeString = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(),
+                                              _useWstring | TypeContextCpp11);
         responseParams += typeString;
         responseParamsDecl += typeString + " " + fixKwd(string(paramPrefix) + (*q)->name());
     }
@@ -7562,9 +7574,9 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p)
 
     if(!inParams.empty())
     {
-        C << nl << "::Ice::InputStream* __is = __inS.startReadParams();";
-        writeAllocateCode(C, inParams, 0, true, _useWstring | TypeContextInParam, true);
-        writeUnmarshalCode(C, inParams, 0, true, TypeContextInParam);
+        C << nl << "auto __is = __inS.startReadParams();";
+        writeAllocateCode(C, inParams, 0, true, _useWstring | TypeContextInParam | TypeContextCpp11);
+        writeUnmarshalCode(C, inParams, 0, true, _useWstring | TypeContextInParam | TypeContextCpp11);
         if(p->sendsClasses(false))
         {
             C << nl << "__is->readPendingValues();";
@@ -7578,7 +7590,7 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p)
 
     if(!amd)
     {
-        writeAllocateCode(C, outParams, 0, true, _useWstring, true);
+        writeAllocateCode(C, outParams, 0, true, _useWstring | TypeContextCpp11);
         if(!throws.empty())
         {
             C << nl << "try";
@@ -7593,7 +7605,7 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p)
         if(ret || !outParams.empty())
         {
             C << nl << "auto __os = __inS.__startWriteParams(" << opFormatTypeToString(p) << ");";
-            writeMarshalCode(C, outParams, p, true);
+            writeMarshalCode(C, outParams, p, true, TypeContextCpp11);
             if(p->returnsClasses(false))
             {
                 C << nl << "__os->writePendingValues();";
@@ -7668,7 +7680,7 @@ Slice::Gen::Cpp11InterfaceVisitor::visitOperation(const OperationPtr& p)
         if(ret || !outParams.empty())
         {
             C << nl << "auto __os = inS->__startWriteParams(" << opFormatTypeToString(p) << ");";
-            writeMarshalCode(C, outParams, p, true);
+            writeMarshalCode(C, outParams, p, true, TypeContextCpp11);
             if(p->returnsClasses(false))
             {
                 C << nl << "__os->writePendingValues();";
@@ -7981,7 +7993,8 @@ Slice::Gen::Cpp11ObjectVisitor::emitOneShotConstructor(const ClassDefPtr& p)
 
         for(DataMemberList::const_iterator q = allDataMembers.begin(); q != allDataMembers.end(); ++q)
         {
-            string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring, true);
+            string typeName = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(),
+                                                _useWstring | TypeContextCpp11);
             allParamDecls.push_back(typeName + " __ice_" + (*q)->name());
         }
 
@@ -8264,7 +8277,7 @@ Slice::Gen::Cpp11ImplVisitor::defaultValue(const TypePtr& type, const StringList
         SequencePtr seq = SequencePtr::dynamicCast(type);
         if(seq)
         {
-            return typeToString(seq, metaData, _useWstring, true) + "()";
+            return typeToString(seq, metaData, _useWstring | TypeContextCpp11) + "()";
         }
 
         DictionaryPtr dict = DictionaryPtr::dynamicCast(type);
@@ -8353,7 +8366,8 @@ Slice::Gen::Cpp11ImplVisitor::visitClassDefStart(const ClassDefPtr& p)
         string opName = op->name();
 
         TypePtr ret = op->returnType();
-        string retS = returnTypeToString(ret, op->returnIsOptional(), op->getMetaData(), _useWstring, true);
+        string retS = returnTypeToString(ret, op->returnIsOptional(), op->getMetaData(),
+                                         _useWstring | TypeContextCpp11);
 
         ParamDeclList params = op->parameters();
         ParamDeclList outParams;
@@ -8380,12 +8394,14 @@ Slice::Gen::Cpp11ImplVisitor::visitClassDefStart(const ClassDefPtr& p)
             for(ParamDeclList::const_iterator q = inParams.begin(); q != inParams.end(); ++q)
             {
                 H << typeToString((*q)->type(), (*q)->optional(),
-                                  (*q)->getMetaData(), _useWstring | TypeContextInParam, true) << "," << nl;
+                                  (*q)->getMetaData(), _useWstring | TypeContextInParam | TypeContextCpp11)
+                  << "," << nl;
             }
 
             if(ret)
             {
-                string typeS = inputTypeToString(ret, op->returnIsOptional(), op->getMetaData(), _useWstring, true);
+                string typeS = inputTypeToString(ret, op->returnIsOptional(), op->getMetaData(),
+                                                 _useWstring | TypeContextCpp11);
                 responseParams = typeS;
                 responseParamsDecl = typeS + " __ret";
                 if(!outParams.empty())
@@ -8402,7 +8418,8 @@ Slice::Gen::Cpp11ImplVisitor::visitClassDefStart(const ClassDefPtr& p)
                     responseParams += ", ";
                     responseParamsDecl += ", ";
                 }
-                string typeS = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring, true);
+                string typeS = inputTypeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(),
+                                                 _useWstring | TypeContextCpp11);
                 responseParams += typeS;
                 responseParamsDecl += typeS + " " + fixKwd(string(paramPrefix) + (*q)->name());
             }
@@ -8418,7 +8435,8 @@ Slice::Gen::Cpp11ImplVisitor::visitClassDefStart(const ClassDefPtr& p)
             C.useCurrentPosAsIndent();
             for(ParamDeclList::const_iterator q = inParams.begin(); q != inParams.end(); ++q)
             {
-                C << typeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(), _useWstring | TypeContextInParam, true);
+                C << typeToString((*q)->type(), (*q)->optional(), (*q)->getMetaData(),
+                                  _useWstring | TypeContextInParam | TypeContextCpp11);
                 C << ' ' << fixKwd((*q)->name()) << "," << nl;
             }
 
@@ -8470,11 +8488,13 @@ Slice::Gen::Cpp11ImplVisitor::visitClassDefStart(const ClassDefPtr& p)
                 string typeString;
                 if((*q)->isOutParam())
                 {
-                    typeString = outputTypeToString((*q)->type(), (*q)->optional(), metaData, _useWstring, true);
+                    typeString = outputTypeToString((*q)->type(), (*q)->optional(), metaData,
+                                                    _useWstring | TypeContextCpp11);
                 }
                 else
                 {
-                    typeString = typeToString((*q)->type(), (*q)->optional(), metaData, _useWstring | TypeContextInParam, true);
+                    typeString = typeToString((*q)->type(), (*q)->optional(), metaData,
+                                              _useWstring | TypeContextInParam | TypeContextCpp11);
                 }
                 H << typeString;
             }
@@ -8505,13 +8525,15 @@ Slice::Gen::Cpp11ImplVisitor::visitClassDefStart(const ClassDefPtr& p)
                 string typeString;
                 if((*q)->isOutParam())
                 {
-                    C << outputTypeToString((*q)->type(), (*q)->optional(), metaData, _useWstring, true) << " "
+                    C << outputTypeToString((*q)->type(), (*q)->optional(), metaData, _useWstring | TypeContextCpp11)
+                      << " "
                       << fixKwd((*q)->name());
                 }
                 else
                 {
-                    C << typeToString((*q)->type(), (*q)->optional(), metaData, _useWstring | TypeContextInParam, true) << " /*"
-                      << fixKwd((*q)->name()) << "*/";
+                    C << typeToString((*q)->type(), (*q)->optional(), metaData,
+                                      _useWstring | TypeContextInParam | TypeContextCpp11)
+                      << " /*" << fixKwd((*q)->name()) << "*/";
                 }
             }
             if(!p->isLocal())
diff --git a/cpp/test/Ice/custom/AllTests.cpp b/cpp/test/Ice/custom/AllTests.cpp
index a674024fde4..4137ad68f30 100644
--- a/cpp/test/Ice/custom/AllTests.cpp
+++ b/cpp/test/Ice/custom/AllTests.cpp
@@ -424,8 +424,6 @@ public:
         called();
     }
 
-#ifndef ICE_CPP11_MAPPING
-
     void opClassStruct(const ::Test::ClassStructPtr& ret,
                        const ::Test::ClassStructPtr& cs1,
                        const ::Test::ClassStructSeq& seq,
@@ -438,7 +436,6 @@ public:
         test(seq == in.second);
         called();
     }
-#endif
 
     void opString(const wstring& ret, const wstring& out, const InParamPtr& cookie)
     {
@@ -642,8 +639,11 @@ allTests(const Ice::CommunicatorPtr& communicator)
         string out;
         string ret = t->opString(in, out);
 
+        test(ret == out);
+#ifdef ICE_CPP11_MAPPING
+        test(ret == in);
+#else
         //
-        // TODO: improve test
         // When a parameter is mapped as a string_view on both sides,
         // no conversion occurs, and all is good
         // However, when a parameter is mapped as a string on one side and
@@ -651,8 +651,8 @@ allTests(const Ice::CommunicatorPtr& communicator)
         // the string converter converts the string but not the string_view,
         // and we have a mismatch
         //
-        test(ret == out);
         test(ret.size() == in.size());
+#endif
     }
     cout << "ok" << endl;
 
@@ -747,10 +747,13 @@ allTests(const Ice::CommunicatorPtr& communicator)
         in[2] = true;
         in[3] = false;
         in[4] = true;
-        pair<Test::BoolSeq::const_iterator, Test::BoolSeq::const_iterator> inPair(in.begin(), in.end());
-
         Test::BoolSeq out;
+#ifdef ICE_CPP11_MAPPING
+        Test::BoolSeq ret = t->opBoolRange(in, out);
+#else
+        pair<Test::BoolSeq::const_iterator, Test::BoolSeq::const_iterator> inPair(in.begin(), in.end());
         Test::BoolSeq ret = t->opBoolRange(inPair, out);
+#endif
         test(out == in);
         test(ret == in);
     }
@@ -762,10 +765,13 @@ allTests(const Ice::CommunicatorPtr& communicator)
         in.push_back('3');
         in.push_back('4');
         in.push_back('5');
-        pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> inPair(in.begin(), in.end());
-
         Test::ByteList out;
+#ifdef ICE_CPP11_MAPPING
+        Test::ByteList ret = t->opByteRange(in, out);
+#else
+        pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> inPair(in.begin(), in.end());
         Test::ByteList ret = t->opByteRange(inPair, out);
+#endif
         test(out == in);
         test(ret == in);
     }
@@ -783,10 +789,13 @@ allTests(const Ice::CommunicatorPtr& communicator)
         in.push_back(v);
         v.s = "strings.";
         in.push_back(v);
-        pair<Test::VariableList::const_iterator, Test::VariableList::const_iterator> inPair(in.begin(), in.end());
-
         Test::VariableList out;
+#ifdef ICE_CPP11_MAPPING
+        Test::VariableList ret = t->opVariableRange(in, out);
+#else
+        pair<Test::VariableList::const_iterator, Test::VariableList::const_iterator> inPair(in.begin(), in.end());
         Test::VariableList ret = t->opVariableRange(inPair, out);
+#endif
         test(out == in);
         test(ret == in);
     }
@@ -798,10 +807,13 @@ allTests(const Ice::CommunicatorPtr& communicator)
         in.push_back('3');
         in.push_back('4');
         in.push_back('5');
-        pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> inPair(in.begin(), in.end());
-
         Test::ByteList out;
+#ifdef ICE_CPP11_MAPPING
+        Test::ByteList ret = t->opByteRangeType(in, out);
+#else
+        pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> inPair(in.begin(), in.end());
         Test::ByteList ret = t->opByteRangeType(inPair, out);
+#endif
         test(out == in);
         test(ret == in);
     }
@@ -825,11 +837,14 @@ allTests(const Ice::CommunicatorPtr& communicator)
         v.s = "strings.";
         in.push_back(v);
         inSeq.push_back(v);
+        Test::VariableList out;
+#ifdef ICE_CPP11_MAPPING
+        Test::VariableList ret = t->opVariableRangeType(in, out);
+#else
         pair<deque<Test::Variable>::const_iterator, deque<Test::Variable>::const_iterator>
             inPair(inSeq.begin(), inSeq.end());
-
-        Test::VariableList out;
         Test::VariableList ret = t->opVariableRangeType(inPair, out);
+#endif
         test(out == in);
         test(ret == in);
     }
@@ -1205,8 +1220,11 @@ allTests(const Ice::CommunicatorPtr& communicator)
         for(std::map<int, Util::string_view>::const_iterator p = idict.begin();
             p != idict.end(); ++p)
         {
+#ifdef ICE_CPP11_MAPPING
+            test(out[p->first] == p->second.to_string());
+#else
             test(out[p->first].size() == p->second.size());
-            //  test(out[p->first] == p->second.to_string()); does not always work due to string converter
+#endif
         }
     }
 
@@ -1264,7 +1282,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
 
         auto r = t->opStringAsync(in).get();
         test(r.returnValue == r.outString);
-        test(r.returnValue.size() == in.size());
+        test(r.returnValue == in);
 
 #else
         Ice::AsyncResultPtr r = t->begin_opString(in);
@@ -1397,13 +1415,12 @@ allTests(const Ice::CommunicatorPtr& communicator)
             in[2] = true;
             in[3] = false;
             in[4] = true;
-            pair<Test::BoolSeq::const_iterator, Test::BoolSeq::const_iterator> inPair(in.begin(), in.end());
-
 #ifdef ICE_CPP11_MAPPING
-            auto r = t->opBoolRangeAsync(inPair).get();
+            auto r = t->opBoolRangeAsync(in).get();
             test(r.outSeq == in);
             test(r.returnValue == in);
 #else
+            pair<Test::BoolSeq::const_iterator, Test::BoolSeq::const_iterator> inPair(in.begin(), in.end());
             Test::BoolSeq out;
             Ice::AsyncResultPtr r = t->begin_opBoolRange(inPair);
             Test::BoolSeq ret = t->end_opBoolRange(out, r);
@@ -1419,13 +1436,13 @@ allTests(const Ice::CommunicatorPtr& communicator)
             in.push_back('3');
             in.push_back('4');
             in.push_back('5');
-            pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> inPair(in.begin(), in.end());
 
 #ifdef ICE_CPP11_MAPPING
-            auto r = t->opByteRangeAsync(inPair).get();
+            auto r = t->opByteRangeAsync(in).get();
             test(r.outSeq == in);
             test(r.returnValue == in);
 #else
+            pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> inPair(in.begin(), in.end());
             Test::ByteList out;
             Ice::AsyncResultPtr r = t->begin_opByteRange(inPair);
             Test::ByteList ret = t->end_opByteRange(out, r);
@@ -1447,13 +1464,13 @@ allTests(const Ice::CommunicatorPtr& communicator)
             in.push_back(v);
             v.s = "strings.";
             in.push_back(v);
-            pair<Test::VariableList::const_iterator, Test::VariableList::const_iterator> inPair(in.begin(), in.end());
 
 #ifdef ICE_CPP11_MAPPING
-            auto r = t->opVariableRangeAsync(inPair).get();
+            auto r = t->opVariableRangeAsync(in).get();
             test(r.outSeq == in);
             test(r.returnValue == in);
 #else
+            pair<Test::VariableList::const_iterator, Test::VariableList::const_iterator> inPair(in.begin(), in.end());
             Test::VariableList out;
             Ice::AsyncResultPtr r = t->begin_opVariableRange(inPair);
             Test::VariableList ret = t->end_opVariableRange(out, r);
@@ -1469,13 +1486,12 @@ allTests(const Ice::CommunicatorPtr& communicator)
             in.push_back('3');
             in.push_back('4');
             in.push_back('5');
-            pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> inPair(in.begin(), in.end());
-
 #ifdef ICE_CPP11_MAPPING
-            auto r = t->opByteRangeTypeAsync(inPair).get();
+            auto r = t->opByteRangeTypeAsync(in).get();
             test(r.outSeq == in);
             test(r.returnValue == in);
 #else
+            pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> inPair(in.begin(), in.end());
             Test::ByteList out;
             Ice::AsyncResultPtr r = t->begin_opByteRangeType(inPair);
             Test::ByteList ret = t->end_opByteRangeType(out, r);
@@ -1503,14 +1519,14 @@ allTests(const Ice::CommunicatorPtr& communicator)
             v.s = "strings.";
             in.push_back(v);
             inSeq.push_back(v);
-            pair<deque<Test::Variable>::const_iterator, deque<Test::Variable>::const_iterator>
-                inPair(inSeq.begin(), inSeq.end());
 
 #ifdef ICE_CPP11_MAPPING
-            auto r = t->opVariableRangeTypeAsync(inPair).get();
+            auto r = t->opVariableRangeTypeAsync(in).get();
             test(r.outSeq == in);
             test(r.returnValue == in);
 #else
+            pair<deque<Test::Variable>::const_iterator, deque<Test::Variable>::const_iterator>
+                inPair(inSeq.begin(), inSeq.end());
             Test::VariableList out;
             Ice::AsyncResultPtr r = t->begin_opVariableRangeType(inPair);
             Test::VariableList ret = t->end_opVariableRangeType(out, r);
@@ -2040,7 +2056,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
             [&](Util::string_view ret, Util::string_view out)
             {
                 test(out == ret);
-                test(in.size() == out.size());
+                test(in == out);
                 done.set_value(true);
             },
             [&](std::exception_ptr)
@@ -2231,18 +2247,16 @@ allTests(const Ice::CommunicatorPtr& communicator)
         in[2] = true;
         in[3] = false;
         in[4] = true;
-        pair<Test::BoolSeq::const_iterator, Test::BoolSeq::const_iterator> inPair(in.begin(), in.end());
 
 #ifdef ICE_CPP11_MAPPING
 
         promise<bool> done;
 
-        t->opBoolRangeAsync(inPair,
-                            [&](pair<Test::BoolSeq::const_iterator, Test::BoolSeq::const_iterator> ret,
-                                pair<Test::BoolSeq::const_iterator, Test::BoolSeq::const_iterator> out)
+        t->opBoolRangeAsync(in,
+                            [&](Test::BoolSeq ret, Test::BoolSeq out)
                             {
-                                   test(equal(out.first, out.second, inPair.first));
-                                   test(equal(ret.first, ret.second, inPair.first));
+                                   test(ret == in);
+                                   test(out == in);
                                    done.set_value(true);
                             },
                             [&](std::exception_ptr)
@@ -2252,6 +2266,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
 
         test(done.get_future().get());
 #else
+        pair<Test::BoolSeq::const_iterator, Test::BoolSeq::const_iterator> inPair(in.begin(), in.end());
 
         CallbackPtr cb = new Callback();
         Test::Callback_TestIntf_opBoolRangePtr callback =
@@ -2269,18 +2284,16 @@ allTests(const Ice::CommunicatorPtr& communicator)
         in.push_back('3');
         in.push_back('4');
         in.push_back('5');
-        pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> inPair(in.begin(), in.end());
 
 #ifdef ICE_CPP11_MAPPING
 
         promise<bool> done;
 
-        t->opByteRangeAsync(inPair,
-                            [&](pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> ret,
-                                pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> out)
+        t->opByteRangeAsync(in,
+                            [&](Test::ByteList ret, Test::ByteList out)
                             {
-                                test(equal(out.first, out.second, inPair.first));
-                                test(equal(ret.first, ret.second, inPair.first));
+                                test(ret == in);
+                                test(out == in);
                                 done.set_value(true);
                             },
                             [&](std::exception_ptr)
@@ -2290,7 +2303,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
 
         test(done.get_future().get());
 #else
-
+        pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> inPair(in.begin(), in.end());
         CallbackPtr cb = new Callback();
         Test::Callback_TestIntf_opByteRangePtr callback =
             Test::newCallback_TestIntf_opByteRange(cb, &Callback::opByteRange, &Callback::noEx);
@@ -2312,18 +2325,16 @@ allTests(const Ice::CommunicatorPtr& communicator)
         in.push_back(v);
         v.s = "strings.";
         in.push_back(v);
-        pair<Test::VariableList::const_iterator, Test::VariableList::const_iterator> inPair(in.begin(), in.end());
 
 #ifdef ICE_CPP11_MAPPING
 
         promise<bool> done;
 
-        t->opVariableRangeAsync(inPair,
-                                [&](pair<Test::VariableList::const_iterator, Test::VariableList::const_iterator> ret,
-                                    pair<Test::VariableList::const_iterator, Test::VariableList::const_iterator> out)
+        t->opVariableRangeAsync(in,
+                                [&](Test::VariableList ret, Test::VariableList out)
                                 {
-                                    test(equal(out.first, out.second, inPair.first));
-                                    test(equal(ret.first, ret.second, inPair.first));
+                                    test(ret == in);
+                                    test(out == in);
                                     done.set_value(true);
                                 },
                                 [&](std::exception_ptr)
@@ -2333,7 +2344,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
 
         test(done.get_future().get());
 #else
-
+        pair<Test::VariableList::const_iterator, Test::VariableList::const_iterator> inPair(in.begin(), in.end());
         CallbackPtr cb = new Callback();
         Test::Callback_TestIntf_opVariableRangePtr callback =
             Test::newCallback_TestIntf_opVariableRange(cb, &Callback::opVariableRange, &Callback::noEx);
@@ -2349,18 +2360,16 @@ allTests(const Ice::CommunicatorPtr& communicator)
         in.push_back('3');
         in.push_back('4');
         in.push_back('5');
-        pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> inPair(in.begin(), in.end());
 
 #ifdef ICE_CPP11_MAPPING
 
         promise<bool> done;
 
-        t->opByteRangeTypeAsync(inPair,
-                                [&](pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> ret,
-                                    pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> out)
+        t->opByteRangeTypeAsync(in,
+                                [&](Test::ByteList ret, Test::ByteList out)
                                 {
-                                    test(equal(out.first, out.second, inPair.first));
-                                    test(equal(ret.first, ret.second, inPair.first));
+                                    test(ret == in);
+                                    test(out == in);
                                     done.set_value(true);
                                 },
                                 [&](std::exception_ptr)
@@ -2370,7 +2379,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
 
         test(done.get_future().get());
 #else
-
+        pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> inPair(in.begin(), in.end());
         CallbackPtr cb = new Callback();
         Test::Callback_TestIntf_opByteRangeTypePtr callback =
             Test::newCallback_TestIntf_opByteRangeType(cb, &Callback::opByteRangeType, &Callback::noEx);
@@ -2398,19 +2407,15 @@ allTests(const Ice::CommunicatorPtr& communicator)
         v.s = "strings.";
         in.push_back(v);
         inSeq.push_back(v);
-        pair<deque<Test::Variable>::const_iterator, deque<Test::Variable>::const_iterator> inPair(inSeq.begin(),
-                                                                                                  inSeq.end());
-
 #ifdef ICE_CPP11_MAPPING
 
         promise<bool> done;
 
-        t->opVariableRangeTypeAsync(inPair,
-                                    [&](pair<deque<Test::Variable>::const_iterator, deque<Test::Variable>::const_iterator> ret,
-                                        pair<deque<Test::Variable>::const_iterator, deque<Test::Variable>::const_iterator> out)
+        t->opVariableRangeTypeAsync(in,
+                                    [&](Test::VariableList ret, Test::VariableList out)
                                     {
-                                        test(equal(out.first, out.second, inPair.first));
-                                        test(equal(ret.first, ret.second, inPair.first));
+                                        test(ret == in);
+                                        test(out == in);
                                         done.set_value(true);
                                     },
                                     [&](std::exception_ptr)
@@ -2420,7 +2425,8 @@ allTests(const Ice::CommunicatorPtr& communicator)
 
         test(done.get_future().get());
 #else
-
+        pair<deque<Test::Variable>::const_iterator, deque<Test::Variable>::const_iterator> inPair(inSeq.begin(),
+                                                                                                  inSeq.end());
         CallbackPtr cb = new Callback();
         Test::Callback_TestIntf_opVariableRangeTypePtr callback =
             Test::newCallback_TestIntf_opVariableRangeType(cb, &Callback::opVariableRangeType, &Callback::noEx);
@@ -3147,9 +3153,9 @@ allTests(const Ice::CommunicatorPtr& communicator)
         promise<bool> done;
 
         t->opOutRangeByteSeqAsync(in,
-                                  [&](pair<vector<Ice::Byte>::const_iterator, vector<Ice::Byte>::const_iterator> out)
+                                  [&](Test::ByteSeq out)
                                   {
-                                      test(in == vector<Ice::Byte>(out.first, out.second));
+                                      test(out == in);
                                       done.set_value(true);
                                   },
                                   [&](std::exception_ptr)
@@ -3243,7 +3249,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
 
             for(auto i: idict)
             {
-                test(r.odict[i.first].size() == i.second.size());
+                test(r.odict[i.first] == i.second);
             }
 #else
             Test::IntStringDict out;
@@ -3358,8 +3364,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
                                               test(ret == out);
                                               for(auto i: idict)
                                               {
-                                                  // TODO: have to compare size not strings because of string converter
-                                                  test(ret[i.first].size() == i.second.size());
+                                                  test(ret[i.first] == i.second);
                                               }
 
                                               done.set_value(true);
diff --git a/cpp/test/Ice/custom/CustomBuffer.h b/cpp/test/Ice/custom/CustomBuffer.h
index 072896bc78b..146266670fc 100644
--- a/cpp/test/Ice/custom/CustomBuffer.h
+++ b/cpp/test/Ice/custom/CustomBuffer.h
@@ -10,7 +10,7 @@
 #ifndef CUSTOM_BUFFER_H
 #define CUSTOM_BUFFER_H
 
-#include <IceUtil/Config.h>
+#include <Ice/Ice.h>
 
 #if defined(_MSC_VER)
 #  pragma warning( disable : 4800 )
@@ -166,12 +166,30 @@ struct StreamHelper< ::Test::CustomBuffer<T>, StreamHelperCategorySequence>
     template<class S> static inline void 
     read(S* stream, ::Test::CustomBuffer<T>& v)
     {
+#ifdef ICE_CPP11_MAPPING
+        std::pair<const T*, const T*> a;
+        stream->read(a);
+        size_t count = a.second - a.first;
+        if(count > 0)
+        {
+            auto b = new T[count];
+            for(size_t i = 0; i < count; ++i)
+            {
+                b[i] = a.first[i];
+            }
+            v.set(b, count);
+        }
+        else
+        {
+            v.set(0, 0);
+        }
+#else
         IceUtil::ScopedArray<T> p;
         std::pair<const T*, const T*> a;
         stream->read(a, p);
         T* b = p.release();
         size_t count = a.second - a.first;
-        if(b == 0)
+        if(b == 0 && count > 0)
         {
             b = new T[count];
             for(size_t i = 0; i < count; ++i)
@@ -180,6 +198,7 @@ struct StreamHelper< ::Test::CustomBuffer<T>, StreamHelperCategorySequence>
             }
         }
         v.set(b, count);
+#endif
     }
 };
 
diff --git a/cpp/test/Ice/custom/Makefile.mk b/cpp/test/Ice/custom/Makefile.mk
index 38cf212f515..49421d060f8 100644
--- a/cpp/test/Ice/custom/Makefile.mk
+++ b/cpp/test/Ice/custom/Makefile.mk
@@ -7,8 +7,6 @@
 #
 # **********************************************************************
 
-$(test)_cppflags		= -DSTRING_VIEW_IGNORE_STRING_CONVERTER
-
 $(test)_client_sources 		= Client.cpp \
 				  AllTests.cpp \
 				  Test.ice \
diff --git a/cpp/test/Ice/custom/StringView.h b/cpp/test/Ice/custom/StringView.h
index 8dd1d7d6f73..43e5bf74bb7 100644
--- a/cpp/test/Ice/custom/StringView.h
+++ b/cpp/test/Ice/custom/StringView.h
@@ -153,11 +153,13 @@ struct StreamHelper<Util::string_view, StreamHelperCategoryBuiltin>
     template<class S> static inline void
     write(S* stream, const Util::string_view& v)
     {
-
-#ifdef STRING_VIEW_IGNORE_STRING_CONVERTER
-        stream->write(v.data(), v.size(), false);
+#ifdef ICE_CPP11_MAPPING
+        stream->write(v.data(), v.size());
 #else
-        stream->write(v.data(), v.size(), true);
+        //
+        // In C++98, for consistency with the read, we don't string-convert
+        //
+        stream->write(v.data(), v.size(), false);
 #endif
     }
 
@@ -167,19 +169,10 @@ struct StreamHelper<Util::string_view, StreamHelperCategoryBuiltin>
         const char* vdata = 0;
         size_t vsize = 0;
 
-#ifdef STRING_VIEW_IGNORE_STRING_CONVERTER
+        //
+        // In C++98, we ignore the string converter
+        //
         stream->read(vdata, vsize);
-#else
-        std::string holder;
-        stream->read(vdata, vsize, holder);
-        
-        // If holder is not empty, a string conversion occured, and we can't return a 
-        // string_view since it does not hold the memory
-        if(!holder.empty())
-        {
-            throw Ice::MarshalException(__FILE__, __LINE__, "string conversion not supported");
-        }
-#endif
 
         if(vsize > 0)
         {
diff --git a/cpp/test/Ice/custom/TestAMDI.cpp b/cpp/test/Ice/custom/TestAMDI.cpp
index 62f26631b26..31f3d5d58ea 100644
--- a/cpp/test/Ice/custom/TestAMDI.cpp
+++ b/cpp/test/Ice/custom/TestAMDI.cpp
@@ -54,54 +54,45 @@ TestIntfI::opVariableArrayAsync(std::pair<const Test::Variable*, const Test::Var
 }
 
 void
-TestIntfI::opBoolRangeAsync(std::pair<Test::BoolSeq::const_iterator, Test::BoolSeq::const_iterator> in,
+TestIntfI::opBoolRangeAsync(Test::BoolSeq in,
                             std::function<void(const Test::BoolSeq&, const Test::BoolSeq&)> response,
                             std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
-    Test::BoolSeq out(in.first, in.second);
-    response(out, out);
+    response(in, in);
 }
 
 void
-TestIntfI::opByteRangeAsync(std::pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> in,
-                            std::function<void(const std::pair<Test::ByteList::const_iterator,
-                                                Test::ByteList::const_iterator>&,
-                                                const std::pair<Test::ByteList::const_iterator,
-                                                Test::ByteList::const_iterator>&)> response,
+TestIntfI::opByteRangeAsync(Test::ByteList in,
+                            std::function<void(const Test::ByteList&, const Test::ByteList&)> response,
                             std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
-TestIntfI::opVariableRangeAsync(std::pair<Test::VariableList::const_iterator,
-                                Test::VariableList::const_iterator> in,
+TestIntfI::opVariableRangeAsync(Test::VariableList in,
                                 std::function<void(const Test::VariableList&, const Test::VariableList&)> response,
                                 std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
-    Test::VariableList out(in.first, in.second);
-    response(out, out);
+    response(in, in);
 }
 
 
 void
-TestIntfI::opByteRangeTypeAsync(std::pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator> in,
+TestIntfI::opByteRangeTypeAsync(Test::ByteList in,
                                 std::function<void(const Test::ByteList&, const Test::ByteList&)> response,
                                 std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
-    Test::ByteList out(in.first, in.second);
-    response(out, out);
+    response(in, in);
 }
 
 void
-TestIntfI::opVariableRangeTypeAsync(std::pair<std::deque<Test::Variable>::const_iterator,
-                                    std::deque<Test::Variable>::const_iterator> in,
+TestIntfI::opVariableRangeTypeAsync(Test::VariableList in,
                                     std::function<void(const Test::VariableList&,
                                                         const Test::VariableList&)> response,
                                     std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
-    Test::VariableList out(in.first, in.second);
-    response(out, out);
+    response(in, in);
 }
 
 void
@@ -291,11 +282,10 @@ TestIntfI::opOutArrayByteSeqAsync(Test::ByteSeq in,
 
 void
 TestIntfI::opOutRangeByteSeqAsync(Test::ByteSeq in,
-                                  std::function<void(const std::pair<Test::ByteSeq::const_iterator,
-                                                      Test::ByteSeq::const_iterator>&)> response,
+                                  std::function<void(const Test::ByteSeq&)> response,
                                   std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
-    response(std::make_pair(in.begin(), in.end()));
+    response(in);
 }
 
 void
diff --git a/cpp/test/Ice/custom/TestAMDI.h b/cpp/test/Ice/custom/TestAMDI.h
index 095af0a68c4..1198e7b02b7 100644
--- a/cpp/test/Ice/custom/TestAMDI.h
+++ b/cpp/test/Ice/custom/TestAMDI.h
@@ -39,31 +39,26 @@ public:
                               std::function<void(const ::Test::VariableList&, const ::Test::VariableList&)>,
                               std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
-    void opBoolRangeAsync(std::pair< ::Test::BoolSeq::const_iterator,	::Test::BoolSeq::const_iterator>,
+    void opBoolRangeAsync(Test::BoolSeq,
                           std::function<void(const ::Test::BoolSeq&, const ::Test::BoolSeq&)>,
                           std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
-    void opByteRangeAsync(std::pair< ::Test::ByteList::const_iterator,	::Test::ByteList::const_iterator>,
-                          std::function<void(const std::pair< ::Test::ByteList::const_iterator,
-                                              ::Test::ByteList::const_iterator>&,
-                                              const std::pair< ::Test::ByteList::const_iterator,
-                                              ::Test::ByteList::const_iterator>&)>,
+    void opByteRangeAsync(Test::ByteList,
+                          std::function<void(const Test::ByteList&, const Test::ByteList&)>,
                           std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
-    void opVariableRangeAsync(std::pair< ::Test::VariableList::const_iterator,
-                              ::Test::VariableList::const_iterator>,
+    void opVariableRangeAsync(Test::VariableList,
                               std::function<void(const ::Test::VariableList&, const ::Test::VariableList&)>,
                               std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
-    void opByteRangeTypeAsync(std::pair< ::Test::ByteList::const_iterator,  ::Test::ByteList::const_iterator>,
+    void opByteRangeTypeAsync(Test::ByteList,
                               std::function<void(const ::Test::ByteList&, const ::Test::ByteList&)>,
                               std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
-    void opVariableRangeTypeAsync(std::pair<std::deque< ::Test::Variable>::const_iterator,
-                                  std::deque< ::Test::Variable>::const_iterator>,
+    void opVariableRangeTypeAsync(Test::VariableList,
                                   std::function<void(const ::Test::VariableList&,
                                                       const ::Test::VariableList&)>,
                                   std::function<void(std::exception_ptr)>, const Ice::Current&) override;
@@ -185,8 +180,7 @@ public:
 
 
     void opOutRangeByteSeqAsync(::Test::ByteSeq,
-                                std::function<void(const std::pair< ::Test::ByteSeq::const_iterator,
-                                                    ::Test::ByteSeq::const_iterator>&)>,
+                                std::function<void(const Test::ByteSeq&)>,
                                 std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
diff --git a/cpp/test/Ice/custom/TestI.cpp b/cpp/test/Ice/custom/TestI.cpp
index 5c0c31ef218..e7c254605a2 100644
--- a/cpp/test/Ice/custom/TestI.cpp
+++ b/cpp/test/Ice/custom/TestI.cpp
@@ -51,8 +51,48 @@ TestIntfI::opVariableArray(ICE_IN(std::pair<const Test::Variable*, const Test::V
     return outSeq;
 }
 
+#ifdef ICE_CPP11_MAPPING
+
+Test::BoolSeq
+TestIntfI::opBoolRange(Test::BoolSeq inSeq, Test::BoolSeq& outSeq, const Ice::Current&)
+{
+    outSeq.swap(inSeq);
+    return outSeq;
+}
+
+Test::ByteList
+TestIntfI::opByteRange(Test::ByteList inSeq, Test::ByteList& outSeq, const Ice::Current&)
+{
+    outSeq.swap(inSeq);
+    return outSeq;
+}
+
+Test::VariableList
+TestIntfI::opVariableRange(Test::VariableList inSeq, Test::VariableList& outSeq, const Ice::Current&)
+{
+    outSeq.swap(inSeq);
+    return outSeq;
+}
+
+
+Test::ByteList
+TestIntfI::opByteRangeType(Test::ByteList inSeq, Test::ByteList& outSeq, const Ice::Current&)
+{
+    outSeq.swap(inSeq);
+    return outSeq;
+}
+
+Test::VariableList
+TestIntfI::opVariableRangeType(Test::VariableList inSeq, Test::VariableList& outSeq, const Ice::Current&)
+{
+    outSeq.swap(inSeq);
+    return outSeq;
+}
+
+#else
+
 Test::BoolSeq
-TestIntfI::opBoolRange(ICE_IN(std::pair<Test::BoolSeq::const_iterator, Test::BoolSeq::const_iterator>) inSeq,
+TestIntfI::opBoolRange(const std::pair<Test::BoolSeq::const_iterator, Test::BoolSeq::const_iterator>& inSeq,
                        Test::BoolSeq& outSeq,
                        const Ice::Current&)
 {
@@ -61,7 +101,7 @@ TestIntfI::opBoolRange(ICE_IN(std::pair<Test::BoolSeq::const_iterator, Test::Boo
 }
 
 Test::ByteList
-TestIntfI::opByteRange(ICE_IN(std::pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator>) inSeq,
+TestIntfI::opByteRange(const std::pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator>& inSeq,
                        Test::ByteList& outSeq,
                        const Ice::Current&)
 {
@@ -71,7 +111,7 @@ TestIntfI::opByteRange(ICE_IN(std::pair<Test::ByteList::const_iterator, Test::By
 
 Test::VariableList
 TestIntfI::opVariableRange(
-    ICE_IN(std::pair<Test::VariableList::const_iterator, Test::VariableList::const_iterator>) inSeq,
+    const std::pair<Test::VariableList::const_iterator, Test::VariableList::const_iterator>& inSeq,
     Test::VariableList& outSeq,
     const Ice::Current&)
 {
@@ -79,17 +119,9 @@ TestIntfI::opVariableRange(
     return outSeq;
 }
 
-Test::BoolSeq
-TestIntfI::opBoolRangeType(ICE_IN(std::pair<const bool*, const bool*>) inSeq,
-                           Test::BoolSeq& outSeq,
-                           const Ice::Current&)
-{
-    Test::BoolSeq(inSeq.first, inSeq.second).swap(outSeq);
-    return outSeq;
-}
 
 Test::ByteList
-TestIntfI::opByteRangeType(ICE_IN(std::pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator>) inSeq,
+TestIntfI::opByteRangeType(const std::pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator>& inSeq,
                            Test::ByteList& outSeq,
                            const Ice::Current&)
 {
@@ -99,7 +131,7 @@ TestIntfI::opByteRangeType(ICE_IN(std::pair<Test::ByteList::const_iterator, Test
 
 Test::VariableList
 TestIntfI::opVariableRangeType(
-    ICE_IN(std::pair<std::deque<Test::Variable>::const_iterator, std::deque<Test::Variable>::const_iterator>) inSeq,
+    const std::pair<std::deque<Test::Variable>::const_iterator, std::deque<Test::Variable>::const_iterator>& inSeq,
     Test::VariableList& outSeq,
     const Ice::Current&)
 {
@@ -110,6 +142,8 @@ TestIntfI::opVariableRangeType(
     return outSeq;
 }
 
+#endif
+
 std::deque<bool>
 TestIntfI::opBoolSeq(ICE_IN(std::deque<bool>) inSeq,
                      std::deque<bool>& outSeq,
@@ -147,9 +181,17 @@ TestIntfI::opBoolDequeListArray(ICE_IN(::std::pair<const std::deque<bool>*, cons
     return outSeq;
 }
 
+#ifdef ICE_CPP11_MAPPING
+Test::BoolDequeList
+TestIntfI::opBoolDequeListRange(Test::BoolDequeList inSeq, Test::BoolDequeList& outSeq, const ::Ice::Current&)
+{
+    outSeq.swap(inSeq);
+    return outSeq;
+}
+#else
 ::Test::BoolDequeList
-TestIntfI::opBoolDequeListRange(ICE_IN(::std::pair< ::Test::BoolDequeList::const_iterator,
-                                                   ::Test::BoolDequeList::const_iterator>) inSeq,
+TestIntfI::opBoolDequeListRange(const ::std::pair< ::Test::BoolDequeList::const_iterator,
+                                                   ::Test::BoolDequeList::const_iterator>& inSeq,
                                 ::Test::BoolDequeList& outSeq,
                                 const ::Ice::Current&)
 {
@@ -159,6 +201,7 @@ TestIntfI::opBoolDequeListRange(ICE_IN(::std::pair< ::Test::BoolDequeList::const
     }
     return outSeq;
 }
+#endif
 
 std::deque< ::Ice::Byte>
 TestIntfI::opByteSeq(ICE_IN(std::deque< ::Ice::Byte>) inSeq,
diff --git a/cpp/test/Ice/custom/TestI.h b/cpp/test/Ice/custom/TestI.h
index c45bcb76def..f0cf2cbd7ae 100644
--- a/cpp/test/Ice/custom/TestI.h
+++ b/cpp/test/Ice/custom/TestI.h
@@ -45,31 +45,44 @@ public:
                                                Test::VariableList&,
                                                const Ice::Current&);
 
-    virtual Test::BoolSeq opBoolRange(ICE_IN(std::pair<Test::BoolSeq::const_iterator, Test::BoolSeq::const_iterator>),
+#ifdef ICE_CPP11_MAPPING
+    virtual Test::BoolSeq opBoolRange(Test::BoolSeq, Test::BoolSeq&, const Ice::Current&);
+
+    virtual Test::ByteList opByteRange(Test::ByteList, Test::ByteList&, const Ice::Current&);
+
+    virtual Test::VariableList
+    opVariableRange(Test::VariableList, Test::VariableList&, const Ice::Current&);
+
+
+    virtual Test::ByteList opByteRangeType(Test::ByteList, Test::ByteList&, const Ice::Current&);
+
+    virtual Test::VariableList
+    opVariableRangeType(Test::VariableList, Test::VariableList&, const Ice::Current&);
+
+#else
+    virtual Test::BoolSeq opBoolRange(const std::pair<Test::BoolSeq::const_iterator, Test::BoolSeq::const_iterator>&,
                                       Test::BoolSeq&,
                                       const Ice::Current&);
 
-    virtual Test::ByteList opByteRange(ICE_IN(std::pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator>),
+    virtual Test::ByteList opByteRange(const std::pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator>&,
                                       Test::ByteList&,
                                       const Ice::Current&);
 
     virtual Test::VariableList
-    opVariableRange(ICE_IN(std::pair<Test::VariableList::const_iterator, Test::VariableList::const_iterator>),
+    opVariableRange(const std::pair<Test::VariableList::const_iterator, Test::VariableList::const_iterator>&,
                     Test::VariableList&,
                     const Ice::Current&);
 
-    virtual Test::BoolSeq opBoolRangeType(ICE_IN(std::pair<const bool*, const bool*>),
-                                          Test::BoolSeq&,
-                                          const Ice::Current&);
 
-    virtual Test::ByteList opByteRangeType(ICE_IN(std::pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator>),
+    virtual Test::ByteList opByteRangeType(const std::pair<Test::ByteList::const_iterator, Test::ByteList::const_iterator>&,
                                            Test::ByteList&,
                                            const Ice::Current&);
 
     virtual Test::VariableList
-    opVariableRangeType(ICE_IN(std::pair<std::deque<Test::Variable>::const_iterator, std::deque<Test::Variable>::const_iterator>),
+    opVariableRangeType(const std::pair<std::deque<Test::Variable>::const_iterator, std::deque<Test::Variable>::const_iterator>&,
                         Test::VariableList&,
                         const Ice::Current&);
+#endif
 
     virtual std::deque<bool> opBoolSeq(ICE_IN(std::deque<bool>),
                                        std::deque<bool>&,
@@ -87,11 +100,18 @@ public:
                                                        ::Test::BoolDequeList&,
                                                        const ::Ice::Current&);
 
+#ifdef ICE_CPP11_MAPPING
+    virtual ::Test::BoolDequeList opBoolDequeListRange(::Test::BoolDequeList,
+                                                       ::Test::BoolDequeList&, const ::Ice::Current&);
+
+#else
     virtual ::Test::BoolDequeList opBoolDequeListRange(
-        ICE_IN(::std::pair< ::Test::BoolDequeList::const_iterator, ::Test::BoolDequeList::const_iterator>),
+        const ::std::pair< ::Test::BoolDequeList::const_iterator, ::Test::BoolDequeList::const_iterator>&,
         ::Test::BoolDequeList&,
         const ::Ice::Current&);
 
+#endif
+
     virtual std::deque< ::Ice::Byte> opByteSeq(ICE_IN(std::deque< ::Ice::Byte>),
                                                std::deque< ::Ice::Byte>&,
                                                const Ice::Current&);
diff --git a/cpp/test/Ice/custom/msbuild/client/client.vcxproj b/cpp/test/Ice/custom/msbuild/client/client.vcxproj
index 97dc60e59e6..6474195efa6 100644
--- a/cpp/test/Ice/custom/msbuild/client/client.vcxproj
+++ b/cpp/test/Ice/custom/msbuild/client/client.vcxproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Cpp11-Debug|Win32">
@@ -115,49 +115,41 @@
   <PropertyGroup Label="UserMacros" />
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Debug|x64'">
     <ClCompile>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <ClCompile>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Release|x64'">
     <ClCompile>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Debug|Win32'">
     <ClCompile>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <ClCompile>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Release|Win32'">
     <ClCompile>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
   </ItemDefinitionGroup>
@@ -465,4 +457,4 @@
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <Import Project="$(IceBuilderCppTargets)" Condition="Exists('$(IceBuilderCppTargets)')" />
-</Project>
\ No newline at end of file
+</Project>
diff --git a/cpp/test/Ice/custom/msbuild/collocated/collocated.vcxproj b/cpp/test/Ice/custom/msbuild/collocated/collocated.vcxproj
index a0ee56db1fc..1bedb71a08a 100644
--- a/cpp/test/Ice/custom/msbuild/collocated/collocated.vcxproj
+++ b/cpp/test/Ice/custom/msbuild/collocated/collocated.vcxproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Cpp11-Debug|Win32">
@@ -115,49 +115,41 @@
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Debug|Win32'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Release|Win32'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Debug|x64'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Release|x64'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemGroup>
@@ -469,4 +461,4 @@
   <PropertyGroup Label="UserMacros" />
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <Import Project="$(IceBuilderCppTargets)" Condition="Exists('$(IceBuilderCppTargets)')" />
-</Project>
\ No newline at end of file
+</Project>
diff --git a/cpp/test/Ice/custom/msbuild/server/server.vcxproj b/cpp/test/Ice/custom/msbuild/server/server.vcxproj
index 26c6da6951f..410fc59423f 100644
--- a/cpp/test/Ice/custom/msbuild/server/server.vcxproj
+++ b/cpp/test/Ice/custom/msbuild/server/server.vcxproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Cpp11-Debug|Win32">
@@ -115,49 +115,41 @@
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Debug|Win32'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Release|Win32'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Debug|x64'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Release|x64'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemGroup>
@@ -468,4 +460,4 @@
   <PropertyGroup Label="UserMacros" />
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <Import Project="$(IceBuilderCppTargets)" Condition="Exists('$(IceBuilderCppTargets)')" />
-</Project>
\ No newline at end of file
+</Project>
diff --git a/cpp/test/Ice/custom/msbuild/serveramd/serveramd.vcxproj b/cpp/test/Ice/custom/msbuild/serveramd/serveramd.vcxproj
index 0ec804bde59..d3e6d8817b8 100644
--- a/cpp/test/Ice/custom/msbuild/serveramd/serveramd.vcxproj
+++ b/cpp/test/Ice/custom/msbuild/serveramd/serveramd.vcxproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Cpp11-Debug|Win32">
@@ -115,49 +115,41 @@
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;ICE_AMD_TEST;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Debug|Win32'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;ICE_AMD_TEST;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;ICE_AMD_TEST;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Release|Win32'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;ICE_AMD_TEST;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;ICE_AMD_TEST;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Debug|x64'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;ICE_AMD_TEST;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;ICE_AMD_TEST;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Cpp11-Release|x64'">
     <ClCompile>
       <AdditionalIncludeDirectories>..\..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>STRING_VIEW_IGNORE_STRING_CONVERTER;ICE_AMD_TEST;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemGroup>
@@ -468,4 +460,4 @@
   <PropertyGroup Label="UserMacros" />
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <Import Project="$(IceBuilderCppTargets)" Condition="Exists('$(IceBuilderCppTargets)')" />
-</Project>
\ No newline at end of file
+</Project>