zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,1091 +1,891 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_OUTPUT_STREAM_H
 #define ICE_OUTPUT_STREAM_H
 
-#include <Ice/CommunicatorF.h>
-#include <Ice/InstanceF.h>
-#include <Ice/Object.h>
-#include <Ice/ValueF.h>
-#include <Ice/ProxyF.h>
-#include <Ice/Buffer.h>
-#include <Ice/Protocol.h>
-#include <Ice/SlicedDataF.h>
-#include <Ice/StreamHelpers.h>
+#include "Buffer.h"
+#include "CommunicatorF.h"
+#include "Ice/Format.h"
+#include "Ice/StringConverter.h"
+#include "Ice/Version.h"
+#include "InstanceF.h"
+#include "SlicedDataF.h"
+#include "StreamableTraits.h"
+#include "ValueF.h"
+
+#include <cassert>
+#include <cstdint>
+#include <cstring>
+#include <map>
+#include <string>
+#include <string_view>
+#include <vector>
 
 namespace Ice
 {
+    class ObjectPrx;
 
-class UserException;
+    /// Identifies Slice encoding version 1.0.
+    constexpr EncodingVersion Encoding_1_0{1, 0};
 
-/**
- * Interface for output streams used to create a sequence of bytes from Slice types.
- * \headerfile Ice/Ice.h
- */
-class ICE_API OutputStream : public IceInternal::Buffer
-{
-public:
-
-    typedef size_t size_type;
-
-    /**
-     * Constructs an OutputStream using the latest encoding version, the default format for
-     * class encoding, and the process string converters. You can supply a communicator later
-     * by calling initialize().
-     */
-    OutputStream();
-
-    /**
-     * Constructs a stream using the communicator's default encoding version.
-     * @param communicator The communicator to use for marshaling tasks.
-     */
-    OutputStream(const CommunicatorPtr& communicator);
-
-    /**
-     * Constructs a stream using the given communicator and encoding version.
-     * @param communicator The communicator to use for marshaling tasks.
-     * @param version The encoding version used to encode the data.
-     */
-    OutputStream(const CommunicatorPtr& communicator, const EncodingVersion& version);
-
-    /**
-     * Constructs a stream using the given communicator and encoding version.
-     * @param communicator The communicator to use for marshaling tasks.
-     * @param version The encoding version used to encode the data.
-     * @param bytes Application-supplied memory that the stream uses as its initial marshaling buffer. The
-     * stream will reallocate if the size of the marshaled data exceeds the application's buffer.
-     */
-    OutputStream(const CommunicatorPtr& communicator, const EncodingVersion& version,
-                 const std::pair<const Byte*, const Byte*>& bytes);
-
-    ~OutputStream()
-    {
-        // Inlined for performance reasons.
+    /// Identifies Slice encoding version 1.1.
+    constexpr EncodingVersion Encoding_1_1{1, 1};
 
-        if(_currentEncaps != &_preAllocatedEncaps)
+    /// Represents a byte buffer used for marshaling data using the Slice encoding.
+    /// @headerfile Ice/Ice.h
+    class ICE_API OutputStream : public IceInternal::Buffer
+    {
+    public:
+        /// The size type for this byte buffer.
+        using size_type = std::size_t;
+
+        /// Constructs an OutputStream.
+        /// @param encoding The encoding version to use.
+        /// @param format The class format to use.
+        /// @param stringConverter The narrow string converter to use.
+        /// @param wstringConverter The wide string converter to use.
+        OutputStream(
+            EncodingVersion encoding = Encoding_1_1,
+            FormatType format = FormatType::CompactFormat,
+            StringConverterPtr stringConverter = nullptr,
+            WstringConverterPtr wstringConverter = nullptr);
+
+        /// Constructs an OutputStream using the format, string converter and wstring converter provided by the
+        /// communicator, and the specified encoding.
+        /// @param communicator The communicator.
+        /// @param encoding The encoding version to use.
+        OutputStream(const CommunicatorPtr& communicator, EncodingVersion encoding);
+
+        /// Constructs an OutputStream using the encoding, format, string converter and wstring converter provided by
+        /// the communicator.
+        /// @param communicator The communicator.
+        OutputStream(const CommunicatorPtr& communicator);
+
+        /// Constructs an OutputStream over an application-supplied buffer.
+        /// @param bytes Application-supplied memory that the OutputStream uses as its initial marshaling buffer. The
+        /// stream will reallocate if the size of the marshaled data exceeds the application's buffer.
+        /// @param encoding The encoding version to use.
+        /// @param format The class format to use.
+        /// @param stringConverter The narrow string converter to use.
+        /// @param wstringConverter The wide string converter to use.
+        OutputStream(
+            std::pair<const std::byte*, const std::byte*> bytes,
+            EncodingVersion encoding = Encoding_1_1,
+            FormatType format = FormatType::CompactFormat,
+            StringConverterPtr stringConverter = nullptr,
+            WstringConverterPtr wstringConverter = nullptr);
+
+        /// Move constructor.
+        /// @param other The output stream to move into this output stream.
+        OutputStream(OutputStream&& other) noexcept;
+
+        /// Move assignment operator.
+        /// @param other The output stream to move into this output stream.
+        /// @return A reference to this output stream.
+        OutputStream& operator=(OutputStream&& other) noexcept;
+
+        ~OutputStream()
         {
-            clear(); // Not inlined.
+            // Inlined for performance reasons.
+
+            if (_currentEncaps != &_preAllocatedEncaps)
+            {
+                clear(); // Not inlined.
+            }
         }
-    }
-
-    /**
-     * Initializes the stream to use the communicator's default encoding version, class
-     * encoding format and string converters. Use this method if you originally constructed
-     * the stream without a communicator.
-     * @param communicator The communicator to use for marshaling tasks.
-     */
-    void initialize(const CommunicatorPtr& communicator);
-
-    /**
-     * Initializes the stream to use the given encoding version and the communicator's
-     * default class encoding format and string converters. Use this method if you
-     * originally constructed the stream without a communicator.
-     * @param communicator The communicator to use for marshaling tasks.
-     * @param version The encoding version used to encode the data.
-     */
-    void initialize(const CommunicatorPtr& communicator, const EncodingVersion& version);
-
-    /**
-     * Releases any data retained by encapsulations.
-     */
-    void clear();
-
-    /// \cond INTERNAL
-    //
-    // Must return Instance*, because we don't hold an InstancePtr for
-    // optimization reasons (see comments below).
-    //
-    IceInternal::Instance* instance() const { return _instance; } // Inlined for performance reasons.
-    /// \endcond
-
-    /**
-     * Sets the class encoding format.
-     * @param format The encoding format.
-     */
-    void setFormat(FormatType format);
-
-    /**
-     * Obtains the closure data associated with this stream.
-     * @return The data as a void pointer.
-     */
-    void* getClosure() const;
-
-    /**
-     * Associates closure data with this stream.
-     * @param p The data as a void pointer.
-     * @return The previous closure data, or nil.
-     */
-    void* setClosure(void* p);
-
-    /**
-     * Swaps the contents of one stream with another.
-     *
-     * @param other The other stream.
-     */
-    void swap(OutputStream& other);
-
-    /// \cond INTERNAL
-    void resetEncapsulation();
-    /// \endcond
-
-    /**
-     * Resizes the stream to a new size.
-     *
-     * @param sz The new size.
-     */
-    void resize(Container::size_type sz)
-    {
-        b.resize(sz);
-    }
-
-    /**
-     * Marks the start of a class instance.
-     * @param data Contains the marshaled form of unknown slices from this instance. If not nil,
-     * these slices will be marshaled with the instance.
-     */
-    void startValue(const SlicedDataPtr& data)
-    {
-        assert(_currentEncaps && _currentEncaps->encoder);
-        _currentEncaps->encoder->startInstance(ValueSlice, data);
-    }
-
-    /**
-     * Marks the end of a class instance.
-     */
-    void endValue()
-    {
-        assert(_currentEncaps && _currentEncaps->encoder);
-        _currentEncaps->encoder->endInstance();
-    }
-
-    /**
-     * Marks the start of an exception instance.
-     * @param data Contains the marshaled form of unknown slices from this instance. If not nil,
-     * these slices will be marshaled with the instance.
-     */
-    void startException(const SlicedDataPtr& data)
-    {
-        assert(_currentEncaps && _currentEncaps->encoder);
-        _currentEncaps->encoder->startInstance(ExceptionSlice, data);
-    }
-
-    /**
-     * Marks the end of an exception instance.
-     */
-    void endException()
-    {
-        assert(_currentEncaps && _currentEncaps->encoder);
-        _currentEncaps->encoder->endInstance();
-    }
-
-    /**
-     * Writes the start of an encapsulation using the default encoding version and
-     * class encoding format.
-     */
-    void startEncapsulation();
-
-    /**
-     * Writes the start of an encapsulation using the given encoding version and
-     * class encoding format.
-     * @param encoding The encoding version to use for the encapsulation.
-     * @param format The class format to use for the encapsulation.
-     */
-    void startEncapsulation(const EncodingVersion& encoding, FormatType format)
-    {
-        IceInternal::checkSupportedEncoding(encoding);
 
-        Encaps* oldEncaps = _currentEncaps;
-        if(!oldEncaps) // First allocated encaps?
+        /// Releases any data retained by encapsulations.
+        void clear();
+
+        /// Swaps the contents of one stream with another.
+        /// @param other The other stream.
+        void swap(OutputStream& other) noexcept;
+
+        /// @cond INTERNAL
+
+        /// Gets the closure associated with this stream.
+        /// @return The closure.
+        [[nodiscard]] void* getClosure() const;
+
+        /// Associates a closure with this stream.
+        /// @param p The closure
+        /// @return The previous closure, or nullptr.
+        void* setClosure(void* p);
+
+        void resetEncapsulation();
+        /// @endcond
+
+        /// Resizes the stream to a new size.
+        /// @param sz The new size.
+        void resize(Container::size_type sz) { b.resize(sz); }
+
+        /// Marks the start of a class instance.
+        /// @param data Contains the marshaled form of unknown slices from the class instance. If not nullptr, these
+        /// slices will be marshaled with the instance.
+        void startValue(const SlicedDataPtr& data)
         {
-            _currentEncaps = &_preAllocatedEncaps;
+            assert(_currentEncaps && _currentEncaps->encoder);
+            _currentEncaps->encoder->startInstance(ValueSlice, data);
         }
-        else
+
+        /// Marks the end of a class instance.
+        void endValue()
         {
-            _currentEncaps = new Encaps();
-            _currentEncaps->previous = oldEncaps;
+            assert(_currentEncaps && _currentEncaps->encoder);
+            _currentEncaps->encoder->endInstance();
         }
-        _currentEncaps->format = format;
-        _currentEncaps->encoding = encoding;
-        _currentEncaps->start = b.size();
-
-        write(Int(0)); // Placeholder for the encapsulation length.
-        write(_currentEncaps->encoding);
-    }
-
-    /**
-     * Ends the current encapsulation.
-     */
-    void endEncapsulation()
-    {
-        assert(_currentEncaps);
 
-        // Size includes size and version.
-        const Int sz = static_cast<Int>(b.size() - _currentEncaps->start);
-        write(sz, &(*(b.begin() + _currentEncaps->start)));
-
-        Encaps* oldEncaps = _currentEncaps;
-        _currentEncaps = _currentEncaps->previous;
-        if(oldEncaps == &_preAllocatedEncaps)
+        /// Marks the start of an exception instance.
+        void startException()
         {
-            oldEncaps->reset();
+            assert(_currentEncaps && _currentEncaps->encoder);
+            _currentEncaps->encoder->startInstance(ExceptionSlice, nullptr);
         }
-        else
+
+        /// Marks the end of an exception instance.
+        void endException()
         {
-            delete oldEncaps;
+            assert(_currentEncaps && _currentEncaps->encoder);
+            _currentEncaps->encoder->endInstance();
         }
-    }
 
-    /**
-     * Writes an empty encapsulation using the given encoding version.
-     * @param encoding The encoding version to use for the encapsulation.
-     */
-    void writeEmptyEncapsulation(const EncodingVersion& encoding)
-    {
-        IceInternal::checkSupportedEncoding(encoding);
-        write(Int(6)); // Size
-        write(encoding);
-    }
-
-    /**
-     * Copies the marshaled form of an encapsulation to the buffer.
-     * @param v The start of the buffer.
-     * @param sz The number of bytes to copy.
-     */
-    void writeEncapsulation(const Byte* v, Int sz)
-    {
-        if(sz < 6)
+        /// Writes the start of an encapsulation using the default encoding version and class encoding format.
+        void startEncapsulation();
+
+        /// Writes the start of an encapsulation using the specified encoding version and class encoding format.
+        /// @param encoding The encoding version to use for the encapsulation.
+        /// @param format The class format to use for the encapsulation. nullopt is equivalent to the OutputStream's
+        /// class format.
+        void startEncapsulation(const EncodingVersion& encoding, std::optional<FormatType> format);
+
+        /// Ends the current encapsulation.
+        void endEncapsulation();
+
+        /// Writes an empty encapsulation using the specified encoding version.
+        /// @param encoding The encoding version to use for the encapsulation.
+        void writeEmptyEncapsulation(const EncodingVersion& encoding);
+
+        /// Copies the marshaled form of an encapsulation to the buffer.
+        /// @param v The start of the buffer.
+        /// @param sz The number of bytes to copy.
+        void writeEncapsulation(const std::byte* v, std::int32_t sz);
+
+        /// Gets the current encoding version.
+        /// @return The encoding version.
+        [[nodiscard]] const EncodingVersion& getEncoding() const
         {
-            throwEncapsulationException(__FILE__, __LINE__);
+            return _currentEncaps ? _currentEncaps->encoding : _encoding;
         }
 
-        Container::size_type position = b.size();
-        resize(position + static_cast<size_t>(sz));
-        memcpy(&b[position], &v[0], static_cast<size_t>(sz));
-    }
-
-    /**
-     * Determines the current encoding version.
-     *
-     * @return The encoding version.
-     */
-    const EncodingVersion& getEncoding() const
-    {
-        return _currentEncaps ? _currentEncaps->encoding : _encoding;
-    }
-
-    /**
-     * Writes the start of a value or exception slice.
-     *
-     * @param typeId The Slice type ID for this slice.
-     * @param compactId The compact ID corresponding to the type, or -1 if no compact ID is used.
-     * @param last True if this is the last slice, false otherwise.
-     */
-    void startSlice(const std::string& typeId, int compactId, bool last)
-    {
-        assert(_currentEncaps && _currentEncaps->encoder);
-        _currentEncaps->encoder->startSlice(typeId, compactId, last);
-    }
-
-    /**
-     * Marks the end of a value or exception slice.
-     */
-    void endSlice()
-    {
-        assert(_currentEncaps && _currentEncaps->encoder);
-        _currentEncaps->encoder->endSlice();
-    }
-
-    /**
-     * Encodes the state of class instances whose insertion was delayed during a previous
-     * call to write. This member function must only be called once. For backward
-     * compatibility with encoding version 1.0, this function must only be called when
-     * non-optional data members or parameters use class types.
-     */
-    void writePendingValues();
-
-    /**
-     * Writes a size value.
-     * @param v A non-negative integer.
-     */
-    void writeSize(Int v) // Inlined for performance reasons.
-    {
-        assert(v >= 0);
-        if(v > 254)
+        /// Writes the start of a class instance or exception slice.
+        /// @param typeId The Slice type ID for this slice.
+        /// @param compactId The compact ID corresponding to the type, or -1 if no compact ID is used.
+        /// @param last `true` if this is the last slice, `false` otherwise.
+        void startSlice(std::string_view typeId, int compactId, bool last)
         {
-            write(Byte(255));
-            write(v);
+            assert(_currentEncaps && _currentEncaps->encoder);
+            _currentEncaps->encoder->startSlice(typeId, compactId, last);
         }
-        else
+
+        /// Marks the end of a class instance or exception slice.
+        void endSlice()
         {
-            write(static_cast<Byte>(v));
+            assert(_currentEncaps && _currentEncaps->encoder);
+            _currentEncaps->encoder->endSlice();
         }
-    }
-
-    /**
-     * Replaces a size value at the given destination in the stream. This function
-     * does not change the stream's current position.
-     * @param v A non-negative integer representing the size.
-     * @param dest The buffer destination for the size.
-     */
-    void rewriteSize(Int v, Container::iterator dest)
-    {
-        assert(v >= 0);
-        if(v > 254)
+
+        /// Encodes the state of class instances whose insertion was delayed during a previous call `write`. This
+        /// function must be called only once. For backward compatibility with encoding version 1.0, this function must
+        /// be called only when non-optional fields or parameters use class types.
+        void writePendingValues();
+
+        /// Writes a size value.
+        /// @param v A non-negative integer.
+        void writeSize(std::int32_t v) // Inlined for performance reasons.
         {
-            *dest++ = Byte(255);
-            write(v, dest);
+            assert(v >= 0);
+            if (v > 254)
+            {
+                write(std::uint8_t(255));
+                write(v);
+            }
+            else
+            {
+                write(static_cast<std::uint8_t>(v));
+            }
         }
-        else
+
+        /// Replaces a size value at the specified position in the stream. This function does not change the stream's
+        /// current position.
+        /// @param v A non-negative integer representing the size.
+        /// @param dest The buffer destination for the size.
+        void rewriteSize(std::int32_t v, Container::iterator dest)
         {
-            *dest = static_cast<Byte>(v);
+            assert(v >= 0);
+            if (v > 254)
+            {
+                *dest++ = std::byte{255};
+                write(v, dest);
+            }
+            else
+            {
+                *dest = static_cast<std::byte>(v);
+            }
         }
-    }
-
-    /**
-     * Writes a placeholder value for the size and returns the starting position of the
-     * size value; after writing the data, call endSize to patch the placeholder with
-     * the actual size at the given position.
-     * @return The starting position of the size value.
-     */
-    size_type startSize()
-    {
-        size_type position = b.size();
-        write(Int(0));
-        return position;
-    }
-
-    /**
-     * Updates the size value at the given position to contain a size based on the
-     * stream's current position.
-     * @param position The starting position of the size value as returned by startSize.
-     */
-    void endSize(size_type position)
-    {
-        rewrite(static_cast<Int>(b.size() - position) - 4, position);
-    }
-
-    /**
-     * Copies the specified blob of bytes to the stream without modification.
-     * @param v The bytes to be copied.
-     */
-    void writeBlob(const std::vector<Byte>& v);
-
-    /**
-     * Copies the specified blob of bytes to the stream without modification.
-     * @param v The start of the buffer to be copied.
-     * @param sz The number of bytes to be copied.
-     */
-    void writeBlob(const Byte* v, Container::size_type sz)
-    {
-        if(sz > 0)
+
+        /// Writes a placeholder value for the size and returns the starting position of the size value; after writing
+        /// the data, call #endSize to patch the placeholder with the actual size at the given position.
+        /// @return The starting position of the size value.
+        size_type startSize()
         {
-            Container::size_type position = b.size();
-            resize(position + sz);
-            memcpy(&b[position], &v[0], sz);
+            size_type position = b.size();
+            write(std::int32_t(0));
+            return position;
         }
-    }
 
-    /**
-     * Writes a data value to the stream.
-     * @param v The data value to be written.
-     */
-    template<typename T> void write(const T& v)
-    {
-        StreamHelper<T, StreamableTraits<T>::helper>::write(this, v);
-    }
-
-    /**
-     * Writes an optional data value to the stream.
-     * @param tag The tag ID.
-     * @param v The data value to be written (if any).
-     */
-    template<typename T> void write(Int tag, const IceUtil::Optional<T>& v)
-    {
-        if(!v)
+        /// Updates the size value at the given position. The new size is computed from stream's current position.
+        /// @param position The starting position of the size value as returned by #startSize.
+        void endSize(size_type position) { rewrite(static_cast<std::int32_t>(b.size() - position) - 4, position); }
+
+        /// Copies the specified blob of bytes to the stream without modification.
+        /// @param v The bytes to copy.
+        void writeBlob(const std::vector<std::byte>& v);
+
+        /// Copies the specified blob of bytes to the stream without modification.
+        /// @param v The start of the buffer to copy.
+        /// @param sz The number of bytes to copy.
+        void writeBlob(const std::byte* v, Container::size_type sz)
         {
-            return; // Optional not set
+            if (sz > 0)
+            {
+                Container::size_type position = b.size();
+                resize(position + sz);
+                memcpy(&b[position], &v[0], sz);
+            }
         }
 
-        if(writeOptional(tag, StreamOptionalHelper<T,
-                                              StreamableTraits<T>::helper,
-                                              StreamableTraits<T>::fixedLength>::optionalFormat))
+        /// Writes a value to the stream.
+        /// @tparam T The type of the value to marshal.
+        /// @param v The value to marshal.
+        template<typename T> void write(const T& v) { StreamHelper<T, StreamableTraits<T>::helper>::write(this, v); }
+
+#ifdef ICE_DOXYGEN
+        /// Writes an optional value to the stream.
+        /// @tparam T The type of the value to marshal.
+        /// @param tag The tag.
+        /// @param v The value to marshal.
+        template<typename T> void write(std::int32_t tag, const std::optional<T>& v);
+
+        /// Writes a tuple to the stream.
+        /// @tparam I The index of the first element to marshal.
+        /// @tparam Te The types of the values in the tuple, starting at index @p I.
+        /// @param tuple The tuple to marshal.
+        // Declared here because the actual definition below breaks doxygen 1.13.2.
+        template<size_t I = 0, typename... Te >> writeAll(std::tuple<Te...> tuple);
+#endif
+
+        /// Writes a value (single element list) to the stream.
+        /// @tparam T The type of the value.
+        /// @param v The value to marshal.
+        template<typename T> void writeAll(const T& v) { write(v); }
+
+        /// Writes a list of values to the stream.
+        /// @tparam T The type of the first value.
+        /// @tparam Te The types of the remaining values.
+        /// @param v The first value to marshal.
+        /// @param ve The remaining values.
+        template<typename T, typename... Te> void writeAll(const T& v, const Te&... ve)
         {
-            StreamOptionalHelper<T,
-                                 StreamableTraits<T>::helper,
-                                 StreamableTraits<T>::fixedLength>::write(this, *v);
+            write(v);
+            writeAll(ve...);
         }
-    }
 
-    /**
-     * Writes a sequence of data values to the stream.
-     * @param v The sequence to be written.
-     */
-    template<typename T> void write(const std::vector<T>& v)
-    {
-        if(v.empty())
+        /// Writes an optional value (single element list) to the stream.
+        /// @tparam T The type of the value.
+        /// @param tags The tag list. The last tag is used to marshal the value.
+        /// @param v The value to marshal.
+        template<typename T> void writeAll(std::initializer_list<std::int32_t> tags, const std::optional<T>& v)
         {
-            writeSize(0);
+            write(*(tags.begin() + tags.size() - 1), v);
         }
-        else
+
+        /// Writes a list of optional values to the stream.
+        /// @tparam T The type of the first value.
+        /// @tparam Te The types of the remaining values.
+        /// @param tags The tag list.
+        /// @param v The first value to marshal.
+        /// @param ve The remaining values.
+        template<typename T, typename... Te>
+        void
+        writeAll(std::initializer_list<std::int32_t> tags, const std::optional<T>& v, const std::optional<Te>&... ve)
         {
-            write(&v[0], &v[0] + v.size());
+            size_t index = tags.size() - sizeof...(ve) - 1;
+            write(*(tags.begin() + index), v);
+            writeAll(tags, ve...);
         }
-    }
-
-    /**
-     * Writes a sequence of data values to the stream.
-     * @param begin The beginning of the sequence.
-     * @param end The end of the sequence.
-     */
-    template<typename T> void write(const T* begin, const T* end)
-    {
-        writeSize(static_cast<Int>(end - begin));
-        for(const T* p = begin; p != end; ++p)
+
+        /// Writes the tag and format of an optional value.
+        /// @param tag The tag.
+        /// @param format The optional format.
+        /// @return `true` if the current encoding version supports optional values, `false` otherwise.
+        /// If `true`, the data associated with the optional value must be written next.
+        bool writeOptional(std::int32_t tag, OptionalFormat format)
         {
-            write(*p);
+            assert(_currentEncaps);
+            if (_currentEncaps->encoder)
+            {
+                return _currentEncaps->encoder->writeOptional(tag, format);
+            }
+            else
+            {
+                return writeOptImpl(tag, format);
+            }
         }
-    }
-
-#ifdef ICE_CPP11_MAPPING
-
-    /**
-     * Writes a list of mandatory data values.
-     */
-    template<typename T> void writeAll(const T& v)
-    {
-        write(v);
-    }
 
-    /**
-     * Writes a list of mandatory data values.
-     */
-    template<typename T, typename... Te> void writeAll(const T& v, const Te&... ve)
-    {
-        write(v);
-        writeAll(ve...);
-    }
-
-    /**
-     * Writes a list of mandatory data values.
-     */
-    template<size_t I = 0, typename... Te>
-    typename std::enable_if<I == sizeof...(Te), void>::type
-    writeAll(std::tuple<Te...>)
-    {
-        // Do nothing. Either tuple is empty or we are at the end.
-    }
-
-    /**
-     * Writes a list of mandatory data values.
-     */
-    template<size_t I = 0, typename... Te>
-    typename std::enable_if<I < sizeof...(Te), void>::type
-    writeAll(std::tuple<Te...> tuple)
-    {
-        write(std::get<I>(tuple));
-        writeAll<I + 1, Te...>(tuple);
-    }
-
-    /**
-     * Writes a list of optional data values.
-     */
-    template<typename T>
-    void writeAll(std::initializer_list<int> tags, const IceUtil::Optional<T>& v)
-    {
-        write(*(tags.begin() + tags.size() - 1), v);
-    }
-
-    /**
-     * Writes a list of optional data values.
-     */
-    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...);
-    }
+        /// @cond INTERNAL
 
-#endif
+        // We don't document all the write "specializations" in Doxygen. But we do keep them mostly documented for
+        // tool-tips.
 
-    /**
-     * Writes the tag and format of an optional value.
-     * @param tag The optional tag ID.
-     * @param format The optional format.
-     * @return True if the current encoding version supports optional values, false otherwise.
-     * If true, the data associated with the optional value must be written next.
-     */
-    bool writeOptional(Int tag, OptionalFormat format)
-    {
-        assert(_currentEncaps);
-        if(_currentEncaps->encoder)
+        /// Writes an optional value to the stream.
+        /// @tparam T The type of the value to marshal. Not for proxy types.
+        /// @param tag The tag.
+        /// @param v The value to marshal.
+        template<typename T, std::enable_if_t<!std::is_base_of_v<ObjectPrx, T>, bool> = true>
+        void write(std::int32_t tag, const std::optional<T>& v)
         {
-            return _currentEncaps->encoder->writeOptional(tag, format);
+            if (!v)
+            {
+                return; // Optional not set
+            }
+
+            if (writeOptional(
+                    tag,
+                    StreamOptionalHelper<T, StreamableTraits<T>::helper, StreamableTraits<T>::fixedLength>::
+                        optionalFormat))
+            {
+                StreamOptionalHelper<T, StreamableTraits<T>::helper, StreamableTraits<T>::fixedLength>::write(this, *v);
+            }
         }
-        else
+
+        /// Writes an optional value to the stream.
+        /// @tparam T The proxy type.
+        /// @param tag The tag.
+        /// @param v The value to marshal.
+        template<typename T, std::enable_if_t<std::is_base_of_v<ObjectPrx, T>, bool> = true>
+        void write(std::int32_t tag, const std::optional<T>& v)
         {
-            return writeOptImpl(tag, format);
+            if (!v)
+            {
+                return; // Optional not set
+            }
+
+            if (writeOptional(tag, OptionalFormat::FSize))
+            {
+                size_type pos = startSize();
+                writeProxy(*v);
+                endSize(pos);
+            }
         }
-    }
 
-    /**
-     * Writes a byte to the stream.
-     * @param v The byte to write.
-     */
-    void write(Byte v)
-    {
-        b.push_back(v);
-    }
-
-    /**
-     * Writes a byte sequence to the stream.
-     * @param start The beginning of the sequence.
-     * @param end The end of the sequence.
-     */
-    void write(const Byte* start, const Byte* end);
-
-    /**
-     * Writes a boolean to the stream.
-     * @param v The boolean to write.
-     */
-    void write(bool v)
-    {
-        b.push_back(static_cast<Byte>(v));
-    }
-
-    /**
-     * Writes a byte sequence to the stream.
-     * @param v The sequence to be written.
-     */
-    void write(const std::vector<bool>& v);
-
-    /**
-     * Writes a byte sequence to the stream.
-     * @param begin The beginning of the sequence.
-     * @param end The end of the sequence.
-     */
-    void write(const bool* begin, const bool* end);
-
-    /**
-     * Writes a short to the stream.
-     * @param v The short to write.
-     */
-    void write(Short v);
-
-    /**
-     * Writes a short sequence to the stream.
-     * @param begin The beginning of the sequence.
-     * @param end The end of the sequence.
-     */
-    void write(const Short* begin, const Short* end);
-
-    /**
-     * Writes an int to the stream.
-     * @param v The int to write.
-     */
-    void write(Int v) // Inlined for performance reasons.
-    {
-        Container::size_type position = b.size();
-        resize(position + sizeof(Int));
-        write(v, &b[position]);
-    }
-
-    /**
-     * Overwrites a 32-bit integer value at the given destination in the stream.
-     * This function does not change the stream's current position.
-     * @param v The integer value to be written.
-     * @param dest The buffer destination for the integer value.
-     */
-    void write(Int v, Container::iterator dest)
-    {
-#ifdef ICE_BIG_ENDIAN
-        const Byte* src = reinterpret_cast<const Byte*>(&v) + sizeof(Int) - 1;
-        *dest++ = *src--;
-        *dest++ = *src--;
-        *dest++ = *src--;
-        *dest = *src;
-#else
-        const Byte* src = reinterpret_cast<const Byte*>(&v);
-        *dest++ = *src++;
-        *dest++ = *src++;
-        *dest++ = *src++;
-        *dest = *src;
-#endif
-    }
-
-    /**
-     * Writes an int sequence to the stream.
-     * @param begin The beginning of the sequence.
-     * @param end The end of the sequence.
-     */
-    void write(const Int* begin, const Int* end);
-
-    /**
-     * Writes a long to the stream.
-     * @param v The long to write.
-     */
-    void write(Long v);
-
-    /**
-     * Writes a long sequence to the stream.
-     * @param begin The beginning of the sequence.
-     * @param end The end of the sequence.
-     */
-    void write(const Long* begin, const Long* end);
-
-    /**
-     * Writes a float to the stream.
-     * @param v The float to write.
-     */
-    void write(Float v);
-
-    /**
-     * Writes a float sequence to the stream.
-     * @param begin The beginning of the sequence.
-     * @param end The end of the sequence.
-     */
-    void write(const Float* begin, const Float* end);
-
-    /**
-     * Writes a double to the stream.
-     * @param v The double to write.
-     */
-    void write(Double v);
-
-    /**
-     * Writes a double sequence to the stream.
-     * @param begin The beginning of the sequence.
-     * @param end The end of the sequence.
-     */
-    void write(const Double* begin, const Double* end);
-
-    /**
-     * Writes a string to the stream.
-     * @param v The string to write.
-     * @param convert Determines whether the string is processed by the narrow string converter,
-     * if one has been configured. The default behavior is to convert the strings.
-     */
-    void write(const std::string& v, bool convert = true)
-    {
-        Int sz = static_cast<Int>(v.size());
-        if(convert && sz > 0)
+        /// Writes a sequence to the stream.
+        /// @tparam T The type of the elements in the sequence.
+        /// @param v The sequence to marshal.
+        template<typename T> void write(const std::vector<T>& v)
         {
-            writeConverted(v.data(), static_cast<size_t>(sz));
+            if (v.empty())
+            {
+                writeSize(0);
+            }
+            else
+            {
+                write(&v[0], &v[0] + v.size());
+            }
         }
-        else
+
+        /// Writes a sequence to the stream.
+        /// @tparam T The type of the elements in the sequence.
+        /// @param begin The beginning of the sequence.
+        /// @param end The end of the sequence.
+        template<typename T> void write(const T* begin, const T* end)
         {
-            writeSize(sz);
-            if(sz > 0)
+            writeSize(static_cast<std::int32_t>(end - begin));
+            for (const T* p = begin; p != end; ++p)
             {
-                Container::size_type position = b.size();
-                resize(position + static_cast<size_t>(sz));
-                memcpy(&b[position], v.data(), static_cast<size_t>(sz));
+                write(*p);
             }
         }
-    }
-
-    /**
-     * Writes a string to the stream.
-     * @param vdata The string to write.
-     * @param vsize The size of the string.
-     * @param convert Determines whether the string is processed by the narrow string converter,
-     * if one has been configured. The default behavior is to convert the strings.
-     */
-    void write(const char* vdata, size_t vsize, bool convert = true)
-    {
-        Int sz = static_cast<Int>(vsize);
-        if(convert && sz > 0)
+
+        // Helper function for the next writeAll.
+        template<size_t I = 0, typename... Te> std::enable_if_t<I == sizeof...(Te), void> writeAll(std::tuple<Te...>)
         {
-            writeConverted(vdata, vsize);
+            // Do nothing. Either tuple is empty or we are at the end.
         }
-        else
+
+        /// Writes a tuple to the stream.
+        /// @tparam I The index of the first element to marshal.
+        /// @tparam Te The types of the values in the tuple, starting at index @p I.
+        /// @param tuple The tuple to marshal.
+        template<size_t I = 0, typename... Te>
+            std::enable_if_t < I<sizeof...(Te), void> writeAll(std::tuple<Te...> tuple)
         {
-            writeSize(sz);
-            if(sz > 0)
-            {
-                Container::size_type position = b.size();
-                resize(position + static_cast<size_t>(sz));
-                memcpy(&b[position], vdata, vsize);
-            }
+            write(std::get<I>(tuple));
+            writeAll<I + 1, Te...>(tuple);
         }
-    }
-
-    /**
-     * Writes a string to the stream.
-     * @param vdata The null-terminated string to write.
-     * @param convert Determines whether the string is processed by the narrow string converter,
-     * if one has been configured. The default behavior is to convert the strings.
-     */
-    void write(const char* vdata, bool convert = true)
-    {
-        write(vdata, strlen(vdata), convert);
-    }
-
-    /**
-     * Writes a string sequence to the stream.
-     * @param begin The beginning of the sequence.
-     * @param end The end of the sequence.
-     * @param convert Determines whether the string is processed by the narrow string converter,
-     * if one has been configured. The default behavior is to convert the strings.
-     */
-    void write(const std::string* begin, const std::string* end, bool convert = true);
-
-    /**
-     * Writes a wide string to the stream.
-     * @param v The wide string to write.
-     */
-    void write(const std::wstring& v);
-
-    /**
-     * Writes a wide string sequence to the stream.
-     * @param begin The beginning of the sequence.
-     * @param end The end of the sequence.
-     */
-    void write(const std::wstring* begin, const std::wstring* end);
-
-#ifdef ICE_CPP11_MAPPING
-    /**
-     * Writes a proxy to the stream.
-     * @param v The proxy to be written.
-     */
-    void writeProxy(const ::std::shared_ptr<ObjectPrx>& v);
-
-    /**
-     * Writes a proxy to the stream.
-     * @param v The proxy to be written.
-     */
-    template<typename T, typename ::std::enable_if<::std::is_base_of<ObjectPrx, T>::value>::type* = nullptr>
-    void write(const ::std::shared_ptr<T>& v)
-    {
-        writeProxy(::std::static_pointer_cast<ObjectPrx>(v));
-    }
-#else
-    /**
-     * Writes a proxy to the stream.
-     * @param v The proxy to be written.
-     */
-    void write(const ObjectPrx& v);
-
-    /**
-     * Writes a proxy to the stream.
-     * @param v The proxy to be written.
-     */
-    template<typename T> void write(const IceInternal::ProxyHandle<T>& v)
-    {
-        write(ObjectPrx(upCast(v.get())));
-    }
-#endif
 
-#ifdef ICE_CPP11_MAPPING // C++11 mapping
-    /**
-     * Writes a value instance to the stream.
-     * @param v The value to be written.
-     */
-    template<typename T, typename ::std::enable_if<::std::is_base_of<Value, T>::value>::type* = nullptr>
-    void write(const ::std::shared_ptr<T>& v)
-    {
-        initEncaps();
-        _currentEncaps->encoder->write(v);
-    }
-#else // C++98 mapping
-    /**
-     * Writes a value instance to the stream.
-     * @param v The value to be written.
-     */
-    void write(const ObjectPtr& v)
-    {
-        initEncaps();
-        _currentEncaps->encoder->write(v);
-    }
-
-    /**
-     * Writes a value instance to the stream.
-     * @param v The value to be written.
-     */
-    template<typename T> void write(const IceInternal::Handle<T>& v)
-    {
-        write(ObjectPtr(upCast(v.get())));
-    }
-#endif
+        /// Writes a byte to the stream.
+        /// @param v The byte to marshal.
+        void write(std::byte v) { b.push_back(v); }
 
-    /**
-     * Writes an enumerator to the stream.
-     * @param v The enumerator to be written.
-     * @param maxValue The maximum value of all enumerators in this enumeration.
-     */
-    void writeEnum(Int v, Int maxValue);
-
-    /**
-     * Writes an exception to the stream.
-     * @param v The exception to be written.
-     */
-    void writeException(const UserException& v);
-
-    /**
-     * Obtains the current position of the stream.
-     * @return The current position.
-     */
-    size_type pos()
-    {
-        return b.size();
-    }
-
-    /**
-     * Overwrite a 32-bit integer value at the given position in the stream.
-     * This function does not change the stream's current position.
-     * @param v The value to be written.
-     * @param pos The buffer position for the value.
-     */
-    void rewrite(Int v, size_type pos)
-    {
-        write(v, b.begin() + pos);
-    }
-
-    /**
-     * Indicates that marshaling is complete. This function must only be called once.
-     * @param v Filled with a copy of the encoded data.
-     */
-    void finished(std::vector<Byte>& v);
-
-    /**
-     * Indicates that marshaling is complete. This function must only be called once.
-     * @return A pair of pointers into the internal marshaling buffer. These pointers are
-     * valid for the lifetime of the stream.
-     */
-    std::pair<const Byte*, const Byte*> finished();
-
-    /// \cond INTERNAL
-    OutputStream(IceInternal::Instance*, const EncodingVersion&);
-    void initialize(IceInternal::Instance*, const EncodingVersion&);
-
-    // Optionals
-    bool writeOptImpl(Int, OptionalFormat);
-    /// \endcond
-
-private:
-
-    //
-    // String
-    //
-    void writeConverted(const char*, size_t);
-
-    //
-    // We can't throw this exception from inline functions from within
-    // this file, because we cannot include the header with the
-    // exceptions. Doing so would screw up the whole include file
-    // ordering.
-    //
-    void throwEncapsulationException(const char*, int);
-
-    //
-    // Optimization. The instance may not be deleted while a
-    // stack-allocated stream still holds it.
-    //
-    IceInternal::Instance* _instance;
-
-    //
-    // The public stream API needs to attach data to a stream.
-    //
-    void* _closure;
-
-    class Encaps;
-    enum SliceType { NoSlice, ValueSlice, ExceptionSlice };
-
-    typedef std::vector<ValuePtr> ValueList;
-
-    class ICE_API EncapsEncoder : private ::IceUtil::noncopyable
-    {
-    public:
+        /// Writes a byte to the stream.
+        /// @param v The byte to marshal.
+        void write(std::uint8_t v) { b.push_back(std::byte{v}); }
 
-        virtual ~EncapsEncoder();
+        /// Writes a boolean to the stream.
+        /// @param v The boolean to marshal.
+        void write(bool v) { b.push_back(static_cast<std::byte>(v)); }
 
-        virtual void write(const ValuePtr&) = 0;
-        virtual void write(const UserException&) = 0;
+        /// Writes a boolean sequence to the stream.
+        /// @param v The sequence to be written.
+        void write(const std::vector<bool>& v);
 
-        virtual void startInstance(SliceType, const SlicedDataPtr&) = 0;
-        virtual void endInstance() = 0;
-        virtual void startSlice(const std::string&, int, bool) = 0;
-        virtual void endSlice() = 0;
+        /// Writes an int16_t as a Slice short.
+        /// @param v The int16_t to marshal.
+        void write(std::int16_t v);
 
-        virtual bool writeOptional(Int, OptionalFormat)
+        /// Writes an int to the stream.
+        /// @param v The int to marshal.
+        void write(std::int32_t v) // Inlined for performance reasons.
         {
-            return false;
+            Container::size_type position = b.size();
+            resize(position + sizeof(std::int32_t));
+            write(v, &b[position]);
+        }
+
+        /// Writes a long to the stream.
+        /// @param v The long to marshal.
+        void write(std::int64_t v);
+
+        /// Writes a float as a Slice float.
+        /// @param v The float to marshal.
+        void write(float v);
+
+        /// Writes a double as a Slice double.
+        /// @param v The double to marshal.
+        void write(double v);
+
+        /// Writes a wide string to the stream.
+        /// @param v The wide string to marshal.
+        void write(const std::wstring& v) { write(std::wstring_view(v)); }
+
+        /// Writes a wide string view to the stream.
+        /// @param v The wide string view to marshal.
+        void write(std::wstring_view v);
+
+        /// @endcond
+
+        /// Overwrites a 32-bit integer value at the given position in the stream.
+        /// This function does not change the stream's current position.
+        /// @param v The integer value to marshal.
+        /// @param dest The buffer destination for the integer value.
+        void write(std::int32_t v, Container::iterator dest);
+
+        /// Writes a byte sequence to the stream.
+        /// @param start The beginning of the sequence.
+        /// @param end The end of the sequence.
+        void write(const std::byte* start, const std::byte* end);
+
+        /// Writes a byte sequence to the stream.
+        /// @param start The beginning of the sequence.
+        /// @param end The end of the sequence.
+        void write(const std::uint8_t* start, const std::uint8_t* end);
+
+        /// Writes a boolean sequence to the stream.
+        /// @param begin The beginning of the sequence.
+        /// @param end The end of the sequence.
+        void write(const bool* begin, const bool* end);
+
+        /// Writes an int16_t sequence as a Slice short sequence.
+        /// @param begin The beginning of the sequence.
+        /// @param end The end of the sequence.
+        void write(const std::int16_t* begin, const std::int16_t* end);
+
+        /// Writes an int sequence to the stream.
+        /// @param begin The beginning of the sequence.
+        /// @param end The end of the sequence.
+        void write(const std::int32_t* begin, const std::int32_t* end);
+
+        /// Writes a long sequence to the stream.
+        /// @param begin The beginning of the sequence.
+        /// @param end The end of the sequence.
+        void write(const std::int64_t* begin, const std::int64_t* end);
+
+        /// Writes a float sequence as a Slice float sequence.
+        /// @param begin The beginning of the sequence.
+        /// @param end The end of the sequence.
+        void write(const float* begin, const float* end);
+
+        /// Writes a double sequence as a Slice double sequence.
+        /// @param begin The beginning of the sequence.
+        /// @param end The end of the sequence.
+        void write(const double* begin, const double* end);
+
+        /// Writes a string to the stream.
+        /// @param v The string to marshal.
+        /// @param convert `true` to process @p v through the narrow string converter (if not null), `false` to write
+        /// @p v as-is.
+        void write(const std::string& v, bool convert = true) { write(std::string_view(v), convert); }
+
+        /// Writes a string view to the stream.
+        /// @param v The string view to marshal.
+        /// @param convert `true` to process @p v through the narrow string converter (if not null), `false` to write
+        /// @p v as-is.
+        void write(std::string_view v, bool convert = true)
+        {
+            auto sz = static_cast<std::int32_t>(v.size());
+            if (convert && sz > 0)
+            {
+                writeConverted(v.data(), static_cast<size_t>(sz));
+            }
+            else
+            {
+                writeSize(sz);
+                if (sz > 0)
+                {
+                    Container::size_type position = b.size();
+                    resize(position + static_cast<size_t>(sz));
+                    memcpy(&b[position], v.data(), static_cast<size_t>(sz));
+                }
+            }
         }
 
-        virtual void writePendingValues()
+        /// Writes a string to the stream.
+        /// @param vdata The string to marshal.
+        /// @param vsize The size of the string.
+        /// @param convert `true` to process @p vdata through the narrow string converter (if not null), `false` to
+        /// write @p vdata as-is.
+        void write(const char* vdata, size_t vsize, bool convert = true)
         {
+            auto sz = static_cast<std::int32_t>(vsize);
+            if (convert && sz > 0)
+            {
+                writeConverted(vdata, vsize);
+            }
+            else
+            {
+                writeSize(sz);
+                if (sz > 0)
+                {
+                    Container::size_type position = b.size();
+                    resize(position + static_cast<size_t>(sz));
+                    memcpy(&b[position], vdata, vsize);
+                }
+            }
         }
 
-    protected:
+        /// Writes a string to the stream.
+        /// @param vdata The null-terminated string to marshal.
+        /// @param convert `true` to process @p vdata through the narrow string converter (if not null), `false` to
+        /// write @p vdata as-is.
+        void write(const char* vdata, bool convert = true) { write(vdata, strlen(vdata), convert); }
+
+        /// Writes a string sequence to the stream.
+        /// @param begin The beginning of the sequence.
+        /// @param end The end of the sequence.
+        /// @param convert `true` to process the strings through the narrow string converter (if not null), `false` to
+        /// write the strings as-is.
+        void write(const std::string* begin, const std::string* end, bool convert = true);
+
+        /// Writes a wide string sequence to the stream.
+        /// @param begin The beginning of the sequence.
+        /// @param end The end of the sequence.
+        void write(const std::wstring* begin, const std::wstring* end);
+
+        /// Writes a proxy to the stream.
+        /// @param v The proxy to be written.
+        void writeProxy(const ObjectPrx& v);
+
+        /// Writes a null proxy to the stream.
+        void writeNullProxy();
+
+        /// @cond INTERNAL
+
+        /// Writes a proxy to the stream.
+        /// @param v The proxy to marshal.
+        template<typename Prx, std::enable_if_t<std::is_base_of_v<ObjectPrx, Prx>, bool> = true>
+        void write(const std::optional<Prx>& v)
+        {
+            if (v)
+            {
+                writeProxy(v.value());
+            }
+            else
+            {
+                writeNullProxy();
+            }
+        }
 
-        EncapsEncoder(OutputStream* stream, Encaps* encaps) : _stream(stream), _encaps(encaps), _typeIdIndex(0)
+        /// Writes a value instance to the stream.
+        /// @param v The value to marshal.
+        template<typename T, std::enable_if_t<std::is_base_of_v<Value, T>>* = nullptr>
+        void write(const std::shared_ptr<T>& v)
         {
+            initEncaps();
+            _currentEncaps->encoder->write(v);
         }
 
-        Int registerTypeId(const std::string&);
+        /// @endcond
 
-        OutputStream* _stream;
-        Encaps* _encaps;
+        /// Writes an enumerator to the stream.
+        /// @param v The enumerator to marshal.
+        /// @param maxValue The maximum value of all enumerators in this enumeration.
+        void writeEnum(std::int32_t v, std::int32_t maxValue);
 
-        typedef std::map<ValuePtr, Int> PtrToIndexMap;
-        typedef std::map<std::string, Int> TypeIdMap;
+        /// Writes a user exception to the stream.
+        /// @param v The exception to marshal.
+        void writeException(const UserException& v);
 
-        // Encapsulation attributes for value marshaling.
-        PtrToIndexMap _marshaledMap;
+        /// Gets the current position of the stream.
+        /// @return The current position.
+        size_type pos() { return b.size(); }
 
-    private:
+        /// Overwrites a 32-bit integer value at the specified position in the stream. This function does not change the
+        /// stream's current position.
+        /// @param v The value to marshal.
+        /// @param pos The buffer position for the value.
+        void rewrite(std::int32_t v, size_type pos) { write(v, b.begin() + pos); }
 
-        // Encapsulation attributes for value marshaling.
-        TypeIdMap _typeIdMap;
-        Int _typeIdIndex;
-    };
+        /// Indicates that marshaling is complete. This function must only be called once.
+        /// @param[out] v Filled with a copy of the encoded data.
+        void finished(std::vector<std::byte>& v);
 
-    class ICE_API EncapsEncoder10 : public EncapsEncoder
-    {
-    public:
+        /// Indicates that marshaling is complete. This function must only be called once.
+        /// @return A pair of pointers into the internal marshaling buffer. These pointers are valid for the lifetime
+        /// of the stream.
+        std::pair<const std::byte*, const std::byte*> finished();
 
-        EncapsEncoder10(OutputStream* stream, Encaps* encaps) :
-            EncapsEncoder(stream, encaps), _sliceType(NoSlice), _valueIdIndex(0)
+        /// @private
+        OutputStream(IceInternal::Instance*, EncodingVersion encoding);
+
+    private:
+        // Optionals
+        bool writeOptImpl(std::int32_t, OptionalFormat);
+
+        //
+        // String
+        //
+        void writeConverted(const char*, size_t);
+
+        /// Writes a 1-byte size placeholder and returns its position; after writing the data, call
+        /// #endOneByteSize to patch the placeholder with the actual size at the given position.
+        /// @return The position of the 1-byte size placeholder.
+        size_type startOneByteSize()
         {
+            size_type position = b.size();
+            write(std::uint8_t(0)); // placeholder
+            return position;
         }
 
-        virtual void write(const ValuePtr&);
-        virtual void write(const UserException&);
+        /// Updates the 1-byte size value at the given position. The new size is computed from the stream's current
+        /// position. The size must be <= 254.
+        /// @param position The position of the 1-byte size placeholder as returned by #startOneByteSize.
+        void endOneByteSize(size_type position)
+        {
+            auto size = static_cast<std::int32_t>(b.size() - position - 1);
+            assert(size >= 0 && size <= 254);
+            rewriteSize(size, b.begin() + position);
+        }
 
-        virtual void startInstance(SliceType, const SlicedDataPtr&);
-        virtual void endInstance();
-        virtual void startSlice(const std::string&, int, bool);
-        virtual void endSlice();
+        StringConverterPtr _stringConverter;
+        WstringConverterPtr _wstringConverter;
 
-        virtual void writePendingValues();
+        //
+        // The public stream API needs to attach data to a stream.
+        //
+        void* _closure;
 
-    private:
+        class Encaps;
+        enum SliceType
+        {
+            NoSlice,
+            ValueSlice,
+            ExceptionSlice
+        };
 
-        Int registerValue(const ValuePtr&);
+        using ValueList = std::vector<ValuePtr>;
 
-        // Instance attributes
-        SliceType _sliceType;
+        class ICE_API EncapsEncoder
+        {
+        public:
+            EncapsEncoder(const EncapsEncoder&) = delete;
+            virtual ~EncapsEncoder();
 
-        // Slice attributes
-        Container::size_type _writeSlice; // Position of the slice data members
+            EncapsEncoder& operator=(const EncapsEncoder&) = delete;
 
-        // Encapsulation attributes for value marshaling.
-        Int _valueIdIndex;
-        PtrToIndexMap _toBeMarshaledMap;
-    };
+            virtual void write(const ValuePtr&) = 0;
+            virtual void write(const UserException&) = 0;
 
-    class ICE_API EncapsEncoder11 : public EncapsEncoder
-    {
-    public:
+            virtual void startInstance(SliceType, const SlicedDataPtr&) = 0;
+            virtual void endInstance() = 0;
+            virtual void startSlice(std::string_view, int, bool) = 0;
+            virtual void endSlice() = 0;
+
+            virtual bool writeOptional(std::int32_t, OptionalFormat) { return false; }
+
+            virtual void writePendingValues() {}
+
+        protected:
+            EncapsEncoder(OutputStream* stream, Encaps* encaps) : _stream(stream), _encaps(encaps) {}
+
+            std::int32_t registerTypeId(std::string_view);
+
+            OutputStream* _stream;
+            Encaps* _encaps;
+
+            using PtrToIndexMap = std::map<ValuePtr, std::int32_t>;
+            using TypeIdMap = std::map<std::string, std::int32_t, std::less<>>;
+
+            // Encapsulation attributes for value marshaling.
+            PtrToIndexMap _marshaledMap;
+
+        private:
+            // Encapsulation attributes for value marshaling.
+            TypeIdMap _typeIdMap;
+            std::int32_t _typeIdIndex{0};
+        };
 
-        EncapsEncoder11(OutputStream* stream, Encaps* encaps) :
-            EncapsEncoder(stream, encaps), _preAllocatedInstanceData(0), _current(0), _valueIdIndex(1)
+        class ICE_API EncapsEncoder10 : public EncapsEncoder
         {
-        }
+        public:
+            EncapsEncoder10(OutputStream* stream, Encaps* encaps) : EncapsEncoder(stream, encaps) {}
 
-        virtual void write(const ValuePtr&);
-        virtual void write(const UserException&);
+            void write(const ValuePtr&) override;
+            void write(const UserException&) override;
 
-        virtual void startInstance(SliceType, const SlicedDataPtr&);
-        virtual void endInstance();
-        virtual void startSlice(const std::string&, int, bool);
-        virtual void endSlice();
+            void startInstance(SliceType, const SlicedDataPtr&) override;
+            void endInstance() override;
+            void startSlice(std::string_view, int, bool) override;
+            void endSlice() override;
 
-        virtual bool writeOptional(Int, OptionalFormat);
+            void writePendingValues() override;
 
-    private:
+        private:
+            std::int32_t registerValue(const ValuePtr&);
 
-        void writeSlicedData(const SlicedDataPtr&);
-        void writeInstance(const ValuePtr&);
+            // Instance attributes
+            SliceType _sliceType{NoSlice};
 
-        struct InstanceData
+            // Slice attributes
+            Container::size_type _writeSlice{0}; // Position of the slice data members
+
+            // Encapsulation attributes for value marshaling.
+            std::int32_t _valueIdIndex{0};
+            PtrToIndexMap _toBeMarshaledMap;
+        };
+
+        class ICE_API EncapsEncoder11 : public EncapsEncoder
         {
-            InstanceData(InstanceData* p) : previous(p), next(0)
+        public:
+            EncapsEncoder11(OutputStream* stream, Encaps* encaps)
+                : EncapsEncoder(stream, encaps),
+                  _preAllocatedInstanceData(nullptr)
             {
-                if(previous)
-                {
-                    previous->next = this;
-                }
             }
 
-            ~InstanceData()
+            void write(const ValuePtr&) override;
+            void write(const UserException&) override;
+
+            void startInstance(SliceType, const SlicedDataPtr&) override;
+            void endInstance() override;
+            void startSlice(std::string_view, int, bool) override;
+            void endSlice() override;
+
+            bool writeOptional(std::int32_t, OptionalFormat) override;
+
+        private:
+            void writeSlicedData(const SlicedDataPtr&);
+            void writeInstance(const ValuePtr&);
+
+            struct InstanceData
             {
-                if(next)
+                InstanceData(InstanceData* p) : previous(p)
                 {
-                    delete next;
+                    if (previous)
+                    {
+                        previous->next = this;
+                    }
                 }
-            }
 
-            // Instance attributes
-            SliceType sliceType;
-            bool firstSlice;
+                ~InstanceData()
+                {
+                    if (next)
+                    {
+                        delete next;
+                    }
+                }
 
-            // Slice attributes
-            Byte sliceFlags;
-            Container::size_type writeSlice;    // Position of the slice data members
-            Container::size_type sliceFlagsPos; // Position of the slice flags
-            PtrToIndexMap indirectionMap;
-            ValueList indirectionTable;
-
-            InstanceData* previous;
-            InstanceData* next;
-        };
-        InstanceData _preAllocatedInstanceData;
-        InstanceData* _current;
+                // Instance attributes
+                SliceType sliceType{NoSlice};
+                bool firstSlice{false};
 
-        Int _valueIdIndex; // The ID of the next value to marhsal
-    };
+                // Slice attributes
+                std::uint8_t sliceFlags{0};
+                Container::size_type writeSlice{0};    // Position of the slice data members
+                Container::size_type sliceFlagsPos{0}; // Position of the slice flags
+                PtrToIndexMap indirectionMap;
+                ValueList indirectionTable;
 
