zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/InputStream.cpp

@@ -1,190 +1,163 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <IceUtil/DisableWarnings.h>
-#include <Ice/InputStream.h>
-#include <Ice/DefaultsAndOverrides.h>
-#include <Ice/Instance.h>
-#include <Ice/Object.h>
-#include <Ice/Proxy.h>
-#include <Ice/ProxyFactory.h>
-#include <Ice/ValueFactory.h>
-#include <Ice/UserExceptionFactory.h>
-#include <Ice/LocalException.h>
-#include <Ice/Protocol.h>
-#include <Ice/FactoryTableInit.h>
-#include <Ice/TraceUtil.h>
-#include <Ice/TraceLevels.h>
-#include <Ice/LoggerUtil.h>
-#include <Ice/SlicedData.h>
-#include <Ice/StringConverter.h>
-#include <iterator>
-
-#ifndef ICE_UNALIGNED
-#   if defined(__i386) || defined(_M_IX86) || defined(__x86_64) || defined(_M_X64)
-#       define ICE_UNALIGNED
-#   endif
-#endif
+// Copyright (c) ZeroC, Inc.
+
+#include "Ice/InputStream.h"
+#include "DefaultsAndOverrides.h"
+#include "Endian.h"
+#include "Ice/DefaultSliceLoader.h" // temporary
+#include "Ice/LocalExceptions.h"
+#include "Ice/SlicedData.h"
+#include "Ice/StringConverter.h"
+#include "Ice/UserExceptionFactory.h"
+#include "Instance.h"
+#include "ReferenceFactory.h"
+#include "TraceLevels.h"
+#include "TraceUtil.h"
+
+#include "DisableWarnings.h"
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-Ice::InputStream::InputStream()
-{
-    initialize(currentEncoding);
-}
-
-Ice::InputStream::InputStream(const vector<Byte>& v) :
-    Buffer(v)
-{
-    initialize(currentEncoding);
-}
-
-Ice::InputStream::InputStream(const pair<const Byte*, const Byte*>& p) :
-    Buffer(p.first, p.second)
-{
-    initialize(currentEncoding);
-}
-
-Ice::InputStream::InputStream(Buffer& buf, bool adopt) :
-    Buffer(buf, adopt)
-{
-    initialize(currentEncoding);
-}
-
-Ice::InputStream::InputStream(const CommunicatorPtr& communicator)
-{
-    initialize(communicator);
-}
-
-Ice::InputStream::InputStream(const CommunicatorPtr& communicator, const vector<Byte>& v) :
-    Buffer(v)
-{
-    initialize(communicator);
-}
-
-Ice::InputStream::InputStream(const CommunicatorPtr& communicator, const pair<const Byte*, const Byte*>& p) :
-    Buffer(p.first, p.second)
+namespace
 {
-    initialize(communicator);
+    const char* endOfBufferMessage = "attempting to unmarshal past the end of the buffer";
 }
 
-Ice::InputStream::InputStream(const CommunicatorPtr& communicator, Buffer& buf, bool adopt) :
-    Buffer(buf, adopt)
+void
+IceInternal::Ex::throwUOE(const char* file, int line, const string& expectedType, const ValuePtr& v)
 {
-    initialize(communicator);
-}
+    UnknownSlicedValuePtr usv = dynamic_pointer_cast<UnknownSlicedValue>(v);
+    if (usv)
+    {
+        throw MarshalException{
+            file,
+            line,
+            "the Slice loader did not find a class for type ID '" + string{usv->ice_id()} + "'"};
+    }
 
-Ice::InputStream::InputStream(const EncodingVersion& encoding)
-{
-    initialize(encoding);
-}
+    string type = v->ice_id();
 
-Ice::InputStream::InputStream(const EncodingVersion& encoding, const vector<Byte>& v) :
-    Buffer(v)
-{
-    initialize(encoding);
+    throw MarshalException{
+        file,
+        line,
+        "failed to unmarshal class with type ID '" + expectedType +
+            "': the Slice loader returned a class with type ID '" + type + "'"};
 }
 
-Ice::InputStream::InputStream(const EncodingVersion& encoding, const pair<const Byte*, const Byte*>& p) :
-    Buffer(p.first, p.second)
+void
+IceInternal::Ex::throwMemoryLimitException(const char* file, int line, size_t requested, int32_t maximum)
 {
-    initialize(encoding);
+    throw MarshalException{
+        file,
+        line,
+        "cannot unmarshal Ice message: the message size of " + to_string(requested) +
+            " bytes exceeds the maximum allowed of " + to_string(maximum) + " bytes (see Ice.MessageSizeMax)."};
 }
 
-Ice::InputStream::InputStream(const EncodingVersion& encoding, Buffer& buf, bool adopt) :
-    Buffer(buf, adopt)
+void
+IceInternal::Ex::throwMarshalException(const char* file, int line, string reason)
 {
-    initialize(encoding);
+    throw Ice::MarshalException{file, line, std::move(reason)};
 }
 
-Ice::InputStream::InputStream(const CommunicatorPtr& communicator, const EncodingVersion& encoding)
+Ice::InputStream::InputStream(Instance* instance, EncodingVersion encoding, SliceLoaderPtr sliceLoader)
+    : InputStream{instance, encoding, Buffer{}, std::move(sliceLoader)}
 {
-    initialize(communicator, encoding);
 }
 
-Ice::InputStream::InputStream(const CommunicatorPtr& communicator, const EncodingVersion& encoding,
-                              const vector<Byte>& v) :
-    Buffer(v)
+Ice::InputStream::InputStream(const CommunicatorPtr& communicator, const vector<byte>& v, SliceLoaderPtr sliceLoader)
+    : InputStream{
+          getInstance(communicator).get(),
+          getInstance(communicator)->defaultsAndOverrides()->defaultEncoding,
+          Buffer{v},
+          std::move(sliceLoader)}
 {
-    initialize(communicator, encoding);
 }
 
-Ice::InputStream::InputStream(const CommunicatorPtr& communicator, const EncodingVersion& encoding,
-                              const pair<const Byte*, const Byte*>& p) :
-    Buffer(p.first, p.second)
+Ice::InputStream::InputStream(
+    const CommunicatorPtr& communicator,
+    pair<const byte*, const byte*> p,
+    SliceLoaderPtr sliceLoader)
+    : InputStream{
+          getInstance(communicator).get(),
+          getInstance(communicator)->defaultsAndOverrides()->defaultEncoding,
+          Buffer{p.first, p.second},
+          std::move(sliceLoader)}
 {
-    initialize(communicator, encoding);
 }
 
-Ice::InputStream::InputStream(const CommunicatorPtr& communicator, const EncodingVersion& encoding,
-                              Buffer& buf, bool adopt) :
-    Buffer(buf, adopt)
+Ice::InputStream::InputStream(
+    const CommunicatorPtr& communicator,
+    EncodingVersion encoding,
+    const vector<byte>& v,
+    SliceLoaderPtr sliceLoader)
+    : InputStream{getInstance(communicator).get(), encoding, Buffer{v}, std::move(sliceLoader)}
 {
-    initialize(communicator, encoding);
 }
 
-Ice::InputStream::InputStream(Instance* instance, const EncodingVersion& encoding)
+Ice::InputStream::InputStream(
+    const CommunicatorPtr& communicator,
+    EncodingVersion encoding,
+    pair<const byte*, const byte*> p,
+    SliceLoaderPtr sliceLoader)
+    : InputStream{getInstance(communicator).get(), encoding, Buffer{p.first, p.second}, std::move(sliceLoader)}
 {
-    initialize(instance, encoding);
 }
 
-Ice::InputStream::InputStream(Instance* instance, const EncodingVersion& encoding, Buffer& buf, bool adopt) :
-    Buffer(buf, adopt)
+Ice::InputStream::InputStream(
+    Instance* instance,
+    EncodingVersion encoding,
+    Buffer& buf,
+    bool adopt,
+    SliceLoaderPtr sliceLoader)
+    : InputStream{instance, encoding, Buffer{buf, adopt}, std::move(sliceLoader)}
 {
-    initialize(instance, encoding);
 }
 
-void
-Ice::InputStream::initialize(const CommunicatorPtr& communicator)
+Ice::InputStream::InputStream(InputStream&& other) noexcept
+    // only moves (and resets) the base class
+    : InputStream{other._instance, other._encoding, std::move(other), other._sliceLoader}
 {
-    Instance* instance = getInstance(communicator).get();
-    initialize(instance, instance->defaultsAndOverrides()->defaultEncoding);
-}
+    _closure = other._closure;
+    _startSeq = other._startSeq;
+    _minSeqSize = other._minSeqSize;
 
-void
-Ice::InputStream::initialize(const CommunicatorPtr& communicator, const EncodingVersion& encoding)
-{
-    initialize(getInstance(communicator).get(), encoding);
+    // Reset other to its default state
+    other.resetEncapsulation();
+    other._closure = nullptr;
+    other._startSeq = -1;
+    other._minSeqSize = 0;
 }
 
-void
-Ice::InputStream::initialize(Instance* instance, const EncodingVersion& encoding)
+InputStream&
+Ice::InputStream::operator=(InputStream&& other) noexcept
 {
-    initialize(encoding);
+    assert(_instance == other._instance);
 
-    _instance = instance;
+    if (this != &other)
+    {
+        Buffer::operator=(std::move(other)); // only moves (and resets) the base class
 
-#ifndef ICE_CPP11_MAPPING
-    _collectObjects = _instance->collectObjects();
-#endif
-    _traceSlicing = _instance->traceLevels()->slicing > 0;
-    _classGraphDepthMax = _instance->classGraphDepthMax();
-}
+        _encoding = other._encoding;
+        _closure = other._closure;
+        _startSeq = other._startSeq;
+        _minSeqSize = other._minSeqSize;
+        resetEncapsulation();
 
-void
-Ice::InputStream::initialize(const EncodingVersion& encoding)
-{
-    _instance = 0;
-    _encoding = encoding;
-    _currentEncaps = 0;
-#ifndef ICE_CPP11_MAPPING
-    _collectObjects = false;
-#endif
-    _traceSlicing = false;
-    _classGraphDepthMax = 0x7fffffff;
-    _closure = 0;
-    _sliceValues = true;
-    _startSeq = -1;
-    _minSeqSize = 0;
+        // Reset other to its default state.
+        other.resetEncapsulation();
+        other._closure = nullptr;
+        other._startSeq = -1;
+        other._minSeqSize = 0;
+    }
+    return *this;
 }
 
 void
 Ice::InputStream::clear()
 {
-    while(_currentEncaps && _currentEncaps != &_preAllocatedEncaps)
+    while (_currentEncaps && _currentEncaps != &_preAllocatedEncaps)
     {
         Encaps* oldEncaps = _currentEncaps;
         _currentEncaps = _currentEncaps->previous;
@@ -192,62 +165,6 @@ Ice::InputStream::clear()
     }
 
     _startSeq = -1;
-    _sliceValues = true;
-}
-
-void
-Ice::InputStream::setValueFactoryManager(const ValueFactoryManagerPtr& vfm)
-{
-    _valueFactoryManager = vfm;
-}
-
-void
-Ice::InputStream::setLogger(const LoggerPtr& logger)
-{
-    _logger = logger;
-}
-
-void
-#ifdef ICE_CPP11_MAPPING
-Ice::InputStream::setCompactIdResolver(std::function<std::string(int)> r)
-#else
-Ice::InputStream::setCompactIdResolver(const CompactIdResolverPtr& r)
-#endif
-{
-    _compactIdResolver = r;
-}
-
-#ifndef ICE_CPP11_MAPPING
-void
-Ice::InputStream::setCollectObjects(bool on)
-{
-    _collectObjects = on;
-}
-#endif
-
-void
-Ice::InputStream::setSliceValues(bool on)
-{
-    _sliceValues = on;
-}
-
-void
-Ice::InputStream::setTraceSlicing(bool on)
-{
-    _traceSlicing = on;
-}
-
-void
-Ice::InputStream::setClassGraphDepthMax(size_t classGraphDepthMax)
-{
-    if(classGraphDepthMax < 1)
-    {
-        _classGraphDepthMax = 0x7fffffff;
-    }
-    else
-    {
-        _classGraphDepthMax = classGraphDepthMax;
-    }
 }
 
 void*
@@ -265,19 +182,16 @@ Ice::InputStream::setClosure(void* p)
 }
 
 void
