zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,20 +1,17 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
+
+#include "Ice/OutputStream.h"
+#include "DefaultsAndOverrides.h"
+#include "Endian.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/Object.h"
+#include "Ice/Proxy.h"
+#include "Ice/SlicedData.h"
+#include "Ice/StringConverter.h"
+#include "Instance.h"
+#include "TraceUtil.h"
 
-#include <Ice/OutputStream.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/LocalException.h>
-#include <Ice/Protocol.h>
-#include <Ice/TraceUtil.h>
-#include <Ice/LoggerUtil.h>
-#include <Ice/SlicedData.h>
-#include <Ice/StringConverter.h>
 #include <iterator>
 
 using namespace std;
@@ -23,119 +20,142 @@ using namespace IceInternal;
 
 namespace
 {
-
-class StreamUTF8BufferI : public IceUtil::UTF8Buffer
-{
-public:
-
-    StreamUTF8BufferI(OutputStream& stream) :
-        _stream(stream)
-    {
-    }
-
-    Ice::Byte* getMoreBytes(size_t howMany, Ice::Byte* firstUnused)
+    class StreamUTF8BufferI final : public Ice::UTF8Buffer
     {
-        assert(howMany > 0);
+    public:
+        StreamUTF8BufferI(OutputStream& stream) : _stream(stream) {}
 
-        if(firstUnused != 0)
+        byte* getMoreBytes(size_t howMany, byte* firstUnused) final
         {
-            //
-            // Return unused bytes
-            //
-            _stream.resize(static_cast<size_t>(firstUnused - _stream.b.begin()));
-        }
-
-        //
-        // Index of first unused byte
-        //
-        Buffer::Container::size_type pos = _stream.b.size();
+            assert(howMany > 0);
 
-        //
-        // Since resize may reallocate the buffer, when firstUnused != 0, the
-        // return value can be != firstUnused
-        //
-        _stream.resize(pos + howMany);
+            if (firstUnused)
+            {
+                //
+                // Return unused bytes
+                //
+                _stream.resize(static_cast<size_t>(firstUnused - _stream.b.begin()));
+            }
 
-        return &_stream.b[pos];
-    }
+            //
+            // Index of first unused byte
+            //
+            Buffer::Container::size_type pos = _stream.b.size();
 
-private:
+            //
+            // Since resize may reallocate the buffer, when firstUnused != 0, the
+            // return value can be != firstUnused
+            //
+            _stream.resize(pos + howMany);
 
-    OutputStream& _stream;
-};
+            return &_stream.b[pos];
+        }
 
+    private:
+        OutputStream& _stream;
+    };
 }
 
-Ice::OutputStream::OutputStream() :
-    _instance(0),
-    _closure(0),
-    _encoding(currentEncoding),
-    _format(ICE_ENUM(FormatType, CompactFormat)),
-    _currentEncaps(0)
+Ice::OutputStream::OutputStream(
+    EncodingVersion encoding,
+    FormatType format,
+    StringConverterPtr stringConverter,
+    WstringConverterPtr wstringConverter)
+    : _stringConverter(std::move(stringConverter)),
+      _wstringConverter(std::move(wstringConverter)),
+      _closure(nullptr),
+      _encoding(encoding),
+      _format(format),
+      _currentEncaps(nullptr)
 {
 }
 
-Ice::OutputStream::OutputStream(const CommunicatorPtr& communicator) :
-    _closure(0),
-    _currentEncaps(0)
+Ice::OutputStream::OutputStream(
+    pair<const byte*, const byte*> buf,
+    EncodingVersion encoding,
+    FormatType format,
+    StringConverterPtr stringConverter,
+    WstringConverterPtr wstringConverter)
+    : Buffer(buf.first, buf.second),
+      _stringConverter(std::move(stringConverter)),
+      _wstringConverter(std::move(wstringConverter)),
+      _closure(nullptr),
+      _encoding(encoding),
+      _format(format),
+      _currentEncaps(nullptr)
 {
-    initialize(communicator);
+    b.reset();
 }
 
-Ice::OutputStream::OutputStream(const CommunicatorPtr& communicator, const EncodingVersion& encoding) :
-    _closure(0),
-    _currentEncaps(0)
+Ice::OutputStream::OutputStream(const CommunicatorPtr& communicator, EncodingVersion encoding)
+    : OutputStream(getInstance(communicator).get(), encoding)
 {
-    initialize(communicator, encoding);
 }
 
-Ice::OutputStream::OutputStream(const CommunicatorPtr& communicator, const EncodingVersion& encoding,
-                                const pair<const Byte*, const Byte*>& buf) :
-    Buffer(buf.first, buf.second),
-    _closure(0),
-    _currentEncaps(0)
+Ice::OutputStream::OutputStream(const CommunicatorPtr& communicator)
+    : OutputStream(communicator, getInstance(communicator)->defaultsAndOverrides()->defaultEncoding)
 {
-    initialize(communicator, encoding);
-    b.reset();
 }
 
-Ice::OutputStream::OutputStream(Instance* instance, const EncodingVersion& encoding) :
-    _closure(0),
-    _currentEncaps(0)
+Ice::OutputStream::OutputStream(Instance* instance, EncodingVersion encoding)
+    : OutputStream(
+          encoding,
+          instance->defaultsAndOverrides()->defaultFormat,
+          instance->getStringConverter(),
+          instance->getWstringConverter())
 {
-    initialize(instance, encoding);
 }
 
