zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/include/Ice/StreamHelpers.h

@@ -1,1190 +1,652 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_STREAM_HELPERS_H
 #define ICE_STREAM_HELPERS_H
 
-#include <Ice/ObjectF.h>
-
-#ifndef ICE_CPP11_MAPPING
-#   include <IceUtil/ScopedArray.h>
-#   include <IceUtil/Iterator.h>
+#include "InputStream.h"
+#include "OutputStream.h"
+#include "StringConverter.h"
+
+#include <iterator>
+#include <ostream>
+
+#if defined(_MSC_VER)
+// With MSVC, __has_include(<span>) evaluates to 1 in c++17 mode and the <span> header then issues a warning that can't
+// be disabled. This is a permissible but impractical behavior. See https://github.com/microsoft/STL/issues/4010.
+#    if _MSVC_LANG >= 202002L
+#        include <span>
+#    endif
+#elif __has_include(<span>)
+#    include <span>
 #endif
 
 namespace Ice
 {
-
-/// \cond STREAM
-
-/**
- * The stream helper category allows streams to select the desired StreamHelper for a given streamable object.
- */
-typedef int StreamHelperCategory;
-
-/** For types with no specialized trait. */
-const StreamHelperCategory StreamHelperCategoryUnknown = 0;
-/** For built-in types. */
-const StreamHelperCategory StreamHelperCategoryBuiltin = 1;
-/** For struct types. */
-const StreamHelperCategory StreamHelperCategoryStruct = 2;
-/** For struct types with cpp:class metadata. */
-const StreamHelperCategory StreamHelperCategoryStructClass = 3;
-/** For enum types. */
-const StreamHelperCategory StreamHelperCategoryEnum = 4;
-/** For sequence types. */
-const StreamHelperCategory StreamHelperCategorySequence = 5;
-/** For dictionary types. */
-const StreamHelperCategory StreamHelperCategoryDictionary = 6;
-/** For proxy types. */
-const StreamHelperCategory StreamHelperCategoryProxy = 7;
-/** For class types. */
-const StreamHelperCategory StreamHelperCategoryClass = 8;
-/** For exception types. */
-const StreamHelperCategory StreamHelperCategoryUserException = 9;
-
-/**
- * The optional format.
- *
- * Optional data members and parameters are encoded with a specific
- * optional format. This optional format describes how the data is encoded
- * and how it can be skipped by the unmarshaling code if the optional ID
- * isn't known to the receiver.
- */
-#ifdef ICE_CPP11_MAPPING
-enum class OptionalFormat : unsigned char
-{
-    /** Fixed 1-byte encoding. */
-    F1 = 0,
-    /** Fixed 2-byte encoding. */
-    F2 = 1,
-    /** Fixed 4-byte encoding. */
-    F4 = 2,
-    /** Fixed 8-byte encoding. */
-    F8 = 3,
-    /** "Size encoding" using 1 to 5 bytes, e.g., enum, class identifier. */
-    Size = 4,
-    /**
-     * "Size encoding" using 1 to 5 bytes followed by data, e.g., string, fixed size
-     * struct, or containers whose size can be computed prior to marshaling.
-     */
-    VSize = 5,
-    /** Fixed size using 4 bytes followed by data, e.g., variable-size struct, container. */
-    FSize = 6,
-    /** Class instance. */
-    Class = 7
-};
-#else
-enum OptionalFormat
-{
-    /** Fixed 1-byte encoding. */
-    OptionalFormatF1 = 0,
-    /** Fixed 2-byte encoding. */
-    OptionalFormatF2 = 1,
-    /** Fixed 4-byte encoding. */
-    OptionalFormatF4 = 2,
-    /** Fixed 8-byte encoding. */
-    OptionalFormatF8 = 3,
-    /** "Size encoding" using 1 to 5 bytes, e.g., enum, class identifier. */
-    OptionalFormatSize = 4,
-    /**
-     * "Size encoding" using 1 to 5 bytes followed by data, e.g., string, fixed size
-     * struct, or containers whose size can be computed prior to marshaling.
-     */
-    OptionalFormatVSize = 5,
-    /** Fixed size using 4 bytes followed by data, e.g., variable-size struct, container. */
-    OptionalFormatFSize = 6,
-    /** Class instance. */
-    OptionalFormatClass = 7
-};
+    // StreamHelper templates used by streams to read, write and print data.
+
+#ifdef ICE_DOXYGEN
+    /// Prints a value to a stream.
+    /// @tparam T The type of the value. It's either built-in Slice type or a type generated by the Slice compiler.
+    /// @param stream The stream.
+    /// @param v The value to print.
+    /// @remarks Depending on the type, @p v is passed by value or by const reference.
+    template<typename T> void print(std::ostream& stream, T v);
+
+    // We only provide this declaration for Doxygen. This template is specialized for all types that we support, and
+    // we want the compilation (not linking) to fail if a specialization is missing.
+
+    /// A helper template class for writing (marshaling) and reading (unmarshaling) values to and from a stream of
+    /// Slice-encoded bytes. This helper also prints Slice-defined types.
+    /// @tparam T The type of the value.
+    /// @tparam st The stream helper category.
+    /// @headerfile Ice/Ice.h
+    template<typename T, StreamHelperCategory st> struct StreamHelper
+    {
+        /// Writes a value to the stream.
+        /// @param stream The stream.
+        /// @param v The value to write.
+        /// @remark Each specialization chooses whether @p v is passed by value or by const reference.
+        static void write(OutputStream* stream, T v);
+
+        /// Reads a value from the stream.
+        /// @param stream The stream.
+        /// @param[out] v A reference to the value to read into.
+        static void read(InputStream* stream, T& v);
+
+        /// Prints a value to the stream.
+        /// @param stream The stream.
+        /// @param v The value to print.
+        /// @remark Each specialization chooses whether @p v is passed by value or by const reference.
+        static void print(std::ostream& stream, T v);
+    };
 #endif
 
-/**
- * Determines whether the provided type is a container. For now, the implementation only checks
- * if there is a T::iterator typedef using SFINAE.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct IsContainer
-{
-    template<typename C>
-    static char test(typename C::iterator*);
-
-    template<typename C>
-    static long test(...);
-
-    static const bool value = sizeof(test<T>(0)) == sizeof(char);
-};
-
-/**
- * Determines whether the provided type is a map. For now, the implementation only checks if there
- * is a T::mapped_type typedef using SFINAE.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct IsMap
-{
-    template<typename C>
-    static char test(typename C::mapped_type*);
-
-    template<typename C>
-    static long test(...);
+    /// @cond INTERNAL
+
+    /// Prints a value with a pass-by-value type (such as `bool`, `int32`, or an enumeration) to a stream.
+    /// @tparam T The type of the value.
+    /// @param stream The stream.
+    /// @param v The value to print.
+    template<
+        typename T,
+        std::enable_if_t<
+            StreamableTraits<T>::helper == StreamHelperCategoryBuiltinValue ||
+                StreamableTraits<T>::helper == StreamHelperCategoryEnum,
+            bool> = true>
+    inline void print(std::ostream& stream, T v)
+    {
+        StreamHelper<T, StreamHelperCategoryBuiltinValue>::print(stream, v);
+    }
+
+    /// Prints an optional value with a pass-by-value type (such as `bool`, `int32`, or an enumeration) to a stream.
+    /// @tparam T The type of the value.
+    /// @param stream The stream.
+    /// @param v The value to print. nullopt is printed as "nullopt".
+    template<
+        typename T,
+        std::enable_if_t<
+            StreamableTraits<T>::helper == StreamHelperCategoryBuiltinValue ||
+                StreamableTraits<T>::helper == StreamHelperCategoryEnum,
+            bool> = true>
+    inline void print(std::ostream& stream, std::optional<T> v)
+    {
+        if (v)
+        {
+            Ice::print(stream, *v);
+        }
+        else
+        {
+            stream << "nullopt";
+        }
+    }
 
-    static const bool value = IsContainer<T>::value && sizeof(test<T>(0)) == sizeof(char);
-};
+    /// Prints a value with a pass-by-const-reference type to the stream.
+    /// @tparam T The type of the value.
+    /// @param stream The stream.
+    /// @param v The value to print.
+    template<
+        typename T,
+        std::enable_if_t<
+            StreamableTraits<T>::helper != StreamHelperCategoryBuiltinValue &&
+                StreamableTraits<T>::helper != StreamHelperCategoryEnum,
+            bool> = true>
+    inline void print(std::ostream& stream, const T& v)
+    {
+        StreamHelper<T, StreamableTraits<T>::helper>::print(stream, v);
+    }
+
+    /// Prints an optional value with a pass-by-const-reference type to the stream.
+    /// @tparam T The type of the value.
+    /// @param stream The stream.
+    /// @param v The value to print. nullopt is printed as "nullopt".
+    template<
+        typename T,
+        std::enable_if_t<
+            StreamableTraits<T>::helper != StreamHelperCategoryBuiltinValue &&
+                StreamableTraits<T>::helper != StreamHelperCategoryEnum &&
+                StreamableTraits<std::optional<T>>::helper != StreamHelperCategoryProxy,
+            bool> = true>
+    inline void print(std::ostream& stream, const std::optional<T>& v)
+    {
+        if (v)
+        {
+            Ice::print(stream, *v);
+        }
+        else
+        {
+            stream << "nullopt";
+        }
+    }
 
-#ifdef ICE_CPP11_MAPPING
+    template<typename T> struct StreamHelper<T, StreamHelperCategoryBuiltinValue>
+    {
+        static void write(OutputStream* stream, T v) { stream->write(v); }
 
-/**
- * Base traits template. Types with no specialized trait use this trait.
- * \headerfile Ice/Ice.h
- */
-template<typename T,  typename Enabler = void>
-struct StreamableTraits
-{
-    static const StreamHelperCategory helper = StreamHelperCategoryUnknown;
+        static void read(InputStream* stream, T& v) { stream->read(v); }
 
-    //
-    // When extracting a sequence<T> from a stream, we can ensure the
-    // stream has at least StreamableTraits<T>::minWireSize * size bytes
-    // For containers, the minWireSize is 1 (just 1 byte for an empty container).
-    //
-    //static const int minWireSize = 1;
+        static void print(std::ostream& stream, T v) { stream << v; }
+    };
 
-    //
-    // Is this type encoded on a fixed number of bytes?
-    // Used only for marshaling/unmarshaling optional data members and parameters.
-    //
-    //static const bool fixedLength = false;
-};
-
-/**
- * Specialization for sequence and dictionary types.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamableTraits<T, typename ::std::enable_if<IsMap<T>::value || IsContainer<T>::value>::type>
-{
-    static const StreamHelperCategory helper = IsMap<T>::value ? StreamHelperCategoryDictionary : StreamHelperCategorySequence;
-    static const int minWireSize = 1;
-    static const bool fixedLength = false;
-};
-
-/**
- * Specialization for exceptions.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamableTraits<T, typename ::std::enable_if<::std::is_base_of<::Ice::UserException, T>::value>::type>
-{
-    static const StreamHelperCategory helper = StreamHelperCategoryUserException;
+    template<> struct StreamHelper<bool, StreamHelperCategoryBuiltinValue>
+    {
+        static void print(std::ostream& stream, bool v) { stream << (v ? "true" : "false"); }
+    };
 
-    //
-    // There is no sequence/dictionary of UserException (so no need for minWireSize)
-    // and no optional UserException (so no need for fixedLength)
-    //
-};
-
-/**
- * Specialization for arrays (std::pair<const T*, const T*>).
- * \headerfile Ice/Ice.h
- */
-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
-
-/**
- * Base traits template. Types with no specialized trait use this trait, including sequence and
- * dictionary types.
- * \headerfile Ice/Ice.h
- */
-template<typename T,  typename Enabler = void>
-struct StreamableTraits
-{
-    static const StreamHelperCategory helper = IsMap<T>::value ? StreamHelperCategoryDictionary :
-        (IsContainer<T>::value ? StreamHelperCategorySequence : StreamHelperCategoryUnknown);
-
-    /**
-     * When extracting a sequence<T> from a stream, we can ensure the
-     * stream has at least StreamableTraits<T>::minWireSize * size bytes.
-     * For containers, the minWireSize is 1 (just 1 byte for an empty container).
-     */
-    static const int minWireSize = 1;
-
-    /**
-     * Is this type encoded on a fixed number of bytes?
-     * Used only for marshaling/unmarshaling optional data members and parameters.
-     */
-    static const bool fixedLength = false;
-};
-
-/**
- * Specialization for exceptions.
- * \headerfile Ice/Ice.h
- */
-template<>
-struct StreamableTraits<UserException>
-{
-    static const StreamHelperCategory helper = StreamHelperCategoryUserException;
+    template<> struct StreamHelper<std::uint8_t, StreamHelperCategoryBuiltinValue>
+    {
+        static void print(std::ostream& stream, std::uint8_t v) { stream << static_cast<int>(v); }
+    };
 
-    //
-    // There is no sequence/dictionary of UserException (so no need for minWireSize)
-    // and no optional UserException (so no need for fixedLength)
-    //
-};
-
-/**
- * Specialization for array / range mapped sequences. The type can be a std::pair<T, T> or a
- * std::pair<IceUtil::ScopedArray<T>, std::pair<const T*, const T*> >.
- * \headerfile Ice/Ice.h
- */
-template<typename T, typename U>
-struct StreamableTraits< ::std::pair<T, U> >
-{
-    static const StreamHelperCategory helper = StreamHelperCategorySequence;
-    static const int minWireSize = 1;
-    static const bool fixedLength = false;
-};
-#endif
+    template<> struct StreamHelper<std::byte, StreamHelperCategoryBuiltinValue>
+    {
+        static void print(std::ostream& stream, std::byte v) { stream << static_cast<int>(v); }
+    };
 