-    class Encaps : private ::IceUtil::noncopyable
-    {
+                InstanceData* previous{nullptr};
+                InstanceData* next{nullptr};
+            };
+            InstanceData _preAllocatedInstanceData;
+            InstanceData* _current{nullptr};
 
-    public:
+            std::int32_t _valueIdIndex{1}; // The ID of the next value to marshal
+        };
 
-        Encaps() : format(ICE_ENUM(FormatType, DefaultFormat)), encoder(0), previous(0)
+        class Encaps
         {
-            // Inlined for performance reasons.
-        }
-        ~Encaps()
-        {
-            // Inlined for performance reasons.
-            delete encoder;
-        }
-        void reset()
-        {
-            // Inlined for performance reasons.
-            delete encoder;
-            encoder = 0;
+        public:
+            Encaps() = default;
+            Encaps(const Encaps&) = delete;
+            ~Encaps() { delete encoder; }
+            Encaps& operator=(const Encaps&) = delete;
 
-            previous = 0;
-        }
+            void reset()
+            {
+                // Inlined for performance reasons.
+                delete encoder;
+                encoder = nullptr;
 
-        Container::size_type start;
-        EncodingVersion encoding;
-        FormatType format;
+                previous = nullptr;
+            }
 
-        EncapsEncoder* encoder;
+            Container::size_type start;
+            EncodingVersion encoding;
+            FormatType format{FormatType::CompactFormat};
 
-        Encaps* previous;
-    };
+            EncapsEncoder* encoder{nullptr};
 
-    //
-    // The encoding version to use when there's no encapsulation to
-    // read from or write to. This is for example used to read message
-    // headers or when the user is using the streaming API with no
-    // encapsulation.
-    //
-    EncodingVersion _encoding;
+            Encaps* previous{nullptr};
+        };
+
+        //
+        // The encoding version to use when there's no encapsulation to
+        // read from or write to. This is for example used to read message
+        // headers or when the user is using the streaming API with no
+        // encapsulation.
+        //
+        EncodingVersion _encoding;
 
-    FormatType _format;
+        FormatType _format; // TODO: make it const
 
-    Encaps* _currentEncaps;
+        Encaps* _currentEncaps;
 
-    void initEncaps();
+        void initEncaps();
 
-    Encaps _preAllocatedEncaps;
-};
+        Encaps _preAllocatedEncaps;
+    };
 
 } // End namespace Ice