-Ice::InputStream::swap(InputStream& other)
+Ice::InputStream::swap(InputStream& other) noexcept
 {
+    assert(_instance == other._instance);
+
     swapBuffer(other);
 
-    std::swap(_instance, other._instance);
     std::swap(_encoding, other._encoding);
-#ifndef ICE_CPP11_MAPPING
-    std::swap(_collectObjects, other._collectObjects);
-#endif
-    std::swap(_traceSlicing, other._traceSlicing);
-    std::swap(_classGraphDepthMax, other._classGraphDepthMax);
     std::swap(_closure, other._closure);
-    std::swap(_sliceValues, other._sliceValues);
+    std::swap(_startSeq, other._startSeq);
+    std::swap(_minSeqSize, other._minSeqSize);
 
     //
     // Swap is never called for streams that have encapsulations being read. However,
@@ -286,19 +200,12 @@ Ice::InputStream::swap(InputStream& other)
     //
     resetEncapsulation();
     other.resetEncapsulation();
-
-    std::swap(_startSeq, other._startSeq);
-    std::swap(_minSeqSize, other._minSeqSize);
-
-    std::swap(_valueFactoryManager, other._valueFactoryManager);
-    std::swap(_logger, other._logger);
-    std::swap(_compactIdResolver, other._compactIdResolver);
 }
 
 void
 Ice::InputStream::resetEncapsulation()
 {
-    while(_currentEncaps && _currentEncaps != &_preAllocatedEncaps)
+    while (_currentEncaps && _currentEncaps != &_preAllocatedEncaps)
     {
         Encaps* oldEncaps = _currentEncaps;
         _currentEncaps = _currentEncaps->previous;
@@ -308,41 +215,178 @@ Ice::InputStream::resetEncapsulation()
     _preAllocatedEncaps.reset();
 }
 
-Int
+const EncodingVersion&
+Ice::InputStream::startEncapsulation()
+{
+    Encaps* oldEncaps = _currentEncaps;
+    if (!oldEncaps) // First allocated encaps?
+    {
+        _currentEncaps = &_preAllocatedEncaps;
+    }
+    else
+    {
+        _currentEncaps = new Encaps();
+        _currentEncaps->previous = oldEncaps;
+    }
+    _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.
+    //
+    std::int32_t sz;
+    read(sz);
+    if (sz < 6)
+    {
+        throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+    }
+    if (i - sizeof(std::int32_t) + sz > b.end())
+    {
+        throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+    }
+    _currentEncaps->sz = sz;
+
+    read(_currentEncaps->encoding);
+    IceInternal::checkSupportedEncoding(_currentEncaps->encoding); // Make sure the encoding is supported
+
+    return _currentEncaps->encoding;
+}
+
+void
+Ice::InputStream::endEncapsulation()
+{
+    assert(_currentEncaps);
+
+    if (_currentEncaps->encoding != Encoding_1_0)
+    {
+        skipOptionals();
+        if (i != b.begin() + _currentEncaps->start + _currentEncaps->sz)
+        {
+            throw MarshalException{__FILE__, __LINE__, "failed to unmarshal encapsulation"};
+        }
+    }
+    else if (i != b.begin() + _currentEncaps->start + _currentEncaps->sz)
+    {
+        if (i + 1 != b.begin() + _currentEncaps->start + _currentEncaps->sz)
+        {
+            throw MarshalException{__FILE__, __LINE__, "failed to unmarshal encapsulation"};
+        }
+
+        //
+        // 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;
+    }
+
+    Encaps* oldEncaps = _currentEncaps;
+    _currentEncaps = _currentEncaps->previous;
+    if (oldEncaps == &_preAllocatedEncaps)
+    {
+        oldEncaps->reset();
+    }
+    else
+    {
+        delete oldEncaps;
+    }
+}
+
+EncodingVersion
+Ice::InputStream::skipEmptyEncapsulation()
+{
+    std::int32_t sz;
+    read(sz);
+    if (sz < 6)
+    {
+        throw MarshalException{__FILE__, __LINE__, to_string(sz) + " is not a valid encapsulation size"};
+    }
+    if (i - sizeof(std::int32_t) + sz > b.end())
+    {
+        throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+    }
+    Ice::EncodingVersion encoding;
+    read(encoding);
+    IceInternal::checkSupportedEncoding(encoding); // Make sure the encoding is supported
+
+    if (encoding == Ice::Encoding_1_0)
+    {
+        if (sz != static_cast<std::int32_t>(sizeof(std::int32_t)) + 2)
+        {
+            throw MarshalException{
+                __FILE__,
+                __LINE__,
+                to_string(sz) + " is not a valid encapsulation size for a 1.0 empty encapsulation"};
+        }
+    }
+    else
+    {
+        // Skip the optional content of the encapsulation if we are expecting an
+        // empty encapsulation.
+        i += static_cast<size_t>(sz) - sizeof(std::int32_t) - 2;
+    }
+    return encoding;
+}
+
+EncodingVersion
+Ice::InputStream::readEncapsulation(const std::byte*& v, std::int32_t& sz)
+{
+    EncodingVersion encoding;
+    v = i;
+    read(sz);
+    if (sz < 6)
+    {
+        throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+    }
+    if (i - sizeof(std::int32_t) + sz > b.end())
+    {
+        throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+    }
+
+    read(encoding);
+    i += static_cast<size_t>(sz) - sizeof(std::int32_t) - 2;
+    return encoding;
+}
+
+int32_t
 Ice::InputStream::getEncapsulationSize()
 {
     assert(_currentEncaps);
-    return _currentEncaps->sz - static_cast<Int>(sizeof(Int)) - 2;
+    return _currentEncaps->sz - static_cast<int32_t>(sizeof(int32_t)) - 2;
 }
 
 EncodingVersion
 Ice::InputStream::skipEncapsulation()
 {
-    Int sz;
+    int32_t sz;
     read(sz);
-    if(sz < 6)
+    if (sz < 6)
     {
-        throw UnmarshalOutOfBoundsException(__FILE__, __LINE__);
+        throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
-    if(i - sizeof(Int) + sz > b.end())
+    if (i - sizeof(int32_t) + sz > b.end())
     {
-        throw UnmarshalOutOfBoundsException(__FILE__, __LINE__);
+        throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
     EncodingVersion encoding;
     read(encoding.major);
     read(encoding.minor);
-    i += static_cast<size_t>(sz) - sizeof(Int) - 2;
+    i += static_cast<size_t>(sz) - sizeof(int32_t) - 2;
     return encoding;
 }
 
 void
 Ice::InputStream::readPendingValues()
 {
-    if(_currentEncaps && _currentEncaps->decoder)
+    if (_currentEncaps && _currentEncaps->decoder)
     {
         _currentEncaps->decoder->readPendingValues();
     }
-    else if(getEncoding() == Ice::Encoding_1_0)
+    else if (getEncoding() == Ice::Encoding_1_0)
     {
         //
         // If using the 1.0 encoding and no instances were read, we
@@ -357,12 +401,12 @@ Ice::InputStream::readPendingValues()
     }
 }
 
-Int
+int32_t
 Ice::InputStream::readAndCheckSeqSize(int minSize)
 {
-    Int sz = readSize();
+    int32_t sz = readSize();
 
-    if(sz == 0)
+    if (sz == 0)
     {
         return sz;
     }
@@ -379,12 +423,12 @@ Ice::InputStream::readAndCheckSeqSize(int minSize)
     // _minSeqSize by the minimum size that this sequence will require on
     // the stream.
     //
-    // The goal of this check is to ensure that when we start un-marshalling
+    // The goal of this check is to ensure that when we start un-marshaling
     // a new sequence, we check the minimal size of this new sequence against
     // the estimated remaining buffer size. This estimation is based on
     // the minimum size of the enclosing sequences, it's _minSeqSize.
     //
-    if(_startSeq == -1 || i > (b.begin() + _startSeq + _minSeqSize))
+    if (_startSeq == -1 || i > (b.begin() + _startSeq + _minSeqSize))
     {
         _startSeq = static_cast<int>(i - b.begin());
         _minSeqSize = sz * minSize;
@@ -396,27 +440,27 @@ Ice::InputStream::readAndCheckSeqSize(int minSize)
 
     //
     // If there isn't enough data to read on the stream for the sequence (and
-    // possibly enclosed sequences), something is wrong with the marshalled
+    // possibly enclosed sequences), something is wrong with the marshaled
     // data: it's claiming having more data that what is possible to read.
     //
-    if(_startSeq + _minSeqSize > static_cast<int>(b.size()))
+    if (_startSeq + _minSeqSize > static_cast<int>(b.size()))
     {
-        throw UnmarshalOutOfBoundsException(__FILE__, __LINE__);
+        throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
 
     return sz;
 }
 
 void
-Ice::InputStream::readBlob(vector<Byte>& v, Int sz)
+Ice::InputStream::readBlob(vector<byte>& v, int32_t sz)
 {
-    if(sz > 0)
+    if (sz > 0)
     {
-        if(b.end() - i < sz)
+        if (b.end() - i < sz)
         {
-            throw UnmarshalOutOfBoundsException(__FILE__, __LINE__);
+            throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
         }
-        vector<Byte>(i, i + sz).swap(v);
+        vector<byte>(i, i + sz).swap(v);
         i += sz;
     }
     else
@@ -426,11 +470,11 @@ Ice::InputStream::readBlob(vector<Byte>& v, Int sz)
 }
 
 void
-Ice::InputStream::read(std::vector<Ice::Byte>& v)
+Ice::InputStream::read(std::vector<byte>& v)
 {
-    std::pair<const Ice::Byte*, const Ice::Byte*> p;
+    std::pair<const byte*, const byte*> p;
     read(p);
-    if(p.first != p.second)
+    if (p.first != p.second)
     {
         v.resize(static_cast<size_t>(p.second - p.first));
         copy(p.first, p.second, v.begin());
@@ -442,10 +486,10 @@ Ice::InputStream::read(std::vector<Ice::Byte>& v)
 }
 
 void
-Ice::InputStream::read(pair<const Byte*, const Byte*>& v)
+Ice::InputStream::read(pair<const byte*, const byte*>& v)
 {
-    Int sz = readAndCheckSeqSize(1);
-    if(sz > 0)
+    int32_t sz = readAndCheckSeqSize(1);
+    if (sz > 0)
     {
         v.first = i;
         v.second = i + sz;
@@ -460,11 +504,11 @@ Ice::InputStream::read(pair<const Byte*, const Byte*>& v)
 void
 Ice::InputStream::read(vector<bool>& v)
 {
-    Int sz = readAndCheckSeqSize(1);
-    if(sz > 0)
+    int32_t sz = readAndCheckSeqSize(1);
+    if (sz > 0)
     {
         v.resize(static_cast<size_t>(sz));
-        copy(i, i + sz, v.begin());
+        copy(reinterpret_cast<uint8_t*>(i), reinterpret_cast<uint8_t*>(i) + sz, v.begin());
         i += sz;
     }
     else
@@ -475,47 +519,42 @@ Ice::InputStream::read(vector<bool>& v)
 
 namespace
 {
-
-template<size_t boolSize>
-struct ReadBoolHelper
-{
-    static bool* read(pair<const bool*, const bool*>& v, Int sz, InputStream::Container::iterator& i)
+    template<size_t boolSize> struct ReadBoolHelper
     {
-        bool* array = new bool[static_cast<size_t>(sz)];
-        for(int idx = 0; idx < sz; ++idx)
+        static bool* read(pair<const bool*, const bool*>& v, int32_t sz, InputStream::Container::iterator& i)
         {
-            array[idx] = static_cast<bool>(*(i + idx));
+            bool* array = new bool[static_cast<size_t>(sz)];
+            for (int idx = 0; idx < sz; ++idx)
+            {
+                array[idx] = static_cast<bool>(*(i + idx));
+            }
+            v.first = array;
+            v.second = array + sz;
+            return array;
         }
-        v.first = array;
-        v.second = array + sz;
-        return array;
-    }
-};
+    };
 
-template<>
-struct ReadBoolHelper<1>
-{
-    static bool* read(pair<const bool*, const bool*>& v, Int sz, InputStream::Container::iterator& i)
+    template<> struct ReadBoolHelper<1>
     {
-        v.first = reinterpret_cast<bool*>(i);
-        v.second = reinterpret_cast<bool*>(i) + sz;
-        return 0;
-    }
-};
-
+        static bool* read(pair<const bool*, const bool*>& v, int32_t sz, InputStream::Container::iterator& i)
+        {
+            v.first = reinterpret_cast<bool*>(i);
+            v.second = reinterpret_cast<bool*>(i) + sz;
+            return nullptr;
+        }
+    };
 }
 
-#ifdef ICE_CPP11_MAPPING
 void
 Ice::InputStream::read(pair<const bool*, const bool*>& v)
 {
-    Int sz = readAndCheckSeqSize(1);
-    if(sz > 0)
+    int32_t sz = readAndCheckSeqSize(1);
+    if (sz > 0)
     {
         auto boolArray = ReadBoolHelper<sizeof(bool)>::read(v, sz, i);
-        if(boolArray)
+        if (boolArray)
         {
-            _deleters.push_back([boolArray] { delete[] boolArray; });
+            _deleters.emplace_back([boolArray] { delete[] boolArray; });
         }
         i += sz;
     }
@@ -525,65 +564,53 @@ Ice::InputStream::read(pair<const bool*, const bool*>& v)
     }
 }
 
-#else
 void
-Ice::InputStream::read(pair<const bool*, const bool*>& v, IceUtil::ScopedArray<bool>& result)
+Ice::InputStream::read(int16_t& v)
 {
-    Int sz = readAndCheckSeqSize(1);
-    if(sz > 0)
+    if (b.end() - i < static_cast<int>(sizeof(int16_t)))
     {
-        result.reset(ReadBoolHelper<sizeof(bool)>::read(v, sz, i));
-        i += sz;
+        throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
-    else
+    const byte* src = &(*i);
+    i += sizeof(int16_t);
+    if constexpr (endian::native == endian::big)
     {
-        result.reset();
-        v.first = v.second = reinterpret_cast<bool*>(i);
+        byte* dest = reinterpret_cast<byte*>(&v) + sizeof(int16_t) - 1;
+        *dest-- = *src++;
+        *dest = *src;
     }
-}
-#endif
-
-void
-Ice::InputStream::read(Short& v)
-{
-    if(b.end() - i < static_cast<int>(sizeof(Short)))
+    else
     {
-        throw UnmarshalOutOfBoundsException(__FILE__, __LINE__);
+        byte* dest = reinterpret_cast<byte*>(&v);
+        *dest++ = *src++;
+        *dest = *src;
     }
-    const Byte* src = &(*i);
-    i += sizeof(Short);
-#ifdef ICE_BIG_ENDIAN
-    Byte* dest = reinterpret_cast<Byte*>(&v) + sizeof(Short) - 1;
-    *dest-- = *src++;
-    *dest = *src;
-#else
-    Byte* dest = reinterpret_cast<Byte*>(&v);
-    *dest++ = *src++;
-    *dest = *src;
-#endif
 }
 
 void
-Ice::InputStream::read(vector<Short>& v)
+Ice::InputStream::read(vector<int16_t>& v)
 {
-    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Short)));
-    if(sz > 0)
+    int32_t sz = readAndCheckSeqSize(static_cast<int>(sizeof(int16_t)));
+    if (sz > 0)
     {
         Container::iterator begin = i;
-        i += sz * static_cast<int>(sizeof(Short));
+        i += sz * static_cast<int>(sizeof(int16_t));
         v.resize(static_cast<size_t>(sz));
-#ifdef ICE_BIG_ENDIAN
-        const Byte* src = &(*begin);
-        Byte* dest = reinterpret_cast<Byte*>(&v[0]) + sizeof(Short) - 1;
-        for(int j = 0 ; j < sz ; ++j)
+        if constexpr (endian::native == endian::big)
+        {
+            const byte* src = &(*begin);
+            byte* dest = reinterpret_cast<byte*>(&v[0]) + sizeof(int16_t) - 1;
+            for (int j = 0; j < sz; ++j)
+            {
+                *dest-- = *src++;
+                *dest-- = *src++;
+                dest += 2 * sizeof(int16_t);
+            }
+        }
+        else
         {
-            *dest-- = *src++;
-            *dest-- = *src++;
-            dest += 2 * sizeof(Short);
+            copy(begin, i, reinterpret_cast<byte*>(&v[0]));
         }
-#else
-        copy(begin, i, reinterpret_cast<Byte*>(&v[0]));
-#endif
     }
     else
     {
@@ -591,81 +618,59 @@ Ice::InputStream::read(vector<Short>& v)
     }
 }
 
-#ifdef ICE_CPP11_MAPPING
 void
-Ice::InputStream::read(pair<const short*, const short*>& v)
-#else
-void
-Ice::InputStream::read(pair<const Short*, const Short*>& v, IceUtil::ScopedArray<Short>& result)
-#endif
-{
-    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Short)));
-    if(sz > 0)
-    {
-#ifdef ICE_UNALIGNED
-        v.first = reinterpret_cast<Short*>(i);
-        i += sz * static_cast<int>(sizeof(Short));
-        v.second = reinterpret_cast<Short*>(i);
-#else
-#  ifdef ICE_CPP11_MAPPING
-        auto result = new short[static_cast<size_t>(sz)];
-        _deleters.push_back([result] { delete[] result; });
-        v.first = result;
-        v.second = result + sz;
-#  else
-        result.reset(new Short[static_cast<size_t>(sz)]);
-        v.first = result.get();
-        v.second = result.get() + sz;
-#   endif
-
-        Container::iterator begin = i;
-        i += sz * static_cast<int>(sizeof(Short));
-#  ifdef ICE_BIG_ENDIAN
-        const Byte* src = &(*begin);
-        Byte* dest = reinterpret_cast<Byte*>(&result[0]) + sizeof(Short) - 1;
-        for(int j = 0 ; j < sz ; ++j)
-        {
-            *dest-- = *src++;
-            *dest-- = *src++;
-            dest += 2 * sizeof(Short);
-        }
-#  else
-        copy(begin, i, reinterpret_cast<Byte*>(&result[0]));
-#  endif
-#endif
+Ice::InputStream::read(int32_t& v)
+{
+    if (b.end() - i < static_cast<int>(sizeof(int32_t)))
+    {
+        throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+    }
+    const byte* src = &(*i);
+    i += sizeof(int32_t);
+    if constexpr (endian::native == endian::big)
+    {
+        byte* dest = reinterpret_cast<byte*>(&v) + sizeof(int32_t) - 1;
+        *dest-- = *src++;
+        *dest-- = *src++;
+        *dest-- = *src++;
+        *dest = *src;
     }
     else
     {
-#ifndef ICE_CPP11_MAPPING
-        result.reset();
-#endif
-        v.first = v.second = 0;
+        byte* dest = reinterpret_cast<byte*>(&v);
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest = *src;
     }
 }
 
 void
-Ice::InputStream::read(vector<Int>& v)
+Ice::InputStream::read(vector<int32_t>& v)
 {
-    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Int)));
-    if(sz > 0)
+    int32_t sz = readAndCheckSeqSize(static_cast<int>(sizeof(int32_t)));
+    if (sz > 0)
     {
         Container::iterator begin = i;
-        i += sz * static_cast<int>(sizeof(Int));
+        i += sz * static_cast<int>(sizeof(int32_t));
         v.resize(static_cast<size_t>(sz));
-#ifdef ICE_BIG_ENDIAN
-        const Byte* src = &(*begin);
-        Byte* dest = reinterpret_cast<Byte*>(&v[0]) + sizeof(Int) - 1;
-        for(int j = 0 ; j < sz ; ++j)
+        if constexpr (endian::native == endian::big)
+        {
+            const byte* src = &(*begin);
+            byte* dest = reinterpret_cast<byte*>(&v[0]) + sizeof(int32_t) - 1;
+            for (int j = 0; j < sz; ++j)
+            {
+                *dest-- = *src++;
+                *dest-- = *src++;
+                *dest-- = *src++;
+                *dest-- = *src++;
+                dest += 2 * sizeof(int32_t);
+            }
+        }
+        else
         {
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            dest += 2 * sizeof(Int);
+            copy(begin, i, reinterpret_cast<byte*>(&v[0]));
         }
-#else
-        copy(begin, i, reinterpret_cast<Byte*>(&v[0]));
-#endif
     }
     else
     {
@@ -673,120 +678,71 @@ Ice::InputStream::read(vector<Int>& v)
     }
 }
 