-void
-Ice::OutputStream::initialize(const CommunicatorPtr& communicator)
-{
-    assert(communicator);
-    Instance* instance = getInstance(communicator).get();
-    initialize(instance, instance->defaultsAndOverrides()->defaultEncoding);
-}
-
-void
-Ice::OutputStream::initialize(const CommunicatorPtr& communicator, const EncodingVersion& encoding)
-{
-    assert(communicator);
-    initialize(getInstance(communicator).get(), encoding);
+Ice::OutputStream::OutputStream(OutputStream&& other) noexcept
+    : Buffer(std::move(other)),
+      _stringConverter(std::move(other._stringConverter)),
+      _wstringConverter(std::move(other._wstringConverter)),
+      _closure(other._closure),
+      _encoding(other._encoding),
+      _format(other._format),
+      _currentEncaps(other._currentEncaps)
+{
+    // Reset other to its default state.
+    other._closure = nullptr;
+    other._encoding = Encoding_1_1;
+    other._format = FormatType::CompactFormat;
+    other._currentEncaps = nullptr;
+    other._preAllocatedEncaps.reset();
+
+    // Reset in the unusual case where other held a "failed" encapsulation.
+    resetEncapsulation();
 }
 
-void
-Ice::OutputStream::initialize(Instance* instance, const EncodingVersion& encoding)
+Ice::OutputStream&
+Ice::OutputStream::operator=(OutputStream&& other) noexcept
 {
-    assert(instance);
+    if (this != &other)
+    {
+        Buffer::operator=(std::move(other));
+        _stringConverter = std::move(other._stringConverter);
+        _wstringConverter = std::move(other._wstringConverter);
+        _closure = other._closure;
+        _encoding = other._encoding;
+        _format = other._format;
+        _currentEncaps = other._currentEncaps;
 
-    _instance = instance;
-    _encoding = encoding;
+        // Reset other to its default state.
+        other._closure = nullptr;
+        other._encoding = Encoding_1_1;
+        other._format = FormatType::CompactFormat;
+        other._currentEncaps = nullptr;
+        other._preAllocatedEncaps.reset();
 
-    _format = _instance->defaultsAndOverrides()->defaultFormat;
+        // Reset in the unusual case where other held a "failed" encapsulation.
+        resetEncapsulation();
+    }
+    return *this;
 }
 
 void
 Ice::OutputStream::clear()
 {
-    while(_currentEncaps && _currentEncaps != &_preAllocatedEncaps)
+    while (_currentEncaps && _currentEncaps != &_preAllocatedEncaps)
     {
         Encaps* oldEncaps = _currentEncaps;
         _currentEncaps = _currentEncaps->previous;
@@ -143,12 +163,6 @@ Ice::OutputStream::clear()
     }
 }
 
-void
-Ice::OutputStream::setFormat(FormatType fmt)
-{
-    _format = fmt;
-}
-
 void*
 Ice::OutputStream::getClosure() const
 {
@@ -164,18 +178,19 @@ Ice::OutputStream::setClosure(void* p)
 }
 
 void
-Ice::OutputStream::swap(OutputStream& other)
+Ice::OutputStream::swap(OutputStream& other) noexcept
 {
     swapBuffer(other);
 
-    std::swap(_instance, other._instance);
+    std::swap(_stringConverter, other._stringConverter);
+    std::swap(_wstringConverter, other._wstringConverter);
     std::swap(_closure, other._closure);
     std::swap(_encoding, other._encoding);
     std::swap(_format, other._format);
 
     //
     // Swap is never called for streams that have encapsulations being written. However,
-    // encapsulations might still be set in case marshalling failed. We just
+    // encapsulations might still be set in case marshaling failed. We just
     // reset the encapsulations if there are still some set.
     //
     resetEncapsulation();
@@ -185,7 +200,7 @@ Ice::OutputStream::swap(OutputStream& other)
 void
 Ice::OutputStream::resetEncapsulation()
 {
-    while(_currentEncaps && _currentEncaps != &_preAllocatedEncaps)
+    while (_currentEncaps && _currentEncaps != &_preAllocatedEncaps)
     {
         Encaps* oldEncaps = _currentEncaps;
         _currentEncaps = _currentEncaps->previous;
@@ -204,24 +219,92 @@ Ice::OutputStream::startEncapsulation()
     // encapsulation, otherwise, use the stream encoding version.
     //
 
-    if(_currentEncaps)
+    if (_currentEncaps)
     {
         startEncapsulation(_currentEncaps->encoding, _currentEncaps->format);
     }
     else
     {
-        startEncapsulation(_encoding, Ice::ICE_ENUM(FormatType, DefaultFormat));
+        startEncapsulation(_encoding, nullopt);
+    }
+}
+
+void
+Ice::OutputStream::startEncapsulation(const EncodingVersion& encoding, std::optional<FormatType> format)
+{
+    IceInternal::checkSupportedEncoding(encoding);
+
+    Encaps* oldEncaps = _currentEncaps;
+    if (!oldEncaps) // First allocated encaps?
+    {
+        _currentEncaps = &_preAllocatedEncaps;
+    }
+    else
+    {
+        _currentEncaps = new Encaps();
+        _currentEncaps->previous = oldEncaps;
     }
+    _currentEncaps->format = format.value_or(_format);
+    _currentEncaps->encoding = encoding;
+    _currentEncaps->start = b.size();
+
+    write(std::int32_t(0)); // Placeholder for the encapsulation length.
+    write(_currentEncaps->encoding);
+}
+
+void
+Ice::OutputStream::endEncapsulation()
+{
+    assert(_currentEncaps);
+
+    // Size includes size and version.
+    auto sz = static_cast<std::int32_t>(b.size() - _currentEncaps->start);
+    write(sz, &(*(b.begin() + _currentEncaps->start)));
+
+    Encaps* oldEncaps = _currentEncaps;
+    _currentEncaps = _currentEncaps->previous;
+    if (oldEncaps == &_preAllocatedEncaps)
+    {
+        oldEncaps->reset();
+    }
+    else
+    {
+        delete oldEncaps;
+    }
+}
+
+void
+Ice::OutputStream::writeEmptyEncapsulation(const EncodingVersion& encoding)
+{
+    IceInternal::checkSupportedEncoding(encoding);
+    write(std::int32_t(6)); // Size
+    write(encoding);
+}
+
+void
+Ice::OutputStream::writeEncapsulation(const byte* v, int32_t sz)
+{
+    if (sz < 6)
+    {
+        throw MarshalException{
+            __FILE__,
+            __LINE__,
+            "the provided array does not have enough bytes for an encapsulation"};
+    }
+
+    Container::size_type position = b.size();
+    resize(position + static_cast<size_t>(sz));
+    memcpy(&b[position], &v[0], static_cast<size_t>(sz));
 }
 
 void
 Ice::OutputStream::writePendingValues()
 {
-    if(_currentEncaps && _currentEncaps->encoder)
+    if (_currentEncaps && _currentEncaps->encoder)
     {
         _currentEncaps->encoder->writePendingValues();
     }
-    else if(getEncoding() == Ice::Encoding_1_0)
+    else if (getEncoding() == Ice::Encoding_1_0)
     {
         //
         // If using the 1.0 encoding and no instances were written, we
@@ -237,9 +320,9 @@ Ice::OutputStream::writePendingValues()
 }
 
 void
-Ice::OutputStream::writeBlob(const vector<Byte>& v)
+Ice::OutputStream::writeBlob(const vector<byte>& v)
 {
-    if(!v.empty())
+    if (!v.empty())
     {
         Container::size_type pos = b.size();
         resize(pos + v.size());
@@ -248,11 +331,11 @@ Ice::OutputStream::writeBlob(const vector<Byte>& v)
 }
 
 void
-Ice::OutputStream::write(const Byte* begin, const Byte* end)
+Ice::OutputStream::write(const byte* begin, const byte* end)
 {
-    Int sz = static_cast<Int>(end - begin);
+    auto sz = static_cast<int32_t>(end - begin);
     writeSize(sz);
-    if(sz > 0)
+    if (sz > 0)
     {
         Container::size_type pos = b.size();
         resize(pos + static_cast<size_t>(sz));
@@ -261,50 +344,61 @@ Ice::OutputStream::write(const Byte* begin, const Byte* end)
 }
 
 void
-Ice::OutputStream::write(const vector<bool>& v)
+Ice::OutputStream::write(const uint8_t* begin, const uint8_t* end)
 {
-    Int sz = static_cast<Int>(v.size());
+    auto sz = static_cast<int32_t>(end - begin);
     writeSize(sz);
-    if(sz > 0)
+    if (sz > 0)
     {
         Container::size_type pos = b.size();
         resize(pos + static_cast<size_t>(sz));
-        copy(v.begin(), v.end(), b.begin() + pos);
+        memcpy(&b[pos], begin, static_cast<size_t>(sz));
     }
 }
 
-namespace
+void
+Ice::OutputStream::write(const vector<bool>& v)
 {
+    auto sz = static_cast<int32_t>(v.size());
+    writeSize(sz);
+    if (sz > 0)
+    {
+        Container::size_type pos = b.size();
+        resize(pos + static_cast<size_t>(sz));
+        copy(v.begin(), v.end(), reinterpret_cast<uint8_t*>(b.begin()) + pos);
+    }
+}
 
-template<size_t boolSize>
-struct WriteBoolHelper
+namespace
 {
-    static void write(const bool* begin, OutputStream::Container::size_type pos, OutputStream::Container& b, Int sz)
+    template<size_t boolSize> struct WriteBoolHelper
     {
-        for(size_t idx = 0; idx < static_cast<size_t>(sz); ++idx)
+        static void
+        write(const bool* begin, OutputStream::Container::size_type pos, OutputStream::Container& b, int32_t sz)
         {
-            b[pos + idx] = static_cast<Byte>(*(begin + idx));
+            for (size_t idx = 0; idx < static_cast<size_t>(sz); ++idx)
+            {
+                b[pos + idx] = static_cast<std::byte>(*(begin + idx));
+            }
         }
-    }
-};
+    };
 
-template<>
-struct WriteBoolHelper<1>
-{
-    static void write(const bool* begin, OutputStream::Container::size_type pos, OutputStream::Container& b, Int sz)
+    template<> struct WriteBoolHelper<1>
     {
-        memcpy(&b[pos], begin, static_cast<size_t>(sz));
-    }
-};
-
+        static void
+        write(const bool* begin, OutputStream::Container::size_type pos, OutputStream::Container& b, int32_t sz)
+        {
+            memcpy(&b[pos], begin, static_cast<size_t>(sz));
+        }
+    };
 }
 
 void
 Ice::OutputStream::write(const bool* begin, const bool* end)
 {
-    Int sz = static_cast<Int>(end - begin);
+    auto sz = static_cast<int32_t>(end - begin);
     writeSize(sz);
-    if(sz > 0)
+    if (sz > 0)
     {
         Container::size_type pos = b.size();
         resize(pos + static_cast<size_t>(sz));
@@ -313,234 +407,282 @@ Ice::OutputStream::write(const bool* begin, const bool* end)
 }
 
 void
-Ice::OutputStream::write(Short v)
+Ice::OutputStream::write(int16_t v)
 {
     Container::size_type pos = b.size();
-    resize(pos + sizeof(Short));
-    Byte* dest = &b[pos];
-#ifdef ICE_BIG_ENDIAN
-    const Byte* src = reinterpret_cast<const Byte*>(&v) + sizeof(Short) - 1;
-    *dest++ = *src--;
-    *dest = *src;
-#else
-    const Byte* src = reinterpret_cast<const Byte*>(&v);
-    *dest++ = *src++;
-    *dest = *src;
-#endif
+    resize(pos + sizeof(int16_t));
+    byte* dest = &b[pos];
+    if constexpr (endian::native == endian::big)
+    {
+        const byte* src = reinterpret_cast<const byte*>(&v) + sizeof(int16_t) - 1;
+        *dest++ = *src--;
+        *dest = *src;
+    }
+    else
+    {
+        const byte* src = reinterpret_cast<const byte*>(&v);
+        *dest++ = *src++;
+        *dest = *src;
+    }
 }
 
 void
-Ice::OutputStream::write(const Short* begin, const Short* end)
+Ice::OutputStream::write(const int16_t* begin, const int16_t* end)
 {
-    Int sz = static_cast<Int>(end - begin);
+    auto sz = static_cast<int32_t>(end - begin);
     writeSize(sz);
-    if(sz > 0)
+    if (sz > 0)
     {
         Container::size_type pos = b.size();
-        resize(pos + static_cast<size_t>(sz) * sizeof(Short));
-#ifdef ICE_BIG_ENDIAN
-        const Byte* src = reinterpret_cast<const Byte*>(begin) + sizeof(Short) - 1;
-        Byte* dest = &(*(b.begin() + pos));
-        for(int j = 0 ; j < sz ; ++j)
+        resize(pos + static_cast<size_t>(sz) * sizeof(int16_t));
+        if constexpr (endian::native == endian::big)
+        {
+            const byte* src = reinterpret_cast<const byte*>(begin) + sizeof(int16_t) - 1;
+            byte* dest = &(*(b.begin() + pos));
+            for (int j = 0; j < sz; ++j)
+            {
+                *dest++ = *src--;
+                *dest++ = *src--;
+                src += 2 * sizeof(int16_t);
+            }
+        }
+        else
         {
-            *dest++ = *src--;
-            *dest++ = *src--;
-            src += 2 * sizeof(Short);
+            memcpy(&b[pos], reinterpret_cast<const byte*>(begin), static_cast<size_t>(sz) * sizeof(int16_t));
         }
-#else
-        memcpy(&b[pos], reinterpret_cast<const Byte*>(begin), static_cast<size_t>(sz) * sizeof(Short));
-#endif
     }
 }
 
 void
-Ice::OutputStream::write(const Int* begin, const Int* end)
+Ice::OutputStream::write(int32_t v, Container::iterator dest)
 {
-    Int sz = static_cast<Int>(end - begin);
+    if constexpr (endian::native == endian::big)
+    {
+        const std::byte* src = reinterpret_cast<const std::byte*>(&v) + sizeof(std::int32_t) - 1;
+        *dest++ = *src--;
+        *dest++ = *src--;
+        *dest++ = *src--;
+        *dest = *src;
+    }
+    else
+    {
+        auto src = reinterpret_cast<const std::byte*>(&v);
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest = *src;
+    }
+}
+
+void
+Ice::OutputStream::write(const int32_t* begin, const int32_t* end)
+{
+    auto sz = static_cast<int32_t>(end - begin);
     writeSize(sz);
-    if(sz > 0)
+    if (sz > 0)
     {
         Container::size_type pos = b.size();
-        resize(pos + static_cast<size_t>(sz) * sizeof(Int));
-#ifdef ICE_BIG_ENDIAN
-        const Byte* src = reinterpret_cast<const Byte*>(begin) + sizeof(Int) - 1;
-        Byte* dest = &(*(b.begin() + pos));
-        for(int j = 0 ; j < sz ; ++j)
+        resize(pos + static_cast<size_t>(sz) * sizeof(int32_t));
+        if constexpr (endian::native == endian::big)
+        {
+            const byte* src = reinterpret_cast<const byte*>(begin) + sizeof(int32_t) - 1;
+            byte* dest = &(*(b.begin() + pos));
+            for (int j = 0; j < sz; ++j)
+            {
+                *dest++ = *src--;
+                *dest++ = *src--;
+                *dest++ = *src--;
+                *dest++ = *src--;
+                src += 2 * sizeof(int32_t);
+            }
+        }
+        else
         {
-            *dest++ = *src--;
-            *dest++ = *src--;
-            *dest++ = *src--;
-            *dest++ = *src--;
-            src += 2 * sizeof(Int);
+            memcpy(&b[pos], reinterpret_cast<const byte*>(begin), static_cast<size_t>(sz) * sizeof(int32_t));
         }
-#else
-        memcpy(&b[pos], reinterpret_cast<const Byte*>(begin), static_cast<size_t>(sz) * sizeof(Int));
-#endif
     }
 }
 
 void
-Ice::OutputStream::write(Long v)
+Ice::OutputStream::write(int64_t v)
 {
     Container::size_type pos = b.size();
-    resize(pos + sizeof(Long));
-    Byte* dest = &b[pos];
-#ifdef ICE_BIG_ENDIAN
-    const Byte* src = reinterpret_cast<const Byte*>(&v) + sizeof(Long) - 1;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest = *src;
-#else
-    const Byte* src = reinterpret_cast<const Byte*>(&v);
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest = *src;
-#endif
+    resize(pos + sizeof(int64_t));
+    byte* dest = &b[pos];
+    if constexpr (endian::native == endian::big)
+    {
+        const byte* src = reinterpret_cast<const byte*>(&v) + sizeof(std::int64_t) - 1;
+        *dest++ = *src--;
+        *dest++ = *src--;
+        *dest++ = *src--;
+        *dest++ = *src--;
+        *dest++ = *src--;
+        *dest++ = *src--;
+        *dest++ = *src--;
+        *dest = *src;
+    }
+    else
+    {
+        const byte* src = reinterpret_cast<const byte*>(&v);
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest = *src;
+    }
 }
 
 void
-Ice::OutputStream::write(const Long* begin, const Long* end)
+Ice::OutputStream::write(const int64_t* begin, const int64_t* end)
 {
-    Int sz = static_cast<Int>(end - begin);
+    auto sz = static_cast<int32_t>(end - begin);
     writeSize(sz);
-    if(sz > 0)
+    if (sz > 0)
     {
         Container::size_type pos = b.size();
-        resize(pos + static_cast<size_t>(sz) * sizeof(Long));
-#ifdef ICE_BIG_ENDIAN
-        const Byte* src = reinterpret_cast<const Byte*>(begin) + sizeof(Long) - 1;
-        Byte* dest = &(*(b.begin() + pos));
-        for(int j = 0 ; j < sz ; ++j)
+        resize(pos + static_cast<size_t>(sz) * sizeof(int64_t));
+        if constexpr (endian::native == endian::big)
+        {
+            const byte* src = reinterpret_cast<const byte*>(begin) + sizeof(int64_t) - 1;
+            byte* dest = &(*(b.begin() + pos));
+            for (int j = 0; j < sz; ++j)
+            {
+                *dest++ = *src--;
+                *dest++ = *src--;
+                *dest++ = *src--;
+                *dest++ = *src--;
+                *dest++ = *src--;
+                *dest++ = *src--;
+                *dest++ = *src--;
+                *dest++ = *src--;
+                src += 2 * sizeof(int64_t);
+            }
+        }
+        else
         {
-            *dest++ = *src--;
-            *dest++ = *src--;
-            *dest++ = *src--;
-            *dest++ = *src--;
-            *dest++ = *src--;
-            *dest++ = *src--;
-            *dest++ = *src--;
-            *dest++ = *src--;
-            src += 2 * sizeof(Long);
+            memcpy(&b[pos], reinterpret_cast<const byte*>(begin), static_cast<size_t>(sz) * sizeof(int64_t));
         }
-#else
-        memcpy(&b[pos], reinterpret_cast<const Byte*>(begin), static_cast<size_t>(sz) * sizeof(Long));
-#endif
     }
 }
 
 void
-Ice::OutputStream::write(Float v)
+Ice::OutputStream::write(float v)
 {
     Container::size_type pos = b.size();
-    resize(pos + sizeof(Float));
-    Byte* dest = &b[pos];
-#ifdef ICE_BIG_ENDIAN
-    const Byte* src = reinterpret_cast<const Byte*>(&v) + sizeof(Float) - 1;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest = *src;
-#else
-    const Byte* src = reinterpret_cast<const Byte*>(&v);
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest = *src;
-#endif
+    resize(pos + sizeof(float));
+    byte* dest = &b[pos];
+    if constexpr (endian::native == endian::big)
+    {
+        const byte* src = reinterpret_cast<const byte*>(&v) + sizeof(float) - 1;
+        *dest++ = *src--;
+        *dest++ = *src--;
+        *dest++ = *src--;
+        *dest = *src;
+    }
+    else
+    {
+        const byte* src = reinterpret_cast<const byte*>(&v);
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest = *src;
+    }
 }
 
 void
-Ice::OutputStream::write(const Float* begin, const Float* end)
+Ice::OutputStream::write(const float* begin, const float* end)
 {
-    Int sz = static_cast<Int>(end - begin);
+    auto sz = static_cast<int32_t>(end - begin);
     writeSize(sz);
-    if(sz > 0)
+    if (sz > 0)
     {
         Container::size_type pos = b.size();
-        resize(pos + static_cast<size_t>(sz) * sizeof(Float));
-#ifdef ICE_BIG_ENDIAN
-        const Byte* src = reinterpret_cast<const Byte*>(begin) + sizeof(Float) - 1;
-        Byte* dest = &(*(b.begin() + pos));
-        for(int j = 0 ; j < sz ; ++j)
+        resize(pos + static_cast<size_t>(sz) * sizeof(float));
+        if constexpr (endian::native == endian::big)
         {
-            *dest++ = *src--;
-            *dest++ = *src--;
-            *dest++ = *src--;
-            *dest++ = *src--;
-            src += 2 * sizeof(Float);
+            const byte* src = reinterpret_cast<const byte*>(begin) + sizeof(float) - 1;
+            byte* dest = &(*(b.begin() + pos));
+            for (int j = 0; j < sz; ++j)
+            {
+                *dest++ = *src--;
+                *dest++ = *src--;
+                *dest++ = *src--;
+                *dest++ = *src--;
+                src += 2 * sizeof(float);
+            }
+        }
+        else
+        {
+            memcpy(&b[pos], reinterpret_cast<const byte*>(begin), static_cast<size_t>(sz) * sizeof(float));
         }
-#else
-        memcpy(&b[pos], reinterpret_cast<const Byte*>(begin), static_cast<size_t>(sz) * sizeof(Float));
-#endif
     }
 }
 
 void
-Ice::OutputStream::write(Double v)
+Ice::OutputStream::write(double v)
 {
     Container::size_type pos = b.size();
-    resize(pos + sizeof(Double));
-    Byte* dest = &b[pos];
-#ifdef ICE_BIG_ENDIAN
-    const Byte* src = reinterpret_cast<const Byte*>(&v) + sizeof(Double) - 1;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest = *src;
-#else
-    const Byte* src = reinterpret_cast<const Byte*>(&v);
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest = *src;
-#endif
+    resize(pos + sizeof(double));
+    byte* dest = &b[pos];
+    if constexpr (endian::native == endian::big)
+    {
+        const byte* src = reinterpret_cast<const byte*>(&v) + sizeof(double) - 1;
+        *dest++ = *src--;
+        *dest++ = *src--;
+        *dest++ = *src--;
+        *dest++ = *src--;
+        *dest++ = *src--;
+        *dest++ = *src--;
+        *dest++ = *src--;
+        *dest = *src;
+    }
+    else
+    {
+        const byte* src = reinterpret_cast<const byte*>(&v);
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest++ = *src++;
+        *dest = *src;
+    }
 }
 
 void
-Ice::OutputStream::write(const Double* begin, const Double* end)
+Ice::OutputStream::write(const double* begin, const double* end)
 {
-    Int sz = static_cast<Int>(end - begin);
+    auto sz = static_cast<int32_t>(end - begin);
     writeSize(sz);
-    if(sz > 0)
+    if (sz > 0)
     {
         Container::size_type pos = b.size();
-        resize(pos + static_cast<size_t>(sz) * sizeof(Double));
-#ifdef ICE_BIG_ENDIAN
-        const Byte* src = reinterpret_cast<const Byte*>(begin) + sizeof(Double) - 1;
-        Byte* dest = &(*(b.begin() + pos));
-        for(int j = 0 ; j < sz ; ++j)
+        resize(pos + static_cast<size_t>(sz) * sizeof(double));
+        if constexpr (endian::native == endian::big)
         {
-            *dest++ = *src--;
-            *dest++ = *src--;
-            *dest++ = *src--;
-            *dest++ = *src--;
-            *dest++ = *src--;
-            *dest++ = *src--;
-            *dest++ = *src--;
-            *dest++ = *src--;
-            src += 2 * sizeof(Double);
+            const byte* src = reinterpret_cast<const byte*>(begin) + sizeof(double) - 1;
+            byte* dest = &(*(b.begin() + pos));
+            for (int j = 0; j < sz; ++j)
+            {
+                *dest++ = *src--;
+                *dest++ = *src--;
+                *dest++ = *src--;
+                *dest++ = *src--;
+                *dest++ = *src--;
+                *dest++ = *src--;
+                *dest++ = *src--;
+                *dest++ = *src--;
+                src += 2 * sizeof(double);
+            }
+        }
+        else
+        {
+            memcpy(&b[pos], reinterpret_cast<const byte*>(begin), static_cast<size_t>(sz) * sizeof(double));
         }
-#else
-        memcpy(&b[pos], reinterpret_cast<const Byte*>(begin), static_cast<size_t>(sz) * sizeof(Double));
-#endif
     }
 }
 
@@ -561,103 +703,76 @@ Ice::OutputStream::write(const char*)
 void
 Ice::OutputStream::writeConverted(const char* vdata, size_t vsize)
 {
+    StringConverterPtr stringConverter = _stringConverter;
+    if (!stringConverter)
+    {
+        stringConverter = getProcessStringConverter();
+    }
+
+    if (!stringConverter)
+    {
+        // No converter installed; write the string as-is (assumed to be UTF-8 already).
+        writeSize(static_cast<int32_t>(vsize));
+        Container::size_type position = b.size();
+        resize(position + vsize);
+        memcpy(&b[position], vdata, vsize);
+        return;
+    }
+
     //
-    // What is the size of the resulting UTF-8 encoded string?
-    // Impossible to tell, so we guess. If we don't guess correctly,
-    // we'll have to fix the mistake afterwards
+    // Convert the narrow string to UTF-8 using the string converter and write the result to the stream.
+    //
+    // The worst-case expansion for converting a narrow string to UTF-8 is 3x (e.g., a single byte in Shift_JIS can
+    // expand to 3 bytes in UTF-8). We use this upper bound to decide the size encoding:
+    //  - If vsize <= 254 / 3 (84), the converted string is at most 252 bytes, which always fits in a 1-byte size.
+    //  - Otherwise, we use the 5-byte size encoding to avoid guessing and memmove fixups.
     //
     try
     {
-        Int guessedSize = static_cast<Int>(vsize);
-        writeSize(guessedSize); // writeSize() only writes the size; it does not reserve any buffer space.
-
-        size_t firstIndex = b.size();
-        StreamUTF8BufferI buffer(*this);
-
-        Byte* lastByte = ICE_NULLPTR;
-        bool converted = false;
-        if(_instance)
-        {
-            const StringConverterPtr& stringConverter = _instance->getStringConverter();
-            if(stringConverter)
-            {
-                lastByte = stringConverter->toUTF8(vdata, vdata + vsize, buffer);
-                converted = true;
-            }
-        }
-        else
+        if (vsize <= 254 / 3)
         {
-            StringConverterPtr stringConverter = getProcessStringConverter();
-            if(stringConverter)
+            // The maximum UTF-8 size is vsize * 3 <= 252, which fits in a 1-byte size encoding.
+            auto sizePos = startOneByteSize();
+
+            StreamUTF8BufferI buffer(*this);
+            byte* lastByte = stringConverter->toUTF8(vdata, vdata + vsize, buffer);
+            if (lastByte != b.end())
             {
-                lastByte = stringConverter->toUTF8(vdata, vdata + vsize, buffer);
-                converted = true;
+                resize(static_cast<size_t>(lastByte - b.begin()));
             }
-        }
 
-        if(!converted)
-        {
-            Container::size_type position = b.size();
-            resize(position + vsize);
-            memcpy(&b[position], vdata, vsize);
-            return;
+            endOneByteSize(sizePos);
         }
-
-        if(lastByte != b.end())
+        else
         {
-            resize(static_cast<size_t>(lastByte - b.begin()));
-        }
-        size_t lastIndex = b.size();
+            // Write the first byte of the 5-byte size encoding, followed by a 4-byte size placeholder.
+            write(uint8_t(255));
+            auto sizePos = startSize();
 
-        Int actualSize = static_cast<Int>(lastIndex - firstIndex);
-
-        //
-        // Check against the guess
-        //
-        if(guessedSize != actualSize)
-        {
-            if(guessedSize <= 254 && actualSize > 254)
+            StreamUTF8BufferI buffer(*this);
+            byte* lastByte = stringConverter->toUTF8(vdata, vdata + vsize, buffer);
+            if (lastByte != b.end())
             {
-                //
-                // Move the UTF-8 sequence 4 bytes further
-                // Use memmove instead of memcpy since the source and destination typically overlap.
-                //
-                resize(b.size() + 4);
-                memmove(b.begin() + firstIndex + 4, b.begin() + firstIndex, static_cast<size_t>(actualSize));
-            }
-            else if(guessedSize > 254 && actualSize <= 254)
-            {
-                //
-                // Move the UTF-8 sequence 4 bytes back
-                //
-                memmove(b.begin() + firstIndex - 4, b.begin() + firstIndex, static_cast<size_t>(actualSize));
-                resize(b.size() - 4);
+                resize(static_cast<size_t>(lastByte - b.begin()));
             }
 
-            if(guessedSize <= 254)
-            {
-                rewriteSize(actualSize, b.begin() + firstIndex - 1);
-            }
-            else
-            {
-                rewriteSize(actualSize, b.begin() + firstIndex - 1 - 4);
-            }
+            endSize(sizePos);
         }
     }
-    catch(const IceUtil::IllegalConversionException& ex)
+    catch (const Ice::IllegalConversionException& ex)
     {
-        throw StringConversionException(__FILE__, __LINE__, ex.reason());
+        throw MarshalException{__FILE__, __LINE__, string{"failed to marshal a string:\n"} + ex.what()};
     }
 }
 
 void
 Ice::OutputStream::write(const string* begin, const string* end, bool convert)
 {
-    Int sz = static_cast<Int>(end - begin);
+    auto sz = static_cast<int32_t>(end - begin);
     writeSize(sz);
-    if(sz > 0)
+    if (sz > 0)
     {
-        for(int j = 0; j < sz; ++j)
+        for (int j = 0; j < sz; ++j)
         {
             write(begin[j], convert);
         }
@@ -665,9 +780,9 @@ Ice::OutputStream::write(const string* begin, const string* end, bool convert)
 }
 
 void
-Ice::OutputStream::write(const wstring& v)
+Ice::OutputStream::write(wstring_view v)
 {
-    if(v.empty())
+    if (v.empty())
     {
         writeSize(0);
         return;
@@ -680,38 +795,36 @@ Ice::OutputStream::write(const wstring& v)
     //
     try
     {
-        Int guessedSize = static_cast<Int>(v.size());
+        auto guessedSize = static_cast<int32_t>(v.size());
         writeSize(guessedSize); // writeSize() only writes the size; it does not reserve any buffer space.
 
         size_t firstIndex = b.size();
         StreamUTF8BufferI buffer(*this);
 
-        Byte* lastByte = ICE_NULLPTR;
+        byte* lastByte = nullptr;
 
-        // Note: wstringConverter is never null; when set to null, get returns the default unicode wstring converter
-        if(_instance)
+        WstringConverterPtr wstringConverter = _wstringConverter;
+        if (!wstringConverter)
         {
-            lastByte = _instance->getWstringConverter()->toUTF8(v.data(), v.data() + v.size(), buffer);
-        }
-        else
-        {
-            lastByte = getProcessWstringConverter()->toUTF8(v.data(), v.data() + v.size(), buffer);
+            wstringConverter = getProcessWstringConverter();
         }
+        assert(wstringConverter); // never null
+        lastByte = wstringConverter->toUTF8(v.data(), v.data() + v.size(), buffer);
 
-        if(lastByte != b.end())
+        if (lastByte != b.end())
         {
             resize(static_cast<size_t>(lastByte - b.begin()));
         }
         size_t lastIndex = b.size();
 
-        Int actualSize = static_cast<Int>(lastIndex - firstIndex);
+        auto actualSize = static_cast<int32_t>(lastIndex - firstIndex);
 
         //
         // Check against the guess
         //
-        if(guessedSize != actualSize)
+        if (guessedSize != actualSize)
         {
-            if(guessedSize <= 254 && actualSize > 254)
+            if (guessedSize <= 254 && actualSize > 254)
             {
                 //
                 // Move the UTF-8 sequence 4 bytes further
@@ -720,7 +833,7 @@ Ice::OutputStream::write(const wstring& v)
                 resize(b.size() + 4);
                 memmove(b.begin() + firstIndex + 4, b.begin() + firstIndex, static_cast<size_t>(actualSize));
             }
-            else if(guessedSize > 254 && actualSize <= 254)
+            else if (guessedSize > 254 && actualSize <= 254)
             {
                 //
                 // Move the UTF-8 sequence 4 bytes back
@@ -729,7 +842,7 @@ Ice::OutputStream::write(const wstring& v)
                 resize(b.size() - 4);
             }
 
-            if(guessedSize <= 254)
+            if (guessedSize <= 254)
             {
                 rewriteSize(actualSize, b.begin() + firstIndex - 1);
             }
@@ -739,20 +852,20 @@ Ice::OutputStream::write(const wstring& v)
             }
         }
     }
-    catch(const IceUtil::IllegalConversionException& ex)
+    catch (const Ice::IllegalConversionException& ex)
     {
-        throw StringConversionException(__FILE__, __LINE__, ex.reason());
+        throw MarshalException{__FILE__, __LINE__, string{"failed to marshal a string:\n"} + ex.what()};
     }
 }
 
 void
 Ice::OutputStream::write(const wstring* begin, const wstring* end)
 {
-    Int sz = static_cast<Int>(end - begin);
+    auto sz = static_cast<int32_t>(end - begin);
     writeSize(sz);
-    if(sz > 0)
+    if (sz > 0)
     {
-        for(int j = 0; j < sz; ++j)
+        for (int j = 0; j < sz; ++j)
         {
             write(begin[j]);
         }
@@ -760,35 +873,30 @@ Ice::OutputStream::write(const wstring* begin, const wstring* end)
 }
 
 void
-#ifdef ICE_CPP11_MAPPING
-Ice::OutputStream::writeProxy(const shared_ptr<ObjectPrx>& v)
-#else
-Ice::OutputStream::write(const ObjectPrx& v)
-#endif
+Ice::OutputStream::writeProxy(const ObjectPrx& v)
 {
-    if(v)
-    {
-        v->_write(*this);
-    }
-    else
-    {
-        Identity ident;
-        write(ident);
-    }
+    v->_write(*this);
 }
 
 void
-Ice::OutputStream::writeEnum(Int v, Int maxValue)
+Ice::OutputStream::writeNullProxy()
 {
-    if(getEncoding() == Encoding_1_0)
+    Identity ident;
+    write(ident);
+}
+
+void
+Ice::OutputStream::writeEnum(int32_t v, int32_t maxValue)
+{
+    if (getEncoding() == Encoding_1_0)
     {
-        if(maxValue < 127)
+        if (maxValue < 127)
         {
-            write(static_cast<Byte>(v));
+            write(static_cast<uint8_t>(v));
         }
-        else if(maxValue < 32767)
+        else if (maxValue < 32767)
         {
-            write(static_cast<Short>(v));
+            write(static_cast<int16_t>(v));
         }
         else
         {
@@ -805,21 +913,23 @@ void
 Ice::OutputStream::writeException(const UserException& e)
 {
     initEncaps();
+    // Exceptions are always encoded with the sliced format.
+    _currentEncaps->format = FormatType::SlicedFormat;
     _currentEncaps->encoder->write(e);
 }
 
 bool
-Ice::OutputStream::writeOptImpl(Int tag, OptionalFormat type)
+Ice::OutputStream::writeOptImpl(int32_t tag, OptionalFormat type)
 {
-    if(getEncoding() == Encoding_1_0)
+    if (getEncoding() == Encoding_1_0)
     {
         return false; // Optional members aren't supported with the 1.0 encoding.
     }
 
-    Byte v = static_cast<Byte>(type);
-    if(tag < 30)
+    auto v = static_cast<uint8_t>(type);
+    if (tag < 30)
     {
-        v |= static_cast<Byte>(tag << 3);
+        v |= static_cast<uint8_t>(tag << 3);
         write(v);
     }
     else
@@ -832,48 +942,37 @@ Ice::OutputStream::writeOptImpl(Int tag, OptionalFormat type)
 }
 
 void
-Ice::OutputStream::finished(vector<Byte>& bytes)
+Ice::OutputStream::finished(vector<byte>& bytes)
 {
-    vector<Byte>(b.begin(), b.end()).swap(bytes);
+    vector<byte>(b.begin(), b.end()).swap(bytes);
 }
 
-pair<const Byte*, const Byte*>
+pair<const byte*, const byte*>
 Ice::OutputStream::finished()
 {
-    if(b.empty())
+    if (b.empty())
     {
-        return pair<const Byte*, const Byte*>(reinterpret_cast<Ice::Byte*>(0), reinterpret_cast<Ice::Byte*>(0));
+        return {nullptr, nullptr};
     }
     else
     {
-        return pair<const Byte*, const Byte*>(&b[0], &b[0] + b.size());
+        return {&b[0], &b[0] + b.size()};
     }
 }
 
-void
-Ice::OutputStream::throwEncapsulationException(const char* file, int line)
-{
-    throw EncapsulationException(file, line);
-}
-
 void
 Ice::OutputStream::initEncaps()
 {
-    if(!_currentEncaps) // Lazy initialization.
+    if (!_currentEncaps) // Lazy initialization.
     {
         _currentEncaps = &_preAllocatedEncaps;
         _currentEncaps->start = b.size();
         _currentEncaps->encoding = _encoding;
     }
 
-    if(_currentEncaps->format == Ice::ICE_ENUM(FormatType, DefaultFormat))
+    if (!_currentEncaps->encoder) // Lazy initialization.
     {
-        _currentEncaps->format = _format;
-    }
-
-    if(!_currentEncaps->encoder) // Lazy initialization.
-    {
-        if(_currentEncaps->encoding == Encoding_1_0)
+        if (_currentEncaps->encoding == Encoding_1_0)
         {
             _currentEncaps->encoder = new EncapsEncoder10(this, _currentEncaps);
         }
@@ -884,33 +983,31 @@ Ice::OutputStream::initEncaps()
     }
 }
 
-Ice::OutputStream::EncapsEncoder::~EncapsEncoder()
-{
-    // Out of line to avoid weak vtable
-}
+// Out of line to avoid weak vtable
+Ice::OutputStream::EncapsEncoder::~EncapsEncoder() = default;
 
-Int
-Ice::OutputStream::EncapsEncoder::registerTypeId(const string& typeId)
+int32_t
+Ice::OutputStream::EncapsEncoder::registerTypeId(string_view typeId)
 {
-    TypeIdMap::const_iterator p = _typeIdMap.find(typeId);
-    if(p != _typeIdMap.end())
+    auto p = _typeIdMap.find(typeId);
+    if (p != _typeIdMap.end())
     {
         return p->second;
     }
     else
     {
-        _typeIdMap.insert(make_pair(typeId, ++_typeIdIndex));
+        _typeIdMap.insert(make_pair(string{typeId}, ++_typeIdIndex));
         return -1;
     }
 }
 
 void
-Ice::OutputStream::EncapsEncoder10::write(const ValuePtr& v)
+Ice::OutputStream::EncapsEncoder10::write(const shared_ptr<Value>& v)
 {
     //
     // Object references are encoded as a negative integer in 1.0.
     //
-    if(v)
+    if (v)
     {
         _stream->write(-registerValue(v));
     }
@@ -934,7 +1031,7 @@ Ice::OutputStream::EncapsEncoder10::write(const UserException& v)
     bool usesClasses = v._usesClasses();
     _stream->write(usesClasses);
     v._write(_stream);
-    if(usesClasses)
+    if (usesClasses)
     {
         writePendingValues();
     }
@@ -949,12 +1046,12 @@ Ice::OutputStream::EncapsEncoder10::startInstance(SliceType sliceType, const Sli
 void
 Ice::OutputStream::EncapsEncoder10::endInstance()
 {
-    if(_sliceType == ValueSlice)
+    if (_sliceType == ValueSlice)
     {
         //
         // Write the Object slice.
         //
-        startSlice(Object::ice_staticId(), -1, true);
+        startSlice(Value::ice_staticId(), -1, true);
         _stream->writeSize(0); // For compatibility with the old AFM.
         endSlice();
     }
@@ -962,17 +1059,17 @@ Ice::OutputStream::EncapsEncoder10::endInstance()
 }
 
 void
-Ice::OutputStream::EncapsEncoder10::startSlice(const string& typeId, int, bool /*last*/)
+Ice::OutputStream::EncapsEncoder10::startSlice(string_view typeId, int, bool /*last*/)
 {
     //
     // For instance slices, encode a boolean to indicate how the type ID
     // is encoded and the type ID either as a string or index. For
     // exception slices, always encode the type ID as a string.
     //
-    if(_sliceType == ValueSlice)
+    if (_sliceType == ValueSlice)
     {
-        Int index = registerTypeId(typeId);
-        if(index < 0)
+        int32_t index = registerTypeId(typeId);
+        if (index < 0)
         {
             _stream->write(false);
             _stream->write(typeId, false);
@@ -988,7 +1085,7 @@ Ice::OutputStream::EncapsEncoder10::startSlice(const string& typeId, int, bool /
         _stream->write(typeId, false);
     }
 
-    _stream->write(Int(0)); // Placeholder for the slice length.
+    _stream->write(int32_t(0)); // Placeholder for the slice length.
 
     _writeSlice = _stream->b.size();
 }
@@ -999,67 +1096,51 @@ Ice::OutputStream::EncapsEncoder10::endSlice()
     //
     // Write the slice length.
     //
-    Int sz = static_cast<Int>(_stream->b.size() - _writeSlice + sizeof(Int));
-    Byte* dest = &(*(_stream->b.begin() + _writeSlice - sizeof(Int)));
+    auto sz = static_cast<int32_t>(_stream->b.size() - _writeSlice + sizeof(int32_t));
+    byte* dest = &(*(_stream->b.begin() + _writeSlice - sizeof(int32_t)));
     _stream->write(sz, dest);
 }
 
 void
 Ice::OutputStream::EncapsEncoder10::writePendingValues()
 {
-    while(!_toBeMarshaledMap.empty())
+    while (!_toBeMarshaledMap.empty())
     {
         //
-        // Consider the to be marshalled instances as marshalled now,
+        // Consider the to be marshaled instances as marshaled now,
         // this is necessary to avoid adding again the "to be
-        // marshalled instances" into _toBeMarshaledMap while writing
+        // marshaled instances" into _toBeMarshaledMap while writing
         // instances.
         //
         _marshaledMap.insert(_toBeMarshaledMap.begin(), _toBeMarshaledMap.end());
 
         PtrToIndexMap savedMap;
         savedMap.swap(_toBeMarshaledMap);
-        _stream->writeSize(static_cast<Int>(savedMap.size()));
-        for(PtrToIndexMap::iterator p = savedMap.begin(); p != savedMap.end(); ++p)
+        _stream->writeSize(static_cast<int32_t>(savedMap.size()));
+        for (const auto& entry : savedMap)
         {
-            //
             // Ask the instance to marshal itself. Any new class
             // instances that are triggered by the classes marshaled
             // are added to toBeMarshaledMap.
-            //
-            _stream->write(p->second);
+            _stream->write(entry.second);
 
-            try
-            {
-                p->first->ice_preMarshal();
-            }
-            catch(const std::exception& ex)
-            {
-                Warning out(_stream->instance()->initializationData().logger);
-                out << "std::exception raised by ice_preMarshal:\n" << ex;
-            }
-            catch(...)
-            {
-                Warning out(_stream->instance()->initializationData().logger);
-                out << "unknown exception raised by ice_preMarshal";
-            }
-
-            p->first->_iceWrite(_stream);
+            entry.first->ice_preMarshal();
+            entry.first->_iceWrite(_stream);
         }
     }
     _stream->writeSize(0); // Zero marker indicates end of sequence of sequences of instances.
 }
 
-Int
-Ice::OutputStream::EncapsEncoder10::registerValue(const ValuePtr& v)
+int32_t
+Ice::OutputStream::EncapsEncoder10::registerValue(const shared_ptr<Value>& v)
 {
     assert(v);
 
     //
     // Look for this instance in the to-be-marshaled map.
     //
-    PtrToIndexMap::const_iterator p = _toBeMarshaledMap.find(v);
-    if(p != _toBeMarshaledMap.end())
+    auto p = _toBeMarshaledMap.find(v);
+    if (p != _toBeMarshaledMap.end())
     {
         return p->second;
     }
@@ -1067,8 +1148,8 @@ Ice::OutputStream::EncapsEncoder10::registerValue(const ValuePtr& v)
     //
     // Didn't find it, try the marshaled map next.
     //
-    PtrToIndexMap::const_iterator q = _marshaledMap.find(v);
-    if(q != _marshaledMap.end())
+    auto q = _marshaledMap.find(v);
+    if (q != _marshaledMap.end())
     {
         return q->second;
     }
@@ -1082,13 +1163,13 @@ Ice::OutputStream::EncapsEncoder10::registerValue(const ValuePtr& v)
 }
 
 void
-Ice::OutputStream::EncapsEncoder11::write(const ValuePtr& v)
+Ice::OutputStream::EncapsEncoder11::write(const shared_ptr<Value>& v)
 {
-    if(!v)
+    if (!v)
     {
         _stream->writeSize(0); // Nil reference.
     }
-    else if(_current && _encaps->format == ICE_ENUM(FormatType, SlicedFormat))
+    else if (_current && _encaps->format == FormatType::SlicedFormat)
     {
         //
         // If writing an instance within a slice and using the sliced
@@ -1097,11 +1178,11 @@ Ice::OutputStream::EncapsEncoder11::write(const ValuePtr& v)
         // each slice and is always read (even if the Slice is
         // unknown).
         //
-        PtrToIndexMap::const_iterator p = _current->indirectionMap.find(v);
-        if(p == _current->indirectionMap.end())
+        auto p = _current->indirectionMap.find(v);
+        if (p == _current->indirectionMap.end())
         {
             _current->indirectionTable.push_back(v);
-            Int idx = static_cast<Int>(_current->indirectionTable.size()); // Position + 1 (0 is reserved for nil)
+            auto idx = static_cast<int32_t>(_current->indirectionTable.size()); // Position + 1 (0 is reserved for nil)
             _current->indirectionMap.insert(make_pair(v, idx));
             _stream->writeSize(idx);
         }
@@ -1125,7 +1206,7 @@ Ice::OutputStream::EncapsEncoder11::write(const UserException& v)
 void
 Ice::OutputStream::EncapsEncoder11::startInstance(SliceType sliceType, const SlicedDataPtr& data)
 {
-    if(!_current)
+    if (!_current)
     {
         _current = &_preAllocatedInstanceData;
     }
@@ -1136,7 +1217,7 @@ Ice::OutputStream::EncapsEncoder11::startInstance(SliceType sliceType, const Sli
     _current->sliceType = sliceType;
     _current->firstSlice = true;
 
-    if(data)
+    if (data)
     {
         writeSlicedData(data);
     }
@@ -1149,46 +1230,46 @@ Ice::OutputStream::EncapsEncoder11::endInstance()
 }
 
 void
-Ice::OutputStream::EncapsEncoder11::startSlice(const string& typeId, int compactId, bool last)
+Ice::OutputStream::EncapsEncoder11::startSlice(string_view typeId, int compactId, bool last)
 {
     assert(_current->indirectionTable.empty() && _current->indirectionMap.empty());
 
     _current->sliceFlagsPos = _stream->b.size();
 
     _current->sliceFlags = 0;
-    if(_encaps->format == ICE_ENUM(FormatType, SlicedFormat))
+    if (_encaps->format == FormatType::SlicedFormat)
     {
         _current->sliceFlags |= FLAG_HAS_SLICE_SIZE; // Encode the slice size if using the sliced format.
     }
-    if(last)
+    if (last)
     {
         _current->sliceFlags |= FLAG_IS_LAST_SLICE; // This is the last slice.
     }
 
-    _stream->write(Byte(0)); // Placeholder for the slice flags
+    _stream->write(std::uint8_t(0)); // Placeholder for the slice flags
 
     //
     // For instance slices, encode the flag and the type ID either as a
     // string or index. For exception slices, always encode the type
     // ID a string.
     //
-    if(_current->sliceType == ValueSlice)
+    if (_current->sliceType == ValueSlice)
     {
         //
         // Encode the type ID (only in the first slice for the compact
         // encoding).
         //
-        if(_encaps->format == ICE_ENUM(FormatType, SlicedFormat) || _current->firstSlice)
+        if (_encaps->format == FormatType::SlicedFormat || _current->firstSlice)
         {
-            if(compactId >= 0)
+            if (compactId != -1)
             {
                 _current->sliceFlags |= FLAG_HAS_TYPE_ID_COMPACT;
                 _stream->writeSize(compactId);
             }
             else
             {
-                Int index = registerTypeId(typeId);
-                if(index < 0)
+                int32_t index = registerTypeId(typeId);
+                if (index < 0)
                 {
                     _current->sliceFlags |= FLAG_HAS_TYPE_ID_STRING;
                     _stream->write(typeId, false);
@@ -1206,9 +1287,9 @@ Ice::OutputStream::EncapsEncoder11::startSlice(const string& typeId, int compact
         _stream->write(typeId, false);
     }
 
-    if(_current->sliceFlags & FLAG_HAS_SLICE_SIZE)
+    if (_current->sliceFlags & FLAG_HAS_SLICE_SIZE)
     {
-        _stream->write(Int(0)); // Placeholder for the slice length.
+        _stream->write(int32_t(0)); // Placeholder for the slice length.
     }
 
     _current->writeSlice = _stream->b.size();
@@ -1223,7 +1304,7 @@ Ice::OutputStream::EncapsEncoder11::endSlice()
     // were encoded. Note that the optional members are encoded before
     // the indirection table and are included in the slice size.
     //
-    if(_current->sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS)
+    if (_current->sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS)
     {
         _stream->write(OPTIONAL_END_MARKER);
     }
@@ -1231,27 +1312,27 @@ Ice::OutputStream::EncapsEncoder11::endSlice()
     //
     // Write the slice length if necessary.
     //
-    if(_current->sliceFlags & FLAG_HAS_SLICE_SIZE)
+    if (_current->sliceFlags & FLAG_HAS_SLICE_SIZE)
     {
-        Int sz = static_cast<Int>(_stream->b.size() - _current->writeSlice + sizeof(Int));
-        Byte* dest = &(*(_stream->b.begin() + _current->writeSlice - sizeof(Int)));
+        auto sz = static_cast<int32_t>(_stream->b.size() - _current->writeSlice + sizeof(int32_t));
+        byte* dest = &(*(_stream->b.begin() + _current->writeSlice - sizeof(int32_t)));
         _stream->write(sz, dest);
     }
 
     //
     // Only write the indirection table if it contains entries.
     //
-    if(!_current->indirectionTable.empty())
+    if (!_current->indirectionTable.empty())
     {
-        assert(_encaps->format == ICE_ENUM(FormatType, SlicedFormat));
+        assert(_encaps->format == FormatType::SlicedFormat);
         _current->sliceFlags |= FLAG_HAS_INDIRECTION_TABLE;
 
         //
         // Write the indirect instance table.
         //
-        _stream->writeSize(static_cast<Int>(_current->indirectionTable.size()));
+        _stream->writeSize(static_cast<int32_t>(_current->indirectionTable.size()));
         ValueList::const_iterator p;
-        for(p = _current->indirectionTable.begin(); p != _current->indirectionTable.end(); ++p)
+        for (p = _current->indirectionTable.begin(); p != _current->indirectionTable.end(); ++p)
         {
             writeInstance(*p);
         }
@@ -1262,20 +1343,20 @@ Ice::OutputStream::EncapsEncoder11::endSlice()
     //
     // Finally, update the slice flags.
     //
-    Byte* dest = &(*(_stream->b.begin() + _current->sliceFlagsPos));
-    *dest = _current->sliceFlags;
+    byte* dest = &(*(_stream->b.begin() + _current->sliceFlagsPos));
+    *dest = byte{_current->sliceFlags};
 }
 
 bool
-Ice::OutputStream::EncapsEncoder11::writeOptional(Ice::Int tag, Ice::OptionalFormat format)
+Ice::OutputStream::EncapsEncoder11::writeOptional(int32_t tag, Ice::OptionalFormat format)
 {
-    if(!_current)
+    if (!_current)
     {
         return _stream->writeOptImpl(tag, format);
     }
     else
     {
-        if(_stream->writeOptImpl(tag, format))
+        if (_stream->writeOptImpl(tag, format))
         {
             _current->sliceFlags |= FLAG_HAS_OPTIONAL_MEMBERS;
             return true;
@@ -1298,21 +1379,21 @@ Ice::OutputStream::EncapsEncoder11::writeSlicedData(const SlicedDataPtr& slicedD
     // essentially "slices" the instance into the most-derived type
     // known by the sender.
     //
-    if(_encaps->format != ICE_ENUM(FormatType, SlicedFormat))
+    if (_encaps->format != FormatType::SlicedFormat)
     {
         return;
     }
 
-    for(SliceInfoSeq::const_iterator p = slicedData->slices.begin(); p != slicedData->slices.end(); ++p)
+    for (const auto& slice : slicedData->slices)
     {
-        startSlice((*p)->typeId, (*p)->compactId, (*p)->isLastSlice);
+        startSlice(slice->typeId, slice->compactId, slice->isLastSlice);
 
         //
         // Write the bytes associated with this slice.
         //
-        _stream->writeBlob((*p)->bytes);
+        _stream->writeBlob(slice->bytes);
 
-        if((*p)->hasOptionalMembers)
+        if (slice->hasOptionalMembers)
         {
             _current->sliceFlags |= FLAG_HAS_OPTIONAL_MEMBERS;
         }
@@ -1320,22 +1401,22 @@ Ice::OutputStream::EncapsEncoder11::writeSlicedData(const SlicedDataPtr& slicedD
         //
         // Make sure to also re-write the instance indirection table.
         //
-        _current->indirectionTable = (*p)->instances;
+        _current->indirectionTable = slice->instances;
 
         endSlice();
     }
 }
 
 void
-Ice::OutputStream::EncapsEncoder11::writeInstance(const ValuePtr& v)
+Ice::OutputStream::EncapsEncoder11::writeInstance(const shared_ptr<Value>& v)
 {
     assert(v);
 
     //
     // If the instance was already marshaled, just write it's ID.
     //
-    PtrToIndexMap::const_iterator q = _marshaledMap.find(v);
-    if(q != _marshaledMap.end())
+    auto q = _marshaledMap.find(v);
+    if (q != _marshaledMap.end())
     {
         _stream->writeSize(q->second);
         return;
@@ -1347,21 +1428,7 @@ Ice::OutputStream::EncapsEncoder11::writeInstance(const ValuePtr& v)
     //
     _marshaledMap.insert(make_pair(v, ++_valueIdIndex));
 
-    try
-    {
-        v->ice_preMarshal();
-    }
-    catch(const std::exception& ex)
-    {
-        Warning out(_stream->instance()->initializationData().logger);
-        out << "std::exception raised by ice_preMarshal:\n" << ex;
-    }
-    catch(...)
-    {
-        Warning out(_stream->instance()->initializationData().logger);
-        out << "unknown exception raised by ice_preMarshal";
-    }
-
+    v->ice_preMarshal();
     _stream->writeSize(1); // Object instance marker.
     v->_iceWrite(_stream);
 }