zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,1513 +1,941 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_INPUT_STREAM_H
 #define ICE_INPUT_STREAM_H
 
-#include <Ice/CommunicatorF.h>
-#include <Ice/InstanceF.h>
-#include <Ice/Object.h>
-#include <Ice/ValueF.h>
-#include <Ice/ProxyF.h>
-#include <Ice/LoggerF.h>
-#include <Ice/ValueFactory.h>
-#include <Ice/Buffer.h>
-#include <Ice/Protocol.h>
-#include <Ice/SlicedDataF.h>
-#include <Ice/UserExceptionFactory.h>
-#include <Ice/StreamHelpers.h>
-#include <Ice/FactoryTable.h>
+#include "Buffer.h"
+#include "CommunicatorF.h"
+#include "Ice/Version.h"
+#include "InstanceF.h"
+#include "LocalException.h"
+#include "Logger.h"
+#include "ReferenceF.h"
+#include "SliceLoader.h"
+#include "SlicedDataF.h"
+#include "StreamableTraits.h"
+#include "UserExceptionFactory.h"
+#include "ValueF.h"
+
+#include <cassert>
+#include <cstdint>
+#include <map>
+#include <string>
+#include <string_view>
+
+namespace IceInternal::Ex
+{
+    ICE_API void throwUOE(const char* file, int line, const std::string&, const Ice::ValuePtr&);
+    ICE_API void throwMemoryLimitException(const char* file, int line, size_t, std::int32_t);
+    ICE_API void throwMarshalException(const char* file, int line, std::string);
+}
 
 namespace Ice
 {
+    class ObjectPrx;
 
-class UserException;
-
-/// \cond INTERNAL
-template<typename T> inline void
-patchHandle(void* addr, const ValuePtr& v)
-{
-#ifdef ICE_CPP11_MAPPING
-    ::std::shared_ptr<T>* handle = static_cast<::std::shared_ptr<T>*>(addr);
-    *handle = ::std::dynamic_pointer_cast<T>(v);
-    if(v && !(*handle))
+    /// @private
+    template<typename T> inline void patchValue(void* addr, const ValuePtr& v)
     {
-        IceInternal::Ex::throwUOE(T::ice_staticId(), v);
+        auto* ptr = static_cast<std::shared_ptr<T>*>(addr);
+        *ptr = std::dynamic_pointer_cast<T>(v);
+        if (v && !(*ptr))
+        {
+            IceInternal::Ex::throwUOE(__FILE__, __LINE__, std::string{T::ice_staticId()}, v);
+        }
     }
-#else
-    IceInternal::Handle<T>* p = static_cast<IceInternal::Handle<T>*>(addr);
-    _icePatchObjectPtr(*p, v); // Generated _icePatchObjectPtr function, necessary for forward declarations.
-#endif
-}
-/// \endcond
 
-/**
- * Interface for input streams used to extract Slice types from a sequence of bytes.
- * \headerfile Ice/Ice.h
- */
-class ICE_API InputStream : public IceInternal::Buffer
-{
-public:
-
-    typedef size_t size_type;
-
-    /**
-     * Signature for a patch function, used to receive an unmarshaled value.
-     * @param addr The target address.
-     * @param v The unmarshaled value.
-     */
-    typedef void (*PatchFunc)(void* addr, const ValuePtr& v);
-
-    /**
-     * Constructs a stream using the latest encoding version but without a communicator.
-     * This stream will not be able to unmarshal a proxy. For other unmarshaling tasks,
-     * you can provide Helpers for objects that are normally provided by a communicator.
-     * You can supply a communicator later by calling initialize().
-     */
-    InputStream();
-
-    /**
-     * Constructs a stream using the latest encoding version but without a communicator.
-     * This stream will not be able to unmarshal a proxy. For other unmarshaling tasks,
-     * you can provide Helpers for objects that are normally provided by a communicator.
-     * You can supply a communicator later by calling initialize().
-     * @param bytes The encoded data.
-     */
-    InputStream(const std::vector<Byte>& bytes);
-
-    /**
-     * Constructs a stream using the latest encoding version but without a communicator.
-     * This stream will not be able to unmarshal a proxy. For other unmarshaling tasks,
-     * you can provide Helpers for objects that are normally provided by a communicator.
-     * You can supply a communicator later by calling initialize().
-     * @param bytes The encoded data.
-     */
-    InputStream(const std::pair<const Byte*, const Byte*>& bytes);
-
-    /// \cond INTERNAL
-    InputStream(IceInternal::Buffer&, bool = false);
-    /// \endcond
-
-    /**
-     * Constructs a stream using the communicator's default encoding version.
-     * @param communicator The communicator to use for unmarshaling tasks.
-     */
-    InputStream(const CommunicatorPtr& communicator);
-
-    /**
-     * Constructs a stream using the communicator's default encoding version.
-     * @param communicator The communicator to use for unmarshaling tasks.
-     * @param bytes The encoded data.
-     */
-    InputStream(const CommunicatorPtr& communicator, const std::vector<Byte>& bytes);
-
-    /**
-     * Constructs a stream using the communicator's default encoding version.
-     * @param communicator The communicator to use for unmarshaling tasks.
-     * @param bytes The encoded data.
-     */
-    InputStream(const CommunicatorPtr& communicator, const std::pair<const Byte*, const Byte*>& bytes);
-
-    /// \cond INTERNAL
-    InputStream(const CommunicatorPtr& communicator, IceInternal::Buffer&, bool = false);
-    /// \endcond
-
-    /**
-     * Constructs a stream using the given encoding version but without a communicator.
-     * This stream will not be able to unmarshal a proxy. For other unmarshaling tasks,
-     * you can provide Helpers for objects that are normally provided by a communicator.
-     * You can supply a communicator later by calling initialize().
-     * @param version The encoding version used to encode the data to be unmarshaled.
-     */
-    InputStream(const EncodingVersion& version);
-
-    /**
-     * Constructs a stream using the given encoding version but without a communicator.
-     * This stream will not be able to unmarshal a proxy. For other unmarshaling tasks,
-     * you can provide Helpers for objects that are normally provided by a communicator.
-     * You can supply a communicator later by calling initialize().
-     * @param version The encoding version used to encode the data to be unmarshaled.
-     * @param bytes The encoded data.
-     */
-    InputStream(const EncodingVersion& version, const std::vector<Byte>& bytes);
-
-    /**
-     * Constructs a stream using the given encoding version but without a communicator.
-     * This stream will not be able to unmarshal a proxy. For other unmarshaling tasks,
-     * you can provide Helpers for objects that are normally provided by a communicator.
-     * You can supply a communicator later by calling initialize().
-     * @param version The encoding version used to encode the data to be unmarshaled.
-     * @param bytes The encoded data.
-     */
-    InputStream(const EncodingVersion& version, const std::pair<const Byte*, const Byte*>& bytes);
-
-    /// \cond INTERNAL
-    InputStream(const EncodingVersion&, IceInternal::Buffer&, bool = false);
-    /// \endcond
-
-    /**
-     * Constructs a stream using the given communicator and encoding version.
-     * @param communicator The communicator to use for unmarshaling tasks.
-     * @param version The encoding version used to encode the data to be unmarshaled.
-     */
-    InputStream(const CommunicatorPtr& communicator, const EncodingVersion& version);
-
-    /**
-     * Constructs a stream using the given communicator and encoding version.
-     * @param communicator The communicator to use for unmarshaling tasks.
-     * @param version The encoding version used to encode the data to be unmarshaled.
-     * @param bytes The encoded data.
-     */
-    InputStream(const CommunicatorPtr& communicator, const EncodingVersion& version, const std::vector<Byte>& bytes);
-
-    /**
-     * Constructs a stream using the given communicator and encoding version.
-     * @param communicator The communicator to use for unmarshaling tasks.
-     * @param version The encoding version used to encode the data to be unmarshaled.
-     * @param bytes The encoded data.
-     */
-    InputStream(const CommunicatorPtr& communicator, const EncodingVersion& version,
-                const std::pair<const Byte*, const Byte*>& bytes);
-
-    /// \cond INTERNAL
-    InputStream(const CommunicatorPtr&, const EncodingVersion&, IceInternal::Buffer&, bool = false);
-    /// \endcond
-
-    ~InputStream()
+    /// Represents a byte buffer used for unmarshaling data encoded using the Slice encoding.
+    /// @headerfile Ice/Ice.h
+    class ICE_API InputStream final : public IceInternal::Buffer
     {
-        // Inlined for performance reasons.
-
-        if(_currentEncaps != &_preAllocatedEncaps)
+    public:
+        /// The size type for this byte buffer.
+        using size_type = std::size_t;
+
+        /// @private
+        using PatchFunc = std::function<void(void* addr, const ValuePtr& v)>;
+
+        /// Constructs an InputStream using a communicator and this communicator's default encoding version.
+        /// @param communicator The communicator to use for unmarshaling tasks.
+        /// @param bytes The encoded data.
+        /// @param sliceLoader The Slice loader. When nullptr, use the communicator's Slice loader.
+        InputStream(
+            const CommunicatorPtr& communicator,
+            const std::vector<std::byte>& bytes,
+            SliceLoaderPtr sliceLoader = nullptr);
+
+        /// @copydoc InputStream(const CommunicatorPtr&, const std::vector<std::byte>&, SliceLoaderPtr)
+        InputStream(
+            const CommunicatorPtr& communicator,
+            std::pair<const std::byte*, const std::byte*> bytes,
+            SliceLoaderPtr sliceLoader = nullptr);
+
+        /// Constructs an InputStream using a communicator and encoding version.
+        /// @param communicator The communicator to use for unmarshaling tasks.
+        /// @param encoding The encoding version used to encode the data to be unmarshaled.
+        /// @param bytes The encoded data.
+        /// @param sliceLoader The Slice loader. When nullptr, use the communicator's Slice loader.
+        InputStream(
+            const CommunicatorPtr& communicator,
+            EncodingVersion encoding,
+            const std::vector<std::byte>& bytes,
+            SliceLoaderPtr sliceLoader = nullptr);
+
+        /// @copydoc InputStream(const CommunicatorPtr&, EncodingVersion, const std::vector<std::byte>&, SliceLoaderPtr)
+        InputStream(
+            const CommunicatorPtr& communicator,
+            EncodingVersion encoding,
+            std::pair<const std::byte*, const std::byte*> bytes,
+            SliceLoaderPtr sliceLoader = nullptr);
+
+        /// @private
+        /// Constructs a stream with an empty buffer.
+        InputStream(IceInternal::Instance* instance, EncodingVersion encoding, SliceLoaderPtr sliceLoader = nullptr);
+
+        /// @private
+        /// Constructs a stream with the specified encoding and buffer.
+        InputStream(
+            IceInternal::Instance* instance,
+            EncodingVersion encoding,
+            IceInternal::Buffer& buf,
+            bool adopt,
+            SliceLoaderPtr sliceLoader = nullptr);
+
+        /// Move constructor.
+        /// @param other The input stream to move into this input stream.
+        InputStream(InputStream&& other) noexcept;
+
+        /// Move assignment operator.
+        /// @param other The input stream to move into this input stream.
+        /// @return A reference to this input stream.
+        InputStream& operator=(InputStream&& other) noexcept;
+
+        ~InputStream()
         {
-            clear(); // Not inlined.
-        }
+            // Inlined for performance reasons.
 
-#ifdef ICE_CPP11_MAPPING
+            if (_currentEncaps != &_preAllocatedEncaps)
+            {
+                clear(); // Not inlined.
+            }
 
-        for(auto d: _deleters)
-        {
-            d();
+            for (const auto& d : _deleters)
+            {
+                d();
+            }
         }
-#endif
-    }
 
-    /**
-     * Initializes the stream to use the communicator's default encoding version.
-     * Use initialize() if you originally constructed the stream without a communicator.
-     * @param communicator The communicator to use for unmarshaling tasks.
-     */
-    void initialize(const CommunicatorPtr& communicator);
-
-    /**
-     * Initializes the stream to use the given communicator and encoding version.
-     * Use initialize() if you originally constructed the stream without a communicator.
-     * @param communicator The communicator to use for unmarshaling tasks.
-     * @param version The encoding version used to encode the data to be unmarshaled.
-     */
-    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 value factory manager to use when unmarshaling value instances. If the stream
-     * was initialized with a communicator, the communicator's value factory manager will
-     * be used by default.
-     *
-     * @param vfm The value factory manager.
-     */
-    void setValueFactoryManager(const ValueFactoryManagerPtr& vfm);
-
-    /**
-     * Sets the logger to use when logging trace messages. If the stream
-     * was initialized with a communicator, the communicator's logger will
-     * be used by default.
-     *
-     * @param logger The logger to use for logging trace messages.
-     */
-    void setLogger(const LoggerPtr& logger);
-
-    /**
-     * Sets the compact ID resolver to use when unmarshaling value and exception
-     * instances. If the stream was initialized with a communicator, the communicator's
-     * resolver will be used by default.
-     *
-     * @param r The compact ID resolver.
-     */
-#ifdef ICE_CPP11_MAPPING
-    void setCompactIdResolver(std::function<std::string(int)> r);
-#else
-    void setCompactIdResolver(const CompactIdResolverPtr& r);
-#endif
+        /// Releases any data retained by encapsulations.
+        void clear();
 
-#ifndef ICE_CPP11_MAPPING
-    /**
-     * Indicates whether to mark instances of Slice classes as collectable. If the stream is
-     * initialized with a communicator, this setting defaults to the value of the
-     * Ice.CollectObjects property, otherwise the setting defaults to false.
-     * @param b True to mark instances as collectable, false otherwise.
-     */
-    void setCollectObjects(bool b);
-#endif
+        /// @private
+        // Must return Instance*, because we don't hold an InstancePtr for optimization reasons (see comments below).
+        [[nodiscard]] IceInternal::Instance* instance() const { return _instance; } // Inlined for performance reasons.
 
-    /**
-     * Indicates whether to slice instances of Slice classes to a known Slice type when a more
-     * derived type is unknown. An instance is "sliced" when no static information is available
-     * for a Slice type ID and no factory can be found for that type, resulting in the creation
-     * of an instance of a less-derived type. If slicing is disabled in this situation, the
-     * stream raises the exception NoValueFactoryException. The default behavior is to allow slicing.
-     * @param b True to enable slicing, false otherwise.
-     */
-    void setSliceValues(bool b);
-
-    /**
-     * Indicates whether to log messages when instances of Slice classes are sliced. If the stream
-     * is initialized with a communicator, this setting defaults to the value of the Ice.Trace.Slicing
-     * property, otherwise the setting defaults to false.
-     * @param b True to enable logging, false otherwise.
-     */
-    void setTraceSlicing(bool b);
-
-    /**
-     * Sets an upper limit on the depth of a class graph. If this limit is exceeded during
-     * unmarshaling, the stream raises MarshalException.
-     * @param n The maximum depth.
-     */
-    void setClassGraphDepthMax(size_t n);
-
-    /**
-     * 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(InputStream& 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);
-        i = b.end();
-    }
+        /// Swaps the contents of one stream with another.
+        /// @param other The other stream.
+        void swap(InputStream& other) noexcept;
 
-    /**
-     * Marks the start of a class instance.
-     */
-    void startValue()
-    {
-        assert(_currentEncaps && _currentEncaps->decoder);
-        _currentEncaps->decoder->startInstance(ValueSlice);
-    }
+        /// @cond INTERNAL
 
-    /**
-     * Marks the end of a class instance.
-     *
-     * @param preserve Pass true and the stream will preserve the unknown slices of the instance, or false
-     * to discard the unknown slices.
-     * @return An object that encapsulates the unknown slice data.
-     */
-    SlicedDataPtr endValue(bool preserve)
-    {
-        assert(_currentEncaps && _currentEncaps->decoder);
-        return _currentEncaps->decoder->endInstance(preserve);
-    }
+        /// Gets the closure associated with this stream.
+        /// @return The closure.
+        [[nodiscard]] void* getClosure() const;
 
-    /**
-     * Marks the start of a user exception.
-     */
-    void startException()
-    {
-        assert(_currentEncaps && _currentEncaps->decoder);
-        _currentEncaps->decoder->startInstance(ExceptionSlice);
-    }
+        /// Associates a closure with this stream.
+        /// @param p The closure.
+        /// @return The previous closure, or nullptr.
+        void* setClosure(void* p);
 
-    /**
-     * Marks the end of a user exception.
-     *
-     * @param preserve Pass true and the stream will preserve the unknown slices of the exception, or false
-     * to discard the unknown slices.
-     * @return An object that encapsulates the unknown slice data.
-     */
-    SlicedDataPtr endException(bool preserve)
-    {
-        assert(_currentEncaps && _currentEncaps->decoder);
-        return _currentEncaps->decoder->endInstance(preserve);
-    }
+        void resetEncapsulation();
 
-    /**
-     * Reads the start of an encapsulation.
-     *
-     * @return The encoding version used by the encapsulation.
-     */
-    const EncodingVersion& startEncapsulation()
-    {
-        Encaps* oldEncaps = _currentEncaps;
-        if(!oldEncaps) // First allocated encaps?
+        /// Resizes the stream to a new size.
+        /// @param sz The new size.
+        void resize(Container::size_type sz)
         {
-            _currentEncaps = &_preAllocatedEncaps;
+            b.resize(sz);
+            i = b.end();
         }
-        else
+        /// @endcond
+
+        /// Marks the start of a class instance.
+        void startValue()
         {
-            _currentEncaps = new Encaps();
-            _currentEncaps->previous = oldEncaps;
+            assert(_currentEncaps && _currentEncaps->decoder);
+            _currentEncaps->decoder->startInstance(ValueSlice);
         }
-        _currentEncaps->start = static_cast<size_t>(i - b.begin());
 
-        //
-        // I don't use readSize() and writeSize() for encapsulations,
-        // because when creating an encapsulation, I must know in advance
-        // how many bytes the size information will require in the data
-        // stream. If I use an Int, it is always 4 bytes. For
-        // readSize()/writeSize(), it could be 1 or 5 bytes.
-        //
-        Int sz;
-        read(sz);
-        if(sz < 6)
+        /// Marks the end of a class instance.
+        /// @return An object that encapsulates the unknown slice data.
+        SlicedDataPtr endValue()
+        {
+            assert(_currentEncaps && _currentEncaps->decoder);
+            return _currentEncaps->decoder->endInstance();
+        }
+
+        /// Marks the start of a user exception.
+        void startException()
         {
-            throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+            assert(_currentEncaps && _currentEncaps->decoder);
+            _currentEncaps->decoder->startInstance(ExceptionSlice);
         }
-        if(i - sizeof(Int) + sz > b.end())
+
+        /// Marks the end of a user exception.
+        void endException()
         {
-            throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+            assert(_currentEncaps && _currentEncaps->decoder);
+            _currentEncaps->decoder->endInstance();
         }
-        _currentEncaps->sz = sz;
 
-        read(_currentEncaps->encoding);
-        IceInternal::checkSupportedEncoding(_currentEncaps->encoding); // Make sure the encoding is supported
+        /// Reads the start of an encapsulation.
+        /// @return The encoding version used by the encapsulation.
+        const EncodingVersion& startEncapsulation();
 
-        return _currentEncaps->encoding;
-    }
+        /// Ends the current encapsulation.
+        void endEncapsulation();
 
-    /**
-     * Ends the current encapsulation.
-     */
-    void endEncapsulation()
-    {
-        assert(_currentEncaps);
+        /// Skips an empty encapsulation.
+        /// @return The encapsulation's encoding version.
+        EncodingVersion skipEmptyEncapsulation();
 
-        if(_currentEncaps->encoding != Encoding_1_0)
+        /// Returns a blob of bytes representing an encapsulation.
+        /// @param[out] v A pointer into the internal marshaling buffer representing the start of the encoded
+        /// encapsulation.
+        /// @param[out] sz The number of bytes in the encapsulation.
+        /// @return encoding The encapsulation's encoding version.
+        EncodingVersion readEncapsulation(const std::byte*& v, std::int32_t& sz);
+
+        /// Gets the current encoding version.
+        /// @return The encoding version.
+        [[nodiscard]] const EncodingVersion& getEncoding() const
         {
-            skipOptionals();
-            if(i != b.begin() + _currentEncaps->start + _currentEncaps->sz)
-            {
-                throwEncapsulationException(__FILE__, __LINE__);
-            }
+            return _currentEncaps ? _currentEncaps->encoding : _encoding;
         }
-        else if(i != b.begin() + _currentEncaps->start + _currentEncaps->sz)
-        {
-            if(i + 1 != b.begin() + _currentEncaps->start + _currentEncaps->sz)
-            {
-                throwEncapsulationException(__FILE__, __LINE__);
-            }
 
-            //
-            // Ice version < 3.3 had a bug where user exceptions with
-            // class members could be encoded with a trailing byte
-            // when dispatched with AMD. So we tolerate an extra byte
-            // in the encapsulation.
-            //
-            ++i;
-        }
+        /// Gets the size of the current encapsulation, excluding the encapsulation header.
+        /// @return The size of the encapsulated data.
+        std::int32_t getEncapsulationSize();
 
-        Encaps* oldEncaps = _currentEncaps;
-        _currentEncaps = _currentEncaps->previous;
-        if(oldEncaps == &_preAllocatedEncaps)
-        {
-            oldEncaps->reset();
-        }
-        else
+        /// Skips over an encapsulation.
+        /// @return The encoding version of the skipped encapsulation.
+        EncodingVersion skipEncapsulation();
+
+        /// Reads the start of a value or exception slice.
+        void startSlice()
         {
-            delete oldEncaps;
+            assert(_currentEncaps && _currentEncaps->decoder);
+            _currentEncaps->decoder->startSlice();
         }
-    }
 
-    /**
-     * Skips an empty encapsulation.
-     *
-     * @return The encapsulation's encoding version.
-     */
-    EncodingVersion skipEmptyEncapsulation()
-    {
-        Ice::Int sz;
-        read(sz);
-        if(sz < 6)
+        /// Indicates that the end of a value or exception slice has been reached.
+        void endSlice()
         {
-            throwEncapsulationException(__FILE__, __LINE__);
+            assert(_currentEncaps && _currentEncaps->decoder);
+            _currentEncaps->decoder->endSlice();
         }
-        if(i - sizeof(Ice::Int) + sz > b.end())
+
+        /// Skips over a value or exception slice.
+        void skipSlice()
         {
-            throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+            assert(_currentEncaps && _currentEncaps->decoder);
+            _currentEncaps->decoder->skipSlice();
         }
-        Ice::EncodingVersion encoding;
-        read(encoding);
-        IceInternal::checkSupportedEncoding(encoding); // Make sure the encoding is supported
 
-        if(encoding == Ice::Encoding_1_0)
+        /// Indicates that unmarshaling is complete, except for any class instances. The application must call this
+        /// function only when the stream actually contains class instances. Calling `readPendingValues` triggers the
+        /// patch callbacks to inform the application that unmarshaling of an instance is complete.
+        void readPendingValues();
+
+        /// Reads a size from the stream.
+        /// @return The unmarshaled size.
+        std::int32_t readSize() // Inlined for performance reasons.
         {
-            if(sz != static_cast<Ice::Int>(sizeof(Ice::Int)) + 2)
+            std::uint8_t byte;
+            read(byte);
+            auto val = static_cast<unsigned char>(byte);
+            if (val == 255)
             {
-                throwEncapsulationException(__FILE__, __LINE__);
+                std::int32_t v;
+                read(v);
+                if (v < 0)
+                {
+                    throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+                }
+                return v;
+            }
+            else
+            {
+                return static_cast<std::int32_t>(static_cast<unsigned char>(byte));
             }
-        }
-        else
-        {
-            // Skip the optional content of the encapsulation if we are expecting an
-            // empty encapsulation.
-            i += static_cast<size_t>(sz) - sizeof(Ice::Int) - 2;
-        }
-        return encoding;
-    }
-
-    /**
-     * Returns a blob of bytes representing an encapsulation.
-     *
-     * @param v A pointer into the internal marshaling buffer representing the start of the encoded encapsulation.
-     * @param sz The number of bytes in the encapsulation.
-     * @return encoding The encapsulation's encoding version.
-     */
-    EncodingVersion readEncapsulation(const Byte*& v, Int& sz)
-    {
-        EncodingVersion encoding;
-        v = i;
-        read(sz);
-        if(sz < 6)
-        {
-            throwEncapsulationException(__FILE__, __LINE__);
-        }
-        if(i - sizeof(Int) + sz > b.end())
-        {
-            throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
         }
 
-        read(encoding);
-        i += static_cast<size_t>(sz) - sizeof(Int) - 2;
-        return encoding;
-    }
+        /// Reads and validates a sequence size.
+        /// @param minSize The minimum size required by the sequence type.
+        /// @return The extracted size.
+        std::int32_t readAndCheckSeqSize(int minSize);
 
-    /**
-     * Determines the current encoding version.
-     *
-     * @return The encoding version.
-     */
-    const EncodingVersion& getEncoding() const
-    {
-        return _currentEncaps ? _currentEncaps->encoding : _encoding;
-    }
+        /// Reads a blob of bytes from the stream.
+        /// @param[out] bytes The vector to hold a copy of the bytes from the marshaling buffer.
+        /// @param sz The number of bytes to read.
+        void readBlob(std::vector<std::byte>& bytes, std::int32_t sz);
 
-    /**
-     * Determines the size of the current encapsulation, excluding the encapsulation header.
-     *
-     * @return The size of the encapsulated data.
-     */
-    Int getEncapsulationSize();
-
-    /**
-     * Skips over an encapsulation.
-     *
-     * @return The encoding version of the skipped encapsulation.
-     */
-    EncodingVersion skipEncapsulation();
-
-    /**
-     * Reads the start of a value or exception slice.
-     *
-     * @return The Slice type ID for this slice.
-     */
-    std::string startSlice()
-    {
-        assert(_currentEncaps && _currentEncaps->decoder);
-        return _currentEncaps->decoder->startSlice();
-    }
-
-    /**
-     * Indicates that the end of a value or exception slice has been reached.
-     */
-    void endSlice()
-    {
-        assert(_currentEncaps && _currentEncaps->decoder);
-        _currentEncaps->decoder->endSlice();
-    }
-
-    /**
-     * Skips over a value or exception slice.
-     */
-    void skipSlice()
-    {
-        assert(_currentEncaps && _currentEncaps->decoder);
-        _currentEncaps->decoder->skipSlice();
-    }
-
-    /**
-     * Indicates that unmarshaling is complete, except for any class instances. The application must call this method
-     * only if the stream actually contains class instances. Calling readPendingValues triggers the
-     * patch callbacks to inform the application that unmarshaling of an instance is complete.
-     */
-    void readPendingValues();
-
-    /**
-     * Extracts a size from the stream.
-     *
-     * @return The extracted size.
-     */
-    Int readSize() // Inlined for performance reasons.
-    {
-        Byte byte;
-        read(byte);
-        unsigned char val = static_cast<unsigned char>(byte);
-        if(val == 255)
+        /// Reads a blob of bytes from the stream.
+        /// @param[out] v A pointer into the internal marshaling buffer representing the start of the blob.
+        /// @param sz The number of bytes to read.
+        void readBlob(const std::byte*& v, Container::size_type sz)
         {
-            Int v;
-            read(v);
-            if(v < 0)
+            if (sz > 0)
             {
-                throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+                v = i;
+                if (static_cast<Container::size_type>(b.end() - i) < sz)
+                {
+                    throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+                }
+                i += sz;
             }
-            return v;
-        }
-        else
-        {
-            return static_cast<Int>(static_cast<unsigned char>(byte));
-        }
-    }
-
-    /**
-     * Reads and validates a sequence size.
-     *
-     * @param minSize The minimum size required by the sequence type.
-     * @return The extracted size.
-     */
-    Int readAndCheckSeqSize(int minSize);
-
-    /**
-     * Reads a blob of bytes from the stream.
-     *
-     * @param bytes The vector to hold a copy of the bytes from the marshaling buffer.
-     * @param sz The number of bytes to read.
-     */
-    void readBlob(std::vector<Byte>& bytes, Int sz);
-
-    /**
-     * Reads a blob of bytes from the stream.
-     *
-     * @param v A pointer into the internal marshaling buffer representing the start of the blob.
-     * @param sz The number of bytes to read.
-     */
-    void readBlob(const Byte*& v, Container::size_type sz)
-    {
-        if(sz > 0)
-        {
-            v = i;
-            if(static_cast<Container::size_type>(b.end() - i) < sz)
+            else
             {
-                throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+                v = i;
             }
-            i += sz;
-        }
-        else
-        {
-            v = i;
         }
-    }
 
-    /**
-     * Reads a data value from the stream.
-     * @param v Holds the extracted data.
-     */
-    template<typename T> void read(T& v)
-    {
-        StreamHelper<T, StreamableTraits<T>::helper>::read(this, v);
-    }
+        /// Reads a value from the stream.
+        /// @tparam T The type of the value to read.
+        /// @param[out] v The unmarshaled value.
+        template<typename T> void read(T& v) { StreamHelper<T, StreamableTraits<T>::helper>::read(this, v); }
 
-    /**
-     * Reads an optional data value from the stream.
-     * @param tag The tag ID.
-     * @param v Holds the extracted data (if any).
-     */
-    template<typename T> void read(Int tag, IceUtil::Optional<T>& v)
-    {
-        if(readOptional(tag, StreamOptionalHelper<T,
-                                             StreamableTraits<T>::helper,
-                                             StreamableTraits<T>::fixedLength>::optionalFormat))
-        {
-#ifdef ICE_CPP11_MAPPING
-            v.emplace();
-#else
-            v.__setIsSet();
+#ifdef ICE_DOXYGEN
+        /// Reads an optional value from the stream.
+        /// @tparam T The type of the value to read.
+        /// @param tag The tag.
+        /// @param[out] v The unmarshaled value.
+        template<typename T> void read(std::int32_t tag, T& v);
 #endif
-            StreamOptionalHelper<T,
-                                 StreamableTraits<T>::helper,
-                                 StreamableTraits<T>::fixedLength>::read(this, *v);
-        }
-        else
-        {
-            v = IceUtil::None;
-        }
-    }
 
-#ifdef ICE_CPP11_MAPPING
+        /// Reads a value (single element list) from the stream.
+        /// @tparam T The type of value.
+        /// @param[out] v The unmarshaled value
+        template<typename T> void readAll(T& v) { read(v); }
 
-    /**
-     * Extracts a sequence of data values from the stream.
-     * @param v A pair of pointers representing the beginning and end of the sequence elements.
-     */
-    template<typename T> void read(std::pair<const T*, const T*>& v)
-    {
-        auto holder = new std::vector<T>;
-        _deleters.push_back([holder] { delete holder; });
-        read(*holder);
-        if(holder->size() > 0)
+        /// Reads a list of values from the stream.
+        /// @tparam T The type of the first value.
+        /// @tparam Te The types of the remaining values.
+        /// @param[out] v The first unmarshaled value
+        /// @param[out] ve The remaining unmarshaled values.
+        template<typename T, typename... Te> void readAll(T& v, Te&... ve)
         {
-            v.first = holder->data();
-            v.second = holder->data() + holder->size();
-        }
-        else
-        {
-            v.first = 0;
-            v.second = 0;
+            read(v);
+            readAll(ve...);
         }
-    }
 
-    /**
-     * Reads a list of mandatory data values.
-     */
-    template<typename T> void readAll(T& v)
-    {
-        read(v);
-    }
-
-    /**
-     * Reads a list of mandatory data values.
-     */
-    template<typename T, typename... Te> void readAll(T& v, Te&... ve)
-    {
-        read(v);
-        readAll(ve...);
-    }
-
-    /**
-     * Reads a list of optional data values.
-     */
-    template<typename T>
-    void readAll(std::initializer_list<int> tags, IceUtil::Optional<T>& v)
-    {
-        read(*(tags.begin() + tags.size() - 1), v);
-    }
-
-    /**
-     * Reads a list of optional data values.
-     */
-    template<typename T, typename... Te>
-    void readAll(std::initializer_list<int> tags, IceUtil::Optional<T>& v, IceUtil::Optional<Te>&... ve)
-    {
-        size_t index = tags.size() - sizeof...(ve) - 1;
-        read(*(tags.begin() + index), v);
-        readAll(tags, ve...);
-    }
-
-#endif
-
-    /**
-     * Determine if an optional value is available for reading.
-     *
-     * @param tag The tag associated with the value.
-     * @param expectedFormat The optional format for the value.
-     * @return True if the value is present, false otherwise.
-     */
-    bool readOptional(Int tag, OptionalFormat expectedFormat)
-    {
-        assert(_currentEncaps);
-        if(_currentEncaps->decoder)
+        /// Reads an optional value (single element list) from the stream.
+        /// @tparam T The type of the value.
+        /// @param tags The tag list.
+        /// @param[out] v The unmarshaled value.
+        template<typename T> void readAll(std::initializer_list<std::int32_t> tags, std::optional<T>& v)
         {
-            return _currentEncaps->decoder->readOptional(tag, expectedFormat);
+            read(*(tags.begin() + tags.size() - 1), v);
         }
-        else
-        {
-            return readOptImpl(tag, expectedFormat);
-        }
-    }
 
-    /**
-     * Reads a byte from the stream.
-     * @param v The extracted byte.
-     */
-    void read(Byte& v)
-    {
-        if(i >= b.end())
+        /// Reads a list of optional values from the stream.
+        /// @tparam T The type of the first value.
+        /// @tparam Te The types of the remaining values.
+        /// @param tags The tag list.
+        /// @param[out] v The first unmarshaled value.
+        /// @param[out] ve The remaining unmarshaled values.
+        template<typename T, typename... Te>
+        void readAll(std::initializer_list<std::int32_t> tags, std::optional<T>& v, std::optional<Te>&... ve)
         {
-            throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+            size_t index = tags.size() - sizeof...(ve) - 1;
+            read(*(tags.begin() + index), v);
+            readAll(tags, ve...);
         }
-        v = *i++;
-    }
-
-    /**
-     * Reads a sequence of bytes from the stream.
-     * @param v A vector to hold a copy of the bytes.
-     */
-    void read(std::vector<Byte>& v);
-
-    /**
-     * Reads a sequence of bytes from the stream.
-     * @param v A pair of pointers into the internal marshaling buffer representing the start and end of the
-     * sequence elements.
-     */
-    void read(std::pair<const Byte*, const Byte*>& v);
-
-#ifndef ICE_CPP11_MAPPING
-    /**
-     * Reads a sequence of bytes from the stream.
-     * @param v A pair of pointers into the internal marshaling buffer representing the start and end of the
-     * sequence elements.
-     * @param arr A scoped array.
-     */
-    void read(std::pair<const Byte*, const Byte*>& v, ::IceUtil::ScopedArray<Byte>& arr)
-    {
-        arr.reset();
-        read(v);
-    }
-#endif
 
-    /**
-     * Reads a bool from the stream.
-     * @param v The extracted bool.
-     */
-    void read(bool& v)
-    {
-        if(i >= b.end())
+        /// Checks if an optional value is available for reading.
+        /// @param tag The tag associated with the value.
+        /// @param expectedFormat The optional format for the value.
+        /// @return `true` if the value is present, `false` otherwise.
+        bool readOptional(std::int32_t tag, OptionalFormat expectedFormat)
         {
-            throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+            assert(_currentEncaps);
+            if (_currentEncaps->decoder)
+            {
+                return _currentEncaps->decoder->readOptional(tag, expectedFormat);
+            }
+            else
+            {
+                return readOptImpl(tag, expectedFormat);
+            }
         }
-        v = (0 != *i++);
-    }
 
-    /**
-     * Reads a sequence of boolean values from the stream.
-     * @param v A vector to hold a copy of the boolean values.
-     */
-    void read(std::vector<bool>& v);
-
-#ifdef ICE_CPP11_MAPPING
-    /**
-     * Reads a sequence of boolean values from the stream.
-     * @param v A pair of pointers into the internal marshaling buffer representing the start and end of the
-     * sequence elements.
-     */
-    void read(std::pair<const bool*, const bool*>& v);
-#else
-    /**
-     * Reads a sequence of boolean values from the stream.
-     * @param v A pair of pointers into the internal marshaling buffer representing the start and end of the
-     * sequence elements.
-     * @param arr A scoped array.
-     */
-    void read(std::pair<const bool*, const bool*>& v, ::IceUtil::ScopedArray<bool>& arr);
-#endif
+        /// @cond INTERNAL
 
-    /**
-     * Reads a short from the stream.
-     * @param v The extracted short.
-     */
-    void read(Short& v);
-
-    /**
-     * Reads a sequence of shorts from the stream.
-     * @param v A vector to hold a copy of the short values.
-     */
-    void read(std::vector<Short>& v);
-
-#ifdef ICE_CPP11_MAPPING
-    /**
-     * Reads a sequence of boolean values from the stream.
-     * @param v A pair of pointers representing the start and end of the sequence elements.
-     */
-    void read(std::pair<const short*, const short*>& v);
-#else
-    /**
-     * Reads a sequence of shorts from the stream.
-     * @param v A pair of pointers representing the start and end of the sequence elements.
-     * @param arr A scoped array.
-     */
-    void read(std::pair<const Short*, const Short*>& v, ::IceUtil::ScopedArray<Short>& arr);
-#endif
+        // We don't document all the read "specializations" in Doxygen. But we do keep them mostly documented for
+        // tool-tips.
 
-    /**
-     * Reads an int from the stream.
-     * @param v The extracted int.
-     */
-    void read(Int& v) // Inlined for performance reasons.
-    {
-        if(b.end() - i < static_cast<int>(sizeof(Int)))
+        /// Reads an optional value from the stream.
+        /// @tparam T The type of the value to read.
+        /// @param tag The tag.
+        /// @param[out] v The unmarshaled value.
+        template<typename T, std::enable_if_t<!std::is_base_of_v<ObjectPrx, T>, bool> = true>
+        void read(std::int32_t tag, std::optional<T>& v)
         {
-            throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+            if (readOptional(
+                    tag,
+                    StreamOptionalHelper<T, StreamableTraits<T>::helper, StreamableTraits<T>::fixedLength>::
+                        optionalFormat))
+            {
+                v.emplace();
+                StreamOptionalHelper<T, StreamableTraits<T>::helper, StreamableTraits<T>::fixedLength>::read(this, *v);
+            }
+            else
+            {
+                v = std::nullopt;
+            }
         }
-        const Byte* src = &(*i);
-        i += sizeof(Int);
-#ifdef ICE_BIG_ENDIAN
-        Byte* dest = reinterpret_cast<Byte*>(&v) + sizeof(Int) - 1;
-        *dest-- = *src++;
-        *dest-- = *src++;
-        *dest-- = *src++;
-        *dest = *src;
-#else
-        Byte* dest = reinterpret_cast<Byte*>(&v);
-        *dest++ = *src++;
-        *dest++ = *src++;
-        *dest++ = *src++;
-        *dest = *src;
-#endif
-    }
-
-    /**
-     * Reads a sequence of ints from the stream.
-     * @param v A vector to hold a copy of the int values.
-     */
-    void read(std::vector<Int>& v);
-
-#ifdef ICE_CPP11_MAPPING
-    /**
-     * Reads a sequence of ints from the stream.
-     * @param v A pair of pointers representing the start and end of the sequence elements.
-     */
-    void read(std::pair<const int*, const int*>& v);
-#else
-    /**
-     * Reads a sequence of ints from the stream.
-     * @param v A pair of pointers representing the start and end of the sequence elements.
-     * @param arr A scoped array.
-     */
-    void read(std::pair<const Int*, const Int*>& v, ::IceUtil::ScopedArray<Int>& arr);
-#endif
 
-    /**
-     * Reads a long from the stream.
-     * @param v The extracted long.
-     */
-    void read(Long& v);
-
-    /**
-     * Reads a sequence of longs from the stream.
-     * @param v A vector to hold a copy of the long values.
-     */
-    void read(std::vector<Long>& v);
-
-#ifdef ICE_CPP11_MAPPING
-    /**
-     * Reads a sequence of longs from the stream.
-     * @param v A pair of pointers representing the start and end of the sequence elements.
-     */
-    void read(std::pair<const long long*, const long long*>& v);
-#else
-    /**
-     * Reads a sequence of longs from the stream.
-     * @param v A pair of pointers representing the start and end of the sequence elements.
-     * @param arr A scoped array.
-     */
-    void read(std::pair<const Long*, const Long*>& v, ::IceUtil::ScopedArray<Long>& arr);
-#endif
-
-    /**
-     * Reads a float from the stream.
-     * @param v The extracted float.
-     */
-    void read(Float& v);
-
-    /**
-     * Reads a sequence of floats from the stream.
-     * @param v A vector to hold a copy of the float values.
-     */
-    void read(std::vector<Float>& v);
-
-#ifdef ICE_CPP11_MAPPING
-    /**
-     * Reads a sequence of floats from the stream.
-     * @param v A pair of pointers representing the start and end of the sequence elements.
-     */
-    void read(std::pair<const float*, const float*>& v);
-#else
-    /**
-     * Reads a sequence of floats from the stream.
-     * @param v A pair of pointers representing the start and end of the sequence elements.
-     * @param arr A scoped array.
-     */
-    void read(std::pair<const Float*, const Float*>& v, ::IceUtil::ScopedArray<Float>& arr);
-#endif
-
-    /**
-     * Reads a double from the stream.
-     * @param v The extracted double.
-     */
-    void read(Double& v);
-
-    /**
-     * Reads a sequence of doubles from the stream.
-     * @param v A vector to hold a copy of the double values.
-     */
-    void read(std::vector<Double>& v);
-
-#ifdef ICE_CPP11_MAPPING
-    /**
-     * Reads a sequence of doubles from the stream.
-     * @param v A pair of pointers representing the start and end of the sequence elements.
-     */
-    void read(std::pair<const double*, const double*>& v);
-#else
-    /**
-     * Reads a sequence of doubles from the stream.
-     * @param v A pair of pointers representing the start and end of the sequence elements.
-     * @param arr A scoped array.
-     */
-    void read(std::pair<const Double*, const Double*>& v, ::IceUtil::ScopedArray<Double>& arr);
-#endif
-
-    /**
-     * Reads a string from the stream.
-     * @param v The extracted string.
-     * @param convert Determines whether the string is processed by the string converter, if one
-     * is installed. The default behavior is to convert strings.
-     */
-    void read(std::string& v, bool convert = true);
-
-#ifdef ICE_CPP11_MAPPING
-    /**
-     * Reads a string from the stream.
-     * @param vdata A pointer to the beginning of the string.
-     * @param vsize The number of bytes in the string.
-     * @param convert Determines whether the string is processed by the string converter, if one
-     * is installed. The default behavior is to convert strings.
-     */
-    void read(const char*& vdata, size_t& vsize, bool convert = true);
-#else
-    // For custom strings, convert = false
-    /**
-     * Reads a string from the stream. String conversion is disabled.
-     * @param vdata A pointer to the beginning of the string.
-     * @param vsize The number of bytes in the string.
-     */
-    void read(const char*& vdata, size_t& vsize);
-
-    // For custom strings, convert = true
-    /**
-     * Reads a string from the stream. String conversion is enabled.
-     * @param vdata A pointer to the beginning of the string.
-     * @param vsize The number of bytes in the string.
-     * @param holder Holds the string contents.
-     */
-    void read(const char*& vdata, size_t& vsize, std::string& holder);
-#endif
-
-    /**
-     * Reads a sequence of strings from the stream.
-     * @param v The extracted string sequence.
-     * @param convert Determines whether strings are processed by the string converter, if one
-     * is installed. The default behavior is to convert the strings.
-     */
-    void read(std::vector<std::string>& v, bool convert = true);
-
-    /**
-     * Reads a wide string from the stream.
-     * @param v The extracted string.
-     */
-    void read(std::wstring& v);
-
-    /**
-     * Reads a sequence of wide strings from the stream.
-     * @param v The extracted sequence.
-     */
-    void read(std::vector<std::wstring>& v);
-
-#ifdef ICE_CPP11_MAPPING
-    /**
-     * Reads a proxy from the stream.
-     * @return The proxy as the base ObjectPrx type.
-     */
-    std::shared_ptr<ObjectPrx> readProxy();
-
-    /**
-     * Reads a typed proxy from the stream.
-     * @param v The proxy as a user-defined type.
-     */
-    template<typename T, typename ::std::enable_if<::std::is_base_of<ObjectPrx, T>::value>::type* = nullptr>
-    void read(::std::shared_ptr<T>& v)
-    {
-        ::std::shared_ptr<ObjectPrx> proxy(readProxy());
-        if(!proxy)
+        /// Reads an optional proxy from the stream.
+        /// @tparam T The type of the value to read.
+        /// @param tag The tag.
+        /// @param[out] v The proxy unmarshaled by this function. If nullopt, the proxy was not present in the stream or
+        /// was set to nullopt (set to nullopt is supported for backward compatibility with Ice 3.7 and earlier
+        /// releases).
+        template<typename T, std::enable_if_t<std::is_base_of_v<ObjectPrx, T>, bool> = true>
+        void read(std::int32_t tag, std::optional<T>& v)
         {
-            v = 0;
+            if (readOptional(tag, OptionalFormat::FSize))
+            {
+                skip(4); // the fixed-length size on 4 bytes
+                read(v); // can be nullopt
+            }
+            else
+            {
+                v = std::nullopt;
+            }
         }
-        else
+
+        /// Reads a sequence from the stream.
+        /// @param[out] v A pair of pointers representing the beginning and end of the sequence elements.
+        template<typename T> void read(std::pair<const T*, const T*>& v)
         {
-            v = ::IceInternal::createProxy<T>();
-            v->_copyFrom(proxy);
+            auto holder = new std::vector<T>;
+            _deleters.push_back([holder] { delete holder; });
+            read(*holder);
+            if (holder->size() > 0)
+            {
+                v.first = holder->data();
+                v.second = holder->data() + holder->size();
+            }
+            else
+            {
+                v.first = 0;
+                v.second = 0;
+            }
         }
-    }
-#else
-    /**
-     * Reads a proxy from the stream.
-     * @param v The proxy as the base ObjectPrx type.
-     */
-    void read(ObjectPrx& v);
-
-    /**
-     * Reads a typed proxy from the stream.
-     * @param v The proxy as a user-defined type.
-     */
-    template<typename T> void read(IceInternal::ProxyHandle<T>& v)
-    {
-        _readProxy(this, v); // Generated _readProxy method, necessary for forward declarations.
-    }
-#endif
 
-    /**
-     * Reads a value (instance of a Slice class) from the stream.
-     * @param v The instance.
-     */
-#ifdef ICE_CPP11_MAPPING // C++11 mapping
-    template<typename T, typename ::std::enable_if<::std::is_base_of<Value, T>::value>::type* = nullptr>
-    void read(::std::shared_ptr<T>& v)
-    {
-        read(&patchHandle<T>, &v);
-    }
-#else // C++98 mapping
-    template<typename T> void read(IceInternal::Handle<T>& v)
-    {
-        read(&patchHandle<T>, &v);
-    }
+#if defined(ICE_UNALIGNED) || (defined(_WIN32) && defined(ICE_API_EXPORTS))
+        // Optimization with unaligned reads
+        void read(std::pair<const std::int16_t*, const std::int16_t*>& v) { unalignedRead(v); }
+        void read(std::pair<const std::int32_t*, const std::int32_t*>& v) { unalignedRead(v); }
+        void read(std::pair<const std::int64_t*, const std::int64_t*>& v) { unalignedRead(v); }
+        void read(std::pair<const float*, const float*>& v) { unalignedRead(v); }
+        void read(std::pair<const double*, const double*>& v) { unalignedRead(v); }
 #endif
 
-    /**
-     * Reads a value (instance of a Slice class) from the stream.
-     * @param patchFunc The patch callback function.
-     * @param patchAddr Closure data passed to the callback.
-     */
-    void read(PatchFunc patchFunc, void* patchAddr)
-    {
-        initEncaps();
-        _currentEncaps->decoder->read(patchFunc, patchAddr);
-    }
-
-    /**
-     * Reads an enumerator from the stream.
-     * @param maxValue The maximum enumerator value in the definition.
-     * @return The enumerator value.
-     */
-    Int readEnum(Int maxValue);
-
-    /**
-     * Extracts a user exception from the stream and throws it.
-     * @param factory If provided, this factory is given the first opportunity to instantiate
-     * the exception. If not provided, or if the factory does not throw an exception when invoked,
-     * the stream will attempt to instantiate the exception using static type information.
-     * @throws UserException The user exception that was unmarshaled.
-     */
-    void throwException(ICE_IN(ICE_DELEGATE(UserExceptionFactory)) factory = ICE_NULLPTR);
-
-    /**
-     * Skips one optional value with the given format.
-     * @param format The expected format of the optional, if present.
-     */
-    void skipOptional(OptionalFormat format);
-
-    /**
-     * Skips all remaining optional values.
-     */
-    void skipOptionals();
-
-    /**
-     * Advances the current stream position by the given number of bytes.
-     * @param size The number of bytes to skip.
-     */
-    void skip(size_type size)
-    {
-        if(i + size > b.end())
+        /// Reads a byte from the stream.
+        /// @param[out] v The extracted byte.
+        void read(std::byte& v)
         {
-            throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+            if (i >= b.end())
+            {
+                throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+            }
+            v = *i++;
         }
-        i += size;
-    }
 
-    /**
-     * Reads a size at the current position and skips that number of bytes.
-     */
-    void skipSize()
-    {
-        Byte bt;
-        read(bt);
-        if(static_cast<unsigned char>(bt) == 255)
+        /// Reads a byte from the stream.
+        /// @param[out] v The extracted byte.
+        void read(std::uint8_t& v)
         {
-            skip(4);
+            if (i >= b.end())
+            {
+                throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+            }
+            v = static_cast<std::uint8_t>(*i++);
         }
-    }
 
-    /**
-     * Obtains the current position of the stream.
-     * @return The current position.
-     */
-    size_type pos()
-    {
-        return static_cast<size_t>(i - b.begin());
-    }
+        /// Reads a sequence of bytes from the stream.
+        /// @param[out] v A vector to hold a copy of the bytes.
+        void read(std::vector<std::byte>& v);
 
-    /**
-     * Sets a new position for the stream.
-     * @param p The new position.
-     */
-    void pos(size_type p)
-    {
-        i = b.begin() + p;
-    }
+        /// Reads a sequence of bytes from the stream.
+        /// @param[out] v A pair of pointers into the internal marshaling buffer representing the start and end of the
+        /// sequence elements.
+        void read(std::pair<const std::byte*, const std::byte*>& v);
+
+        /// Reads a bool from the stream.
+        /// @param[out] v The extracted bool.
+        void read(bool& v)
+        {
+            if (i >= b.end())
+            {
+                throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+            }
+            v = (std::byte{0} != *i++);
+        }
 
-    /// \cond INTERNAL
-    InputStream(IceInternal::Instance*, const EncodingVersion&);
-    InputStream(IceInternal::Instance*, const EncodingVersion&, IceInternal::Buffer&, bool = false);
+        /// Reads a sequence of boolean values from the stream.
+        /// @param[out] v A vector to hold a copy of the boolean values.
+        void read(std::vector<bool>& v);
 
-    void initialize(IceInternal::Instance*, const EncodingVersion&);
+        /// Reads a sequence of boolean values from the stream.
+        /// @param[out] v A pair of pointers into the internal marshaling buffer representing the start and end of the
+        /// sequence elements.
+        void read(std::pair<const bool*, const bool*>& v);
 
-    bool readOptImpl(Int, OptionalFormat);
-    /// \endcond
+        /// Reads a short into an int16_t.
+        /// @param[out] v The extracted int16_t.
+        void read(std::int16_t& v);
 
-private:
+        /// Reads a sequence of Slice shorts into a vector of int16_t.
+        /// @param[out] v A vector to hold a copy of the int16_t values.
+        void read(std::vector<std::int16_t>& v);
 
-    void initialize(const EncodingVersion&);
+        /// Reads an int from the stream.
+        /// @param[out] v The extracted int.
+        void read(std::int32_t& v);
 
-    //
-    // String
-    //
-    bool readConverted(std::string&, Int);
+        /// Reads a sequence of ints from the stream.
+        /// @param[out] v A vector to hold a copy of the int values.
+        void read(std::vector<std::int32_t>& v);
 
-    //
-    // We can't throw these 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 throwUnmarshalOutOfBoundsException(const char*, int);
-    void throwEncapsulationException(const char*, int);
+        /// Reads a long from the stream.
+        /// @param[out]v The extracted long.
+        void read(std::int64_t& v);
 
-    std::string resolveCompactId(int) const;
+        /// Reads a sequence of longs from the stream.
+        /// @param[out] v A vector to hold a copy of the long values.
+        void read(std::vector<std::int64_t>& v);
 
-    void postUnmarshal(const ValuePtr&) const;
+        /// Read a float into a float.
+        /// @param[out] v The extracted float.
+        void read(float& v);
 
-    class Encaps;
-    enum SliceType { NoSlice, ValueSlice, ExceptionSlice };
+        /// Reads a sequence of floats into a vector of float.
+        /// @param[out] v An output vector filled by this function.
+        void read(std::vector<float>& v);
 
-    void traceSkipSlice(const std::string&, SliceType) const;
+        /// Reads a double into a double.
+        /// @param[out] v The extracted double.
+        void read(double& v);
 
-    ValueFactoryManagerPtr valueFactoryManager() const;
+        /// Reads a sequence of doubles into a vector of double.
+        /// @param[out] v An output vector filled by this function.
+        void read(std::vector<double>& v);
 
-    LoggerPtr logger() const;
+        /// @endcond
 
-#ifdef ICE_CPP11_MAPPING
-    std::function<std::string(int)> compactIdResolver() const;
-#else
-    CompactIdResolverPtr compactIdResolver() const;
-#endif
+        // We document read functions with an extra parameter.
 
-    typedef std::vector<ValuePtr> ValueList;
+        /// Reads a string from the stream.
+        /// @param[out] v The unmarshaled string.
+        /// @param convert `true` to process the unmarshaled string through the string converter (if installed on the
+        /// communicator), `false` otherwise.
+        void read(std::string& v, bool convert = true);
 
-    class ICE_API EncapsDecoder : private ::IceUtil::noncopyable
-    {
-    public:
+        /// Reads a string from the stream.
+        /// @param[out] vdata A pointer to the beginning of the string.
+        /// @param[out] vsize The number of bytes in the string.
+        /// @param convert `true` to process the unmarshaled string through the string converter (if installed on the
+        /// communicator), `false` otherwise.
+        void read(const char*& vdata, size_t& vsize, bool convert = true);
 
-        virtual ~EncapsDecoder();
+        /// Reads a sequence of strings from the stream.
+        /// @param[out] v The unmarshaled string sequence.
+        /// @param convert `true` to process the unmarshaled string through the string converter (if installed on the
+        /// communicator), `false` otherwise.
+        void read(std::vector<std::string>& v, bool convert = true);
 
-        virtual void read(PatchFunc, void*) = 0;
-        virtual void throwException(ICE_IN(ICE_DELEGATE(UserExceptionFactory))) = 0;
+        /// @cond INTERNAL
 
-        virtual void startInstance(SliceType) = 0;
-        virtual SlicedDataPtr endInstance(bool) = 0;
-        virtual const std::string& startSlice() = 0;
-        virtual void endSlice() = 0;
-        virtual void skipSlice() = 0;
+        /// Reads a wide string from the stream.
+        /// @param[out] v The extracted string.
+        void read(std::wstring& v);
 
-        virtual bool readOptional(Int, OptionalFormat)
+        /// Reads a sequence of wide strings from the stream.
+        /// @param[out] v The extracted sequence.
+        void read(std::vector<std::wstring>& v);
+
+        /// Reads a typed proxy from the stream.
+        /// @tparam Prx The type of the value to read.
+        /// @param[out] v The unmarshaled proxy.
+        template<typename Prx, std::enable_if_t<std::is_base_of_v<ObjectPrx, Prx>, bool> = true>
+        void read(std::optional<Prx>& v)
         {
-            return false;
+            IceInternal::ReferencePtr ref = readReference();
+            if (ref)
+            {
+                v = Prx::_fromReference(ref);
+            }
+            else
+            {
+                v = std::nullopt;
+            }
         }
 
-        virtual void readPendingValues()
+        /// Reads an instance of a Slice class from the stream.
+        /// @tparam T The type of the value to read.
+        /// @param[out] v The unmarshaled instance.
+        template<typename T, std::enable_if_t<std::is_base_of_v<Value, T>>* = nullptr> void read(std::shared_ptr<T>& v)
         {
+            read(patchValue<T>, &v);
         }
 
-    protected:
-
-        EncapsDecoder(InputStream* stream, Encaps* encaps, bool sliceValues, size_t classGraphDepthMax,
-                      const Ice::ValueFactoryManagerPtr& f) :
-            _stream(stream), _encaps(encaps), _sliceValues(sliceValues), _classGraphDepthMax(classGraphDepthMax),
-            _classGraphDepth(0), _valueFactoryManager(f), _typeIdIndex(0)
+        /// @private
+        /// Reads a value (instance of a Slice class) from the stream.
+        /// @param patchFunc The patch callback function.
+        /// @param patchAddr Closure data passed to the callback.
+        void read(PatchFunc patchFunc, void* patchAddr)
         {
+            initEncaps();
+            _currentEncaps->decoder->read(std::move(patchFunc), patchAddr);
         }
 
-        std::string readTypeId(bool);
-        ValuePtr newInstance(const std::string&);
-
-        void addPatchEntry(Int, PatchFunc, void*);
-        void unmarshal(Int, const ValuePtr&);
-
-        typedef std::map<Int, ValuePtr> IndexToPtrMap;
-        typedef std::map<Int, std::string> TypeIdMap;
-
-        struct PatchEntry
-        {
-            PatchFunc patchFunc;
-            void* patchAddr;
-            size_t classGraphDepth;
-        };
-        typedef std::vector<PatchEntry> PatchList;
-        typedef std::map<Int, PatchList> PatchMap;
+        /// @endcond
 
-        InputStream* _stream;
-        Encaps* _encaps;
-        const bool _sliceValues;
-        const size_t _classGraphDepthMax;
-        size_t _classGraphDepth;
-        Ice::ValueFactoryManagerPtr _valueFactoryManager;
+        /// Reads an enumerator from the stream.
+        /// @param maxValue The maximum enumerator value in the definition.
+        /// @return The enumerator value.
+        std::int32_t readEnum(std::int32_t maxValue);
 
-        // Encapsulation attributes for object un-marshalling
-        PatchMap _patchMap;
+        /// Reads a user exception from the stream and throws it.
+        /// @param factory The factory function that creates the exception instance. When null, the exception is created
+        /// using helper functions generated by the Slice compiler.
+        /// @throws UserException The user exception that was unmarshaled.
+        void throwException(UserExceptionFactory factory = nullptr);
 
-    private:
+        /// Skips one optional value with the given format.
+        /// @param format The expected format of the optional, if present.
+        void skipOptional(OptionalFormat format);
 
-        // Encapsulation attributes for object un-marshalling
-        IndexToPtrMap _unmarshaledMap;
-        TypeIdMap _typeIdMap;
-        Int _typeIdIndex;
-        ValueList _valueList;
-    };
+        /// Skips all remaining optional values.
+        void skipOptionals();
 
-    class ICE_API EncapsDecoder10 : public EncapsDecoder
-    {
-    public:
+        /// Advances the current stream position by the given number of bytes.
+        /// @param size The number of bytes to skip.
+        void skip(size_type size)
+        {
+            if (i + size > b.end())
+            {
+                throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+            }
+            i += size;
+        }
 
-        EncapsDecoder10(InputStream* stream, Encaps* encaps, bool sliceValues, size_t classGraphDepthMax,
-                        const Ice::ValueFactoryManagerPtr& f) :
-            EncapsDecoder(stream, encaps, sliceValues, classGraphDepthMax, f),
-            _sliceType(NoSlice)
+        /// Reads a size at the current position and skips that number of bytes.
+        void skipSize()
         {
+            std::uint8_t bt;
+            read(bt);
+            if (static_cast<unsigned char>(bt) == 255)
+            {
+                skip(4);
+            }
         }
 
-        virtual void read(PatchFunc, void*);
-        virtual void throwException(ICE_IN(ICE_DELEGATE(UserExceptionFactory)));
+        /// Gets the current position of the stream.
+        /// @return The current position.
+        size_type pos() { return static_cast<size_t>(i - b.begin()); }
 
-        virtual void startInstance(SliceType);
-        virtual SlicedDataPtr endInstance(bool);
-        virtual const std::string& startSlice();
-        virtual void endSlice();
-        virtual void skipSlice();
+        /// Sets a new position for the stream.
+        /// @param p The new position.
+        void pos(size_type p) { i = b.begin() + p; }
 
-        virtual void readPendingValues();
+        /// @private
+        bool readOptImpl(std::int32_t, OptionalFormat);
 
     private:
+#if defined(ICE_UNALIGNED) || (defined(_WIN32) && defined(ICE_API_EXPORTS))
+        template<typename T> void unalignedRead(std::pair<const T*, const T*>& v)
+        {
+            int sz = readAndCheckSeqSize(static_cast<int>(sizeof(T)));
 
-        void readInstance();
+            if (sz > 0)
+            {
+                v.first = reinterpret_cast<T*>(i);
+                i += sz * static_cast<int>(sizeof(T));
+                v.second = reinterpret_cast<T*>(i);
+            }
+            else
+            {
+                v.first = v.second = nullptr;
+            }
+        }
+#endif
 
-        // Instance attributes
-        SliceType _sliceType;
-        bool _skipFirstSlice;
+        // The primary constructor, called by all other constructors. It requires a non-null instance.
+        InputStream(
+            IceInternal::Instance* instance,
+            EncodingVersion encoding,
+            IceInternal::Buffer&& buf,
+            SliceLoaderPtr sliceLoader);
 
-        // Slice attributes
-        Int _sliceSize;
-        std::string _typeId;
-    };
+        // Reads a reference from the stream; the return value can be null.
+        IceInternal::ReferencePtr readReference();
 
-    class ICE_API EncapsDecoder11 : public EncapsDecoder
-    {
-    public:
+        bool readConverted(std::string&, std::int32_t);
 
-        EncapsDecoder11(InputStream* stream, Encaps* encaps, bool sliceValues, size_t classGraphDepthMax,
-                        const Ice::ValueFactoryManagerPtr& f) :
-            EncapsDecoder(stream, encaps, sliceValues, classGraphDepthMax, f),
-            _preAllocatedInstanceData(0), _current(0), _valueIdIndex(1)
+        void throwUnmarshalOutOfBoundsException(const char*, int);
+
+        class Encaps;
+        enum SliceType
         {
-        }
+            NoSlice,
+            ValueSlice,
+            ExceptionSlice
+        };
 
-        virtual void read(PatchFunc, void*);
-        virtual void throwException(ICE_IN(ICE_DELEGATE(UserExceptionFactory)));
+        void traceSkipSlice(std::string_view, SliceType) const;
 
-        virtual void startInstance(SliceType);
-        virtual SlicedDataPtr endInstance(bool);
-        virtual const std::string& startSlice();
-        virtual void endSlice();
-        virtual void skipSlice();
+        using ValueList = std::vector<ValuePtr>;
 
-        virtual bool readOptional(Int, OptionalFormat);
+        class ICE_API EncapsDecoder
+        {
+        public:
+            EncapsDecoder(const EncapsDecoder&) = delete;
+            virtual ~EncapsDecoder();
 
-    private:
+            EncapsDecoder& operator=(const EncapsDecoder&) = delete;
 
-        Int readInstance(Int, PatchFunc, void*);
-        SlicedDataPtr readSlicedData();
+            virtual void read(PatchFunc, void*) = 0;
+            virtual void throwException(UserExceptionFactory) = 0;
 
-        struct IndirectPatchEntry
-        {
-            Int index;
-            PatchFunc patchFunc;
-            void* patchAddr;
-        };
-        typedef std::vector<IndirectPatchEntry> IndirectPatchList;
+            virtual void startInstance(SliceType) = 0;
+            virtual SlicedDataPtr endInstance() = 0;
+            virtual void startSlice() = 0;
+            virtual void endSlice() = 0;
+            virtual void skipSlice() = 0;
 
-        typedef std::vector<Int> IndexList;
-        typedef std::vector<IndexList> IndexListList;
+            virtual bool readOptional(std::int32_t, OptionalFormat) { return false; }
 
-        struct InstanceData
-        {
-            InstanceData(InstanceData* p) : previous(p), next(0)
+            virtual void readPendingValues() {}
+
+        protected:
+            EncapsDecoder(InputStream* stream, Encaps* encaps, std::int32_t classGraphDepthMax)
+                : _stream(stream),
+                  _encaps(encaps),
+                  _classGraphDepthMax(classGraphDepthMax)
             {
-                if(previous)
-                {
-                    previous->next = this;
-                }
             }
 
-            ~InstanceData()
+            std::string readTypeId(bool);
+            ValuePtr newInstance(std::string_view);
+
+            void addPatchEntry(std::int32_t, const PatchFunc&, void*);
+            void unmarshal(std::int32_t, const ValuePtr&);
+
+            using IndexToPtrMap = std::map<std::int32_t, ValuePtr>;
+            using TypeIdMap = std::map<std::int32_t, std::string>;
+
+            /// @private
+            struct PatchEntry
+            {
+                PatchFunc patchFunc;
+                void* patchAddr;
+                std::int32_t classGraphDepth;
+            };
+            using PatchList = std::vector<PatchEntry>;
+            using PatchMap = std::map<std::int32_t, PatchList>;
+
+            InputStream* _stream;
+            Encaps* _encaps;
+            const std::int32_t _classGraphDepthMax;
+            std::int32_t _classGraphDepth{0};
+
+            // Encapsulation attributes for object un-marshaling
+            PatchMap _patchMap;
+
+        private:
+            // Encapsulation attributes for object un-marshaling
+            IndexToPtrMap _unmarshaledMap;
+            TypeIdMap _typeIdMap;
+            std::int32_t _typeIdIndex{0};
+            ValueList _valueList;
+        };
+
+        class ICE_API EncapsDecoder10 : public EncapsDecoder
+        {
+        public:
+            EncapsDecoder10(InputStream* stream, Encaps* encaps, std::int32_t classGraphDepthMax)
+                : EncapsDecoder(stream, encaps, classGraphDepthMax)
             {
-                if(next)
-                {
-                    delete next;
-                }
             }
 
+            void read(PatchFunc, void*) override;
+            void throwException(UserExceptionFactory) override;
+
+            void startInstance(SliceType) override;
+            SlicedDataPtr endInstance() override;
+            void startSlice() override;
+            void endSlice() override;
+            void skipSlice() override;
+
+            void readPendingValues() override;
+
+        private:
+            void readInstance();
+
             // Instance attributes
-            SliceType sliceType;
-            bool skipFirstSlice;
-            SliceInfoSeq slices; // Preserved slices.
-            IndexListList indirectionTables;
+            SliceType _sliceType{NoSlice};
+            bool _skipFirstSlice{false};
 
             // Slice attributes
-            Byte sliceFlags;
-            Int sliceSize;
-            std::string typeId;
-            int compactId;
-            IndirectPatchList indirectPatchList;
-
-            InstanceData* previous;
-            InstanceData* next;
+            std::int32_t _sliceSize{0};
+            std::string _typeId;
         };
-        InstanceData _preAllocatedInstanceData;
-        InstanceData* _current;
 
-        void push(SliceType sliceType)
+        class ICE_API EncapsDecoder11 : public EncapsDecoder
         {
-            if(!_current)
+        public:
+            EncapsDecoder11(InputStream* stream, Encaps* encaps, std::int32_t classGraphDepthMax)
+                : EncapsDecoder(stream, encaps, classGraphDepthMax),
+                  _preAllocatedInstanceData(nullptr)
             {
-                _current = &_preAllocatedInstanceData;
             }
-            else
+
+            void read(PatchFunc, void*) override;
+            void throwException(UserExceptionFactory) override;
+
+            void startInstance(SliceType) override;
+            SlicedDataPtr endInstance() override;
+            void startSlice() override;
+            void endSlice() override;
+            void skipSlice() override;
+
+            bool readOptional(std::int32_t, OptionalFormat) override;
+
+        private:
+            std::int32_t readInstance(std::int32_t, const PatchFunc&, void*);
+            SlicedDataPtr readSlicedData();
+
+            struct IndirectPatchEntry
             {
-                _current = _current->next ? _current->next : new InstanceData(_current);
-            }
-            _current->sliceType = sliceType;
-            _current->skipFirstSlice = false;
-        }
+                std::int32_t index;
+                PatchFunc patchFunc;
+                void* patchAddr;
+            };
+            using IndirectPatchList = std::vector<IndirectPatchEntry>;
 
-        Int _valueIdIndex; // The ID of the next value to unmarshal.
-    };
+            using IndexList = std::vector<std::int32_t>;
+            using IndexListList = std::vector<IndexList>;
 
-    class Encaps : private ::IceUtil::noncopyable
-    {
-    public:
+            struct InstanceData
+            {
+                InstanceData(InstanceData* p) : previous(p)
+                {
+                    if (previous)
+                    {
+                        previous->next = this;
+                    }
+                }
 
-        Encaps() : start(0), decoder(0), previous(0)
-        {
-            // Inlined for performance reasons.
-        }
-        ~Encaps()
-        {
-            // Inlined for performance reasons.
-            delete decoder;
-        }
-        void reset()
-        {
-            // Inlined for performance reasons.
-            delete decoder;
-            decoder = 0;
+                ~InstanceData()
+                {
+                    if (next)
+                    {
+                        delete next;
+                    }
+                }
 
-            previous = 0;
-        }
+                // Instance attributes
+                SliceType sliceType{NoSlice};
+                bool skipFirstSlice{false};
+                SliceInfoSeq slices; // Preserved slices.
+                IndexListList indirectionTables;
+
+                // Slice attributes
+                std::uint8_t sliceFlags{0};
+                std::int32_t sliceSize{0};
+                std::string typeId;
+                int compactId{-1};
+                IndirectPatchList indirectPatchList;
+
+                InstanceData* previous{nullptr};
+                InstanceData* next{nullptr};
+            };
+            InstanceData _preAllocatedInstanceData;
+            InstanceData* _current{nullptr};
+
+            void push(SliceType sliceType)
+            {
+                if (!_current)
+                {
+                    _current = &_preAllocatedInstanceData;
+                }
+                else
+                {
+                    _current = _current->next ? _current->next : new InstanceData(_current);
+                }
+                _current->sliceType = sliceType;
+                _current->skipFirstSlice = false;
+            }
 
-        Container::size_type start;
-        Int sz;
-        EncodingVersion encoding;
+            std::int32_t _valueIdIndex{1}; // The ID of the next value to unmarshal.
+        };
 
-        EncapsDecoder* decoder;
+        class Encaps
+        {
+        public:
+            Encaps() = default;
+            Encaps(const Encaps&) = delete;
+            ~Encaps() { delete decoder; }
+            Encaps& operator=(const Encaps&) = delete;
 
-        Encaps* previous;
-    };
+            void reset()
+            {
+                // Inlined for performance reasons.
+                delete decoder;
+                decoder = nullptr;
 
-    //
-    // Optimization. The instance may not be deleted while a
-    // stack-allocated stream still holds it.
-    //
-    IceInternal::Instance* _instance;
+                previous = nullptr;
+            }
 
-    //
-    // The encoding version to use when there's no encapsulation to
-    // read from. This is for example used to read message headers.
-    //
-    EncodingVersion _encoding;
+            Container::size_type start{0};
+            std::int32_t sz;
+            EncodingVersion encoding;
 
-    Encaps* _currentEncaps;
+            EncapsDecoder* decoder{nullptr};
 
-    void initEncaps();
+            Encaps* previous{nullptr};
+        };
 