-/**
- * Specialization for built-in type (this is needed for sequence
- * marshaling to figure out the minWireSize of each type).
- * \headerfile Ice/Ice.h
- */
-template<>
-struct StreamableTraits<bool>
-{
-    static const StreamHelperCategory helper = StreamHelperCategoryBuiltin;
-    static const int minWireSize = 1;
-    static const bool fixedLength = true;
-};
-
-/**
- * Specialization for built-in type (this is needed for sequence
- * marshaling to figure out the minWireSize of each type).
- * \headerfile Ice/Ice.h
- */
-template<>
-struct StreamableTraits<Byte>
-{
-    static const StreamHelperCategory helper = StreamHelperCategoryBuiltin;
-    static const int minWireSize = 1;
-    static const bool fixedLength = true;
-};
-
-/**
- * Specialization for built-in type (this is needed for sequence
- * marshaling to figure out the minWireSize of each type).
- * \headerfile Ice/Ice.h
- */
-template<>
-struct StreamableTraits<Short>
-{
-    static const StreamHelperCategory helper = StreamHelperCategoryBuiltin;
-    static const int minWireSize = 2;
-    static const bool fixedLength = true;
-};
-
-/**
- * Specialization for built-in type (this is needed for sequence
- * marshaling to figure out the minWireSize of each type).
- * \headerfile Ice/Ice.h
- */
-template<>
-struct StreamableTraits<Int>
-{
-    static const StreamHelperCategory helper = StreamHelperCategoryBuiltin;
-    static const int minWireSize = 4;
-    static const bool fixedLength = true;
-};
-
-/**
- * Specialization for built-in type (this is needed for sequence
- * marshaling to figure out the minWireSize of each type).
- * \headerfile Ice/Ice.h
- */
-template<>
-struct StreamableTraits<Long>
-{
-    static const StreamHelperCategory helper = StreamHelperCategoryBuiltin;
-    static const int minWireSize = 8;
-    static const bool fixedLength = true;
-};
-
-/**
- * Specialization for built-in type (this is needed for sequence
- * marshaling to figure out the minWireSize of each type).
- * \headerfile Ice/Ice.h
- */
-template<>
-struct StreamableTraits<Float>
-{
-    static const StreamHelperCategory helper = StreamHelperCategoryBuiltin;
-    static const int minWireSize = 4;
-    static const bool fixedLength = true;
-};
-
-/**
- * Specialization for built-in type (this is needed for sequence
- * marshaling to figure out the minWireSize of each type).
- * \headerfile Ice/Ice.h
- */
-template<>
-struct StreamableTraits<Double>
-{
-    static const StreamHelperCategory helper = StreamHelperCategoryBuiltin;
-    static const int minWireSize = 8;
-    static const bool fixedLength = true;
-};
-
-/**
- * Specialization for built-in type (this is needed for sequence
- * marshaling to figure out the minWireSize of each type).
- * \headerfile Ice/Ice.h
- */
-template<>
-struct StreamableTraits< ::std::string>
-{
-    static const StreamHelperCategory helper = StreamHelperCategoryBuiltin;
-    static const int minWireSize = 1;
-    static const bool fixedLength = false;
-};
-
-/**
- * Specialization for built-in type (this is needed for sequence
- * marshaling to figure out the minWireSize of each type).
- * \headerfile Ice/Ice.h
- */
-template<>
-struct StreamableTraits< ::std::wstring>
-{
-    static const StreamHelperCategory helper = StreamHelperCategoryBuiltin;
-    static const int minWireSize = 1;
-    static const bool fixedLength = false;
-};
-
-/**
- * vector<bool> is a special type in C++: the streams handle it like a built-in type.
- * \headerfile Ice/Ice.h
- */
-template<>
-struct StreamableTraits< ::std::vector<bool> >
-{
-    static const StreamHelperCategory helper = StreamHelperCategoryBuiltin;
-    static const int minWireSize = 1;
-    static const bool fixedLength = false;
-};
-
-/**
- * Specialization for proxy types.
- * \headerfile Ice/Ice.h
- */
-#ifdef ICE_CPP11_MAPPING
-template<typename T>
-struct StreamableTraits<::std::shared_ptr<T>, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, T>::value>::type>
-{
-    static const StreamHelperCategory helper = StreamHelperCategoryProxy;
-    static const int minWireSize = 2;
-    static const bool fixedLength = false;
-};
-#else
-template<typename T>
-struct StreamableTraits< ::IceInternal::ProxyHandle<T> >
-{
-    static const StreamHelperCategory helper = StreamHelperCategoryProxy;
-    static const int minWireSize = 2;
-    static const bool fixedLength = false;
-};
-#endif
+    template<> struct StreamHelper<std::string_view, StreamHelperCategoryBuiltinValue>
+    {
+        static void write(OutputStream* stream, std::string_view v) { stream->write(v); }
 
-/**
- * Specialization for class types.
- * \headerfile Ice/Ice.h
- */
-#ifdef ICE_CPP11_MAPPING
-template<typename T>
-struct StreamableTraits<::std::shared_ptr<T>, typename ::std::enable_if<::std::is_base_of<::Ice::Value, T>::value>::type>
-{
-    static const StreamHelperCategory helper = StreamHelperCategoryClass;
-    static const int minWireSize = 1;
-    static const bool fixedLength = false;
-};
-#else
-template<typename T>
-struct StreamableTraits< ::IceInternal::Handle<T> >
-{
-    static const StreamHelperCategory helper = StreamHelperCategoryClass;
-    static const int minWireSize = 1;
-    static const bool fixedLength = false;
-};
-#endif
+        // No read: we marshal string views but unmarshal strings.
+        // No print: we only print fields.
+    };
 