-#ifdef ICE_CPP11_MAPPING
-void
-Ice::InputStream::read(pair<const Int*, const Int*>& v)
-#else
 void
-Ice::InputStream::read(pair<const Int*, const Int*>& v, ::IceUtil::ScopedArray<Int>& result)
-#endif
-{
-    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Int)));
-    if(sz > 0)
-    {
-#ifdef ICE_UNALIGNED
-        v.first = reinterpret_cast<Int*>(i);
-        i += sz * static_cast<int>(sizeof(Int));
-        v.second = reinterpret_cast<Int*>(i);
-#else
-
-#  ifdef ICE_CPP11_MAPPING
-        auto result = new int[static_cast<size_t>(sz)];
-        _deleters.push_back([result] { delete[] result; });
-        v.first = result;
-        v.second = result + sz;
-#  else
-        result.reset(new Int[static_cast<size_t>(sz)]);
-        v.first = result.get();
-        v.second = result.get() + sz;
-#  endif
-
-        Container::iterator begin = i;
-        i += sz * static_cast<int>(sizeof(Int));
-#  ifdef ICE_BIG_ENDIAN
-        const Byte* src = &(*begin);
-        Byte* dest = reinterpret_cast<Byte*>(&result[0]) + sizeof(Int) - 1;
-        for(int j = 0 ; j < sz ; ++j)
-        {
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            dest += 2 * sizeof(Int);
-        }
-#  else
-        copy(begin, i, reinterpret_cast<Byte*>(&result[0]));
-#  endif
-#endif
+Ice::InputStream::read(int64_t& v)
+{
+    if (b.end() - i < static_cast<int>(sizeof(int64_t)))
+    {
+        throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+    }
+    const byte* src = &(*i);
+    i += sizeof(int64_t);
+    if constexpr (endian::native == endian::big)
+    {
+        byte* dest = reinterpret_cast<byte*>(&v) + sizeof(int64_t) - 1;
+        *dest-- = *src++;
+        *dest-- = *src++;
+        *dest-- = *src++;
+        *dest-- = *src++;
+        *dest-- = *src++;
+        *dest-- = *src++;
+        *dest-- = *src++;
+        *dest = *src;
     }
     else
     {
-#ifndef ICE_CPP11_MAPPING
-        result.reset();
-#endif
-        v.first = v.second = 0;
+        byte* dest = reinterpret_cast<byte*>(&v);
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest = *src;
     }
 }
 
 void
-Ice::InputStream::read(Long& v)
-{
-    if(b.end() - i < static_cast<int>(sizeof(Long)))
-    {
-        throw UnmarshalOutOfBoundsException(__FILE__, __LINE__);
-    }
-    const Byte* src = &(*i);
-    i += sizeof(Long);
-#ifdef ICE_BIG_ENDIAN
-    Byte* dest = reinterpret_cast<Byte*>(&v) + sizeof(Long) - 1;
-    *dest-- = *src++;
-    *dest-- = *src++;
-    *dest-- = *src++;
-    *dest-- = *src++;
-    *dest-- = *src++;
-    *dest-- = *src++;
-    *dest-- = *src++;
-    *dest = *src;
-#else
-    Byte* dest = reinterpret_cast<Byte*>(&v);
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest = *src;
-#endif
-}
-
-void
-Ice::InputStream::read(vector<Long>& v)
+Ice::InputStream::read(vector<int64_t>& v)
 {
-    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Long)));
-    if(sz > 0)
+    int32_t sz = readAndCheckSeqSize(static_cast<int>(sizeof(int64_t)));
+    if (sz > 0)
     {
         Container::iterator begin = i;
-        i += sz * static_cast<int>(sizeof(Long));
+        i += sz * static_cast<int>(sizeof(int64_t));
         v.resize(static_cast<size_t>(sz));
-#ifdef ICE_BIG_ENDIAN
-        const Byte* src = &(*begin);
-        Byte* dest = reinterpret_cast<Byte*>(&v[0]) + sizeof(Long) - 1;
-        for(int j = 0 ; j < sz ; ++j)
-        {
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            dest += 2 * sizeof(Long);
-        }
-#else
-        copy(begin, i, reinterpret_cast<Byte*>(&v[0]));
-#endif
+        if constexpr (endian::native == endian::big)
+        {
+            const byte* src = &(*begin);
+            byte* dest = reinterpret_cast<byte*>(&v[0]) + sizeof(int64_t) - 1;
+            for (int j = 0; j < sz; ++j)
+            {
+                *dest-- = *src++;
+                *dest-- = *src++;
+                *dest-- = *src++;
+                *dest-- = *src++;
+                *dest-- = *src++;
+                *dest-- = *src++;
+                *dest-- = *src++;
+                *dest-- = *src++;
+                dest += 2 * sizeof(int64_t);
+            }
+        }
+        else
+        {
+            copy(begin, i, reinterpret_cast<byte*>(&v[0]));
+        }
     }
     else
     {
@@ -794,112 +750,59 @@ Ice::InputStream::read(vector<Long>& v)
     }
 }
 
-#ifdef ICE_CPP11_MAPPING
-void
-Ice::InputStream::read(pair<const Long*, const Long*>& v)
-#else
 void
-Ice::InputStream::read(pair<const Long*, const Long*>& v, IceUtil::ScopedArray<Long>& result)
-#endif
-{
-    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Long)));
-    if(sz > 0)
-    {
-#ifdef ICE_UNALIGNED
-        v.first = reinterpret_cast<Long*>(i);
-        i += sz * static_cast<int>(sizeof(Long));
-        v.second = reinterpret_cast<Long*>(i);
-#else
-
-#  ifdef ICE_CPP11_MAPPING
-        auto result = new long long[static_cast<size_t>(sz)];
-        _deleters.push_back([result] { delete[] result; });
-        v.first = result;
-        v.second = result + sz;
-#  else
-        result.reset(new Long[static_cast<size_t>(sz)]);
-        v.first = result.get();
-        v.second = result.get() + sz;
-#  endif
-
-        Container::iterator begin = i;
-        i += sz * static_cast<int>(sizeof(Long));
-#  ifdef ICE_BIG_ENDIAN
-        const Byte* src = &(*begin);
-        Byte* dest = reinterpret_cast<Byte*>(&result[0]) + sizeof(Long) - 1;
-        for(int j = 0 ; j < sz ; ++j)
-        {
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            dest += 2 * sizeof(Long);
-        }
-#  else
-        copy(begin, i, reinterpret_cast<Byte*>(&result[0]));
-#  endif
-#endif
+Ice::InputStream::read(float& v)
+{
+    if (b.end() - i < static_cast<int>(sizeof(float)))
+    {
+        throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
-    else
+    const byte* src = &(*i);
+    i += sizeof(float);
+    if constexpr (endian::native == endian::big)
     {
-#ifndef ICE_CPP11_MAPPING
-        result.reset();
-#endif
-        v.first = v.second = 0;
+        byte* dest = reinterpret_cast<byte*>(&v) + sizeof(float) - 1;
+        *dest-- = *src++;
+        *dest-- = *src++;
+        *dest-- = *src++;
+        *dest = *src;
     }
-}
-
-void
-Ice::InputStream::read(Float& v)
-{
-    if(b.end() - i < static_cast<int>(sizeof(Float)))
+    else
     {
-        throw UnmarshalOutOfBoundsException(__FILE__, __LINE__);
+        byte* dest = reinterpret_cast<byte*>(&v);
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest = *src;
     }
-    const Byte* src = &(*i);
-    i += sizeof(Float);
-#ifdef ICE_BIG_ENDIAN
-    Byte* dest = reinterpret_cast<Byte*>(&v) + sizeof(Float) - 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
 }
 
 void
-Ice::InputStream::read(vector<Float>& v)
+Ice::InputStream::read(vector<float>& v)
 {
-    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Float)));
-    if(sz > 0)
+    int32_t sz = readAndCheckSeqSize(static_cast<int>(sizeof(float)));
+    if (sz > 0)
     {
         Container::iterator begin = i;
-        i += sz * static_cast<int>(sizeof(Float));
+        i += sz * static_cast<int>(sizeof(float));
         v.resize(static_cast<size_t>(sz));
-#ifdef ICE_BIG_ENDIAN
-        const Byte* src = &(*begin);
-        Byte* dest = reinterpret_cast<Byte*>(&v[0]) + sizeof(Float) - 1;
-        for(int j = 0 ; j < sz ; ++j)
+        if constexpr (endian::native == endian::big)
         {
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            dest += 2 * sizeof(Float);
+            const byte* src = &(*begin);
+            byte* dest = reinterpret_cast<byte*>(&v[0]) + sizeof(float) - 1;
+            for (int j = 0; j < sz; ++j)
+            {
+                *dest-- = *src++;
+                *dest-- = *src++;
+                *dest-- = *src++;
+                *dest-- = *src++;
+                dest += 2 * sizeof(float);
+            }
+        }
+        else
+        {
+            copy(begin, i, reinterpret_cast<byte*>(&v[0]));
         }
-#else
-        copy(begin, i, reinterpret_cast<Byte*>(&v[0]));
-#endif
     }
     else
     {
@@ -907,120 +810,71 @@ Ice::InputStream::read(vector<Float>& v)
     }
 }
 