-    Encaps _preAllocatedEncaps;
+        // Optimization. The instance may not be deleted while a stack-allocated stream still holds it.
+        IceInternal::Instance* const _instance;
 
-#ifndef ICE_CPP11_MAPPING
-    bool _collectObjects;
-#endif
+        //
+        // The encoding version to use when there's no encapsulation to
+        // read from. This is for example used to read message headers.
+        //
+        EncodingVersion _encoding;
 
-    bool _traceSlicing;
+        Encaps* _currentEncaps{nullptr};
 
-    size_t _classGraphDepthMax;
+        void initEncaps();
 
-    void* _closure;
+        Encaps _preAllocatedEncaps;
 
-    bool _sliceValues;
+        // Retrieved during construction and cached.
+        const std::int32_t _classGraphDepthMax;
 
-    int _startSeq;
-    int _minSeqSize;
+        void* _closure{nullptr};
 
-    ValueFactoryManagerPtr _valueFactoryManager;
-    LoggerPtr _logger;
-#ifdef ICE_CPP11_MAPPING
-    std::function<std::string(int)> _compactIdResolver;
-#else
-    CompactIdResolverPtr _compactIdResolver;
-#endif
+        int _startSeq{-1};
+        int _minSeqSize{0};
 
-#ifdef ICE_CPP11_MAPPING
-    std::vector<std::function<void()>> _deleters;
-#endif
+        const SliceLoaderPtr _sliceLoader; // never null
 
-};
+        std::vector<std::function<void()>> _deleters;
+    };
 
 } // End namespace Ice