-//
-// StreamHelper templates used by streams to read and write data.
-//
+    template<> struct StreamHelper<std::wstring_view, StreamHelperCategoryBuiltinValue>
+    {
+        static void write(OutputStream* stream, std::wstring_view v) { stream->write(v); }
 
-/** Base StreamHelper template; it must be specialized for each type. */
-template<typename T, StreamHelperCategory st>
-struct StreamHelper;
+        // No read: we marshal wstring views but don't unmarshal wstrings.
+        // No print: we only print fields.
+    };
 
-/**
- * Helper for built-ins, delegates read/write to the stream.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamHelper<T, StreamHelperCategoryBuiltin>
-{
-    template<class S> static inline void
-    write(S* stream, const T& v)
+    /// Helper for built-in types that are not passed by value.
+    template<typename T> struct StreamHelper<T, StreamHelperCategoryBuiltin>
     {
-        stream->write(v);
-    }
+        static void write(OutputStream* stream, const T& v) { stream->write(v); }
 
-    template<class S> static inline void
-    read(S* stream, T& v)
-    {
-        stream->read(v);
-    }
-};
-
-//
-// "helpers" for the StreamHelper<T, StreamHelperCategoryStruct[Class]> below
-// slice2cpp generates specializations as needed
-//
-
-/**
- * General writer. slice2cpp generates specializations as needed.
- * \headerfile Ice/Ice.h
- */
-template<typename T, typename S>
-struct StreamWriter
-{
-#ifdef ICE_CPP11_MAPPING
-    static inline void write(S* stream, const T& v)
-    {
-        stream->writeAll(v.ice_tuple());
-    }
-#else
-    static inline void write(S*, const T&)
-    {
-        // Default is to write nothing for C++98
-    }
-#endif
-};
-
-/**
- * General reader. slice2cpp generates specializations as needed.
- * \headerfile Ice/Ice.h
- */
-template<typename T, typename S>
-struct StreamReader
-{
-    static inline void read(S*, T&)
-    {
-        // Default is to read nothing
-    }
-};
-
-/**
- * Helper for structs.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamHelper<T, StreamHelperCategoryStruct>
-{
-    template<class S> static inline void
-    write(S* stream, const T& v)
-    {
-        StreamWriter<T, S>::write(stream, v);
-    }
+        static void read(InputStream* stream, T& v) { stream->read(v); }
 
-    template<class S> static inline void
-    read(S* stream, T& v)
-    {
-        StreamReader<T, S>::read(stream, v);
-    }
-};
-
-/**
- * Helper for class structs.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamHelper<T, StreamHelperCategoryStructClass>
-{
-    template<class S> static inline void
-    write(S* stream, const T& v)
-    {
-        StreamWriter<T, S>::write(stream, v);
-    }
+        static void print(std::ostream& stream, const T& v) { stream << v; }
+    };
 
-    template<class S> static inline void
-    read(S* stream, T& v)
+    template<> struct StreamHelper<std::wstring, StreamHelperCategoryBuiltin>
     {
-        v = new typename T::element_type;
-        StreamReader<T, S>::read(stream, v);
-    }
-};
-
-/**
- * Helper for enums.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamHelper<T, StreamHelperCategoryEnum>
-{
-    template<class S> static inline void
-    write(S* stream, const T& v)
+        static void print(std::ostream& stream, const std::wstring& v) { stream << Ice::wstringToString(v); }
+    };
+
+    template<> struct StreamHelper<std::vector<bool>, StreamHelperCategoryBuiltin>
     {
-        if(static_cast<Int>(v) < StreamableTraits<T>::minValue || static_cast<Int>(v) > StreamableTraits<T>::maxValue)
+        static void print(std::ostream& stream, const std::vector<bool>& v)
         {
-            IceInternal::Ex::throwMarshalException(__FILE__, __LINE__, "enumerator out of range");
+            stream << '[';
+            bool firstElement = true;
+            for (bool element : v)
+            {
+                if (!firstElement)
+                {
+                    stream << ", ";
+                }
+                firstElement = false;
+                Ice::print(stream, element);
+            }
+            stream << ']';
         }
-        stream->writeEnum(static_cast<Int>(v), StreamableTraits<T>::maxValue);
-    }
+    };
 
-    template<class S> static inline void
-    read(S* stream, T& v)
+    //
+    // "helpers" for the StreamHelper<T, StreamHelperCategoryStruct>. slice2cpp generates specializations as needed.
+    //
+
+    /// Reader used/generated for structs. Always specialized.
+    template<typename T> struct StreamReader;
+
+    template<typename T> struct StreamHelper<T, StreamHelperCategoryStruct>
     {
-        Int value = stream->readEnum(StreamableTraits<T>::maxValue);
-        if(value < StreamableTraits<T>::minValue || value > StreamableTraits<T>::maxValue)
-        {
-            IceInternal::Ex::throwMarshalException(__FILE__, __LINE__, "enumerator out of range");
-        }
-        v = static_cast<T>(value);
-    }
-};
-
-/**
- * Helper for sequences.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamHelper<T, StreamHelperCategorySequence>
-{
-    template<class S> static inline void
-    write(S* stream, const T& v)
+        static void write(OutputStream* stream, const T& v) { stream->writeAll(v.ice_tuple()); }
+
+        static void read(InputStream* stream, T& v) { StreamReader<T>::read(stream, v); }
+
+        static void print(std::ostream& stream, const T& v) { stream << v; }
+    };
+
+    template<typename T> struct StreamHelper<T, StreamHelperCategoryEnum>
     {
-        stream->writeSize(static_cast<Int>(v.size()));
-        for(typename T::const_iterator p = v.begin(); p != v.end(); ++p)
+        static void write(OutputStream* stream, T v)
         {
-            stream->write(*p);
+            if (static_cast<std::int32_t>(v) < StreamableTraits<T>::minValue ||
+                static_cast<std::int32_t>(v) > StreamableTraits<T>::maxValue)
+            {
+                IceInternal::Ex::throwMarshalException(__FILE__, __LINE__, "enumerator out of range");
+            }
+            stream->writeEnum(static_cast<std::int32_t>(v), StreamableTraits<T>::maxValue);
         }
-    }
 
-    template<class S> static inline void
-    read(S* stream, T& v)
-    {
-        Int sz = stream->readAndCheckSeqSize(StreamableTraits<typename T::value_type>::minWireSize);
-        T(static_cast<size_t>(sz)).swap(v);
-        for(typename T::iterator p = v.begin(); p != v.end(); ++p)
+        static void read(InputStream* stream, T& v)
         {
-            stream->read(*p);
+            std::int32_t value = stream->readEnum(StreamableTraits<T>::maxValue);
+            if (value < StreamableTraits<T>::minValue || value > StreamableTraits<T>::maxValue)
+            {
+                IceInternal::Ex::throwMarshalException(__FILE__, __LINE__, "enumerator out of range");
+            }
+            v = static_cast<T>(value); // NOLINT
         }
-    }
-};
-
-/**
- * Helper for array custom sequence parameters.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamHelper<std::pair<const T*, const T*>, StreamHelperCategorySequence>
-{
-    template<class S> static inline void
-    write(S* stream, const std::pair<const T*, const T*>& v)
-    {
-        stream->write(v.first, v.second);
-    }
 
-    template<class S> static inline void
-    read(S* stream, std::pair<const T*, const T*>& v)
-    {
-        stream->read(v);
-    }
-};
-
-#ifndef ICE_CPP11_MAPPING
+        static void print(std::ostream& stream, T v) { stream << v; }
+    };
 
-/**
- * Helper for range custom sequence parameters.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamHelper<std::pair<T, T>, StreamHelperCategorySequence>
-{
-    template<class S> static inline void
-    write(S* stream, const std::pair<T, T>& v)
+    template<typename T> struct StreamHelper<T, StreamHelperCategorySequence>
     {
-        stream->writeSize(static_cast<Int>(IceUtilInternal::distance(v.first, v.second)));
-        for(T p = v.first; p != v.second; ++p)
+        static void write(OutputStream* stream, const T& v)
         {
-            stream->write(*p);
+            stream->writeSize(static_cast<std::int32_t>(v.size()));
+            for (const auto& element : v)
+            {
+                stream->write(element);
+            }
         }
-    }
 
-    template<class S> static inline void
-    read(S* stream, std::pair<T, T>& v)
-    {
-        stream->read(v);
-    }
-};
-
-/**
- * Specialization for sequence<bool>.
- * \headerfile Ice/Ice.h
- */
-template<>
-struct StreamHelper<std::pair< ::std::vector<bool>::const_iterator,
-                               ::std::vector<bool>::const_iterator>, StreamHelperCategorySequence>
-{
-    template<class S> static inline void
-    write(S* stream, const std::pair< ::std::vector<bool>::const_iterator,
-                                      ::std::vector<bool>::const_iterator>& v)
-    {
-        stream->writeSize(static_cast<Int>(IceUtilInternal::distance(v.first, v.second)));
-        for(::std::vector<bool>::const_iterator p = v.first; p != v.second; ++p)
+        static void read(InputStream* stream, T& v)
         {
-            stream->write(static_cast<bool>(*p));
+            std::int32_t sz = stream->readAndCheckSeqSize(StreamableTraits<typename T::value_type>::minWireSize);
+            T(static_cast<size_t>(sz)).swap(v);
+            for (auto& element : v)
+            {
+                stream->read(element);
+            }
         }
-    }
-};
-
-/**
- * Helper for zero-copy array sequence parameters.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamHelper<std::pair<IceUtil::ScopedArray<T>, std::pair<const T*, const T*> >, StreamHelperCategorySequence>
-{
-    template<class S> static inline void
-    read(S* stream, std::pair<IceUtil::ScopedArray<T>, std::pair<const T*, const T*> >& v)
+
+        static void print(std::ostream& stream, const T& v)
+        {
+            stream << '[';
+            bool firstElement = true;
+            for (const auto& element : v)
+            {
+                if (!firstElement)
+                {
+                    stream << ", ";
+                }
+                firstElement = false;
+                Ice::print(stream, element);
+            }
+            stream << ']';
+        }
+    };
+
+    /// Helper the array custom sequence mapping.
+    template<typename T> struct StreamHelper<std::pair<const T*, const T*>, StreamHelperCategorySequence>
     {
-        stream->read(v.second, v.first);
-    }
+        static void write(OutputStream* stream, std::pair<const T*, const T*> v) { stream->write(v.first, v.second); }
+
+        static void read(InputStream* stream, std::pair<const T*, const T*>& v) { stream->read(v); }
+
+        // No print: we only print fields.
+    };
 
-    // no write: only used for unmarshaling
-};
+#ifdef __cpp_lib_span
+    /// Helper for span (C++20 or later).
+    template<typename T> struct StreamHelper<std::span<T>, StreamHelperCategorySequence>
+    {
+        static void write(OutputStream* stream, const std::span<T>& v) { stream->write(v.data(), v.data() + v.size()); }
+
+        // No read. span are only for view types.
+        // No print: we only print fields.
+    };
 #endif
 
-/**
- * Helper for dictionaries.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamHelper<T, StreamHelperCategoryDictionary>
-{
-    template<class S> static inline void
-    write(S* stream, const T& v)
+    template<typename T> struct StreamHelper<T, StreamHelperCategoryDictionary>
     {
-        stream->writeSize(static_cast<Int>(v.size()));
-        for(typename T::const_iterator p = v.begin(); p != v.end(); ++p)
+        static void write(OutputStream* stream, const T& v)
         {
-            stream->write(p->first);
-            stream->write(p->second);
+            stream->writeSize(static_cast<std::int32_t>(v.size()));
+            for (const auto& entry : v)
+            {
+                stream->write(entry.first);
+                stream->write(entry.second);
+            }
         }
-    }
 
-    template<class S> static inline void
-    read(S* stream, T& v)
-    {
-        Int sz = stream->readSize();
-        v.clear();
-        while(sz--)
+        static void read(InputStream* stream, T& v)
         {
-            typename T::value_type p;
-            stream->read(const_cast<typename T::key_type&>(p.first));
-            typename T::iterator i = v.insert(v.end(), p);
-            stream->read(i->second);
+            std::int32_t sz = stream->readSize();
+            v.clear();
+            while (sz--)
+            {
+                typename T::value_type p;
+                stream->read(const_cast<typename T::key_type&>(p.first));
+                auto i = v.insert(v.end(), p);
+                stream->read(i->second);
+            }
         }
-    }
-};
-
-/**
- * Helper for user exceptions.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamHelper<T, StreamHelperCategoryUserException>
-{
-    template<class S> static inline void
-    write(S* stream, const T& v)
-    {
-        stream->writeException(v);
-    }
 
-    // no read: only used for marshaling
-};
+        static void print(std::ostream& stream, const T& v)
+        {
+            stream << '[';
+            bool firstEntry = true;
+            for (const auto& entry : v)
+            {
+                if (!firstEntry)
+                {
+                    stream << ", ";
+                }
+                firstEntry = false;
+                stream << '{';
+                Ice::print(stream, entry.first);
+                stream << " : ";
+                Ice::print(stream, entry.second);
+                stream << '}';
+            }
+            stream << ']';
+        }
+    };
 
-/**
- * Helper for proxies.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamHelper<T, StreamHelperCategoryProxy>
-{
-    template<class S> static inline void
-    write(S* stream, const T& v)
+    template<typename T> struct StreamHelper<T, StreamHelperCategoryUserException>
     {
-        stream->write(v);
-    }
+        static void write(OutputStream* stream, const T& v) { stream->writeException(v); }
 
-    template<class S> static inline void
-    read(S* stream, T& v)
-    {
-        stream->read(v);
-    }
-};
-
-/**
- * Helper for classes.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamHelper<T, StreamHelperCategoryClass>
-{
-    template<class S> static inline void
-    write(S* stream, const T& v)
+        // no read: we don't use this helper for unmarshaling.
+
+        // We provide print for consistency even though user exceptions cannot appear in fields.
+        static void print(std::ostream& stream, const T& v) { stream << v; }
+    };
+
+    template<typename T> struct StreamHelper<T, StreamHelperCategoryProxy>
     {
-        stream->write(v);
-    }
+        static void write(OutputStream* stream, const T& v) { stream->write(v); }
 
-    template<class S> static inline void
-    read(S* stream, T& v)
+        static void read(InputStream* stream, T& v) { stream->read(v); }
+
+        static void print(std::ostream& stream, const T& v) { stream << v; }
+    };
+
+    template<typename T> struct StreamHelper<T, StreamHelperCategoryClass>
     {
-        stream->read(v);
-    }
-};
-
-//
-// Helpers to read/write optional attributes or members.
-//
-
-//
-// Extract / compute the optionalFormat
-// This is used _only_ for the base StreamOptionalHelper below
-// /!\ Do not use in StreamOptionalHelper specializations, and do
-// not provide specialization not handled by the base StreamOptionalHelper
-//
-/**
- * Extract / compute the optionalFormat.
- * \headerfile Ice/Ice.h
- */
-template<StreamHelperCategory st, int minWireSize, bool fixedLength>
-struct GetOptionalFormat;
-
-/**
- * Specialization for 1-byte built-in fixed-length types.
- * \headerfile Ice/Ice.h
- */
-template<>
-struct GetOptionalFormat<StreamHelperCategoryBuiltin, 1, true>
-{
-    static const OptionalFormat value = ICE_SCOPED_ENUM(OptionalFormat, F1);
-};
-
-/**
- * Specialization for 2-byte built-in fixed-length types.
- * \headerfile Ice/Ice.h
- */
-template<>
-struct GetOptionalFormat<StreamHelperCategoryBuiltin, 2, true>
-{
-    static const OptionalFormat value = ICE_SCOPED_ENUM(OptionalFormat, F2);
-};
-
-/**
- * Specialization for 4-byte built-in fixed-length types.
- * \headerfile Ice/Ice.h
- */
-template<>
-struct GetOptionalFormat<StreamHelperCategoryBuiltin, 4, true>
-{
-    static const OptionalFormat value = ICE_SCOPED_ENUM(OptionalFormat, F4);
-};
-
-/**
- * Specialization for 8-byte built-in fixed-length types.
- * \headerfile Ice/Ice.h
- */
-template<>
-struct GetOptionalFormat<StreamHelperCategoryBuiltin, 8, true>
-{
-    static const OptionalFormat value = ICE_SCOPED_ENUM(OptionalFormat, F8);
-};
-
-/**
- * Specialization for built-in variable-length types.
- * \headerfile Ice/Ice.h
- */
-template<>
-struct GetOptionalFormat<StreamHelperCategoryBuiltin, 1, false>
-{
-    static const OptionalFormat value = ICE_SCOPED_ENUM(OptionalFormat, VSize);
-};
-
-/**
- * Specialization for class types.
- * \headerfile Ice/Ice.h
- */
-template<>
-struct GetOptionalFormat<StreamHelperCategoryClass, 1, false>
-{
-    static const OptionalFormat value = ICE_SCOPED_ENUM(OptionalFormat, Class);
-};
-
-/**
- * Specialization for enum types.
- * \headerfile Ice/Ice.h
- */
-template<int minWireSize>
-struct GetOptionalFormat<StreamHelperCategoryEnum, minWireSize, false>
-{
-    static const OptionalFormat value = ICE_SCOPED_ENUM(OptionalFormat, Size);
-};
-
-/**
- * Base helper for optional values: simply read/write the data.
- * \headerfile Ice/Ice.h
- */
-template<typename T, StreamHelperCategory st, bool fixedLength>
-struct StreamOptionalHelper
-{
-    typedef StreamableTraits<T> Traits;
+        static void write(OutputStream* stream, const T& v) { stream->write(v); }
+
+        static void read(InputStream* stream, T& v) { stream->read(v); }
 
-    // If this optionalFormat fails to compile, you must either define your specialization
-    // for GetOptionalFormat (in which case the optional data will be marshaled/unmarshaled
-    // with straight calls to write/read on the stream), or define your own
-    // StreamOptionalHelper specialization (which gives you more control over marshaling)
+        static void print(std::ostream& stream, const T& v) { stream << v; }
+    };
+
+    //
+    // Helpers to read/write optional fields and arguments.
     //