-#ifdef ICE_CPP11_MAPPING
 void
-Ice::InputStream::read(pair<const Float*, const Float*>& v)
-#else
-void
-Ice::InputStream::read(pair<const Float*, const Float*>& v, IceUtil::ScopedArray<Float>& result)
-#endif
-{
-    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Float)));
-    if(sz > 0)
-    {
-#ifdef ICE_UNALIGNED
-        v.first = reinterpret_cast<Float*>(i);
-        i += sz * static_cast<int>(sizeof(Float));
-        v.second = reinterpret_cast<Float*>(i);
-#else
-
-#  ifdef ICE_CPP11_MAPPING
-        auto result = new float[static_cast<size_t>(sz)];
-        _deleters.push_back([result] { delete[] result; });
-        v.first = result;
-        v.second = result + sz;
-#  else
-        result.reset(new Float[static_cast<size_t>(sz)]);
-        v.first = result.get();
-        v.second = result.get() + sz;
-#  endif
-
-        Container::iterator begin = i;
-        i += sz * static_cast<int>(sizeof(Float));
-#  ifdef ICE_BIG_ENDIAN
-        const Byte* src = &(*begin);
-        Byte* dest = reinterpret_cast<Byte*>(&result[0]) + sizeof(Float) - 1;
-        for(int j = 0 ; j < sz ; ++j)
-        {
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            dest += 2 * sizeof(Float);
-        }
-#  else
-        copy(begin, i, reinterpret_cast<Byte*>(&result[0]));
-#  endif
-#endif
+Ice::InputStream::read(double& v)
+{
+    if (b.end() - i < static_cast<int>(sizeof(double)))
+    {
+        throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
+    }
+    const byte* src = &(*i);
+    i += sizeof(double);
+    if constexpr (endian::native == endian::big)
+    {
+        byte* dest = reinterpret_cast<byte*>(&v) + sizeof(double) - 1;
+        *dest-- = *src++;
+        *dest-- = *src++;
+        *dest-- = *src++;
+        *dest-- = *src++;
+        *dest-- = *src++;
+        *dest-- = *src++;
+        *dest-- = *src++;
+        *dest = *src;
     }
     else
     {
-#ifndef ICE_CPP11_MAPPING
-        result.reset();
-#endif
-        v.first = v.second = 0;
+        byte* dest = reinterpret_cast<byte*>(&v);
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest = *src;
     }
 }
 
 void
-Ice::InputStream::read(Double& v)
-{
-    if(b.end() - i < static_cast<int>(sizeof(Double)))
-    {
-        throw UnmarshalOutOfBoundsException(__FILE__, __LINE__);
-    }
-    const Byte* src = &(*i);
-    i += sizeof(Double);
-#ifdef ICE_BIG_ENDIAN
-    Byte* dest = reinterpret_cast<Byte*>(&v) + sizeof(Double) - 1;
-    *dest-- = *src++;
-    *dest-- = *src++;
-    *dest-- = *src++;
-    *dest-- = *src++;
-    *dest-- = *src++;
-    *dest-- = *src++;
-    *dest-- = *src++;
-    *dest = *src;
-#else
-    Byte* dest = reinterpret_cast<Byte*>(&v);
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest = *src;
-#endif
-}
-
-void
-Ice::InputStream::read(vector<Double>& v)
+Ice::InputStream::read(vector<double>& v)
 {
-    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Double)));
-    if(sz > 0)
+    int32_t sz = readAndCheckSeqSize(static_cast<int>(sizeof(double)));
+    if (sz > 0)
     {
         Container::iterator begin = i;
-        i += sz * static_cast<int>(sizeof(Double));
+        i += sz * static_cast<int>(sizeof(double));
         v.resize(static_cast<size_t>(sz));
-#ifdef ICE_BIG_ENDIAN
-        const Byte* src = &(*begin);
-        Byte* dest = reinterpret_cast<Byte*>(&v[0]) + sizeof(Double) - 1;
-        for(int j = 0 ; j < sz ; ++j)
-        {
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            dest += 2 * sizeof(Double);
-        }
-#else
-        copy(begin, i, reinterpret_cast<Byte*>(&v[0]));
-#endif
+        if constexpr (endian::native == endian::big)
+        {
+            const byte* src = &(*begin);
+            byte* dest = reinterpret_cast<byte*>(&v[0]) + sizeof(double) - 1;
+            for (int j = 0; j < sz; ++j)
+            {
+                *dest-- = *src++;
+                *dest-- = *src++;
+                *dest-- = *src++;
+                *dest-- = *src++;
+                *dest-- = *src++;
+                *dest-- = *src++;
+                *dest-- = *src++;
+                *dest-- = *src++;
+                dest += 2 * sizeof(double);
+            }
+        }
+        else
+        {
+            copy(begin, i, reinterpret_cast<byte*>(&v[0]));
+        }
     }
     else
     {
@@ -1028,77 +882,18 @@ Ice::InputStream::read(vector<Double>& v)
     }
 }
 
-#ifdef ICE_CPP11_MAPPING
-void
-Ice::InputStream::read(pair<const Double*, const Double*>& v)
-#else
-void
-Ice::InputStream::read(pair<const Double*, const Double*>& v, IceUtil::ScopedArray<Double>& result)
-#endif
-{
-    Int sz = readAndCheckSeqSize(static_cast<int>(sizeof(Double)));
-    if(sz > 0)
-    {
-#ifdef ICE_UNALIGNED
-        v.first = reinterpret_cast<Double*>(i);
-        i += sz * static_cast<int>(sizeof(Double));
-        v.second = reinterpret_cast<Double*>(i);
-#else
-
-#  ifdef ICE_CPP11_MAPPING
-        auto result = new double[static_cast<size_t>(sz)];
-        _deleters.push_back([result] { delete[] result; });
-        v.first = result;
-        v.second = result + sz;
-#  else
-        result.reset(new Double[static_cast<size_t>(sz)]);
-        v.first = result.get();
-        v.second = result.get() + sz;
-#  endif
-
-        Container::iterator begin = i;
-        i += sz * static_cast<int>(sizeof(Double));
-#  ifdef ICE_BIG_ENDIAN
-        const Byte* src = &(*begin);
-        Byte* dest = reinterpret_cast<Byte*>(&result[0]) + sizeof(Double) - 1;
-        for(int j = 0 ; j < sz ; ++j)
-        {
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            *dest-- = *src++;
-            dest += 2 * sizeof(Double);
-        }
-#  else
-        copy(begin, i, reinterpret_cast<Byte*>(&result[0]));
-#  endif
-#endif
-    }
-    else
-    {
-#ifndef ICE_CPP11_MAPPING
-        result.reset();
-#endif
-        v.first = v.second = 0;
-    }
-}
-
 void
 Ice::InputStream::read(std::string& v, bool convert)
 {
-    Int sz = readSize();
-    if(sz > 0)
+    int32_t sz = readSize();
+    if (sz > 0)
     {
-        if(b.end() - i < sz)
+        if (b.end() - i < sz)
         {
             throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
         }
 
-        if(!convert || !readConverted(v, sz))
+        if (!convert || !readConverted(v, sz))
         {
             string(reinterpret_cast<const char*>(&*i), reinterpret_cast<const char*>(&*i) + sz).swap(v);
         }
@@ -1110,19 +905,18 @@ Ice::InputStream::read(std::string& v, bool convert)
     }
 }
 