-    static const OptionalFormat optionalFormat = GetOptionalFormat<st, Traits::minWireSize, fixedLength>::value;
 
-    template<class S> static inline void
-    write(S* stream, const T& v)
-    {
-        stream->write(v);
-    }
+    /// Extracts / computes the optionalFormat.
+    // This is used _only_ for the base StreamOptionalHelper below.
+    // /!\ Do not use in StreamOptionalHelper specializations, and do not provide specialization not handled by the
+    // base StreamOptionalHelper.
+    template<StreamHelperCategory st, int minWireSize, bool fixedLength> struct GetOptionalFormat;
 
-    template<class S> static inline void
-    read(S* stream, T& v)
+    /// Specialization for 1-byte built-in fixed-length types.
+    template<> struct GetOptionalFormat<StreamHelperCategoryBuiltinValue, 1, true>
     {
-        stream->read(v);
-    }
-};
-
-/**
- * Helper to write fixed-size structs.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamOptionalHelper<T, StreamHelperCategoryStruct, true>
-{
-    static const OptionalFormat optionalFormat = ICE_SCOPED_ENUM(OptionalFormat, VSize);
+        static constexpr OptionalFormat value = OptionalFormat::F1;
+    };
 
-    template<class S> static inline void
-    write(S* stream, const T& v)
+    /// Specialization for 2-byte built-in fixed-length types.
+    template<> struct GetOptionalFormat<StreamHelperCategoryBuiltinValue, 2, true>
     {
-        stream->writeSize(StreamableTraits<T>::minWireSize);
-        stream->write(v);
-    }
+        static constexpr OptionalFormat value = OptionalFormat::F2;
+    };
 
-    template<class S> static inline void
-    read(S* stream, T& v)
+    /// Specialization for 4-byte built-in fixed-length types.
+    template<> struct GetOptionalFormat<StreamHelperCategoryBuiltinValue, 4, true>
     {
-        stream->skipSize();
-        stream->read(v);
-    }
-};
-
-/**
- * Helper to write variable-size structs.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamOptionalHelper<T, StreamHelperCategoryStruct, false>
-{
-    static const OptionalFormat optionalFormat = ICE_SCOPED_ENUM(OptionalFormat, FSize);
+        static constexpr OptionalFormat value = OptionalFormat::F4;
+    };
 
-    template<class S> static inline void
-    write(S* stream, const T& v)
+    /// Specialization for 8-byte built-in fixed-length types.
+    template<> struct GetOptionalFormat<StreamHelperCategoryBuiltinValue, 8, true>
     {
-        typename S::size_type pos = stream->startSize();
-        stream->write(v);
-        stream->endSize(pos);
-    }
+        static constexpr OptionalFormat value = OptionalFormat::F8;
+    };
 
-    template<class S> static inline void
-    read(S* stream, T& v)
+    /// Specialization for built-in variable-length types.
+    template<> struct GetOptionalFormat<StreamHelperCategoryBuiltinValue, 1, false>
     {
-        stream->skip(4);
-        stream->read(v);
-    }
-};
-
-/**
- * Class structs are encoded like structs.
- * \headerfile Ice/Ice.h
- */
-template<typename T, bool fixedLength>
-struct StreamOptionalHelper<T, StreamHelperCategoryStructClass, fixedLength> : StreamOptionalHelper<T, StreamHelperCategoryStruct, fixedLength>
-{
-};
-
-/**
- * Optional proxies are encoded like variable size structs, using the FSize encoding.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamOptionalHelper<T, StreamHelperCategoryProxy, false> : StreamOptionalHelper<T, StreamHelperCategoryStruct, false>
-{
-};
-
-/**
- * Helper to read/write optional sequences or dictionaries.
- * \headerfile Ice/Ice.h
- */
-template<typename T, bool fixedLength, int sz>
-struct StreamOptionalContainerHelper;
-
-/**
- * Encode containers of variable-size elements with the FSize optional
- * type, since we can't easily figure out the size of the container
- * before encoding. This is the same encoding as variable size structs
- * so we just re-use its implementation.
- * \headerfile Ice/Ice.h
- */
-template<typename T, int sz>
-struct StreamOptionalContainerHelper<T, false, sz>
-{
-    static const OptionalFormat optionalFormat = ICE_SCOPED_ENUM(OptionalFormat, FSize);
+        static constexpr OptionalFormat value = OptionalFormat::VSize;
+    };
 
-    template<class S> static inline void
-    write(S* stream, const T& v, Int)
+    /// Specialization for built-in variable-length types.
+    template<> struct GetOptionalFormat<StreamHelperCategoryBuiltin, 1, false>
     {
-        StreamOptionalHelper<T, StreamHelperCategoryStruct, false>::write(stream, v);
-    }
+        static constexpr OptionalFormat value = OptionalFormat::VSize;
+    };
 
-    template<class S> static inline void
-    read(S* stream, T& v)
+    /// Specialization for enum types.
+    template<int minWireSize> struct GetOptionalFormat<StreamHelperCategoryEnum, minWireSize, false>
     {
-        StreamOptionalHelper<T, StreamHelperCategoryStruct, false>::read(stream, v);
-    }
-};
-
-/**
- * Encode containers of fixed-size elements with the VSize optional
- * type since we can figure out the size of the container before
- * encoding.
- * \headerfile Ice/Ice.h
- */
-template<typename T, int sz>
-struct StreamOptionalContainerHelper<T, true, sz>
-{
-    static const OptionalFormat optionalFormat = ICE_SCOPED_ENUM(OptionalFormat, VSize);
+        static constexpr OptionalFormat value = OptionalFormat::Size;
+    };
 
-    template<class S> static inline void
-    write(S* stream, const T& v, Int n)
+    /// Base helper template for reading and writing optional values. The default implementations reads/writes the
+    /// value as-is.
+    template<typename T, StreamHelperCategory st, bool fixedLength> struct StreamOptionalHelper
     {
+        using Traits = StreamableTraits<T>;
+
+        // If this optionalFormat fails to compile, you must either define your specialization
+        // for GetOptionalFormat (in which case the optional data will be marshaled/unmarshaled
+        // with straight calls to write/read on the stream), or define your own
+        // StreamOptionalHelper specialization (which gives you more control over marshaling)
         //
-        // The container size is the number of elements * the size of
-        // an element and the size-encoded number of elements (1 or
-        // 5 depending on the number of elements).
-        //
-        stream->writeSize(sz * n + (n < 255 ? 1 : 5));
-        stream->write(v);
-    }
+        static constexpr OptionalFormat optionalFormat = GetOptionalFormat<st, Traits::minWireSize, fixedLength>::value;
 