-#ifdef ICE_CPP11_MAPPING
 void
 Ice::InputStream::read(const char*& vdata, size_t& vsize, bool convert)
 {
     int sz = readSize();
-    if(sz > 0)
+    if (sz > 0)
     {
-        if(b.end() - i < sz)
+        if (b.end() - i < sz)
         {
             throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
         }
 
-        if(convert == false)
+        if (convert == false)
         {
             vdata = reinterpret_cast<const char*>(&*i);
             vsize = static_cast<size_t>(sz);
@@ -1131,9 +925,9 @@ Ice::InputStream::read(const char*& vdata, size_t& vsize, bool convert)
         else
         {
             string converted;
-            if(readConverted(converted, sz))
+            if (readConverted(converted, sz))
             {
-                if(converted.size() <= static_cast<size_t>(sz))
+                if (converted.size() <= static_cast<size_t>(sz))
                 {
                     //
                     // Write converted string directly into buffer
@@ -1145,7 +939,7 @@ Ice::InputStream::read(const char*& vdata, size_t& vsize, bool convert)
                 else
                 {
                     auto holder = new string(std::move(converted));
-                    _deleters.push_back([holder] { delete holder; });
+                    _deleters.emplace_back([holder] { delete holder; });
                     vdata = holder->data();
                     vsize = holder->size();
                 }
@@ -1160,153 +954,70 @@ Ice::InputStream::read(const char*& vdata, size_t& vsize, bool convert)
     }
     else
     {
-        vdata = 0;
+        vdata = nullptr;
         vsize = 0;
     }
 }
 
-#else
-
-void
-Ice::InputStream::read(const char*& vdata, size_t& vsize)
-{
-    Int sz = readSize();
-    if(sz > 0)
-    {
-        if(b.end() - i < sz)
-        {
-            throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
-        }
-
-        vdata = reinterpret_cast<const char*>(&*i);
-        vsize = static_cast<size_t>(sz);
-        i += sz;
-    }
-    else
-    {
-        vdata = 0;
-        vsize = 0;
-    }
-}
-
-void
-Ice::InputStream::read(const char*& vdata, size_t& vsize, string& holder)
-{
-    Int sz = readSize();
-    if(sz > 0)
-    {
-        if(b.end() - i < sz)
-        {
-            throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
-        }
-
-        if(readConverted(holder, sz))
-        {
-            vdata = holder.data();
-            vsize = holder.size();
-        }
-        else
-        {
-            vdata = reinterpret_cast<const char*>(&*i);
-            vsize = static_cast<size_t>(sz);
-        }
-        i += sz;
-    }
-    else
-    {
-        holder.clear();
-        vdata = 0;
-        vsize = 0;
-    }
-}
-#endif
-
 bool
 Ice::InputStream::readConverted(string& v, int sz)
 {
     try
     {
         bool converted = false;
-
-        //
-        // NOTE: When using an _instance, we get a const& on the string reference to
-        // not have to increment unecessarily its reference count.
-        //
-
-        if(_instance)
+        const StringConverterPtr& stringConverter = _instance->getStringConverter();
+        if (stringConverter)
         {
-            const StringConverterPtr& stringConverter = _instance->getStringConverter();
-            if(stringConverter)
-            {
-                stringConverter->fromUTF8(i, i + sz, v);
-                converted = true;
-            }
-        }
-        else
-        {
-            StringConverterPtr stringConverter = getProcessStringConverter();
-            if(stringConverter)
-            {
-                stringConverter->fromUTF8(i, i + sz, v);
-                converted = true;
-            }
+            stringConverter->fromUTF8(i, i + sz, v);
+            converted = true;
         }
 
         return converted;
     }
-    catch(const IllegalConversionException& ex)
+    catch (const IllegalConversionException& ex)
     {
-        throw StringConversionException(__FILE__, __LINE__, ex.reason());
+        throw MarshalException{__FILE__, __LINE__, string{"failed to unmarshal a string:\n"} + ex.what()};
     }
 }
 
 void
 Ice::InputStream::read(vector<string>& v, bool convert)
 {
-    Int sz = readAndCheckSeqSize(1);
-    if(sz > 0)
+    int32_t sz = readAndCheckSeqSize(1);
+    if (sz > 0)
     {
         v.resize(static_cast<size_t>(sz));
-        for(size_t j = 0; j < static_cast<size_t>(sz); ++j)
+        for (size_t j = 0; j < static_cast<size_t>(sz); ++j)
         {
             read(v[j], convert);
         }
     }
     else
     {
-       v.clear();
+        v.clear();
     }
 }
 
 void
 Ice::InputStream::read(wstring& v)
 {
-    Int sz = readSize();
-    if(sz > 0)
+    int32_t sz = readSize();
+    if (sz > 0)
     {
-        if(b.end() - i < sz)
+        if (b.end() - i < sz)
         {
             throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
         }
 
         try
         {
-            if(_instance)
-            {
-                const WstringConverterPtr& wstringConverter = _instance->getWstringConverter();
-                wstringConverter->fromUTF8(i, i + sz, v);
-            }
-            else
-            {
-                WstringConverterPtr wstringConverter = getProcessWstringConverter();
-                wstringConverter->fromUTF8(i, i + sz, v);
-            }
-
+            const WstringConverterPtr& wstringConverter = _instance->getWstringConverter();
+            wstringConverter->fromUTF8(i, i + sz, v);
             i += sz;
         }
-        catch(const IllegalConversionException& ex)
+        catch (const IllegalConversionException& ex)
         {
-            throw StringConversionException(__FILE__, __LINE__, ex.reason());
+            throw MarshalException{__FILE__, __LINE__, string{"failed to unmarshal a string:\n"} + ex.what()};
         }
     }
     else
@@ -1318,65 +1029,77 @@ Ice::InputStream::read(wstring& v)
 void
 Ice::InputStream::read(vector<wstring>& v)
 {
-    size_t sz = static_cast<size_t>(readAndCheckSeqSize(1));
-    if(sz > 0)
+    auto sz = static_cast<size_t>(readAndCheckSeqSize(1));
+    if (sz > 0)
     {
         v.resize(sz);
-        for(size_t j = 0; j < sz; ++j)
+        for (size_t j = 0; j < sz; ++j)
         {
             read(v[j]);
         }
     }
     else
     {
-       v.clear();
+        v.clear();
     }
 }
 
-#ifdef ICE_CPP11_MAPPING
-shared_ptr<ObjectPrx>
-Ice::InputStream::readProxy()
+namespace
 {
-    if(!_instance)
+    inline Ice::SliceLoaderPtr getSliceLoader(SliceLoaderPtr sliceLoader, Instance* instance)
     {
-        throw MarshalException(__FILE__, __LINE__, "cannot unmarshal a proxy without a communicator");
+        if (!sliceLoader)
+        {
+            sliceLoader = instance->sliceLoader();
+        }
+        return sliceLoader;
     }
+}
 
-    return _instance->proxyFactory()->streamToProxy(this);
+Ice::InputStream::InputStream(Instance* instance, EncodingVersion encoding, Buffer&& buf, SliceLoaderPtr sliceLoader)
+    : Buffer(std::move(buf)),
+      _instance(instance),
+      _encoding(encoding),
+      _classGraphDepthMax(instance->classGraphDepthMax()),
+      _sliceLoader{getSliceLoader(std::move(sliceLoader), instance)}
+{
 }
-#else
-void
-Ice::InputStream::read(ObjectPrx& v)
+
+ReferencePtr
+Ice::InputStream::readReference()
 {
-    if(!_instance)
+    Identity ident;
+    read(ident);
+    if (ident.name.empty())
     {
-        throw MarshalException(__FILE__, __LINE__, "cannot unmarshal a proxy without a communicator");
+        return nullptr;
+    }
+    else
+    {
+        return _instance->referenceFactory()->create(std::move(ident), this);
     }
-
-    v = _instance->proxyFactory()->streamToProxy(this);
 }
-#endif
 
-Int
-Ice::InputStream::readEnum(Int maxValue)
+int32_t
+Ice::InputStream::readEnum(int32_t maxValue)
 {
-    if(getEncoding() == Encoding_1_0)
+    if (getEncoding() == Encoding_1_0)
     {
-        if(maxValue < 127)
+        if (maxValue < 127)
         {
-            Byte value;
+            uint8_t value;
             read(value);
             return value;
         }
-        else if(maxValue < 32767)
+        else if (maxValue < 32767)
         {
-            Short value;
+            int16_t value;
             read(value);
             return value;
         }
         else
         {
-            Int value;
+            int32_t value;
             read(value);
             return value;
         }
@@ -1388,57 +1111,57 @@ Ice::InputStream::readEnum(Int maxValue)
 }
 
 void
-Ice::InputStream::throwException(ICE_IN(ICE_DELEGATE(UserExceptionFactory)) factory)
+Ice::InputStream::throwException(UserExceptionFactory factory)
 {
     initEncaps();
-    _currentEncaps->decoder->throwException(factory);
+    _currentEncaps->decoder->throwException(std::move(factory));
 }
 
 bool
-Ice::InputStream::readOptImpl(Int readTag, OptionalFormat expectedFormat)
+Ice::InputStream::readOptImpl(int32_t readTag, OptionalFormat expectedFormat)
 {
-    if(getEncoding() == Encoding_1_0)
+    if (getEncoding() == Encoding_1_0)
     {
         return false; // Optional members aren't supported with the 1.0 encoding.
     }
 
-    while(true)
+    while (true)
     {
-        if(i >= b.begin() + _currentEncaps->start + _currentEncaps->sz)
+        if (i >= b.begin() + _currentEncaps->start + _currentEncaps->sz)
         {
             return false; // End of encapsulation also indicates end of optionals.
         }
 
-        Byte v;
+        uint8_t v;
         read(v);
-        if(v == OPTIONAL_END_MARKER)
+        if (v == OPTIONAL_END_MARKER)
         {
             --i; // Rewind
             return false;
         }
 
-        OptionalFormat format = static_cast<OptionalFormat>(v & 0x07); // First 3 bits.
-        Int tag = static_cast<Int>(v >> 3);
-        if(tag == 30)
+        auto format = static_cast<OptionalFormat>(v & 0x07); // First 3 bits.
+        auto tag = static_cast<int32_t>(v >> 3);
+        if (tag == 30)
         {
             tag = readSize();
         }
 
-        if(tag > readTag)
+        if (tag > readTag)
         {
             i -= tag < 30 ? 1 : (tag < 255 ? 2 : 6); // Rewind
-            return false; // No optional data members with the requested tag.
+            return false;                            // No optional data members with the requested tag.
         }
-        else if(tag < readTag)
+        else if (tag < readTag)
         {
             skipOptional(format); // Skip optional data members
         }
         else
         {
-            if(format != expectedFormat)
+            if (format != expectedFormat)
             {
                 ostringstream os;
-                os << "invalid optional data member `" << tag << "': unexpected format";
+                os << "invalid optional data member '" << tag << "': unexpected format";
                 throw MarshalException(__FILE__, __LINE__, os.str());
             }
             return true;
@@ -1450,53 +1173,52 @@ Ice::InputStream::readOptImpl(Int readTag, OptionalFormat expectedFormat)
 void
 Ice::InputStream::skipOptional(OptionalFormat type)
 {
-    switch(type)
+    switch (type)
     {
-        case ICE_SCOPED_ENUM(OptionalFormat, F1):
+        case OptionalFormat::F1:
         {
             skip(1);
             break;
         }
-        case ICE_SCOPED_ENUM(OptionalFormat, F2):
+        case OptionalFormat::F2:
         {
             skip(2);
             break;
         }
-        case ICE_SCOPED_ENUM(OptionalFormat, F4):
+        case OptionalFormat::F4:
         {
             skip(4);
             break;
         }
-        case ICE_SCOPED_ENUM(OptionalFormat, F8):
+        case OptionalFormat::F8:
         {
             skip(8);
             break;
         }
-        case ICE_SCOPED_ENUM(OptionalFormat, Size):
+        case OptionalFormat::Size:
         {
             skipSize();
             break;
         }
-        case ICE_SCOPED_ENUM(OptionalFormat, VSize):
+        case OptionalFormat::VSize:
         {
             skip(static_cast<size_t>(readSize()));
             break;
         }
-        case ICE_SCOPED_ENUM(OptionalFormat, FSize):
+        case OptionalFormat::FSize:
         {
-            Int sz;
+            int32_t sz;
             read(sz);
-            if(sz < 0)
+            if (sz < 0)
             {
-                throw UnmarshalOutOfBoundsException(__FILE__, __LINE__);
+                throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
             }
             skip(static_cast<size_t>(sz));
             break;
         }
-        case ICE_SCOPED_ENUM(OptionalFormat, Class):
+        case OptionalFormat::Class:
         {
-            read(0, 0);
-            break;
+            throw MarshalException{__FILE__, __LINE__, "cannot skip optional class"};
         }
     }
 }
@@ -1507,22 +1229,22 @@ Ice::InputStream::skipOptionals()
     //
     // Skip remaining un-read optional members.
     //
-    while(true)
+    while (true)
     {
-        if(i >= b.begin() + _currentEncaps->start + _currentEncaps->sz)
+        if (i >= b.begin() + _currentEncaps->start + _currentEncaps->sz)
         {
             return; // End of encapsulation also indicates end of optionals.
         }
 
-        Byte v;
+        uint8_t v;
         read(v);
-        if(v == OPTIONAL_END_MARKER)
+        if (v == OPTIONAL_END_MARKER)
         {
             return;
         }
 
-        OptionalFormat format = static_cast<OptionalFormat>(v & 0x07); // Read first 3 bits.
-        if(static_cast<Int>(v >> 3) == 30)
+        auto format = static_cast<OptionalFormat>(v & 0x07); // Read first 3 bits.
+        if (static_cast<int32_t>(v >> 3) == 30)
         {
             skipSize();
         }
@@ -1533,204 +1255,59 @@ Ice::InputStream::skipOptionals()
 void
 Ice::InputStream::throwUnmarshalOutOfBoundsException(const char* file, int line)
 {
-    throw UnmarshalOutOfBoundsException(file, line);
+    throw MarshalException{file, line, endOfBufferMessage};
 }
 
 void
-Ice::InputStream::throwEncapsulationException(const char* file, int line)
+Ice::InputStream::traceSkipSlice(string_view typeId, SliceType sliceType) const
 {
-    throw EncapsulationException(file, line);
-}
-
-string
-Ice::InputStream::resolveCompactId(int id) const
-{
-    string type;
-
-#ifdef ICE_CPP11_MAPPING
-    function<string(int)> resolver = compactIdResolver();
-#else
-    CompactIdResolverPtr resolver = compactIdResolver();
-#endif
-
-    if(resolver)
+    assert(_instance->initializationData().logger); // not null once the communicator is initialized
+    if (_instance->traceLevels()->slicing > 0)
     {
-        try
-        {
-#ifdef ICE_CPP11_MAPPING
-            type = resolver(id);
-#else
-            type = resolver->resolve(id);
-#endif
-        }
-        catch(const LocalException&)
-        {
-            throw;
-        }
-        catch(const std::exception& ex)
-        {
-            ostringstream ostr;
-            ostr << "exception in CompactIdResolver for ID " << id;
-            string msg = ostr.str();
-            string what = ex.what();
-            if(!what.empty())
-            {
-                msg += ":\n" + what;
-            }
-            throw MarshalException(__FILE__, __LINE__, msg);
-        }
-        catch(...)
-        {
-            ostringstream ostr;
-            ostr << "unknown exception in CompactIdResolver for ID " << id;
-            throw MarshalException(__FILE__, __LINE__, ostr.str());
-        }
-    }
-
-    return type;
-}
-
-void
-Ice::InputStream::postUnmarshal(const ValuePtr& v) const
-{
-    try
-    {
-#ifndef ICE_CPP11_MAPPING
-        if(_collectObjects)
-        {
-            v->ice_collectable(true);
-        }
-#endif
-        v->ice_postUnmarshal();
-    }
-    catch(const std::exception& ex)
-    {
-        if(logger())
-        {
-            Warning out(logger());
-            out << "std::exception raised by ice_postUnmarshal:\n" << ex;
-        }
-    }
-    catch(...)
-    {
-        if(logger())
-        {
-            Warning out(logger());
-            out << "unknown exception raised by ice_postUnmarshal";
-        }
+        traceSlicing(
+            sliceType == ExceptionSlice ? "exception" : "object",
+            typeId,
+            "Slicing",
+            _instance->initializationData().logger);
     }
 }
 
-void
-Ice::InputStream::traceSkipSlice(const string& typeId, SliceType sliceType) const
-{
-    if(_traceSlicing && logger())
-    {
-        traceSlicing(sliceType == ExceptionSlice ? "exception" : "object", typeId, "Slicing", logger());
-    }
-}
-
-ValueFactoryManagerPtr
-Ice::InputStream::valueFactoryManager() const
-{
-    if(_valueFactoryManager)
-    {
-        return _valueFactoryManager;
-    }
-    else if(_instance)
-    {
-        return _instance->initializationData().valueFactoryManager;
-    }
-
-    return 0;
-}
-
-LoggerPtr
-Ice::InputStream::logger() const
-{
-    if(_logger)
-    {
-        return _logger;
-    }
-    else if(_instance)
-    {
-        return _instance->initializationData().logger;
-    }
-
-    return 0;
-}
-
-#ifdef ICE_CPP11_MAPPING
-function<string(int)>
-Ice::InputStream::compactIdResolver() const
-{
-    if(_compactIdResolver)
-    {
-        return _compactIdResolver;
-    }
-    else if(_instance)
-    {
-        return _instance->initializationData().compactIdResolver;
-    }
-
-    return nullptr;
-}
-#else
-CompactIdResolverPtr
-Ice::InputStream::compactIdResolver() const
-{
-    if(_compactIdResolver)
-    {
-        return _compactIdResolver;
-    }
-    else if(_instance)
-    {
-        return _instance->initializationData().compactIdResolver;
-    }
-
-    return 0;
-}
-#endif
-
 void
 Ice::InputStream::initEncaps()
 {
-    if(!_currentEncaps) // Lazy initialization.
+    if (!_currentEncaps) // Lazy initialization.
     {
         _currentEncaps = &_preAllocatedEncaps;
         _currentEncaps->encoding = _encoding;
-        _currentEncaps->sz = static_cast<Ice::Int>(b.size());
+        _currentEncaps->sz = static_cast<int32_t>(b.size());
     }
 
-    if(!_currentEncaps->decoder) // Lazy initialization.
+    if (!_currentEncaps->decoder) // Lazy initialization.
     {
-        ValueFactoryManagerPtr vfm = valueFactoryManager();
-        if(_currentEncaps->encoding == Encoding_1_0)
+        if (_currentEncaps->encoding == Encoding_1_0)
         {
-            _currentEncaps->decoder = new EncapsDecoder10(this, _currentEncaps, _sliceValues, _classGraphDepthMax, vfm);
+            _currentEncaps->decoder = new EncapsDecoder10(this, _currentEncaps, _classGraphDepthMax);
         }
         else
         {
-            _currentEncaps->decoder = new EncapsDecoder11(this, _currentEncaps, _sliceValues, _classGraphDepthMax, vfm);
+            _currentEncaps->decoder = new EncapsDecoder11(this, _currentEncaps, _classGraphDepthMax);
         }
     }
 }
 
-Ice::InputStream::EncapsDecoder::~EncapsDecoder()
-{
-    // Out of line to avoid weak vtable
-}
+// Out of line to avoid weak vtable
+Ice::InputStream::EncapsDecoder::~EncapsDecoder() = default;
 
 string
 Ice::InputStream::EncapsDecoder::readTypeId(bool isIndex)
 {
-    if(isIndex)
+    if (isIndex)
     {
-        Int index = _stream->readSize();
-        TypeIdMap::const_iterator k = _typeIdMap.find(index);
-        if(k == _typeIdMap.end())
+        int32_t index = _stream->readSize();
+        auto k = _typeIdMap.find(index);
+        if (k == _typeIdMap.end())
         {
-            throw UnmarshalOutOfBoundsException(__FILE__, __LINE__);
+            throw MarshalException{__FILE__, __LINE__, endOfBufferMessage};
         }
         return k->second;
     }
@@ -1743,94 +1320,31 @@ Ice::InputStream::EncapsDecoder::readTypeId(bool isIndex)
     }
 }
 
-Ice::ValuePtr
-Ice::InputStream::EncapsDecoder::newInstance(const string& typeId)
+ValuePtr
+Ice::InputStream::EncapsDecoder::newInstance(string_view typeId)
 {
-    Ice::ValuePtr v;
-
-    //
-    // Try to find a factory registered for the specific type.
-    //
-#ifdef ICE_CPP11_MAPPING
-    function<ValuePtr(const string&)> userFactory;
-    if(_valueFactoryManager)
-    {
-        userFactory = _valueFactoryManager->find(typeId);
-        if(userFactory)
-        {
-            v = userFactory(typeId);
-        }
-    }
-#else
-    ValueFactoryPtr userFactory;
-    if(_valueFactoryManager)
-    {
-        userFactory = _valueFactoryManager->find(typeId);
-        if(userFactory)
-        {
-            v = userFactory->create(typeId);
-        }
-    }
-#endif
-    //
-    // If that fails, invoke the default factory if one has been registered.
-    //
-    if(!v && _valueFactoryManager)
-    {
-        userFactory = _valueFactoryManager->find("");
-        if(userFactory)
-        {
-#ifdef ICE_CPP11_MAPPING
-            v = userFactory(typeId);
-#else
-            v = userFactory->create(typeId);
-#endif
-        }
-    }
-
-    //
-    // Last chance: check the table of static factories (i.e.,
-    // automatically generated factories for concrete classes).
-    //
-    if(!v)
-    {
-#ifdef ICE_CPP11_MAPPING
-        function<ValuePtr(const string&)> of = IceInternal::factoryTable->getValueFactory(typeId);
-        if(of)
-        {
-            v = of(typeId);
-            assert(v);
-        }
-#else
-        ValueFactoryPtr of = IceInternal::factoryTable->getValueFactory(typeId);
-        if(of)
-        {
-            v = of->create(typeId);
-            assert(v);
-        }
-#endif
-    }
-    return v;
+    return _stream->_sliceLoader->newClassInstance(typeId);
 }
 
 void
-Ice::InputStream::EncapsDecoder::addPatchEntry(Int index, PatchFunc patchFunc, void* patchAddr)
+Ice::InputStream::EncapsDecoder::addPatchEntry(int32_t index, const PatchFunc& patchFunc, void* patchAddr)
 {
     assert(index > 0);
 
     //
-    // Check if we already unmarshaled the object. If that's the case, just patch the object smart pointer
-    // and we're done. A null value indicates we've encountered a cycle and Ice.AllowClassCycles is false.
+    // Check if we already unmarshaled the object. If that's the case, just patch the object smart
+    // pointer and we're done. A null value indicates we've encountered a cycle and Ice.AllowClassCycles
+    // is false.
     //
-    IndexToPtrMap::iterator p = _unmarshaledMap.find(index);
-    if(p != _unmarshaledMap.end())
+    auto p = _unmarshaledMap.find(index);
+    if (p != _unmarshaledMap.end())
     {
-        if (p->second == ICE_NULLPTR)
+        if (p->second == nullptr)
         {
             assert(!_stream->_instance->acceptClassCycles());
             throw MarshalException(__FILE__, __LINE__, "cycle detected during Value unmarshaling");
         }
-        (*patchFunc)(patchAddr, p->second);
+        patchFunc(patchAddr, p->second);
         return;
     }
 
@@ -1840,8 +1354,8 @@ Ice::InputStream::EncapsDecoder::addPatchEntry(Int index, PatchFunc patchFunc, v
     // unmarshaled.
     //
 
-    PatchMap::iterator q = _patchMap.find(index);
-    if(q == _patchMap.end())
+    auto q = _patchMap.find(index);
+    if (q == _patchMap.end())
     {
         //
         // We have no outstanding instances to be patched for this
@@ -1861,7 +1375,7 @@ Ice::InputStream::EncapsDecoder::addPatchEntry(Int index, PatchFunc patchFunc, v
 }
 
 void
-Ice::InputStream::EncapsDecoder::unmarshal(Int index, const Ice::ValuePtr& v)
+Ice::InputStream::EncapsDecoder::unmarshal(int32_t index, const ValuePtr& v)
 {
     //
     // Add the object to the map of unmarshaled instances, this must
@@ -1870,7 +1384,7 @@ Ice::InputStream::EncapsDecoder::unmarshal(Int index, const Ice::ValuePtr& v)
     // If circular references are not allowed we insert null (for cycle detection) and add
     // the object to the map once it has been fully unmarshaled.
     //
-    _unmarshaledMap.insert(make_pair(index, _stream->_instance->acceptClassCycles() ? v : Ice::ValuePtr()));
+    _unmarshaledMap.insert(make_pair(index, _stream->_instance->acceptClassCycles() ? v : nullptr));
 
     //
     // Read the object.
@@ -1880,17 +1394,17 @@ Ice::InputStream::EncapsDecoder::unmarshal(Int index, const Ice::ValuePtr& v)
     //
     // Patch all instances now that the object is unmarshaled.
     //
-    PatchMap::iterator patchPos = _patchMap.find(index);
-    if(patchPos != _patchMap.end())
+    auto patchPos = _patchMap.find(index);
+    if (patchPos != _patchMap.end())
     {
         assert(patchPos->second.size() > 0);
 
         //
         // Patch all pointers that refer to the instance.
         //
-        for(PatchList::iterator k = patchPos->second.begin(); k != patchPos->second.end(); ++k)
+        for (const auto& k : patchPos->second)
         {
-            (*k->patchFunc)(k->patchAddr, v);
+            k.patchFunc(k.patchAddr, v);
         }
 
         //
@@ -1900,31 +1414,29 @@ Ice::InputStream::EncapsDecoder::unmarshal(Int index, const Ice::ValuePtr& v)
         _patchMap.erase(patchPos);
     }
 
-    if(_valueList.empty() && _patchMap.empty())
+    if (_valueList.empty() && _patchMap.empty())
     {
-        _stream->postUnmarshal(v);
+        v->ice_postUnmarshal();
     }
     else
     {
         _valueList.push_back(v);
 
-        if(_patchMap.empty())
+        if (_patchMap.empty())
         {
-            //
             // Iterate over the value list and invoke ice_postUnmarshal on
             // each value. We must do this after all values have been
             // unmarshaled in order to ensure that any value data members
             // have been properly patched.
-            //
-            for(ValueList::iterator p = _valueList.begin(); p != _valueList.end(); ++p)
+            for (const auto& value : _valueList)
             {
-                _stream->postUnmarshal(*p);
+                value->ice_postUnmarshal();
             }
             _valueList.clear();
         }
     }
 
-    if(!_stream->_instance->acceptClassCycles())
+    if (!_stream->_instance->acceptClassCycles())
     {
         // This class has been fully unmarshaled without creating any cycles
         // It can be added to the map now.
@@ -1940,22 +1452,21 @@ Ice::InputStream::EncapsDecoder10::read(PatchFunc patchFunc, void* patchAddr)
     //
     // Object references are encoded as a negative integer in 1.0.
     //
-    Int index;
+    int32_t index;
     _stream->read(index);
-    if(index > 0)
+    if (index > 0)
     {
         throw MarshalException(__FILE__, __LINE__, "invalid object id");
     }
     index = -index;
 
-    if(index == 0)
+    if (index == 0)
     {
         //
         // Calling the patch function for null instances is necessary for correct functioning of Ice for
         // Python and Ruby.
         //
-        ValuePtr nil;
-        patchFunc(patchAddr, nil);
+        patchFunc(patchAddr, nullptr);
     }
     else
     {
@@ -1964,7 +1475,7 @@ Ice::InputStream::EncapsDecoder10::read(PatchFunc patchFunc, void* patchAddr)
 }
 
 void
-Ice::InputStream::EncapsDecoder10::throwException(ICE_IN(ICE_DELEGATE(UserExceptionFactory)) factory)
+Ice::InputStream::EncapsDecoder10::throwException(UserExceptionFactory exceptionFactory)
 {
     assert(_sliceType == NoSlice);
 
@@ -1986,21 +1497,26 @@ Ice::InputStream::EncapsDecoder10::throwException(ICE_IN(ICE_DELEGATE(UserExcept
     //
     startSlice();
     const string mostDerivedId = _typeId;
-    ICE_DELEGATE(UserExceptionFactory) exceptionFactory = factory;
-    while(true)
+    while (true)
     {
         //
         // Look for a statically-generated factory for this ID.
         //
-        if(!exceptionFactory)
+        if (!exceptionFactory)
         {
-            exceptionFactory = factoryTable->getExceptionFactory(_typeId);
+            std::exception_ptr exceptionPtr = _stream->_sliceLoader->newExceptionInstance(_typeId);
+
+            if (exceptionPtr)
+            {
+                exceptionFactory = [exceptionPtr](string_view) { std::rethrow_exception(exceptionPtr); };
+            }
         }
 
         //
         // We found a factory, we get out of this loop.
+        // A factory that doesn't throw is equivalent to a null factory.
         //
-        if(exceptionFactory)
+        if (exceptionFactory)
         {
             //
             // Got factory -- ask the factory to instantiate the
@@ -2009,22 +1525,16 @@ Ice::InputStream::EncapsDecoder10::throwException(ICE_IN(ICE_DELEGATE(UserExcept
             //
             try
             {
-#ifdef ICE_CPP11_MAPPING
                 exceptionFactory(_typeId);
-#else
-                exceptionFactory->createAndThrow(_typeId);
-#endif
             }
-            catch(UserException& ex)
+            catch (UserException& ex)
             {
                 ex._read(_stream);
-                if(usesClasses)
+                if (usesClasses)
                 {
                     readPendingValues();
                 }
                 throw;
-
-                // Never reached.
             }
         }
 
@@ -2036,64 +1546,56 @@ Ice::InputStream::EncapsDecoder10::throwException(ICE_IN(ICE_DELEGATE(UserExcept
         {
             startSlice();
         }
-        catch(UnmarshalOutOfBoundsException& ex)
+        catch (const MarshalException&)
         {
             //
             // An oversight in the 1.0 encoding means there is no marker to indicate
             // the last slice of an exception. As a result, we just try to read the
-            // next type ID, which raises UnmarshalOutOfBoundsException when the
+            // next type ID, which raises MarshalException when the
             // input buffer underflows.
-            //
-            // Set the reason member to a more helpful message.
-            //
-            ex.reason = "unknown exception type `" + mostDerivedId + "'";
-            throw;
+            throw MarshalException{__FILE__, __LINE__, "unknown exception type '" + mostDerivedId + "'"};
         }
     }
 }
 
 void
-#ifndef NDEBUG
-Ice::InputStream::EncapsDecoder10::startInstance(SliceType sliceType)
-#else
-Ice::InputStream::EncapsDecoder10::startInstance(SliceType)
-#endif
+Ice::InputStream::EncapsDecoder10::startInstance([[maybe_unused]] SliceType sliceType)
 {
     assert(_sliceType == sliceType);
     _skipFirstSlice = true;
 }
 
 SlicedDataPtr
-Ice::InputStream::EncapsDecoder10::endInstance(bool)
+Ice::InputStream::EncapsDecoder10::endInstance()
 {
     //
     // Read the Ice::Value slice.
     //
-    if(_sliceType == ValueSlice)
+    if (_sliceType == ValueSlice)
     {
         startSlice();
-        Int sz = _stream->readSize(); // For compatibility with the old AFM.
-        if(sz != 0)
+        int32_t sz = _stream->readSize(); // For compatibility with the old AFM.
+        if (sz != 0)
         {
             throw MarshalException(__FILE__, __LINE__, "invalid Object slice");
         }
         endSlice();
     }
     _sliceType = NoSlice;
-    return 0;
+    return nullptr;
 }
 
-const std::string&
+void
 Ice::InputStream::EncapsDecoder10::startSlice()
 {
     //
     // If first slice, don't read the header, it was already read in
     // readInstance or throwException to find the factory.
     //
-    if(_skipFirstSlice)
+    if (_skipFirstSlice)
     {
         _skipFirstSlice = false;
-        return _typeId;
+        return;
     }
 
     //
@@ -2102,7 +1604,7 @@ Ice::InputStream::EncapsDecoder10::startSlice()
     // index. For exceptions, the type ID is always encoded as a
     // string.
     //
-    if(_sliceType == ValueSlice)
+    if (_sliceType == ValueSlice)
     {
         bool isIndex;
         _stream->read(isIndex);
@@ -2114,11 +1616,10 @@ Ice::InputStream::EncapsDecoder10::startSlice()
     }
 
     _stream->read(_sliceSize);
-    if(_sliceSize < 4)
+    if (_sliceSize < 4)
     {
-        throw UnmarshalOutOfBoundsException(__FILE__, __LINE__);
+        throw MarshalException{__FILE__, __LINE__, endOfBufferMessage};
     }
-    return _typeId;
 }
 
 void
@@ -2131,28 +1632,27 @@ Ice::InputStream::EncapsDecoder10::skipSlice()
 {
     _stream->traceSkipSlice(_typeId, _sliceType);
     assert(_sliceSize >= 4);
-    _stream->skip(static_cast<size_t>(_sliceSize) - sizeof(Int));
+    _stream->skip(static_cast<size_t>(_sliceSize) - sizeof(int32_t));
 }
 
 void
 Ice::InputStream::EncapsDecoder10::readPendingValues()
 {
-    Int num;
+    int32_t num;
     do
     {
         num = _stream->readSize();
-        for(Int k = num; k > 0; --k)
+        for (int32_t k = num; k > 0; --k)
         {
             readInstance();
         }
-    }
-    while(num);
+    } while (num);
 
-    if(!_patchMap.empty())
+    if (!_patchMap.empty())
     {
         //
-        // If any entries remain in the patch map, the sender has sent an index for an object, but failed
-        // to supply the object.
+        // If any entries remain in the patch map, the sender has sent an index for an object, but
+        // failed to supply the object.
         //
         throw MarshalException(__FILE__, __LINE__, "index for class received, but no instance");
     }
@@ -2161,10 +1661,10 @@ Ice::InputStream::EncapsDecoder10::readPendingValues()
 void
 Ice::InputStream::EncapsDecoder10::readInstance()
 {
-    Int index;
+    int32_t index;
     _stream->read(index);
 
-    if(index <= 0)
+    if (index <= 0)
     {
         throw MarshalException(__FILE__, __LINE__, "invalid object id");
     }
@@ -2177,16 +1677,16 @@ Ice::InputStream::EncapsDecoder10::readInstance()
     //
     startSlice();
     const string mostDerivedId = _typeId;
-    ValuePtr v;
-    while(true)
+    shared_ptr<Value> v;
+    while (true)
     {
-        //
-        // For the 1.0 encoding, the type ID for the base Object class
-        // marks the last slice.
-        //
-        if(_typeId == Object::ice_staticId())
+        // For the 1.0 encoding, the type ID for the base Object class marks the last slice.
+        if (_typeId == Value::ice_staticId())
         {
-            throw NoValueFactoryException(__FILE__, __LINE__, "", mostDerivedId);
+            throw MarshalException{
+                __FILE__,
+                __LINE__,
+                "the Slice loader did not find a class for type ID '" + mostDerivedId + "'"};
         }
 
         v = newInstance(_typeId);
@@ -2194,20 +1694,11 @@ Ice::InputStream::EncapsDecoder10::readInstance()
         //
         // We found a factory, we get out of this loop.
         //
-        if(v)
+        if (v)
         {
             break;
         }
 
-        //
-        // If value slicing is disabled, stop unmarshaling.
-        //
-        if(!_sliceValues)
-        {
-            throw NoValueFactoryException(__FILE__, __LINE__, "no value factory found and value slicing is disabled",
-                                           _typeId);
-        }
-
         //
         // Slice off what we don't understand.
         //
@@ -2221,20 +1712,20 @@ Ice::InputStream::EncapsDecoder10::readInstance()
     // keep the biggest one.
     //
     _classGraphDepth = 0;
-    PatchMap::iterator patchPos = _patchMap.find(index);
-    if(patchPos != _patchMap.end())
+    auto patchPos = _patchMap.find(index);
+    if (patchPos != _patchMap.end())
     {
         assert(patchPos->second.size() > 0);
-        for(PatchList::iterator k = patchPos->second.begin(); k != patchPos->second.end(); ++k)
+        for (const auto& k : patchPos->second)
         {
-            if(k->classGraphDepth > _classGraphDepth)
+            if (k.classGraphDepth > _classGraphDepth)
             {
-                _classGraphDepth = k->classGraphDepth;
+                _classGraphDepth = k.classGraphDepth;
             }
         }
     }
 
-    if(++_classGraphDepth > _classGraphDepthMax)
+    if (++_classGraphDepth > _classGraphDepthMax)
     {
         throw MarshalException(__FILE__, __LINE__, "maximum class graph depth reached");
     }
@@ -2248,24 +1739,22 @@ Ice::InputStream::EncapsDecoder10::readInstance()
 void
 Ice::InputStream::EncapsDecoder11::read(PatchFunc patchFunc, void* patchAddr)
 {
-    Int index = _stream->readSize();
-    if(index < 0)
+    assert(patchFunc && patchAddr); // we used to support null for optional classes
+
+    int32_t index = _stream->readSize();
+    if (index < 0)
     {
         throw MarshalException(__FILE__, __LINE__, "invalid object id");
     }
-    else if(index == 0)
+    else if (index == 0)
     {
         //
         // Calling the patch function for null instances is necessary for correct functioning of Ice for
         // Python and Ruby.
         //
-        if(patchFunc)
-        {
-            ValuePtr nil;
-            patchFunc(patchAddr, nil);
-        }
+        patchFunc(patchAddr, nullptr);
     }
-    else if(_current && _current->sliceFlags & FLAG_HAS_INDIRECTION_TABLE)
+    else if (_current && _current->sliceFlags & FLAG_HAS_INDIRECTION_TABLE)
     {
         //
         // When reading an object within a slice and there's an
@@ -2278,14 +1767,11 @@ Ice::InputStream::EncapsDecoder11::read(PatchFunc patchFunc, void* patchAddr)
         // derive an index into the indirection table that we'll read
         // at the end of the slice.
         //
-        if(patchFunc)
-        {
-            IndirectPatchEntry e;
-            e.index = index - 1;
-            e.patchFunc = patchFunc;
-            e.patchAddr = patchAddr;
-            _current->indirectPatchList.push_back(e);
-        }
+        IndirectPatchEntry e;
+        e.index = index - 1;
+        e.patchFunc = patchFunc;
+        e.patchAddr = patchAddr;
+        _current->indirectPatchList.push_back(e);
     }
     else
     {
@@ -2294,7 +1780,7 @@ Ice::InputStream::EncapsDecoder11::read(PatchFunc patchFunc, void* patchAddr)
 }
 
 void
-Ice::InputStream::EncapsDecoder11::throwException(ICE_IN(ICE_DELEGATE(UserExceptionFactory)) factory)
+Ice::InputStream::EncapsDecoder11::throwException(UserExceptionFactory exceptionFactory)
 {
     assert(!_current);
 
@@ -2305,21 +1791,26 @@ Ice::InputStream::EncapsDecoder11::throwException(ICE_IN(ICE_DELEGATE(UserExcept
     //
     startSlice();
     const string mostDerivedId = _current->typeId;
-    ICE_DELEGATE(UserExceptionFactory) exceptionFactory = factory;
-    while(true)
+    while (true)
     {
         //
         // Look for a statically-generated factory for this ID.
         //
-        if(!exceptionFactory)
+        if (!exceptionFactory)
         {
-            exceptionFactory = factoryTable->getExceptionFactory(_current->typeId);
+            std::exception_ptr exceptionPtr = _stream->_sliceLoader->newExceptionInstance(_current->typeId);
+
+            if (exceptionPtr)
+            {
+                exceptionFactory = [exceptionPtr](string_view) { std::rethrow_exception(exceptionPtr); };
+            }
         }
 
         //
         // We found a factory, we get out of this loop.
+        // A factory that doesn't throw is equivalent to a null factory.
         //
-        if(exceptionFactory)
+        if (exceptionFactory)
         {
             //
             // Got factory -- ask the factory to instantiate the
@@ -2328,18 +1819,12 @@ Ice::InputStream::EncapsDecoder11::throwException(ICE_IN(ICE_DELEGATE(UserExcept
             //
             try
             {
-#ifdef ICE_CPP11_MAPPING
                 exceptionFactory(_current->typeId);
-#else
-                exceptionFactory->createAndThrow(_current->typeId);
-#endif
             }
-            catch(UserException& ex)
+            catch (UserException& ex)
             {
                 ex._read(_stream);
                 throw;
-
-                // Never reached.
             }
         }
 
@@ -2349,11 +1834,14 @@ Ice::InputStream::EncapsDecoder11::throwException(ICE_IN(ICE_DELEGATE(UserExcept
         skipSlice();
 
         //
-        // If this is the last slice, raise an exception and stop un-marshalling.
+        // If this is the last slice, raise an exception and stop un-marshaling.
         //
-        if(_current->sliceFlags & FLAG_IS_LAST_SLICE)
+        if (_current->sliceFlags & FLAG_IS_LAST_SLICE)
         {
-            throw UnknownUserException(__FILE__, __LINE__, mostDerivedId);
+            throw MarshalException{
+                __FILE__,
+                __LINE__,
+                "cannot unmarshal exception with type ID '" + mostDerivedId + "'"};
         }
 
         startSlice();
@@ -2361,41 +1849,33 @@ Ice::InputStream::EncapsDecoder11::throwException(ICE_IN(ICE_DELEGATE(UserExcept
 }
 
 void
-#ifndef NDEBUG
-Ice::InputStream::EncapsDecoder11::startInstance(SliceType sliceType)
-#else
-Ice::InputStream::EncapsDecoder11::startInstance(SliceType)
-#endif
+Ice::InputStream::EncapsDecoder11::startInstance([[maybe_unused]] SliceType sliceType)
 {
     assert(_current->sliceType == sliceType);
     _current->skipFirstSlice = true;
 }
 
 SlicedDataPtr
-Ice::InputStream::EncapsDecoder11::endInstance(bool preserve)
+Ice::InputStream::EncapsDecoder11::endInstance()
 {
-    SlicedDataPtr slicedData;
-    if(preserve)
-    {
-        slicedData = readSlicedData();
-    }
-    _current->slices.clear();
+    SlicedDataPtr slicedData = readSlicedData();
     _current->indirectionTables.clear();
+    _current->slices.clear();
     _current = _current->previous;
     return slicedData;
 }
 
-const std::string&
+void
 Ice::InputStream::EncapsDecoder11::startSlice()
 {
     //
     // If first slice, don't read the header, it was already read in
     // readInstance or throwException to find the factory.
     //
-    if(_current->skipFirstSlice)
+    if (_current->skipFirstSlice)
     {
         _current->skipFirstSlice = false;
-        return _current->typeId;
+        return;
     }
 
     _stream->read(_current->sliceFlags);
@@ -2405,14 +1885,14 @@ Ice::InputStream::EncapsDecoder11::startSlice()
     // string or as an index, for exceptions it's always encoded as a
     // string.
     //
-    if(_current->sliceType == ValueSlice)
+    if (_current->sliceType == ValueSlice)
     {
-        if((_current->sliceFlags & FLAG_HAS_TYPE_ID_COMPACT) == FLAG_HAS_TYPE_ID_COMPACT) // Must be checked first!
+        if ((_current->sliceFlags & FLAG_HAS_TYPE_ID_COMPACT) == FLAG_HAS_TYPE_ID_COMPACT) // Must be checked first!
         {
-            _current->typeId.clear();
             _current->compactId = _stream->readSize();
+            _current->typeId = std::to_string(_current->compactId);
         }
-        else if(_current->sliceFlags & (FLAG_HAS_TYPE_ID_STRING | FLAG_HAS_TYPE_ID_INDEX))
+        else if (_current->sliceFlags & (FLAG_HAS_TYPE_ID_STRING | FLAG_HAS_TYPE_ID_INDEX))
         {
             _current->typeId = readTypeId(_current->sliceFlags & FLAG_HAS_TYPE_ID_INDEX);
             _current->compactId = -1;
@@ -2427,31 +1907,30 @@ Ice::InputStream::EncapsDecoder11::startSlice()
     else
     {
         _stream->read(_current->typeId, false);
+        _current->compactId = -1;
     }
 
     //
     // Read the slice size if necessary.
     //
-    if(_current->sliceFlags & FLAG_HAS_SLICE_SIZE)
+    if (_current->sliceFlags & FLAG_HAS_SLICE_SIZE)
     {
         _stream->read(_current->sliceSize);
-        if(_current->sliceSize < 4)
+        if (_current->sliceSize < 4)
         {
-            throw UnmarshalOutOfBoundsException(__FILE__, __LINE__);
+            throw MarshalException{__FILE__, __LINE__, endOfBufferMessage};
         }
     }
     else
     {
         _current->sliceSize = 0;
     }
-
-    return _current->typeId;
 }
 
 void
 Ice::InputStream::EncapsDecoder11::endSlice()
 {
-    if(_current->sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS)
+    if (_current->sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS)
     {
         _stream->skipOptionals();
     }
@@ -2459,12 +1938,12 @@ Ice::InputStream::EncapsDecoder11::endSlice()
     //
     // Read the indirect object table if one is present.
     //
-    if(_current->sliceFlags & FLAG_HAS_INDIRECTION_TABLE)
+    if (_current->sliceFlags & FLAG_HAS_INDIRECTION_TABLE)
     {
         IndexList indirectionTable(static_cast<size_t>(_stream->readAndCheckSeqSize(1)));
-        for(IndexList::iterator p = indirectionTable.begin(); p != indirectionTable.end(); ++p)
+        for (auto& p : indirectionTable)
         {
-            *p = readInstance(_stream->readSize(), 0, 0);
+            p = readInstance(_stream->readSize(), nullptr, nullptr);
         }
 
         //
@@ -2472,11 +1951,11 @@ Ice::InputStream::EncapsDecoder11::endSlice()
         // that not all object references were read if they are from
         // unknown optional data members.
         //
-        if(indirectionTable.empty())
+        if (indirectionTable.empty())
         {
             throw MarshalException(__FILE__, __LINE__, "empty indirection table");
         }
-        if(_current->indirectPatchList.empty() && !(_current->sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS))
+        if (_current->indirectPatchList.empty() && !(_current->sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS))
         {
             throw MarshalException(__FILE__, __LINE__, "no references to indirection table");
         }
@@ -2485,10 +1964,10 @@ Ice::InputStream::EncapsDecoder11::endSlice()
         // Convert indirect references into direct references.
         //
         IndirectPatchList::iterator p;
-        for(p = _current->indirectPatchList.begin(); p != _current->indirectPatchList.end(); ++p)
+        for (p = _current->indirectPatchList.begin(); p != _current->indirectPatchList.end(); ++p)
         {
             assert(p->index >= 0);
-            if(p->index >= static_cast<Int>(indirectionTable.size()))
+            if (p->index >= static_cast<int32_t>(indirectionTable.size()))
             {
                 throw MarshalException(__FILE__, __LINE__, "indirection out of range");
             }
@@ -2505,92 +1984,101 @@ Ice::InputStream::EncapsDecoder11::skipSlice()
 
     Container::iterator start = _stream->i;
 
-    if(_current->sliceFlags & FLAG_HAS_SLICE_SIZE)
+    if (_current->sliceFlags & FLAG_HAS_SLICE_SIZE)
     {
         assert(_current->sliceSize >= 4);
-        _stream->skip(static_cast<size_t>(_current->sliceSize) - sizeof(Int));
+        _stream->skip(static_cast<size_t>(_current->sliceSize) - sizeof(int32_t));
     }
     else
     {
-        if(_current->sliceType == ValueSlice)
+        if (_current->sliceType == ValueSlice)
         {
-            throw NoValueFactoryException(__FILE__, __LINE__,
-                                          "no value factory found and compact format prevents "
-                                          "slicing (the sender should use the sliced format instead)",
-                                          _current->typeId);
+            throw MarshalException{
+                __FILE__,
+                __LINE__,
+                "the Slice loader did not find a class for type ID '" + _current->typeId +
+                    "' and compact format prevents slicing"};
         }
         else
         {
-            throw UnknownUserException(__FILE__, __LINE__, _current->typeId);
+            throw MarshalException{
+                __FILE__,
+                __LINE__,
+                "the Slice loader did not find a user exception class for type ID '" + _current->typeId +
+                    "' and compact format prevents slicing"};
         }
     }
 
     //
-    // Preserve this slice.
+    // Preserve this slice if unmarshaling a value in Slice format. Exception slices are not preserved.
     //
-    SliceInfoPtr info = ICE_MAKE_SHARED(SliceInfo);
-    info->typeId = _current->typeId;
-    info->compactId = _current->compactId;
-    info->hasOptionalMembers = _current->sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS;
-    info->isLastSlice = _current->sliceFlags & FLAG_IS_LAST_SLICE;
-    if(info->hasOptionalMembers)
-    {
-        //
-        // Don't include the optional member end marker. It will be re-written by
-        // endSlice when the sliced data is re-written.
-        //
-        vector<Byte>(start, _stream->i - 1).swap(info->bytes);
-    }
-    else
+    if (_current->sliceType == ValueSlice)
     {
-        vector<Byte>(start, _stream->i).swap(info->bytes);
+        bool hasOptionalMembers = _current->sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS;
+        vector<byte> bytes;
+        if (hasOptionalMembers)
+        {
+            //
+            // Don't include the optional member end marker. It will be re-written by
+            // endSlice when the sliced data is re-written.
+            //
+            bytes = vector<byte>(start, _stream->i - 1);
+        }
+        else
+        {
+            bytes = vector<byte>(start, _stream->i);
+        }
+
+        SliceInfoPtr info = make_shared<SliceInfo>(
+            _current->compactId == -1 ? _current->typeId : "",
+            _current->compactId,
+            std::move(bytes),
+            hasOptionalMembers,
+            _current->sliceFlags & FLAG_IS_LAST_SLICE);
+
+        _current->slices.push_back(info);
     }
 
-    _current->indirectionTables.push_back(IndexList());
+    _current->indirectionTables.emplace_back();
 
     //
     // Read the indirect object table. We read the instances or their
-    // IDs if the instance is a reference to an already un-marhsaled
+    // IDs if the instance is a reference to an already un-marshaled
     // object.
     //
-    // The SliceInfo object sequence is initialized only if
-    // readSlicedData is called.
-    //
-    if(_current->sliceFlags & FLAG_HAS_INDIRECTION_TABLE)
+    if (_current->sliceFlags & FLAG_HAS_INDIRECTION_TABLE)
     {
         IndexList& table = _current->indirectionTables.back();
         table.resize(static_cast<size_t>(_stream->readAndCheckSeqSize(1)));
-        for(IndexList::iterator p = table.begin(); p != table.end(); ++p)
+        for (auto& entry : table)
         {
-            *p = readInstance(_stream->readSize(), 0, 0);
+            entry = readInstance(_stream->readSize(), nullptr, nullptr);
         }
     }
-
-    _current->slices.push_back(info);
 }
 
 bool
-Ice::InputStream::EncapsDecoder11::readOptional(Ice::Int readTag, Ice::OptionalFormat expectedFormat)
+Ice::InputStream::EncapsDecoder11::readOptional(int32_t readTag, Ice::OptionalFormat expectedFormat)
 {
-    if(!_current)
+    if (!_current)
     {
         return _stream->readOptImpl(readTag, expectedFormat);
     }
-    else if(_current->sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS)
+    else if (_current->sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS)
     {
         return _stream->readOptImpl(readTag, expectedFormat);
     }
     return false;
 }
 
-Int
-Ice::InputStream::EncapsDecoder11::readInstance(Int index, PatchFunc patchFunc, void* patchAddr)
+int32_t
+Ice::InputStream::EncapsDecoder11::readInstance(int32_t index, const PatchFunc& patchFunc, void* patchAddr)
 {
     assert(index > 0);
 
-    if(index > 1)
+    if (index > 1)
     {
-        if(patchFunc)
+        if (patchFunc)
         {
             addPatchEntry(index, patchFunc, patchAddr);
         }
@@ -2611,43 +2099,22 @@ Ice::InputStream::EncapsDecoder11::readInstance(Int index, PatchFunc patchFunc,
     //
     startSlice();
     const string mostDerivedId = _current->typeId;
-    Ice::ValuePtr v;
-    while(true)
+    shared_ptr<Value> v;
+    while (true)
     {
-        if(_current->compactId >= 0)
-        {
-            //
-            // Translate a compact (numeric) type ID into a string type ID.
-            //
-            _current->typeId = _stream->resolveCompactId(_current->compactId);
-            if(_current->typeId.empty())
-            {
-                _current->typeId = IceInternal::factoryTable->getTypeId(_current->compactId);
-            }
-        }
-
-        if(!_current->typeId.empty())
+        if (!_current->typeId.empty())
         {
             v = newInstance(_current->typeId);
 
             //
             // We found a factory, we get out of this loop.
             //
-            if(v)
+            if (v)
             {
                 break;
             }
         }
 
-        //
-        // If value slicing is disabled, stop unmarshaling.
-        //
-        if(!_sliceValues)
-        {
-            throw NoValueFactoryException(__FILE__, __LINE__, "no value factory found and value slicing is disabled",
-                                          _current->typeId);
-        }
-
         //
         // Slice off what we don't understand.
         //
@@ -2656,17 +2123,17 @@ Ice::InputStream::EncapsDecoder11::readInstance(Int index, PatchFunc patchFunc,
         //
         // If this is the last slice, keep the object as an opaque UnknownSlicedValue.
         //
-        if(_current->sliceFlags & FLAG_IS_LAST_SLICE)
+        if (_current->sliceFlags & FLAG_IS_LAST_SLICE)
         {
             //
             // Provide a factory with an opportunity to supply the object.
             // We pass the "::Ice::Object" ID to indicate that this is the
             // last chance to preserve the object.
             //
-            v = newInstance(Object::ice_staticId());
-            if(!v)
+            v = newInstance(Value::ice_staticId());
+            if (!v)
             {
-                v = ICE_MAKE_SHARED(UnknownSlicedValue, mostDerivedId);
+                v = make_shared<UnknownSlicedValue>(mostDerivedId);
             }
 
             break;
@@ -2675,7 +2142,7 @@ Ice::InputStream::EncapsDecoder11::readInstance(Int index, PatchFunc patchFunc,
         startSlice(); // Read next Slice header for next iteration.
     }
 
-    if(++_classGraphDepth > _classGraphDepthMax)
+    if (++_classGraphDepth > _classGraphDepthMax)
     {
         throw MarshalException(__FILE__, __LINE__, "maximum class graph depth reached");
     }
@@ -2687,16 +2154,16 @@ Ice::InputStream::EncapsDecoder11::readInstance(Int index, PatchFunc patchFunc,
 
     --_classGraphDepth;
 
-    if(!_current && !_patchMap.empty())
+    if (!_current && !_patchMap.empty())
     {
         //
-        // If any entries remain in the patch map, the sender has sent an index for an object, but failed
-        // to supply the object.
+        // If any entries remain in the patch map, the sender has sent an index for an object, but
+        // failed to supply the object.
         //
         throw MarshalException(__FILE__, __LINE__, "index for class received, but no instance");
     }
 
-    if(patchFunc)
+    if (patchFunc)
     {
         patchFunc(patchAddr, v);
     }
@@ -2706,9 +2173,9 @@ Ice::InputStream::EncapsDecoder11::readInstance(Int index, PatchFunc patchFunc,
 SlicedDataPtr
 Ice::InputStream::EncapsDecoder11::readSlicedData()
 {
-    if(_current->slices.empty()) // No preserved slices.
+    if (_current->slices.empty()) // No preserved slices.
     {
-        return 0;
+        return nullptr;
     }
 
     //
@@ -2716,7 +2183,7 @@ Ice::InputStream::EncapsDecoder11::readSlicedData()
     // each slice in slices.
     //
     assert(_current->slices.size() == _current->indirectionTables.size());
-    for(SliceInfoSeq::size_type n = 0; n < _current->slices.size(); ++n)
+    for (SliceInfoSeq::size_type n = 0; n < _current->slices.size(); ++n)
     {
         //
         // We use the "instances" list in SliceInfo to hold references
@@ -2725,17 +2192,13 @@ Ice::InputStream::EncapsDecoder11::readSlicedData()
         // enclosing instance.
         //
         const IndexList& table = _current->indirectionTables[n];
-        vector<ValuePtr>& instances = _current->slices[n]->instances;
+        vector<shared_ptr<Value>>& instances = _current->slices[n]->instances;
         instances.resize(table.size());
         IndexList::size_type j = 0;
-        for(IndexList::const_iterator p = table.begin(); p != table.end(); ++p)
+        for (const auto& p : table)
         {
-#ifdef ICE_CPP11_MAPPING
-            addPatchEntry(*p, &patchHandle<Value>, &instances[j++]);
-#else
-            addPatchEntry(*p, &patchHandle<Object>, &instances[j++]);
-#endif
+            addPatchEntry(p, patchValue<Value>, &instances[j++]);
         }
     }
-    return ICE_MAKE_SHARED(SlicedData, _current->slices);
+    return make_shared<SlicedData>(_current->slices);
 }