-    template<class S> static inline void
-    read(S* stream, T& v)
-    {
-        stream->skipSize();
-        stream->read(v);
-    }
-};
-
-/**
- * Optimization: containers of 1 byte elements are encoded with the
- * VSize optional type. There's no need to encode an additional size
- * for those, the number of elements of the container can be used to
- * skip the optional.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamOptionalContainerHelper<T, true, 1>
-{
-    static const OptionalFormat optionalFormat = ICE_SCOPED_ENUM(OptionalFormat, VSize);
+        static void write(OutputStream* stream, const T& v) { stream->write(v); }
+
+        static void read(InputStream* stream, T& v) { stream->read(v); }
+    };
 
-    template<class S> static inline void
-    write(S* stream, const T& v, Int)
+    /// Helper to write fixed-size structs.
+    template<typename T> struct StreamOptionalHelper<T, StreamHelperCategoryStruct, true>
     {
-        stream->write(v);
-    }
+        static constexpr OptionalFormat optionalFormat = OptionalFormat::VSize;
 
-    template<class S> static inline void
-    read(S* stream, T& v)
+        static void write(OutputStream* stream, const T& v)
+        {
+            stream->writeSize(StreamableTraits<T>::minWireSize);
+            stream->write(v);
+        }
+
+        static void read(InputStream* stream, T& v)
+        {
+            stream->skipSize();
+            stream->read(v);
+        }
+    };
+
+    /// Helper to write variable-size structs.
+    template<typename T> struct StreamOptionalHelper<T, StreamHelperCategoryStruct, false>
     {
-        stream->read(v);
-    }
-};
-
-/**
- * Helper to write sequences, delegates to the optional container
- * helper template partial specializations.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamOptionalHelper<T, StreamHelperCategorySequence, false>
-{
-    typedef typename T::value_type E;
-    static const int size = StreamableTraits<E>::minWireSize;
-    static const bool fixedLength = StreamableTraits<E>::fixedLength;
+        static constexpr OptionalFormat optionalFormat = OptionalFormat::FSize;
 
-    // The optional type of a sequence depends on whether or not elements are fixed
-    // or variable size elements and their size.
-    static const OptionalFormat optionalFormat = StreamOptionalContainerHelper<T, fixedLength, size>::optionalFormat;
+        static void write(OutputStream* stream, const T& v)
+        {
+            OutputStream::size_type pos = stream->startSize();
+            stream->write(v);
+            stream->endSize(pos);
+        }
 
-    template<class S> static inline void
-    write(S* stream, const T& v)
+        static void read(InputStream* stream, T& v)
+        {
+            stream->skip(4);
+            stream->read(v);
+        }
+    };
+
+    // InputStream and OutputStream have special logic for optional proxies that does not rely on the
+    // StreamOptional helpers.
+
+    /// Helper to read/write optional sequences or dictionaries.
+    template<typename T, bool fixedLength, int sz> struct StreamOptionalContainerHelper;
+
+    /// Encodes containers of variable-size elements with the FSize optional type, since we can't easily figure out
+    /// total number of bytes we're about to write.
+    // This is the same encoding as variable size structs so we just re-use its implementation.
+    template<typename T, int sz> struct StreamOptionalContainerHelper<T, false, sz>
     {
-        StreamOptionalContainerHelper<T, fixedLength, size>::write(stream, v, static_cast<Int>(v.size()));
-    }
+        static constexpr OptionalFormat optionalFormat = OptionalFormat::FSize;
 
-    template<class S> static inline void
-    read(S* stream, T& v)
+        static void write(OutputStream* stream, const T& v, std::int32_t)
+        {
+            StreamOptionalHelper<T, StreamHelperCategoryStruct, false>::write(stream, v);
+        }
+
+        static void read(InputStream* stream, T& v)
+        {
+            StreamOptionalHelper<T, StreamHelperCategoryStruct, false>::read(stream, v);
+        }
+    };
+
+    /// Encodes containers of fixed-size elements with the VSize optional type since we can figure out the total number
+    /// of bytes we're about to write.
+    template<typename T, int sz> struct StreamOptionalContainerHelper<T, true, sz>
     {
-        StreamOptionalContainerHelper<T, fixedLength, size>::read(stream, v);
-    }
-};
-
-/**
- * Helper to write sequences, delegates to the optional container
- * helper template partial specializations.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamOptionalHelper<std::pair<const T*, const T*>, StreamHelperCategorySequence, false>
-{
-    typedef std::pair<const T*, const T*> P;
-    static const int size = StreamableTraits<T>::minWireSize;
-    static const bool fixedLength = StreamableTraits<T>::fixedLength;
+        static constexpr OptionalFormat optionalFormat = OptionalFormat::VSize;
 
-    // The optional type of a sequence depends on whether or not elements are fixed
-    // or variable size elements and their size.
-    static const OptionalFormat optionalFormat = StreamOptionalContainerHelper<P, fixedLength, size>::optionalFormat;
+        static void write(OutputStream* stream, const T& v, std::int32_t n)
+        {
+            // The total number of bytes is the number of elements * the size of an element and the size-encoded number
+            // of elements (1 or 5 depending on the number of elements).
+            stream->writeSize(sz * n + (n < 255 ? 1 : 5));
+            stream->write(v);
+        }
 
-    template<class S> static inline void
-    write(S* stream, const P& v)
+        static void read(InputStream* stream, T& v)
+        {
+            stream->skipSize();
+            stream->read(v);
+        }
+    };
+
+    // Optimization: containers of 1 byte elements are encoded with the VSize optional type. There's no need to encode
+    // an additional size for those, the number of elements of the container can be used to skip the optional.
+    template<typename T> struct StreamOptionalContainerHelper<T, true, 1>
     {
-        Int n = static_cast<Int>(v.second - v.first);
-        StreamOptionalContainerHelper<P, fixedLength, size>::write(stream, v, n);
-    }
+        static constexpr OptionalFormat optionalFormat = OptionalFormat::VSize;
+
+        static void write(OutputStream* stream, const T& v, std::int32_t) { stream->write(v); }
 
-    template<class S> static inline void
-    read(S* stream, P& v)
+        static void read(InputStream* stream, T& v) { stream->read(v); }
+    };
+
+    // Helper to write sequences, delegates to the optional container helper template partial specializations.
+    template<typename T> struct StreamOptionalHelper<T, StreamHelperCategorySequence, false>
     {
-        StreamOptionalContainerHelper<P, fixedLength, size>::read(stream, v);
-    }
-};
+        using E = typename T::value_type;
+        static constexpr int size = StreamableTraits<E>::minWireSize;
+        static constexpr bool fixedLength = StreamableTraits<E>::fixedLength;
 
-#ifndef ICE_CPP11_MAPPING
+        // The optional type of a sequence depends on whether or not elements are fixed
+        // or variable size elements and their size.
+        static constexpr OptionalFormat optionalFormat =
+            StreamOptionalContainerHelper<T, fixedLength, size>::optionalFormat;
 
-/**
- * Helper to write sequences, delegates to the optional container
- * helper template partial specializations.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamOptionalHelper<std::pair<T, T>, StreamHelperCategorySequence, false>
-{
-    typedef std::pair<T, T> P;
-    static const int size = StreamableTraits<typename T::value_type>::minWireSize;
-    static const bool fixedLength = StreamableTraits<typename T::value_type>::fixedLength;
+        static void write(OutputStream* stream, const T& v)
+        {
+            StreamOptionalContainerHelper<T, fixedLength, size>::write(stream, v, static_cast<std::int32_t>(v.size()));
+        }
 
-    // The optional type of a sequence depends on whether or not elements are fixed
-    // or variable size elements and their size.
-    static const OptionalFormat optionalFormat = StreamOptionalContainerHelper<P, fixedLength, size>::optionalFormat;
+        static void read(InputStream* stream, T& v)
+        {
+            StreamOptionalContainerHelper<T, fixedLength, size>::read(stream, v);
+        }
+    };
 
-    template<class S> static inline void
-    write(S* stream, const P& v)
+    // Helper to write sequences, delegates to the optional container helper template partial specializations.
+    template<typename T> struct StreamOptionalHelper<std::pair<const T*, const T*>, StreamHelperCategorySequence, false>
     {
-        Int n = static_cast<Int>(v.second - v.first);
-        StreamOptionalContainerHelper<P, fixedLength, size>::write(stream, v, n);
-    }
+        using P = std::pair<const T*, const T*>;
+        static constexpr int size = StreamableTraits<T>::minWireSize;
+        static constexpr bool fixedLength = StreamableTraits<T>::fixedLength;
 
-    template<class S> static inline void
-    read(S* stream, P& v)
-    {
-        StreamOptionalContainerHelper<P, fixedLength, size>::read(stream, v);
-    }
-};
-
-/**
- * Helper to write sequences, delegates to the optional container
- * helper template partial specializations.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamOptionalHelper<std::pair<IceUtil::ScopedArray<T>, std::pair<const T*, const T*> >,
-                            StreamHelperCategorySequence, false>
-{
-    typedef std::pair<IceUtil::ScopedArray<T>, std::pair<const T*, const T*> > P;
-    static const int size = StreamableTraits<T>::minWireSize;
-    static const bool fixedLength = StreamableTraits<T>::fixedLength;
+        // The optional type of a sequence depends on whether or not elements are fixed
+        // or variable size elements and their size.
+        static constexpr OptionalFormat optionalFormat =
+            StreamOptionalContainerHelper<P, fixedLength, size>::optionalFormat;
+
+        static void write(OutputStream* stream, const P& v)
+        {
+            auto n = static_cast<std::int32_t>(v.second - v.first);
+            StreamOptionalContainerHelper<P, fixedLength, size>::write(stream, v, n);
+        }
 
-    // The optional type of a sequence depends on whether or not elements are fixed
-    // or variable size elements and their size.
-    static const OptionalFormat optionalFormat = StreamOptionalContainerHelper<P, fixedLength, size>::optionalFormat;
+        static void read(InputStream* stream, P& v)
+        {
+            StreamOptionalContainerHelper<P, fixedLength, size>::read(stream, v);
+        }
+    };
 
-    template<class S> static inline void
-    read(S* stream, P& v)
+    // Helper to write dictionaries, delegates to the optional container helper template partial specializations.
+    template<typename T> struct StreamOptionalHelper<T, StreamHelperCategoryDictionary, false>
     {
-        StreamOptionalContainerHelper<P, fixedLength, size>::read(stream, v);
-    }
+        using K = typename T::key_type;
+        using V = typename T::mapped_type;
 
-    // no write: only used for unmarshaling
-};
-#endif
+        static constexpr int size = StreamableTraits<K>::minWireSize + StreamableTraits<V>::minWireSize;
+        static constexpr bool fixedLength = StreamableTraits<K>::fixedLength && StreamableTraits<V>::fixedLength;
 
-/**
- * Helper to write dictionaries, delegates to the optional container
- * helper template partial specializations.
- * \headerfile Ice/Ice.h
- */
-template<typename T>
-struct StreamOptionalHelper<T, StreamHelperCategoryDictionary, false>
-{
-    typedef typename T::key_type K;
-    typedef typename T::mapped_type V;
+        // The optional type of a dictionary depends on whether or not elements are fixed
+        // or variable size elements.
+        static constexpr OptionalFormat optionalFormat =
+            StreamOptionalContainerHelper<T, fixedLength, size>::optionalFormat;
+
+        static void write(OutputStream* stream, const T& v)
+        {
+            StreamOptionalContainerHelper<T, fixedLength, size>::write(stream, v, static_cast<std::int32_t>(v.size()));
+        }
 
-    static const int size = StreamableTraits<K>::minWireSize + StreamableTraits<V>::minWireSize;
-    static const bool fixedLength = StreamableTraits<K>::fixedLength && StreamableTraits<V>::fixedLength;
+        static void read(InputStream* stream, T& v)
+        {
+            StreamOptionalContainerHelper<T, fixedLength, size>::read(stream, v);
+        }
+    };
 
-    // The optional type of a dictionary depends on whether or not elements are fixed
-    // or variable size elements.
-    static const OptionalFormat optionalFormat = StreamOptionalContainerHelper<T, fixedLength, size>::optionalFormat;
+    // Specializations for ProtocolVersion and EncodingVersion
+    template<> struct StreamableTraits<ProtocolVersion>
+    {
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
+        static constexpr int minWireSize = 2;
+        static constexpr bool fixedLength = true;
+    };
 
-    template<class S> static inline void
-    write(S* stream, const T& v)
+    template<> struct StreamReader<ProtocolVersion>
     {
-        StreamOptionalContainerHelper<T, fixedLength, size>::write(stream, v, static_cast<Int>(v.size()));
-    }
+        static void read(InputStream* istr, ProtocolVersion& v) { istr->readAll(v.major, v.minor); }
+    };
 
-    template<class S> static inline void
-    read(S* stream, T& v)
+    template<> struct StreamableTraits<EncodingVersion>
     {
-        StreamOptionalContainerHelper<T, fixedLength, size>::read(stream, v);
-    }
-};
+        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
+        static constexpr int minWireSize = 2;
+        static constexpr bool fixedLength = true;
+    };
 
-/// \endcond
+    template<> struct StreamReader<EncodingVersion>
+    {
+        static void read(InputStream* istr, EncodingVersion& v) { istr->readAll(v.major, v.minor); }
+    };
 
+    /// @endcond
 }
 
 #endif