zeroc-ice 3.7.11 → 3.8.1

data/dist/IceRuby/Types.cpp

@@ -1,23 +1,15 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#if defined(__clang__)
-#   pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-#include <Types.h>
-#include <Proxy.h>
-#include <Util.h>
-#include <IceUtil/InputUtil.h>
-#include <IceUtil/OutputUtil.h>
-#include <IceUtil/ScopedArray.h>
-#include <Ice/InputStream.h>
-#include <Ice/LocalException.h>
-#include <Ice/OutputStream.h>
-#include <Ice/SlicedData.h>
-#include <list>
+// Copyright (c) ZeroC, Inc.
+
+#include "Types.h"
+#include "Ice/InputStream.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/OutputStream.h"
+#include "Ice/OutputUtil.h"
+#include "Ice/SlicedData.h"
+#include "Proxy.h"
+#include "Util.h"
 #include <limits>
+#include <list>
 #include <math.h>
 
 //
@@ -25,78 +17,69 @@
 // T_ZOMBIE is only defined in Ruby 1.9.
 //
 #ifndef T_ZOMBIE
-#   include "st.h"
+#    include "st.h"
 #endif
 
 #ifndef RHASH_SIZE
-#   define RHASH_SIZE(v) RHASH(v)->tbl->num_entries
+#    define RHASH_SIZE(v) RHASH(v)->tbl->num_entries
 #endif
 
 using namespace std;
 using namespace IceRuby;
-using namespace IceUtil;
-using namespace IceUtilInternal;
+using namespace Ice;
+using namespace IceInternal;
 
-static VALUE _typeInfoClass, _exceptionInfoClass, _unsetTypeClass;
+static VALUE _typeInfoClass, _exceptionInfoClass;
 
-typedef map<string, ClassInfoPtr> ClassInfoMap;
+typedef map<string, ClassInfoPtr, std::less<>> ClassInfoMap;
 static ClassInfoMap _classInfoMap;
 
-typedef map<Ice::Int, ClassInfoPtr> CompactIdMap;
-static CompactIdMap _compactIdMap;
-
-typedef map<string, ProxyInfoPtr> ProxyInfoMap;
+typedef map<string, ProxyInfoPtr, std::less<>> ProxyInfoMap;
 static ProxyInfoMap _proxyInfoMap;
 
-typedef map<string, ExceptionInfoPtr> ExceptionInfoMap;
+typedef map<string, ExceptionInfoPtr, std::less<>> ExceptionInfoMap;
 static ExceptionInfoMap _exceptionInfoMap;
 
 namespace IceRuby
 {
+    class InfoMapDestroyer
+    {
+    public:
+        ~InfoMapDestroyer();
+    };
+    static InfoMapDestroyer infoMapDestroyer;
 
-VALUE Unset;
-
-class InfoMapDestroyer
-{
-public:
-
-    ~InfoMapDestroyer();
-};
-static InfoMapDestroyer infoMapDestroyer;
-
-string
-escapeString(const string& str)
-{
-    static const string basicSourceChars = "abcdefghijklmnopqrstuvwxyz"
-                                           "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                                           "0123456789"
-                                           "_{}[]#()<>%:;.?*+-/^&|~!=,\\\"' ";
-    static const set<char> charSet(basicSourceChars.begin(), basicSourceChars.end());
+    string escapeString(const string& str)
+    {
+        static const string basicSourceChars = "abcdefghijklmnopqrstuvwxyz"
+                                               "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                               "0123456789"
+                                               "_{}[]#()<>%:;.?*+-/^&|~!=,\\\"' ";
+        static const set<char> charSet(basicSourceChars.begin(), basicSourceChars.end());
 
-    ostringstream out;
+        ostringstream out;
 
-    for(string::const_iterator c = str.begin(); c != str.end(); ++c)
-    {
-        if(charSet.find(*c) == charSet.end())
-        {
-            unsigned char uc = static_cast<unsigned char>(*c); // char may be signed, so make it positive
-            ostringstream s;
-            s << "\\";                                         // Print as octal if not in basic source character set
-            s.width(3);
-            s.fill('0');
-            s << oct;
-            s << static_cast<unsigned>(uc);
-            out << s.str();
-        }
-        else
+        for (string::const_iterator c = str.begin(); c != str.end(); ++c)
         {
-            out << *c;                              // Print normally if in basic source character set
+            if (charSet.find(*c) == charSet.end())
+            {
+                unsigned char uc = static_cast<unsigned char>(*c); // char may be signed, so make it positive
+                ostringstream s;
+                s << "\\"; // Print as octal if not in basic source character set
+                s.width(3);
+                s.fill('0');
+                s << oct;
+                s << static_cast<unsigned>(uc);
+                out << s.str();
+            }
+            else
+            {
+                out << *c; // Print normally if in basic source character set
+            }
         }
-    }
-
-    return out.str();
-}
 
+        return out.str();
+    }
 }
 
 //
@@ -110,9 +93,9 @@ addClassInfo(const string& id, const ClassInfoPtr& info)
     // translated definitions and then dynamically load
     // duplicate definitions.
     //
-//    assert(_classInfoMap.find(id) == _classInfoMap.end());
+    //    assert(_classInfoMap.find(id) == _classInfoMap.end());
     ClassInfoMap::iterator p = _classInfoMap.find(id);
-    if(p != _classInfoMap.end())
+    if (p != _classInfoMap.end())
     {
         _classInfoMap.erase(p);
     }
@@ -130,9 +113,9 @@ addProxyInfo(const string& id, const ProxyInfoPtr& info)
     // translated definitions and then dynamically load
     // duplicate definitions.
     //
-//    assert(_proxyInfoMap.find(id) == _proxyInfoMap.end());
+    //    assert(_proxyInfoMap.find(id) == _proxyInfoMap.end());
     ProxyInfoMap::iterator p = _proxyInfoMap.find(id);
-    if(p != _proxyInfoMap.end())
+    if (p != _proxyInfoMap.end())
     {
         _proxyInfoMap.erase(p);
     }
@@ -143,10 +126,10 @@ addProxyInfo(const string& id, const ProxyInfoPtr& info)
 // lookupProxyInfo()
 //
 static IceRuby::ProxyInfoPtr
-lookupProxyInfo(const string& id)
+lookupProxyInfo(string_view id)
 {
     ProxyInfoMap::iterator p = _proxyInfoMap.find(id);
-    if(p != _proxyInfoMap.end())
+    if (p != _proxyInfoMap.end())
     {
         return p->second;
     }
@@ -164,7 +147,7 @@ addExceptionInfo(const string& id, const ExceptionInfoPtr& info)
     // translated definitions and then dynamically load
     // duplicate definitions.
     //
-//    assert(_exceptionInfoMap.find(id) == _exceptionInfoMap.end());
+    //    assert(_exceptionInfoMap.find(id) == _exceptionInfoMap.end());
     _exceptionInfoMap.insert(ExceptionInfoMap::value_type(id, info));
 }
 
@@ -174,19 +157,17 @@ addExceptionInfo(const string& id, const ExceptionInfoPtr& info)
 VALUE IceRuby::StreamUtil::_slicedDataType = Qnil;
 VALUE IceRuby::StreamUtil::_sliceInfoType = Qnil;
 
-IceRuby::StreamUtil::StreamUtil()
-{
-}
+IceRuby::StreamUtil::StreamUtil() = default;
 
 IceRuby::StreamUtil::~StreamUtil()
 {
     //
-    // Make sure we break any cycles among the ObjectReaders in preserved slices.
+    // Make sure we break any cycles among the ValueReaders in preserved slices.
     //
-    for(set<ObjectReaderPtr>::iterator p = _readers.begin(); p != _readers.end(); ++p)
+    for (set<shared_ptr<ValueReader>>::iterator p = _readers.begin(); p != _readers.end(); ++p)
     {
         Ice::SlicedDataPtr slicedData = (*p)->getSlicedData();
-        for(Ice::SliceInfoSeq::const_iterator q = slicedData->slices.begin(); q != slicedData->slices.end(); ++q)
+        for (Ice::SliceInfoSeq::const_iterator q = slicedData->slices.begin(); q != slicedData->slices.end(); ++q)
         {
             //
             // Don't just call (*q)->instances.clear(), as releasing references
@@ -194,20 +175,20 @@ IceRuby::StreamUtil::~StreamUtil()
             // the vector into a temporary and then let the temporary fall out
             // of scope.
             //
-            vector<Ice::ObjectPtr> tmp;
+            vector<shared_ptr<Ice::Value>> tmp;
             tmp.swap((*q)->instances);
         }
     }
 }
 
 void
-IceRuby::StreamUtil::add(const ReadObjectCallbackPtr& callback)
+IceRuby::StreamUtil::add(const ReadValueCallbackPtr& callback)
 {
     _callbacks.push_back(callback);
 }
 
 void
-IceRuby::StreamUtil::add(const ObjectReaderPtr& reader)
+IceRuby::StreamUtil::add(const shared_ptr<ValueReader>& reader)
 {
     assert(reader->getSlicedData());
     _readers.insert(reader);
@@ -216,7 +197,7 @@ IceRuby::StreamUtil::add(const ObjectReaderPtr& reader)
 void
 IceRuby::StreamUtil::updateSlicedData()
 {
-    for(set<ObjectReaderPtr>::iterator p = _readers.begin(); p != _readers.end(); ++p)
+    for (set<shared_ptr<ValueReader>>::iterator p = _readers.begin(); p != _readers.end(); ++p)
     {
         setSlicedDataMember((*p)->getObject(), (*p)->getSlicedData());
     }
@@ -231,12 +212,12 @@ IceRuby::StreamUtil::setSlicedDataMember(VALUE obj, const Ice::SlicedDataPtr& sl
 
     assert(slicedData);
 
-    if(_slicedDataType == Qnil)
+    if (_slicedDataType == Qnil)
     {
         _slicedDataType = callRuby(rb_path2class, "Ice::SlicedData");
         assert(!NIL_P(_slicedDataType));
     }
-    if(_sliceInfoType == Qnil)
+    if (_sliceInfoType == Qnil)
     {
         _sliceInfoType = callRuby(rb_path2class, "Ice::SliceInfo");
         assert(!NIL_P(_sliceInfoType));
@@ -252,7 +233,7 @@ IceRuby::StreamUtil::setSlicedDataMember(VALUE obj, const Ice::SlicedDataPtr& sl
     // Translate each SliceInfo object into its Ruby equivalent.
     //
     int i = 0;
-    for(vector<Ice::SliceInfoPtr>::const_iterator p = slicedData->slices.begin(); p != slicedData->slices.end(); ++p)
+    for (vector<Ice::SliceInfoPtr>::const_iterator p = slicedData->slices.begin(); p != slicedData->slices.end(); ++p)
     {
         volatile VALUE slice = callRuby(rb_class_new_instance, 0, static_cast<VALUE*>(0), _sliceInfoType);
 
@@ -274,9 +255,10 @@ IceRuby::StreamUtil::setSlicedDataMember(VALUE obj, const Ice::SlicedDataPtr& sl
         //
         // bytes
         //
-        volatile VALUE bytes = callRuby(rb_str_new,
-                                        (*p)->bytes.empty() ? 0 : reinterpret_cast<const char*>(&(*p)->bytes[0]),
-                                        static_cast<long>((*p)->bytes.size()));
+        volatile VALUE bytes = callRuby(
+            rb_str_new,
+            (*p)->bytes.empty() ? 0 : reinterpret_cast<const char*>(&(*p)->bytes[0]),
+            static_cast<long>((*p)->bytes.size()));
         callRuby(rb_iv_set, slice, "@bytes", bytes);
 
         //
@@ -286,13 +268,13 @@ IceRuby::StreamUtil::setSlicedDataMember(VALUE obj, const Ice::SlicedDataPtr& sl
         callRuby(rb_iv_set, slice, "@instances", instances);
 
         int j = 0;
-        for(vector<Ice::ObjectPtr>::iterator q = (*p)->instances.begin(); q != (*p)->instances.end(); ++q)
+        for (vector<shared_ptr<Ice::Value>>::iterator q = (*p)->instances.begin(); q != (*p)->instances.end(); ++q)
         {
             //
-            // Each element in the instances list is an instance of ObjectReader that wraps a Ruby object.
+            // Each element in the instances list is an instance of ValueReader that wraps a Ruby object.
             //
             assert(*q);
-            ObjectReaderPtr r = ObjectReaderPtr::dynamicCast(*q);
+            auto r = dynamic_pointer_cast<ValueReader>(*q);
             assert(r);
             VALUE o = r->getObject();
             assert(o != Qnil); // Should be non-nil.
@@ -315,19 +297,19 @@ IceRuby::StreamUtil::setSlicedDataMember(VALUE obj, const Ice::SlicedDataPtr& sl
 }
 
 //
-// Instances of preserved class and exception types may have a data member
-// named _ice_slicedData which is an instance of the Ruby class Ice::SlicedData.
+// Instances of class types may have a data member named _ice_slicedData which is an instance of the Ruby class
+// Ice::SlicedData. This data member is only set for unmarshaled instances.
 //
 Ice::SlicedDataPtr
-IceRuby::StreamUtil::getSlicedDataMember(VALUE obj, ObjectMap* objectMap)
+IceRuby::StreamUtil::getSlicedDataMember(VALUE obj, ValueMap* valueMap)
 {
     Ice::SlicedDataPtr slicedData;
 
-    if(callRuby(rb_ivar_defined, obj, rb_intern("@_ice_slicedData")) == Qtrue)
+    if (callRuby(rb_ivar_defined, obj, rb_intern("@_ice_slicedData")) == Qtrue)
     {
         volatile VALUE sd = callRuby(rb_iv_get, obj, "@_ice_slicedData");
 
-        if(sd != Qnil)
+        if (sd != Qnil)
         {
             //
             // The "slices" member is an array of Ice::SliceInfo objects.
@@ -338,43 +320,42 @@ IceRuby::StreamUtil::getSlicedDataMember(VALUE obj, ObjectMap* objectMap)
             Ice::SliceInfoSeq slices;
 
             long sz = RARRAY_LEN(sl);
-            for(long i = 0; i < sz; ++i)
+            for (long i = 0; i < sz; ++i)
             {
                 volatile VALUE s = RARRAY_AREF(sl, i);
 
-                Ice::SliceInfoPtr info = new Ice::SliceInfo;
-
                 volatile VALUE typeId = callRuby(rb_iv_get, s, "@typeId");
-                info->typeId = getString(typeId);
-
                 volatile VALUE compactId = callRuby(rb_iv_get, s, "@compactId");
-                info->compactId = static_cast<Ice::Int>(getInteger(compactId));
 
                 volatile VALUE bytes = callRuby(rb_iv_get, s, "@bytes");
                 assert(TYPE(bytes) == T_STRING);
                 const char* str = RSTRING_PTR(bytes);
                 const long len = RSTRING_LEN(bytes);
-                if(str != 0 && len != 0)
-                {
-                    vector<Ice::Byte> vtmp(reinterpret_cast<const Ice::Byte*>(str),
-                                           reinterpret_cast<const Ice::Byte*>(str + len));
-                    info->bytes.swap(vtmp);
-                }
+                vector<byte> vtmp(reinterpret_cast<const byte*>(str), reinterpret_cast<const byte*>(str + len));
+                volatile VALUE hasOptionalMembers = callRuby(rb_iv_get, s, "@hasOptionalMembers");
+                volatile VALUE isLastSlice = callRuby(rb_iv_get, s, "@isLastSlice");
+
+                auto info = std::make_shared<Ice::SliceInfo>(
+                    getString(typeId),
+                    static_cast<int32_t>(getInteger(compactId)),
+                    std::move(vtmp),
+                    hasOptionalMembers == Qtrue,
+                    isLastSlice == Qtrue);
 
                 volatile VALUE instances = callRuby(rb_iv_get, s, "@instances");
                 assert(TYPE(instances) == T_ARRAY);
                 long osz = RARRAY_LEN(instances);
-                for(long j = 0; j < osz; ++j)
+                for (long j = 0; j < osz; ++j)
                 {
                     VALUE o = RARRAY_AREF(instances, j);
 
-                    Ice::ObjectPtr writer;
+                    shared_ptr<Ice::Value> writer;
 
-                    ObjectMap::iterator k = objectMap->find(o);
-                    if(k == objectMap->end())
+                    ValueMap::iterator k = valueMap->find(o);
+                    if (k == valueMap->end())
                     {
-                        writer = new ObjectWriter(o, objectMap, 0);
-                        objectMap->insert(ObjectMap::value_type(o, writer));
+                        writer = make_shared<ValueWriter>(o, valueMap, nullptr);
+                        valueMap->insert(ValueMap::value_type(o, writer));
                     }
                     else
                     {
@@ -384,16 +365,10 @@ IceRuby::StreamUtil::getSlicedDataMember(VALUE obj, ObjectMap* objectMap)
                     info->instances.push_back(writer);
                 }
 
-                volatile VALUE hasOptionalMembers = callRuby(rb_iv_get, s, "@hasOptionalMembers");
-                info->hasOptionalMembers = hasOptionalMembers == Qtrue;
-
-                volatile VALUE isLastSlice = callRuby(rb_iv_get, s, "@isLastSlice");
-                info->isLastSlice = isLastSlice == Qtrue;
-
                 slices.push_back(info);
             }
 
-            slicedData = new Ice::SlicedData(slices);
+            slicedData = std::make_shared<Ice::SlicedData>(slices);
         }
     }
 
@@ -403,16 +378,12 @@ IceRuby::StreamUtil::getSlicedDataMember(VALUE obj, ObjectMap* objectMap)
 //
 // UnmarshalCallback implementation.
 //
-IceRuby::UnmarshalCallback::~UnmarshalCallback()
-{
-}
+IceRuby::UnmarshalCallback::~UnmarshalCallback() = default;
 
 //
 // TypeInfo implementation.
 //
-IceRuby::TypeInfo::TypeInfo()
-{
-}
+IceRuby::TypeInfo::TypeInfo() = default;
 
 bool
 IceRuby::TypeInfo::usesClasses() const
@@ -434,35 +405,31 @@ IceRuby::TypeInfo::destroy()
 //
 // PrimitiveInfo implementation.
 //
-IceRuby::PrimitiveInfo::PrimitiveInfo()
-{
-}
+IceRuby::PrimitiveInfo::PrimitiveInfo() = default;
 
-IceRuby::PrimitiveInfo::PrimitiveInfo(Kind k) : kind(k)
-{
-}
+IceRuby::PrimitiveInfo::PrimitiveInfo(Kind k) : kind(k) {}
 
 string
 IceRuby::PrimitiveInfo::getId() const
 {
-    switch(kind)
-    {
-    case KindBool:
-        return "bool";
-    case KindByte:
-        return "byte";
-    case KindShort:
-        return "short";
-    case KindInt:
-        return "int";
-    case KindLong:
-        return "long";
-    case KindFloat:
-        return "float";
-    case KindDouble:
-        return "double";
-    case KindString:
-        return "string";
+    switch (kind)
+    {
+        case KindBool:
+            return "bool";
+        case KindByte:
+            return "byte";
+        case KindShort:
+            return "short";
+        case KindInt:
+            return "int";
+        case KindLong:
+            return "long";
+        case KindFloat:
+            return "float";
+        case KindDouble:
+            return "double";
+        case KindString:
+            return "string";
     }
     assert(false);
     return string();
@@ -489,23 +456,23 @@ IceRuby::PrimitiveInfo::variableLength() const
 int
 IceRuby::PrimitiveInfo::wireSize() const
 {
-    switch(kind)
-    {
-    case KindBool:
-    case KindByte:
-        return 1;
-    case KindShort:
-        return 2;
-    case KindInt:
-        return 4;
-    case KindLong:
-        return 8;
-    case KindFloat:
-        return 4;
-    case KindDouble:
-        return 8;
-    case KindString:
-        return 1;
+    switch (kind)
+    {
+        case KindBool:
+        case KindByte:
+            return 1;
+        case KindShort:
+            return 2;
+        case KindInt:
+            return 4;
+        case KindLong:
+            return 8;
+        case KindFloat:
+            return 4;
+        case KindDouble:
+            return 8;
+        case KindString:
+            return 1;
     }
     assert(false);
     return 0;
@@ -514,226 +481,216 @@ IceRuby::PrimitiveInfo::wireSize() const
 Ice::OptionalFormat
 IceRuby::PrimitiveInfo::optionalFormat() const
 {
-    switch(kind)
-    {
-    case KindBool:
-    case KindByte:
-        return Ice::OptionalFormatF1;
-    case KindShort:
-        return Ice::OptionalFormatF2;
-    case KindInt:
-        return Ice::OptionalFormatF4;
-    case KindLong:
-        return Ice::OptionalFormatF8;
-    case KindFloat:
-        return Ice::OptionalFormatF4;
-    case KindDouble:
-        return Ice::OptionalFormatF8;
-    case KindString:
-        return Ice::OptionalFormatVSize;
+    switch (kind)
+    {
+        case KindBool:
+        case KindByte:
+            return Ice::OptionalFormat::F1;
+        case KindShort:
+            return Ice::OptionalFormat::F2;
+        case KindInt:
+            return Ice::OptionalFormat::F4;
+        case KindLong:
+            return Ice::OptionalFormat::F8;
+        case KindFloat:
+            return Ice::OptionalFormat::F4;
+        case KindDouble:
+            return Ice::OptionalFormat::F8;
+        case KindString:
+            return Ice::OptionalFormat::VSize;
     }
 
     assert(false);
-    return Ice::OptionalFormatF1;
+    return Ice::OptionalFormat::F1;
 }
 
 void
-IceRuby::PrimitiveInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap*, bool)
+IceRuby::PrimitiveInfo::marshal(VALUE p, Ice::OutputStream* os, ValueMap*, bool)
 {
-    switch(kind)
-    {
-    case PrimitiveInfo::KindBool:
-    {
-        os->write(static_cast<bool>(RTEST(p)));
-        break;
-    }
-    case PrimitiveInfo::KindByte:
+    switch (kind)
     {
-        long i = getInteger(p);
-        if(i >= 0 && i <= 255)
+        case PrimitiveInfo::KindBool:
         {
-            os->write(static_cast<Ice::Byte>(i));
+            os->write(static_cast<bool>(RTEST(p)));
             break;
         }
-        throw RubyException(rb_eTypeError, "value is out of range for a byte");
-    }
-    case PrimitiveInfo::KindShort:
-    {
-        long i = getInteger(p);
-        if(i >= SHRT_MIN && i <= SHRT_MAX)
+        case PrimitiveInfo::KindByte:
         {
-            os->write(static_cast<Ice::Short>(i));
-            break;
+            long i = getInteger(p);
+            if (i >= 0 && i <= 255)
+            {
+                os->write(static_cast<uint8_t>(i));
+                break;
+            }
+            throw RubyException(rb_eTypeError, "value is out of range for a byte");
         }
-        throw RubyException(rb_eTypeError, "value is out of range for a short");
-    }
-    case PrimitiveInfo::KindInt:
-    {
-        long i = getInteger(p);
-        if(i >= INT_MIN && i <= INT_MAX)
+        case PrimitiveInfo::KindShort:
         {
-            os->write(static_cast<Ice::Int>(i));
+            long i = getInteger(p);
+            if (i >= SHRT_MIN && i <= SHRT_MAX)
+            {
+                os->write(static_cast<int16_t>(i));
+                break;
+            }
+            throw RubyException(rb_eTypeError, "value is out of range for a short");
+        }
+        case PrimitiveInfo::KindInt:
+        {
+            long i = getInteger(p);
+            if (i >= INT_MIN && i <= INT_MAX)
+            {
+                os->write(static_cast<int32_t>(i));
+                break;
+            }
+            throw RubyException(rb_eTypeError, "value is out of range for an int");
+        }
+        case PrimitiveInfo::KindLong:
+        {
+            os->write(getLong(p));
             break;
         }
-        throw RubyException(rb_eTypeError, "value is out of range for an int");
-    }
-    case PrimitiveInfo::KindLong:
-    {
-        os->write(getLong(p));
-        break;
-    }
-    case PrimitiveInfo::KindFloat:
-    {
-        volatile VALUE val = callRuby(rb_Float, p);
-        if(NIL_P(val))
+        case PrimitiveInfo::KindFloat:
         {
-            throw RubyException(rb_eTypeError, "unable to convert value to a float");
+            volatile VALUE val = callRuby(rb_Float, p);
+            if (NIL_P(val))
+            {
+                throw RubyException(rb_eTypeError, "unable to convert value to a float");
+            }
+            assert(TYPE(val) == T_FLOAT);
+            double d = static_cast<double>(RFLOAT_VALUE(val));
+            if (isfinite(d) && (d > numeric_limits<float>::max() || d < -numeric_limits<float>::max()))
+            {
+                throw RubyException(rb_eTypeError, "value is out of range for a float");
+            }
+            os->write(static_cast<float>(d));
+            break;
         }
-        assert(TYPE(val) == T_FLOAT);
-        double d = static_cast<double>(RFLOAT_VALUE(val));
-        if(
-#if defined(_MSC_VER) && (_MSC_VER <= 1700)
-            _finite(val) &&
-#else
-            isfinite(d) &&
-#endif
-            (d > numeric_limits<float>::max() || d < -numeric_limits<float>::max()))
+        case PrimitiveInfo::KindDouble:
         {
-            throw RubyException(rb_eTypeError, "value is out of range for a float");
+            volatile VALUE val = callRuby(rb_Float, p);
+            if (NIL_P(val))
+            {
+                throw RubyException(rb_eTypeError, "unable to convert value to a double");
+            }
+            assert(TYPE(val) == T_FLOAT);
+            os->write(static_cast<double>(RFLOAT_VALUE(val)));
+            break;
         }
-        os->write(static_cast<float>(d));
-        break;
-    }
-    case PrimitiveInfo::KindDouble:
-    {
-        volatile VALUE val = callRuby(rb_Float, p);
-        if(NIL_P(val))
+        case PrimitiveInfo::KindString:
         {
-            throw RubyException(rb_eTypeError, "unable to convert value to a double");
+            string val = getString(p);
+            os->write(val, false); // Bypass string conversion.
+            break;
         }
-        assert(TYPE(val) == T_FLOAT);
-        os->write(static_cast<double>(RFLOAT_VALUE(val)));
-        break;
-    }
-    case PrimitiveInfo::KindString:
-    {
-        string val = getString(p);
-#ifdef HAVE_RUBY_ENCODING_H
-        os->write(val, false); // Bypass string conversion.
-#else
-        os->write(val, true);
-#endif
-        break;
-    }
     }
 }
 
 void
-IceRuby::PrimitiveInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr& cb, VALUE target,
-                                  void* closure, bool)
+IceRuby::PrimitiveInfo::unmarshal(
+    Ice::InputStream* is,
+    const UnmarshalCallbackPtr& cb,
+    VALUE target,
+    void* closure,
+    bool)
 {
     volatile VALUE val = Qnil;
-    switch(kind)
-    {
-    case PrimitiveInfo::KindBool:
-    {
-        bool b;
-        is->read(b);
-        val = b ? Qtrue : Qfalse;
-        break;
-    }
-    case PrimitiveInfo::KindByte:
+    switch (kind)
     {
-        Ice::Byte b;
-        is->read(b);
-        val = callRuby(rb_int2inum, b);
-        break;
-    }
-    case PrimitiveInfo::KindShort:
-    {
-        Ice::Short sh;
-        is->read(sh);
-        val = callRuby(rb_int2inum, sh);
-        break;
-    }
-    case PrimitiveInfo::KindInt:
-    {
-        Ice::Int i;
-        is->read(i);
-        val = callRuby(rb_int2inum, i);
-        break;
-    }
-    case PrimitiveInfo::KindLong:
-    {
-        Ice::Long l;
-        is->read(l);
-        val = callRuby(rb_ll2inum, l);
-        break;
-    }
-    case PrimitiveInfo::KindFloat:
-    {
-        Ice::Float f;
-        is->read(f);
-        val = callRuby(rb_float_new, f);
-        break;
-    }
-    case PrimitiveInfo::KindDouble:
-    {
-        Ice::Double d;
-        is->read(d);
-        val = callRuby(rb_float_new, d);
-        break;
-    }
-    case PrimitiveInfo::KindString:
-    {
-        string str;
-#ifdef HAVE_RUBY_ENCODING_H
-        is->read(str, false); // Bypass string conversion.
-#else
-        is->read(str, true);
-#endif
-        val = createString(str);
-        break;
-    }
+        case PrimitiveInfo::KindBool:
+        {
+            bool b;
+            is->read(b);
+            val = b ? Qtrue : Qfalse;
+            break;
+        }
+        case PrimitiveInfo::KindByte:
+        {
+            uint8_t b;
+            is->read(b);
+            val = callRuby(rb_int2inum, b);
+            break;
+        }
+        case PrimitiveInfo::KindShort:
+        {
+            int16_t sh;
+            is->read(sh);
+            val = callRuby(rb_int2inum, sh);
+            break;
+        }
+        case PrimitiveInfo::KindInt:
+        {
+            int32_t i;
+            is->read(i);
+            val = callRuby(rb_int2inum, i);
+            break;
+        }
+        case PrimitiveInfo::KindLong:
+        {
+            int64_t l;
+            is->read(l);
+            val = callRuby(rb_ll2inum, l);
+            break;
+        }
+        case PrimitiveInfo::KindFloat:
+        {
+            float f;
+            is->read(f);
+            val = callRuby(rb_float_new, f);
+            break;
+        }
+        case PrimitiveInfo::KindDouble:
+        {
+            double d;
+            is->read(d);
+            val = callRuby(rb_float_new, d);
+            break;
+        }
+        case PrimitiveInfo::KindString:
+        {
+            string str;
+            is->read(str, false); // Bypass string conversion.
+            val = createString(str);
+            break;
+        }
     }
     cb->unmarshaled(val, target, closure);
 }
 
 void
-IceRuby::PrimitiveInfo::print(VALUE value, IceUtilInternal::Output& out, PrintObjectHistory*)
+IceRuby::PrimitiveInfo::print(VALUE value, IceInternal::Output& out, PrintObjectHistory*)
 {
-    switch(kind)
+    switch (kind)
     {
-    case PrimitiveInfo::KindBool:
-    {
-        out << (RTEST(value) ? "true" : "false");
-        break;
-    }
-    case PrimitiveInfo::KindByte:
-    case PrimitiveInfo::KindShort:
-    case PrimitiveInfo::KindInt:
-    {
-        out << getInteger(value);
-        break;
-    }
-    case PrimitiveInfo::KindLong:
-    {
-        Ice::Long l = getLong(value);
-        out << IceUtilInternal::int64ToString(l);
-        break;
-    }
-    case PrimitiveInfo::KindFloat:
-    case PrimitiveInfo::KindDouble:
-    {
-        double d = toDouble(value);
-        out << d;
-        break;
-    }
-    case PrimitiveInfo::KindString:
-    {
-        out << "'" << getString(value) << "'";
-        break;
-    }
+        case PrimitiveInfo::KindBool:
+        {
+            out << (RTEST(value) ? "true" : "false");
+            break;
+        }
+        case PrimitiveInfo::KindByte:
+        case PrimitiveInfo::KindShort:
+        case PrimitiveInfo::KindInt:
+        {
+            out << getInteger(value);
+            break;
+        }
+        case PrimitiveInfo::KindLong:
+        {
+            int64_t l = getLong(value);
+            out << l;
+            break;
+        }
+        case PrimitiveInfo::KindFloat:
+        case PrimitiveInfo::KindDouble:
+        {
+            double d = toDouble(value);
+            out << d;
+            break;
+        }
+        case PrimitiveInfo::KindString:
+        {
+            out << "'" << getString(value) << "'";
+            break;
+        }
     }
 }
 
@@ -741,7 +698,7 @@ double
 IceRuby::PrimitiveInfo::toDouble(VALUE v)
 {
     volatile VALUE val = callRuby(rb_Float, v);
-    if(NIL_P(val))
+    if (NIL_P(val))
     {
         throw RubyException(rb_eTypeError, "unable to convert value to a double");
     }
@@ -755,39 +712,35 @@ IceRuby::PrimitiveInfo::toDouble(VALUE v)
 
 namespace
 {
-struct EnumDefinitionIterator : public IceRuby::HashIterator
-{
-    EnumDefinitionIterator() :
-        maxValue(0)
-    {
-    }
-
-    virtual void element(VALUE key, VALUE value)
+    struct EnumDefinitionIterator : public IceRuby::HashIterator
     {
-        const Ice::Int v = static_cast<Ice::Int>(getInteger(key));
-        assert(enumerators.find(v) == enumerators.end());
-        enumerators[v] = value;
+        EnumDefinitionIterator() : maxValue(0) {}
 
-        if(v > maxValue)
+        virtual void element(VALUE key, VALUE value)
         {
-            maxValue = v;
+            const int32_t v = static_cast<int32_t>(getInteger(key));
+            assert(enumerators.find(v) == enumerators.end());
+            enumerators[v] = value;
+
+            if (v > maxValue)
+            {
+                maxValue = v;
+            }
         }
-    }
 
-    Ice::Int maxValue;
-    IceRuby::EnumeratorMap enumerators;
-};
+        int32_t maxValue;
+        IceRuby::EnumeratorMap enumerators;
+    };
 }
 
-IceRuby::EnumInfo::EnumInfo(VALUE ident, VALUE t, VALUE e) :
-    rubyClass(t), maxValue(0)
+IceRuby::EnumInfo::EnumInfo(VALUE ident, VALUE t, VALUE e) : rubyClass(t), maxValue(0)
 {
     const_cast<string&>(id) = getString(ident);
 
     EnumDefinitionIterator iter;
     hashIterate(e, iter);
 
-    const_cast<Ice::Int&>(maxValue) = iter.maxValue;
+    const_cast<int32_t&>(maxValue) = iter.maxValue;
     const_cast<EnumeratorMap&>(enumerators) = iter.enumerators;
 }
 
@@ -818,11 +771,11 @@ IceRuby::EnumInfo::wireSize() const
 Ice::OptionalFormat
 IceRuby::EnumInfo::optionalFormat() const
 {
-    return Ice::OptionalFormatSize;
+    return Ice::OptionalFormat::Size;
 }
 
 void
-IceRuby::EnumInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap*, bool)
+IceRuby::EnumInfo::marshal(VALUE p, Ice::OutputStream* os, ValueMap*, bool)
 {
     assert(callRuby(rb_obj_is_instance_of, p, rubyClass) == Qtrue); // validate() should have caught this.
 
@@ -830,8 +783,8 @@ IceRuby::EnumInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap*, bool)
     // Validate value.
     //
     volatile VALUE val = callRuby(rb_iv_get, p, "@value");
-    const Ice::Int ival = static_cast<Ice::Int>(getInteger(val));
-    if(enumerators.find(ival) == enumerators.end())
+    const int32_t ival = static_cast<int32_t>(getInteger(val));
+    if (enumerators.find(ival) == enumerators.end())
     {
         throw RubyException(rb_eRangeError, "invalid enumerator %ld for enum %s", ival, id.c_str());
     }
@@ -840,13 +793,12 @@ IceRuby::EnumInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap*, bool)
 }
 
 void
-IceRuby::EnumInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr& cb, VALUE target, void* closure,
-                             bool)
+IceRuby::EnumInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr& cb, VALUE target, void* closure, bool)
 {
-    Ice::Int val = is->readEnum(maxValue);
+    int32_t val = is->readEnum(maxValue);
 
     EnumeratorMap::const_iterator p = enumerators.find(val);
-    if(p == enumerators.end())
+    if (p == enumerators.end())
     {
         ostringstream ostr;
         ostr << "invalid enumerator " << val << " for enum " << id;
@@ -857,9 +809,9 @@ IceRuby::EnumInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr& c
 }
 
 void
-IceRuby::EnumInfo::print(VALUE value, IceUtilInternal::Output& out, PrintObjectHistory*)
+IceRuby::EnumInfo::print(VALUE value, IceInternal::Output& out, PrintObjectHistory*)
 {
-    if(!validate(value))
+    if (!validate(value))
     {
         out << "<invalid value - expected " << id << ">";
         return;
@@ -884,20 +836,20 @@ convertDataMembers(VALUE members, DataMemberList& reqMembers, DataMemberList& op
 
     volatile VALUE arr = callRuby(rb_check_array_type, members);
     assert(!NIL_P(arr));
-    for(long i = 0; i < RARRAY_LEN(arr); ++i)
+    for (long i = 0; i < RARRAY_LEN(arr); ++i)
     {
         volatile VALUE m = callRuby(rb_check_array_type, RARRAY_AREF(arr, i));
         assert(!NIL_P(m));
         assert(RARRAY_LEN(m) == (allowOptional ? 4 : 2));
 
-        DataMemberPtr member = new DataMember;
+        DataMemberPtr member = make_shared<DataMember>();
 
         member->name = getString(RARRAY_AREF(m, 0));
         member->type = getType(RARRAY_AREF(m, 1));
         string s = "@" + member->name;
         member->rubyID = rb_intern(s.c_str());
 
-        if(allowOptional)
+        if (allowOptional)
         {
             member->optional = RTEST(RARRAY_AREF(m, 2));
             member->tag = static_cast<int>(getInteger(RARRAY_AREF(m, 3)));
@@ -908,7 +860,7 @@ convertDataMembers(VALUE members, DataMemberList& reqMembers, DataMemberList& op
             member->tag = 0;
         }
 
-        if(member->optional)
+        if (member->optional)
         {
             optList.push_back(member);
         }
@@ -918,15 +870,12 @@ convertDataMembers(VALUE members, DataMemberList& reqMembers, DataMemberList& op
         }
     }
 
-    if(allowOptional)
+    if (allowOptional)
     {
         class SortFn
         {
         public:
-            static bool compare(const DataMemberPtr& lhs, const DataMemberPtr& rhs)
-            {
-                return lhs->tag < rhs->tag;
-            }
+            static bool compare(const DataMemberPtr& lhs, const DataMemberPtr& rhs) { return lhs->tag < rhs->tag; }
         };
 
         optList.sort(SortFn::compare);
@@ -937,8 +886,7 @@ convertDataMembers(VALUE members, DataMemberList& reqMembers, DataMemberList& op
 //
 // StructInfo implementation.
 //
-IceRuby::StructInfo::StructInfo(VALUE ident, VALUE t, VALUE m) :
-    rubyClass(t), _nullMarshalValue(Qnil)
+IceRuby::StructInfo::StructInfo(VALUE ident, VALUE t, VALUE m) : rubyClass(t)
 {
     const_cast<string&>(id) = getString(ident);
 
@@ -948,9 +896,9 @@ IceRuby::StructInfo::StructInfo(VALUE ident, VALUE t, VALUE m) :
 
     _variableLength = false;
     _wireSize = 0;
-    for(DataMemberList::const_iterator p = members.begin(); p != members.end(); ++p)
+    for (DataMemberList::const_iterator p = members.begin(); p != members.end(); ++p)
     {
-        if(!_variableLength && (*p)->type->variableLength())
+        if (!_variableLength && (*p)->type->variableLength())
         {
             _variableLength = true;
         }
@@ -967,7 +915,7 @@ IceRuby::StructInfo::getId() const
 bool
 IceRuby::StructInfo::validate(VALUE val)
 {
-    return NIL_P(val) || callRuby(rb_obj_is_kind_of, val, rubyClass) == Qtrue;
+    return !NIL_P(val) && callRuby(rb_obj_is_kind_of, val, rubyClass) == Qtrue;
 }
 
 bool
@@ -985,15 +933,15 @@ IceRuby::StructInfo::wireSize() const
 Ice::OptionalFormat
 IceRuby::StructInfo::optionalFormat() const
 {
-    return _variableLength ? Ice::OptionalFormatFSize : Ice::OptionalFormatVSize;
+    return _variableLength ? Ice::OptionalFormat::FSize : Ice::OptionalFormat::VSize;
 }
 
 bool
 IceRuby::StructInfo::usesClasses() const
 {
-    for(DataMemberList::const_iterator p = members.begin(); p != members.end(); ++p)
+    for (const auto& dm : members)
     {
-        if((*p)->type->usesClasses())
+        if (dm->type->usesClasses())
         {
             return true;
         }
@@ -1003,24 +951,14 @@ IceRuby::StructInfo::usesClasses() const
 }
 
 void
-IceRuby::StructInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap* objectMap, bool optional)
+IceRuby::StructInfo::marshal(VALUE p, Ice::OutputStream* os, ValueMap* valueMap, bool optional)
 {
-    assert(NIL_P(p) || callRuby(rb_obj_is_kind_of, p, rubyClass) == Qtrue); // validate() should have caught this.
-
-    if(NIL_P(p))
-    {
-        if(NIL_P(_nullMarshalValue))
-        {
-            _nullMarshalValue = callRuby(rb_class_new_instance, 0, static_cast<VALUE*>(0), rubyClass);
-            rb_gc_register_address(&_nullMarshalValue); // Prevent garbage collection
-        }
-        p = _nullMarshalValue;
-    }
+    assert(!NIL_P(p) && callRuby(rb_obj_is_kind_of, p, rubyClass) == Qtrue); // validate() should have caught this.
 
     Ice::OutputStream::size_type sizePos = 0;
-    if(optional)
+    if (optional)
     {
-        if(_variableLength)
+        if (_variableLength)
         {
             sizePos = os->startSize();
         }
@@ -1030,33 +968,40 @@ IceRuby::StructInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap* objectMa
         }
     }
 
-    for(DataMemberList::const_iterator q = members.begin(); q != members.end(); ++q)
+    for (DataMemberList::const_iterator q = members.begin(); q != members.end(); ++q)
     {
         DataMemberPtr member = *q;
         volatile VALUE val = callRuby(rb_ivar_get, p, member->rubyID);
-        if(!member->type->validate(val))
+        if (!member->type->validate(val))
         {
-            throw RubyException(rb_eTypeError, "invalid value for %s member `%s'", const_cast<char*>(id.c_str()),
-                                member->name.c_str());
+            throw RubyException(
+                rb_eTypeError,
+                "invalid value for %s member `%s'",
+                const_cast<char*>(id.c_str()),
+                member->name.c_str());
         }
-        member->type->marshal(val, os, objectMap, false);
+        member->type->marshal(val, os, valueMap, false);
     }
 
-    if(optional && _variableLength)
+    if (optional && _variableLength)
     {
         os->endSize(sizePos);
     }
 }
 
 void
-IceRuby::StructInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr& cb, VALUE target,
-                               void* closure, bool optional)
+IceRuby::StructInfo::unmarshal(
+    Ice::InputStream* is,
+    const UnmarshalCallbackPtr& cb,
+    VALUE target,
+    void* closure,
+    bool optional)
 {
     volatile VALUE obj = callRuby(rb_class_new_instance, 0, static_cast<VALUE*>(0), rubyClass);
 
-    if(optional)
+    if (optional)
     {
-        if(_variableLength)
+        if (_variableLength)
         {
             is->skip(4);
         }
@@ -1066,7 +1011,7 @@ IceRuby::StructInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr&
         }
     }
 
-    for(DataMemberList::const_iterator q = members.begin(); q != members.end(); ++q)
+    for (DataMemberList::const_iterator q = members.begin(); q != members.end(); ++q)
     {
         DataMemberPtr member = *q;
         member->type->unmarshal(is, member, obj, 0, false);
@@ -1076,52 +1021,39 @@ IceRuby::StructInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr&
 }
 
 void
-IceRuby::StructInfo::print(VALUE value, IceUtilInternal::Output& out, PrintObjectHistory* history)
+IceRuby::StructInfo::print(VALUE value, IceInternal::Output& out, PrintObjectHistory* history)
 {
-    if(!validate(value))
+    if (!validate(value))
     {
         out << "<invalid value - expected " << id << ">";
         return;
     }
 
-    if(NIL_P(value))
-    {
-        out << "<nil>";
-    }
-    else
+    out.sb();
+    for (const auto& member : members)
     {
-        out.sb();
-        for(DataMemberList::const_iterator q = members.begin(); q != members.end(); ++q)
+        out << nl << member->name << " = ";
+        if (callRuby(rb_ivar_defined, value, member->rubyID) == Qfalse)
         {
-            DataMemberPtr member = *q;
-            out << nl << member->name << " = ";
-            if(callRuby(rb_ivar_defined, value, member->rubyID) == Qfalse)
-            {
-                out << "<not defined>";
-            }
-            else
-            {
-                volatile VALUE val = callRuby(rb_ivar_get, value, member->rubyID);
-                member->type->print(val, out, history);
-            }
+            out << "<not defined>";
+        }
+        else
+        {
+            volatile VALUE val = callRuby(rb_ivar_get, value, member->rubyID);
+            member->type->print(val, out, history);
         }
-        out.eb();
     }
+    out.eb();
 }
 
 void
 IceRuby::StructInfo::destroy()
 {
-    for(DataMemberList::const_iterator p = members.begin(); p != members.end(); ++p)
+    for (DataMemberList::const_iterator p = members.begin(); p != members.end(); ++p)
     {
         (*p)->type->destroy();
     }
     const_cast<DataMemberList&>(members).clear();
-    if(!NIL_P(_nullMarshalValue))
-    {
-        rb_gc_unregister_address(&_nullMarshalValue); // Prevent garbage collection
-        _nullMarshalValue = Qnil;
-    }
 }
 
 //
@@ -1145,14 +1077,14 @@ IceRuby::SequenceInfo::validate(VALUE val)
     //
     // Accept nil, an array, a string (for sequence<byte>), or any object that responds to to_ary.
     //
-    if(NIL_P(val) || TYPE(val) == T_ARRAY)
+    if (NIL_P(val) || TYPE(val) == T_ARRAY)
     {
         return true;
     }
-    if(TYPE(val) == T_STRING)
+    if (TYPE(val) == T_STRING)
     {
-        PrimitiveInfoPtr pi = PrimitiveInfoPtr::dynamicCast(elementType);
-        if(pi && pi->kind == PrimitiveInfo::KindByte)
+        PrimitiveInfoPtr pi = dynamic_pointer_cast<PrimitiveInfo>(elementType);
+        if (pi && pi->kind == PrimitiveInfo::KindByte)
         {
             return true;
         }
@@ -1176,7 +1108,7 @@ IceRuby::SequenceInfo::wireSize() const
 Ice::OptionalFormat
 IceRuby::SequenceInfo::optionalFormat() const
 {
-    return elementType->variableLength() ? Ice::OptionalFormatFSize : Ice::OptionalFormatVSize;
+    return elementType->variableLength() ? Ice::OptionalFormat::FSize : Ice::OptionalFormat::VSize;
 }
 
 bool
@@ -1186,35 +1118,35 @@ IceRuby::SequenceInfo::usesClasses() const
 }
 
 void
-IceRuby::SequenceInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap* objectMap, bool optional)
+IceRuby::SequenceInfo::marshal(VALUE p, Ice::OutputStream* os, ValueMap* valueMap, bool optional)
 {
-    PrimitiveInfoPtr pi = PrimitiveInfoPtr::dynamicCast(elementType);
+    PrimitiveInfoPtr pi = dynamic_pointer_cast<PrimitiveInfo>(elementType);
 
     volatile VALUE arr = Qnil;
 
     Ice::OutputStream::size_type sizePos = 0;
-    if(optional)
+    if (optional)
     {
-        if(elementType->variableLength())
+        if (elementType->variableLength())
         {
             sizePos = os->startSize();
         }
-        else if(elementType->wireSize() > 1)
+        else if (elementType->wireSize() > 1)
         {
             //
             // Determine the sequence size.
             //
             int sz = 0;
-            if(!NIL_P(p))
+            if (!NIL_P(p))
             {
-                if(TYPE(p) == T_ARRAY)
+                if (TYPE(p) == T_ARRAY)
                 {
                     sz = static_cast<int>(RARRAY_LEN(p));
                 }
                 else
                 {
                     arr = callRuby(rb_Array, p);
-                    if(NIL_P(arr))
+                    if (NIL_P(arr))
                     {
                         throw RubyException(rb_eTypeError, "unable to convert value to an array");
                     }
@@ -1225,74 +1157,81 @@ IceRuby::SequenceInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap* object
         }
     }
 
-    if(NIL_P(p))
+    if (NIL_P(p))
     {
         os->writeSize(0);
     }
-    else if(pi)
+    else if (pi)
     {
         marshalPrimitiveSequence(pi, p, os);
     }
     else
     {
-        if(NIL_P(arr))
+        if (NIL_P(arr))
         {
             arr = callRuby(rb_Array, p);
-            if(NIL_P(arr))
+            if (NIL_P(arr))
             {
                 throw RubyException(rb_eTypeError, "unable to convert value to an array");
             }
         }
 
         long sz = RARRAY_LEN(arr);
-        os->writeSize(static_cast<Ice::Int>(sz));
-        for(long i = 0; i < sz; ++i)
+        os->writeSize(static_cast<int32_t>(sz));
+        for (long i = 0; i < sz; ++i)
         {
-            if(!elementType->validate(RARRAY_AREF(arr, i)))
+            if (!elementType->validate(RARRAY_AREF(arr, i)))
             {
-                throw RubyException(rb_eTypeError, "invalid value for element %ld of `%s'", i,
-                                    const_cast<char*>(id.c_str()));
+                throw RubyException(
+                    rb_eTypeError,
+                    "invalid value for element %ld of `%s'",
+                    i,
+                    const_cast<char*>(id.c_str()));
             }
-            elementType->marshal(RARRAY_AREF(arr, i), os, objectMap, false);
+            elementType->marshal(RARRAY_AREF(arr, i), os, valueMap, false);
         }
     }
 
-    if(optional && elementType->variableLength())
+    if (optional && elementType->variableLength())
     {
         os->endSize(sizePos);
     }
 }
 
 void
-IceRuby::SequenceInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr& cb, VALUE target,
-                                 void* closure, bool optional)
+IceRuby::SequenceInfo::unmarshal(
+    Ice::InputStream* is,
+    const UnmarshalCallbackPtr& cb,
+    VALUE target,
+    void* closure,
+    bool optional)
 {
-    if(optional)
+    if (optional)
     {
-        if(elementType->variableLength())
+        if (elementType->variableLength())
         {
             is->skip(4);
         }
-        else if(elementType->wireSize() > 1)
+        else if (elementType->wireSize() > 1)
         {
             is->skipSize();
         }
     }
 
-    PrimitiveInfoPtr pi = PrimitiveInfoPtr::dynamicCast(elementType);
-    if(pi)
+    PrimitiveInfoPtr pi = dynamic_pointer_cast<PrimitiveInfo>(elementType);
+    if (pi)
     {
         unmarshalPrimitiveSequence(pi, is, cb, target, closure);
         return;
     }
 
-    Ice::Int sz = is->readSize();
+    int32_t sz = is->readSize();
     volatile VALUE arr = createArray(sz);
 
-    for(Ice::Int i = 0; i < sz; ++i)
+    for (int32_t i = 0; i < sz; ++i)
     {
         void* cl = reinterpret_cast<void*>(i);
-        elementType->unmarshal(is, this, arr, cl, false);
+        elementType->unmarshal(is, shared_from_this(), arr, cl, false);
     }
 
     cb->unmarshaled(arr, target, closure);
@@ -1301,33 +1240,30 @@ IceRuby::SequenceInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPt
 void
 IceRuby::SequenceInfo::unmarshaled(VALUE val, VALUE target, void* closure)
 {
-#ifdef ICE_64
-    long i = static_cast<long>(reinterpret_cast<long long>(closure));
-#else
+    static_assert(sizeof(long) == sizeof(void*), "long and void* must have the same size");
     long i = reinterpret_cast<long>(closure);
-#endif
     RARRAY_ASET(target, i, val);
 }
 
 void
-IceRuby::SequenceInfo::print(VALUE value, IceUtilInternal::Output& out, PrintObjectHistory* history)
+IceRuby::SequenceInfo::print(VALUE value, IceInternal::Output& out, PrintObjectHistory* history)
 {
-    if(!validate(value))
+    if (!validate(value))
     {
         out << "<invalid value - expected " << id << ">";
         return;
     }
 
-    if(NIL_P(value))
+    if (NIL_P(value))
     {
         out << "{}";
     }
     else
     {
-        if(TYPE(value) == T_STRING)
+        if (TYPE(value) == T_STRING)
         {
-            PrimitiveInfoPtr pi = PrimitiveInfoPtr::dynamicCast(elementType);
-            if(pi && pi->kind == PrimitiveInfo::KindByte)
+            PrimitiveInfoPtr pi = dynamic_pointer_cast<PrimitiveInfo>(elementType);
+            if (pi && pi->kind == PrimitiveInfo::KindByte)
             {
                 out << "'" << escapeString(getString(value)) << "'";
                 return;
@@ -1335,7 +1271,7 @@ IceRuby::SequenceInfo::print(VALUE value, IceUtilInternal::Output& out, PrintObj
         }
 
         volatile VALUE arr = callRuby(rb_Array, value);
-        if(NIL_P(arr))
+        if (NIL_P(arr))
         {
             throw RubyException(rb_eTypeError, "unable to convert value to an array");
         }
@@ -1343,7 +1279,7 @@ IceRuby::SequenceInfo::print(VALUE value, IceUtilInternal::Output& out, PrintObj
         long sz = RARRAY_LEN(arr);
 
         out.sb();
-        for(long i = 0; i < sz; ++i)
+        for (long i = 0; i < sz; ++i)
         {
             out << nl << '[' << i << "] = ";
             elementType->print(RARRAY_AREF(arr, i), out, history);
@@ -1355,7 +1291,7 @@ IceRuby::SequenceInfo::print(VALUE value, IceUtilInternal::Output& out, PrintObj
 void
 IceRuby::SequenceInfo::destroy()
 {
-    if(elementType)
+    if (elementType)
     {
         elementType->destroy();
         const_cast<TypeInfoPtr&>(elementType) = 0;
@@ -1371,16 +1307,16 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
     //
     // Accept a string or an array for sequence<byte>.
     //
-    if(pi->kind == PrimitiveInfo::KindByte)
+    if (pi->kind == PrimitiveInfo::KindByte)
     {
-        if(TYPE(p) == T_STRING)
+        if (TYPE(p) == T_STRING)
         {
             str = p;
         }
         else
         {
             arr = callRuby(rb_Array, p);
-            if(NIL_P(arr))
+            if (NIL_P(arr))
             {
                 throw RubyException(rb_eTypeError, "argument is not a string or an array");
             }
@@ -1389,293 +1325,284 @@ IceRuby::SequenceInfo::marshalPrimitiveSequence(const PrimitiveInfoPtr& pi, VALU
     else
     {
         arr = callRuby(rb_Array, p);
-        if(NIL_P(arr))
+        if (NIL_P(arr))
         {
             throw RubyException(rb_eTypeError, "unable to convert value to an array");
         }
     }
 
-    switch(pi->kind)
-    {
-    case PrimitiveInfo::KindBool:
+    switch (pi->kind)
     {
-        long sz = RARRAY_LEN(arr);
-        Ice::BoolSeq seq(static_cast<size_t>(sz));
-        for(long i = 0; i < sz; ++i)
+        case PrimitiveInfo::KindBool:
         {
-            seq[static_cast<size_t>(i)] = RTEST(RARRAY_AREF(arr, i));
+            long sz = RARRAY_LEN(arr);
+            Ice::BoolSeq seq(static_cast<size_t>(sz));
+            for (long i = 0; i < sz; ++i)
+            {
+                seq[static_cast<size_t>(i)] = RTEST(RARRAY_AREF(arr, i));
+            }
+            os->write(seq);
+            break;
         }
-        os->write(seq);
-        break;
-    }
-    case PrimitiveInfo::KindByte:
-    {
-        if(!NIL_P(str))
+        case PrimitiveInfo::KindByte:
         {
-            const char* s = RSTRING_PTR(str);
-            const long len = RSTRING_LEN(str);
-            if(s == 0 || len == 0)
+            if (!NIL_P(str))
             {
-                os->write(Ice::Int(0));
+                const char* s = RSTRING_PTR(str);
+                const long len = RSTRING_LEN(str);
+                if (s == 0 || len == 0)
+                {
+                    os->write(int32_t(0));
+                }
+                else
+                {
+                    os->write(reinterpret_cast<const byte*>(s), reinterpret_cast<const byte*>(s + len));
+                }
             }
             else
             {
-                os->write(reinterpret_cast<const Ice::Byte*>(s), reinterpret_cast<const Ice::Byte*>(s + len));
+                long sz = RARRAY_LEN(arr);
+                Ice::ByteSeq seq(static_cast<size_t>(sz));
+                for (long i = 0; i < sz; ++i)
+                {
+                    long val = getInteger(RARRAY_AREF(arr, i));
+                    if (val < 0 || val > 255)
+                    {
+                        throw RubyException(rb_eTypeError, "invalid value for element %ld of sequence<byte>", i);
+                    }
+                    seq[static_cast<size_t>(i)] = static_cast<byte>(val);
+                }
+                os->write(seq);
             }
+            break;
         }
-        else
+        case PrimitiveInfo::KindShort:
         {
             long sz = RARRAY_LEN(arr);
-            Ice::ByteSeq seq(static_cast<size_t>(sz));
-            for(long i = 0; i < sz; ++i)
+            Ice::ShortSeq seq(static_cast<size_t>(sz));
+            for (long i = 0; i < sz; ++i)
             {
                 long val = getInteger(RARRAY_AREF(arr, i));
-                if(val < 0 || val > 255)
+                if (val < SHRT_MIN || val > SHRT_MAX)
                 {
-                    throw RubyException(rb_eTypeError, "invalid value for element %ld of sequence<byte>", i);
+                    throw RubyException(rb_eTypeError, "invalid value for element %ld of sequence<short>", i);
                 }
-                seq[static_cast<size_t>(i)] = static_cast<Ice::Byte>(val);
+                seq[static_cast<size_t>(i)] = static_cast<int16_t>(val);
             }
             os->write(seq);
+            break;
         }
-        break;
-    }
-    case PrimitiveInfo::KindShort:
-    {
-        long sz = RARRAY_LEN(arr);
-        Ice::ShortSeq seq(static_cast<size_t>(sz));
-        for(long i = 0; i < sz; ++i)
+        case PrimitiveInfo::KindInt:
         {
-            long val = getInteger(RARRAY_AREF(arr, i));
-            if(val < SHRT_MIN || val > SHRT_MAX)
+            long sz = RARRAY_LEN(arr);
+            Ice::IntSeq seq(static_cast<size_t>(sz));
+            for (long i = 0; i < sz; ++i)
             {
-                throw RubyException(rb_eTypeError, "invalid value for element %ld of sequence<short>", i);
+                long val = getInteger(RARRAY_AREF(arr, i));
+                if (val < INT_MIN || val > INT_MAX)
+                {
+                    throw RubyException(rb_eTypeError, "invalid value for element %ld of sequence<int>", i);
+                }
+                seq[static_cast<size_t>(i)] = static_cast<int32_t>(val);
             }
-            seq[static_cast<size_t>(i)] = static_cast<Ice::Short>(val);
+            os->write(seq);
+            break;
         }
-        os->write(seq);
-        break;
-    }
-    case PrimitiveInfo::KindInt:
-    {
-        long sz = RARRAY_LEN(arr);
-        Ice::IntSeq seq(static_cast<size_t>(sz));
-        for(long i = 0; i < sz; ++i)
+        case PrimitiveInfo::KindLong:
         {
-            long val = getInteger(RARRAY_AREF(arr, i));
-            if(val < INT_MIN || val > INT_MAX)
+            long sz = RARRAY_LEN(arr);
+            Ice::LongSeq seq(static_cast<size_t>(sz));
+            for (long i = 0; i < sz; ++i)
             {
-                throw RubyException(rb_eTypeError, "invalid value for element %ld of sequence<int>", i);
+                seq[static_cast<size_t>(i)] = getLong(RARRAY_AREF(arr, i));
             }
-            seq[static_cast<size_t>(i)] = static_cast<Ice::Int>(val);
-        }
-        os->write(seq);
-        break;
-    }
-    case PrimitiveInfo::KindLong:
-    {
-        long sz = RARRAY_LEN(arr);
-        Ice::LongSeq seq(static_cast<size_t>(sz));
-        for(long i = 0; i < sz; ++i)
-        {
-            seq[static_cast<size_t>(i)] = getLong(RARRAY_AREF(arr, i));
+            os->write(seq);
+            break;
         }
-        os->write(seq);
-        break;
-    }
-    case PrimitiveInfo::KindFloat:
-    {
-        long sz = RARRAY_LEN(arr);
-        Ice::FloatSeq seq(static_cast<size_t>(sz));
-        for(long i = 0; i < sz; ++i)
+        case PrimitiveInfo::KindFloat:
         {
-            volatile VALUE v = callRuby(rb_Float, RARRAY_AREF(arr, i));
-            if(NIL_P(v))
+            long sz = RARRAY_LEN(arr);
+            Ice::FloatSeq seq(static_cast<size_t>(sz));
+            for (long i = 0; i < sz; ++i)
             {
-                throw RubyException(rb_eTypeError, "unable to convert array element %ld to a float", i);
+                volatile VALUE v = callRuby(rb_Float, RARRAY_AREF(arr, i));
+                if (NIL_P(v))
+                {
+                    throw RubyException(rb_eTypeError, "unable to convert array element %ld to a float", i);
+                }
+                assert(TYPE(v) == T_FLOAT);
+                seq[static_cast<size_t>(i)] = static_cast<float>(RFLOAT_VALUE(v));
             }
-            assert(TYPE(v) == T_FLOAT);
-            seq[static_cast<size_t>(i)] = static_cast<Ice::Float>(RFLOAT_VALUE(v));
+            os->write(seq);
+            break;
         }
-        os->write(seq);
-        break;
-    }
-    case PrimitiveInfo::KindDouble:
-    {
-        long sz = RARRAY_LEN(arr);
-        Ice::DoubleSeq seq(static_cast<size_t>(sz));
-        for(long i = 0; i < sz; ++i)
+        case PrimitiveInfo::KindDouble:
         {
-            volatile VALUE v = callRuby(rb_Float, RARRAY_AREF(arr, i));
-            if(NIL_P(v))
+            long sz = RARRAY_LEN(arr);
+            Ice::DoubleSeq seq(static_cast<size_t>(sz));
+            for (long i = 0; i < sz; ++i)
             {
-                throw RubyException(rb_eTypeError, "unable to convert array element %ld to a double", i);
+                volatile VALUE v = callRuby(rb_Float, RARRAY_AREF(arr, i));
+                if (NIL_P(v))
+                {
+                    throw RubyException(rb_eTypeError, "unable to convert array element %ld to a double", i);
+                }
+                assert(TYPE(v) == T_FLOAT);
+                seq[static_cast<size_t>(i)] = RFLOAT_VALUE(v);
             }
-            assert(TYPE(v) == T_FLOAT);
-            seq[static_cast<size_t>(i)] = RFLOAT_VALUE(v);
-        }
-        os->write(seq);
-        break;
-    }
-    case PrimitiveInfo::KindString:
-    {
-        long sz = RARRAY_LEN(arr);
-        Ice::StringSeq seq(static_cast<size_t>(sz));
-        for(long i = 0; i < sz; ++i)
-        {
-            seq[static_cast<size_t>(i)] = getString(RARRAY_AREF(arr, i));
-        }
-        if(seq.empty())
-        {
             os->write(seq);
+            break;
         }
-        else
+        case PrimitiveInfo::KindString:
         {
-#ifdef HAVE_RUBY_ENCODING_H
-            os->write(&seq[0], &seq[0] + seq.size(), false); // Bypass string conversion.
-#else
-            os->write(&seq[0], &seq[0] + seq.size(), true);
-#endif
+            long sz = RARRAY_LEN(arr);
+            Ice::StringSeq seq(static_cast<size_t>(sz));
+            for (long i = 0; i < sz; ++i)
+            {
+                seq[static_cast<size_t>(i)] = getString(RARRAY_AREF(arr, i));
+            }
+            if (seq.empty())
+            {
+                os->write(seq);
+            }
+            else
+            {
+                os->write(&seq[0], &seq[0] + seq.size(), false); // Bypass string conversion.
+            }
+            break;
         }
-        break;
-    }
     }
 }
 
 void
-IceRuby::SequenceInfo::unmarshalPrimitiveSequence(const PrimitiveInfoPtr& pi, Ice::InputStream* is,
-                                                  const UnmarshalCallbackPtr& cb, VALUE target, void* closure)
+IceRuby::SequenceInfo::unmarshalPrimitiveSequence(
+    const PrimitiveInfoPtr& pi,
+    Ice::InputStream* is,
+    const UnmarshalCallbackPtr& cb,
+    VALUE target,
+    void* closure)
 {
     volatile VALUE result = Qnil;
 
-    switch(pi->kind)
+    switch (pi->kind)
     {
-    case PrimitiveInfo::KindBool:
-    {
-        pair<const bool*, const bool*> p;
-        IceUtil::ScopedArray<bool> sa;
-        is->read(p, sa);
-        long sz = static_cast<long>(p.second - p.first);
-        result = createArray(sz);
-
-        if(sz > 0)
+        case PrimitiveInfo::KindBool:
         {
-            for(long i = 0; i < sz; ++i)
+            pair<const bool*, const bool*> p;
+            is->read(p);
+            long sz = static_cast<long>(p.second - p.first);
+            result = createArray(sz);
+
+            if (sz > 0)
             {
-                RARRAY_ASET(result, i, p.first[i] ? Qtrue : Qfalse);
+                for (long i = 0; i < sz; ++i)
+                {
+                    RARRAY_ASET(result, i, p.first[i] ? Qtrue : Qfalse);
+                }
             }
+            break;
         }
-        break;
-    }
-    case PrimitiveInfo::KindByte:
-    {
-        pair<const Ice::Byte*, const Ice::Byte*> p;
-        is->read(p);
-        result = callRuby(rb_str_new, reinterpret_cast<const char*>(p.first), static_cast<long>(p.second - p.first));
-        break;
-    }
-    case PrimitiveInfo::KindShort:
-    {
-        pair<const Ice::Short*, const Ice::Short*> p;
-        IceUtil::ScopedArray<Ice::Short> sa;
-        is->read(p, sa);
-        long sz = static_cast<long>(p.second - p.first);
-        result = createArray(sz);
-
-        if(sz > 0)
+        case PrimitiveInfo::KindByte:
         {
-            for(long i = 0; i < sz; ++i)
+            pair<const uint8_t*, const uint8_t*> p;
+            is->read(p);
+            result =
+                callRuby(rb_str_new, reinterpret_cast<const char*>(p.first), static_cast<long>(p.second - p.first));
+            break;
+        }
+        case PrimitiveInfo::KindShort:
+        {
+            pair<const int16_t*, const int16_t*> p;
+            is->read(p);
+            long sz = static_cast<long>(p.second - p.first);
+            result = createArray(sz);
+
+            if (sz > 0)
             {
-                RARRAY_ASET(result, i, INT2FIX(p.first[i]));
+                for (long i = 0; i < sz; ++i)
+                {
+                    RARRAY_ASET(result, i, INT2FIX(p.first[i]));
+                }
             }
+            break;
         }
-        break;
-    }
-    case PrimitiveInfo::KindInt:
-    {
-        pair<const Ice::Int*, const Ice::Int*> p;
-        IceUtil::ScopedArray<Ice::Int> sa;
-        is->read(p, sa);
-        long sz = static_cast<long>(p.second - p.first);
-        result = createArray(sz);
-
-        if(sz > 0)
+        case PrimitiveInfo::KindInt:
         {
-            for(long i = 0; i < sz; ++i)
+            pair<const int32_t*, const int32_t*> p;
+            is->read(p);
+            long sz = static_cast<long>(p.second - p.first);
+            result = createArray(sz);
+
+            if (sz > 0)
             {
-                RARRAY_ASET(result, i, INT2FIX(p.first[i]));
+                for (long i = 0; i < sz; ++i)
+                {
+                    RARRAY_ASET(result, i, INT2FIX(p.first[i]));
+                }
             }
+            break;
         }
-        break;
-    }
-    case PrimitiveInfo::KindLong:
-    {
-        pair<const Ice::Long*, const Ice::Long*> p;
-        IceUtil::ScopedArray<Ice::Long> sa;
-        is->read(p, sa);
-        long sz = static_cast<long>(p.second - p.first);
-        result = createArray(sz);
-
-        if(sz > 0)
+        case PrimitiveInfo::KindLong:
         {
-            for(long i = 0; i < sz; ++i)
+            pair<const int64_t*, const int64_t*> p;
+            is->read(p);
+            long sz = static_cast<long>(p.second - p.first);
+            result = createArray(sz);
+
+            if (sz > 0)
             {
-                RARRAY_ASET(result, i, callRuby(rb_ll2inum, p.first[i]));
+                for (long i = 0; i < sz; ++i)
+                {
+                    RARRAY_ASET(result, i, callRuby(rb_ll2inum, p.first[i]));
+                }
             }
+            break;
         }
-        break;
-    }
-    case PrimitiveInfo::KindFloat:
-    {
-        pair<const Ice::Float*, const Ice::Float*> p;
-        IceUtil::ScopedArray<Ice::Float> sa;
-        is->read(p, sa);
-        long sz = static_cast<long>(p.second - p.first);
-        result = createArray(sz);
-
-        if(sz > 0)
+        case PrimitiveInfo::KindFloat:
         {
-            for(long i = 0; i < sz; ++i)
+            pair<const float*, const float*> p;
+            is->read(p);
+            long sz = static_cast<long>(p.second - p.first);
+            result = createArray(sz);
+
+            if (sz > 0)
             {
-                RARRAY_ASET(result, i, callRuby(rb_float_new, p.first[i]));
+                for (long i = 0; i < sz; ++i)
+                {
+                    RARRAY_ASET(result, i, callRuby(rb_float_new, p.first[i]));
+                }
             }
+            break;
         }
-        break;
-    }
-    case PrimitiveInfo::KindDouble:
-    {
-        pair<const Ice::Double*, const Ice::Double*> p;
-        IceUtil::ScopedArray<Ice::Double> sa;
-        is->read(p, sa);
-        long sz = static_cast<long>(p.second - p.first);
-        result = createArray(sz);
-
-        if(sz > 0)
+        case PrimitiveInfo::KindDouble:
         {
-            for(long i = 0; i < sz; ++i)
+            pair<const double*, const double*> p;
+            is->read(p);
+            long sz = static_cast<long>(p.second - p.first);
+            result = createArray(sz);
+
+            if (sz > 0)
             {
-                RARRAY_ASET(result, i, callRuby(rb_float_new, p.first[i]));
+                for (long i = 0; i < sz; ++i)
+                {
+                    RARRAY_ASET(result, i, callRuby(rb_float_new, p.first[i]));
+                }
             }
+            break;
         }
-        break;
-    }
-    case PrimitiveInfo::KindString:
-    {
-        Ice::StringSeq seq;
-#ifdef HAVE_RUBY_ENCODING_H
-        is->read(seq, false); // Bypass string conversion.
-#else
-        is->read(seq, true);
-#endif
-        long sz = static_cast<long>(seq.size());
-        result = createArray(sz);
-
-        for(long i = 0; i < sz; ++i)
+        case PrimitiveInfo::KindString:
         {
-            RARRAY_ASET(result, i, createString(seq[static_cast<size_t>(i)]));
+            Ice::StringSeq seq;
+            is->read(seq, false); // Bypass string conversion.
+            long sz = static_cast<long>(seq.size());
+            result = createArray(sz);
+
+            for (long i = 0; i < sz; ++i)
+            {
+                RARRAY_ASET(result, i, createString(seq[static_cast<size_t>(i)]));
+            }
+            break;
         }
-        break;
-    }
     }
     cb->unmarshaled(result, target, closure);
 }
@@ -1705,7 +1632,7 @@ IceRuby::DictionaryInfo::validate(VALUE val)
     //
     // Accept nil, a hash, or any object that responds to to_hash.
     //
-    if(NIL_P(val) || TYPE(val) == T_HASH)
+    if (NIL_P(val) || TYPE(val) == T_HASH)
     {
         return true;
     }
@@ -1728,7 +1655,7 @@ IceRuby::DictionaryInfo::wireSize() const
 Ice::OptionalFormat
 IceRuby::DictionaryInfo::optionalFormat() const
 {
-    return _variableLength ? Ice::OptionalFormatFSize : Ice::OptionalFormatVSize;
+    return _variableLength ? Ice::OptionalFormat::FSize : Ice::OptionalFormat::VSize;
 }
 
 bool
@@ -1739,48 +1666,47 @@ IceRuby::DictionaryInfo::usesClasses() const
 
 namespace
 {
-struct DictionaryMarshalIterator : public IceRuby::HashIterator
-{
-    DictionaryMarshalIterator(const IceRuby::DictionaryInfoPtr& d, Ice::OutputStream* o, IceRuby::ObjectMap* m)
-        : dict(d), os(o), objectMap(m)
+    struct DictionaryMarshalIterator : public IceRuby::HashIterator
     {
-    }
+        DictionaryMarshalIterator(const IceRuby::DictionaryInfoPtr& d, Ice::OutputStream* o, IceRuby::ValueMap* m)
+            : dict(d),
+              os(o),
+              valueMap(m)
+        {
+        }
 
-    virtual void element(VALUE key, VALUE value)
-    {
-        dict->marshalElement(key, value, os, objectMap);
-    }
+        virtual void element(VALUE key, VALUE value) { dict->marshalElement(key, value, os, valueMap); }
 
-    IceRuby::DictionaryInfoPtr dict;
-    Ice::OutputStream* os;
-    IceRuby::ObjectMap* objectMap;
-};
+        IceRuby::DictionaryInfoPtr dict;
+        Ice::OutputStream* os;
+        IceRuby::ValueMap* valueMap;
+    };
 }
 
 void
-IceRuby::DictionaryInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap* objectMap, bool optional)
+IceRuby::DictionaryInfo::marshal(VALUE p, Ice::OutputStream* os, ValueMap* valueMap, bool optional)
 {
     volatile VALUE hash = Qnil;
 
-    if(!NIL_P(p))
+    if (!NIL_P(p))
     {
         hash = callRuby(rb_convert_type, p, T_HASH, "Hash", "to_hash");
-        if(NIL_P(hash))
+        if (NIL_P(hash))
         {
             throw RubyException(rb_eTypeError, "unable to convert value to a hash");
         }
     }
 
-    Ice::Int sz = 0;
-    if(!NIL_P(hash))
+    int32_t sz = 0;
+    if (!NIL_P(hash))
     {
-        sz = static_cast<Ice::Int>(RHASH_SIZE(hash));
+        sz = static_cast<int32_t>(RHASH_SIZE(hash));
     }
 
     Ice::OutputStream::size_type sizePos = 0;
-    if(optional)
+    if (optional)
     {
-        if(_variableLength)
+        if (_variableLength)
         {
             sizePos = os->startSize();
         }
@@ -1790,50 +1716,54 @@ IceRuby::DictionaryInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap* obje
         }
     }
 
-    if(NIL_P(hash))
+    if (NIL_P(hash))
     {
         os->writeSize(0);
     }
     else
     {
         os->writeSize(sz);
-        if(sz > 0)
+        if (sz > 0)
         {
-            DictionaryMarshalIterator iter(this, os, objectMap);
+            DictionaryMarshalIterator iter(shared_from_this(), os, valueMap);
             hashIterate(hash, iter);
         }
     }
 
-    if(optional && _variableLength)
+    if (optional && _variableLength)
     {
         os->endSize(sizePos);
     }
 }
 
 void
-IceRuby::DictionaryInfo::marshalElement(VALUE key, VALUE value, Ice::OutputStream* os, ObjectMap* objectMap)
+IceRuby::DictionaryInfo::marshalElement(VALUE key, VALUE value, Ice::OutputStream* os, ValueMap* valueMap)
 {
-    if(!keyType->validate(key))
+    if (!keyType->validate(key))
     {
         throw RubyException(rb_eTypeError, "invalid key in `%s' element", const_cast<char*>(id.c_str()));
     }
 
-    if(!valueType->validate(value))
+    if (!valueType->validate(value))
     {
         throw RubyException(rb_eTypeError, "invalid value in `%s' element", const_cast<char*>(id.c_str()));
     }
 
-    keyType->marshal(key, os, objectMap, false);
-    valueType->marshal(value, os, objectMap, false);
+    keyType->marshal(key, os, valueMap, false);
+    valueType->marshal(value, os, valueMap, false);
 }
 
 void
-IceRuby::DictionaryInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr& cb, VALUE target,
-                                   void* closure, bool optional)
+IceRuby::DictionaryInfo::unmarshal(
+    Ice::InputStream* is,
+    const UnmarshalCallbackPtr& cb,
+    VALUE target,
+    void* closure,
+    bool optional)
 {
-    if(optional)
+    if (optional)
     {
-        if(_variableLength)
+        if (_variableLength)
         {
             is->skip(4);
         }
@@ -1845,11 +1775,11 @@ IceRuby::DictionaryInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallback
 
     volatile VALUE hash = callRuby(rb_hash_new);
 
-    KeyCallbackPtr keyCB = new KeyCallback;
+    KeyCallbackPtr keyCB = make_shared<KeyCallback>();
     keyCB->key = Qnil;
 
-    Ice::Int sz = is->readSize();
-    for(Ice::Int i = 0; i < sz; ++i)
+    int32_t sz = is->readSize();
+    for (int32_t i = 0; i < sz; ++i)
     {
         //
         // A dictionary key cannot be a class (or contain one), so the key must be
@@ -1874,7 +1804,7 @@ IceRuby::DictionaryInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallback
         // so we pass it the key.
         //
         void* cl = reinterpret_cast<void*>(keyCB->key);
-        valueType->unmarshal(is, this, hash, cl, false);
+        valueType->unmarshal(is, shared_from_this(), hash, cl, false);
     }
 
     cb->unmarshaled(hash, target, closure);
@@ -1889,60 +1819,59 @@ IceRuby::DictionaryInfo::unmarshaled(VALUE val, VALUE target, void* closure)
 
 namespace
 {
-struct DictionaryPrintIterator : public IceRuby::HashIterator
-{
-    DictionaryPrintIterator(const DictionaryInfoPtr& d, IceUtilInternal::Output& o, PrintObjectHistory* h) :
-        dict(d), out(o), history(h)
+    struct DictionaryPrintIterator : public IceRuby::HashIterator
     {
-    }
+        DictionaryPrintIterator(const DictionaryInfoPtr& d, IceInternal::Output& o, PrintObjectHistory* h)
+            : dict(d),
+              out(o),
+              history(h)
+        {
+        }
 
-    virtual void element(VALUE key, VALUE value)
-    {
-        dict->printElement(key, value, out, history);
-    }
+        virtual void element(VALUE key, VALUE value) { dict->printElement(key, value, out, history); }
 
-    IceRuby::DictionaryInfoPtr dict;
-    IceUtilInternal::Output& out;
-    IceRuby::PrintObjectHistory* history;
-};
+        IceRuby::DictionaryInfoPtr dict;
+        IceInternal::Output& out;
+        IceRuby::PrintObjectHistory* history;
+    };
 }
 
 void
-IceRuby::DictionaryInfo::print(VALUE value, IceUtilInternal::Output& out, PrintObjectHistory* history)
+IceRuby::DictionaryInfo::print(VALUE value, IceInternal::Output& out, PrintObjectHistory* history)
 {
-    if(!validate(value))
+    if (!validate(value))
     {
         out << "<invalid value - expected " << id << ">";
         return;
     }
 
-    if(NIL_P(value))
+    if (NIL_P(value))
     {
         out << "{}";
     }
     else
     {
         volatile VALUE hash = callRuby(rb_convert_type, value, T_HASH, "Hash", "to_hash");
-        if(NIL_P(hash))
+        if (NIL_P(hash))
         {
             throw RubyException(rb_eTypeError, "unable to convert value to a hash");
         }
 
-        if(RHASH_SIZE(hash) == 0)
+        if (RHASH_SIZE(hash) == 0)
         {
             out << "{}";
             return;
         }
 
         out.sb();
-        DictionaryPrintIterator iter(this, out, history);
+        DictionaryPrintIterator iter(shared_from_this(), out, history);
         hashIterate(hash, iter);
         out.eb();
     }
 }
 
 void
-IceRuby::DictionaryInfo::printElement(VALUE key, VALUE value, IceUtilInternal::Output& out, PrintObjectHistory* history)
+IceRuby::DictionaryInfo::printElement(VALUE key, VALUE value, IceInternal::Output& out, PrintObjectHistory* history)
 {
     out << nl << "key = ";
     keyType->print(key, out, history);
@@ -1959,12 +1888,12 @@ IceRuby::DictionaryInfo::KeyCallback::unmarshaled(VALUE val, VALUE, void*)
 void
 IceRuby::DictionaryInfo::destroy()
 {
-    if(keyType)
+    if (keyType)
     {
         keyType->destroy();
         const_cast<TypeInfoPtr&>(keyType) = 0;
     }
-    if(valueType)
+    if (valueType)
     {
         valueType->destroy();
         const_cast<TypeInfoPtr&>(valueType) = 0;
@@ -1974,33 +1903,37 @@ IceRuby::DictionaryInfo::destroy()
 //
 // ClassInfo implementation.
 //
-IceRuby::ClassInfo::ClassInfo(VALUE ident, bool loc) :
-    compactId(-1), isBase(false), isLocal(loc), preserve(false), interface(false), rubyClass(Qnil), typeObj(Qnil),
-    defined(false)
+
+ClassInfoPtr
+IceRuby::ClassInfo::create(VALUE ident)
+{
+    shared_ptr<ClassInfo> classInfo{new ClassInfo{ident}};
+    const_cast<VALUE&>(classInfo->typeObj) = createType(classInfo);
+    return classInfo;
+}
+
+IceRuby::ClassInfo::ClassInfo(VALUE ident)
+    : compactId(-1),
+      isBase(false),
+      interface(false),
+      rubyClass(Qnil),
+      typeObj(Qnil),
+      defined(false)
 {
     const_cast<string&>(id) = getString(ident);
-    if(isLocal)
-    {
-        const_cast<bool&>(isBase) = id == "::Ice::LocalObject";
-    }
-    else
-    {
-        const_cast<bool&>(isBase) = id == Ice::Object::ice_staticId();
-    }
-    const_cast<VALUE&>(typeObj) = createType(this);
+    const_cast<bool&>(isBase) = id == Ice::Value::ice_staticId();
 }
 
 void
-IceRuby::ClassInfo::define(VALUE t, VALUE compact, VALUE pres, VALUE intf, VALUE b, VALUE m)
+IceRuby::ClassInfo::define(VALUE t, VALUE compact, VALUE intf, VALUE b, VALUE m)
 {
-    if(!NIL_P(b))
+    if (!NIL_P(b))
     {
-        const_cast<ClassInfoPtr&>(base) = ClassInfoPtr::dynamicCast(getType(b));
+        const_cast<ClassInfoPtr&>(base) = dynamic_pointer_cast<ClassInfo>(getType(b));
         assert(base);
     }
 
-    const_cast<Ice::Int&>(compactId) = static_cast<Ice::Int>(getInteger(compact));
-    const_cast<bool&>(preserve) = RTEST(pres);
+    const_cast<int32_t&>(compactId) = static_cast<int32_t>(getInteger(compact));
     const_cast<bool&>(interface) = RTEST(intf);
     convertDataMembers(m, const_cast<DataMemberList&>(members), const_cast<DataMemberList&>(optionalMembers), true);
     const_cast<VALUE&>(rubyClass) = t;
@@ -2016,7 +1949,7 @@ IceRuby::ClassInfo::getId() const
 bool
 IceRuby::ClassInfo::validate(VALUE val)
 {
-    if(NIL_P(val))
+    if (NIL_P(val))
     {
         return true;
     }
@@ -2027,31 +1960,11 @@ IceRuby::ClassInfo::validate(VALUE val)
     //
     volatile VALUE cls = CLASS_OF(val);
     volatile VALUE type = Qnil;
-    try
-    {
-        type = callRuby(rb_const_get, cls, rb_intern("ICE_TYPE"));
-    }
-    catch(const RubyException& ex)
-    {
-        if(callRuby(rb_obj_is_instance_of, ex.ex, rb_eNameError) == Qtrue)
-        {
-            //
-            // The ICE_TYPE constant will be missing from an instance of LocalObject
-            // if it does not implement a user-defined type. This means the user
-            // could potentially pass any kind of object; there isn't much we can do
-            // since LocalObject maps to the base object type.
-            //
-            return id == "::Ice::LocalObject";
-        }
-        else
-        {
-            throw;
-        }
-    }
+    type = callRuby(rb_const_get, cls, rb_intern("ICE_TYPE"));
     assert(!NIL_P(type));
-    ClassInfoPtr info = ClassInfoPtr::dynamicCast(getType(type));
+    ClassInfoPtr info = dynamic_pointer_cast<ClassInfo>(getType(type));
     assert(info);
-    return this->interface || info->isA(this);
+    return this->interface || info->isA(shared_from_this());
 }
 
 bool
@@ -2069,7 +1982,7 @@ IceRuby::ClassInfo::wireSize() const
 Ice::OptionalFormat
 IceRuby::ClassInfo::optionalFormat() const
 {
-    return Ice::OptionalFormatClass;
+    return Ice::OptionalFormat::Class;
 }
 
 bool
@@ -2079,33 +1992,33 @@ IceRuby::ClassInfo::usesClasses() const
 }
 
 void
-IceRuby::ClassInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap* objectMap, bool)
+IceRuby::ClassInfo::marshal(VALUE p, Ice::OutputStream* os, ValueMap* valueMap, bool)
 {
-    if(!defined)
+    if (!defined)
     {
         throw RubyException(rb_eRuntimeError, "class %s is declared but not defined", id.c_str());
     }
 
-    if(NIL_P(p))
+    if (NIL_P(p))
     {
-        Ice::ObjectPtr nil;
-        os->write(nil);
+        shared_ptr<Ice::Value> value; // nullptr
+        os->write(value);
         return;
     }
 
     //
-    // Ice::ObjectWriter is a subclass of Ice::Object that wraps a Ruby object for marshaling.
+    // Ice::ValueWriter is a subclass of Ice::Value that wraps a Ruby object for marshaling.
     // It is possible that this Ruby object has already been marshaled, therefore we first must
-    // check the object map to see if this object is present. If so, we use the existing ObjectWriter,
+    // check the object map to see if this object is present. If so, we use the existing ValueWriter,
     // otherwise we create a new one.
     //
-    Ice::ObjectPtr writer;
-    assert(objectMap);
-    ObjectMap::iterator q = objectMap->find(p);
-    if(q == objectMap->end())
+    shared_ptr<Ice::Value> writer;
+    assert(valueMap);
+    ValueMap::iterator q = valueMap->find(p);
+    if (q == valueMap->end())
     {
-        writer = new ObjectWriter(p, objectMap, this);
-        objectMap->insert(ObjectMap::value_type(p, writer));
+        writer = make_shared<ValueWriter>(p, valueMap, shared_from_this());
+        valueMap->insert(ValueMap::value_type(p, writer));
     }
     else
     {
@@ -2120,21 +2033,18 @@ IceRuby::ClassInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap* objectMap
 
 namespace
 {
-
-void
-patchObject(void* addr, const Ice::ObjectPtr& v)
-{
-    ReadObjectCallback* cb = static_cast<ReadObjectCallback*>(addr);
-    assert(cb);
-    cb->invoke(v);
-}
-
+    void patchObject(void* addr, const shared_ptr<Ice::Value>& v)
+    {
+        ReadValueCallback* cb = static_cast<ReadValueCallback*>(addr);
+        assert(cb);
+        cb->invoke(v);
+    }
 }
 
 void
 IceRuby::ClassInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr& cb, VALUE target, void* closure, bool)
 {
-    if(!defined)
+    if (!defined)
     {
         throw RubyException(rb_eRuntimeError, "class %s is declared but not defined", id.c_str());
     }
@@ -2144,7 +2054,7 @@ IceRuby::ClassInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr&
     // attached to the stream keeps a reference to the callback object to ensure it lives
     // long enough.
     //
-    ReadObjectCallbackPtr rocb = new ReadObjectCallback(this, cb, target, closure);
+    ReadValueCallbackPtr rocb = make_shared<ReadValueCallback>(shared_from_this(), cb, target, closure);
     StreamUtil* util = reinterpret_cast<StreamUtil*>(is->getClosure());
     assert(util);
     util->add(rocb);
@@ -2152,22 +2062,22 @@ IceRuby::ClassInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr&
 }
 
 void
-IceRuby::ClassInfo::print(VALUE value, IceUtilInternal::Output& out, PrintObjectHistory* history)
+IceRuby::ClassInfo::print(VALUE value, IceInternal::Output& out, PrintObjectHistory* history)
 {
-    if(!validate(value))
+    if (!validate(value))
     {
         out << "<invalid value - expected " << id << ">";
         return;
     }
 
-    if(NIL_P(value))
+    if (NIL_P(value))
     {
         out << "<nil>";
     }
     else
     {
         map<VALUE, int>::iterator q = history->objects.find(value);
-        if(q != history->objects.end())
+        if (q != history->objects.end())
         {
             out << "<object #" << q->second << ">";
         }
@@ -2176,36 +2086,8 @@ IceRuby::ClassInfo::print(VALUE value, IceUtilInternal::Output& out, PrintObject
             volatile VALUE cls = CLASS_OF(value);
             volatile VALUE type = Qnil;
             ClassInfoPtr info;
-            try
-            {
-                type = callRuby(rb_const_get, cls, rb_intern("ICE_TYPE"));
-                info = ClassInfoPtr::dynamicCast(getType(type));
-            }
-            catch(const RubyException& ex)
-            {
-                if(callRuby(rb_obj_is_instance_of, ex.ex, rb_eNameError) == Qtrue)
-                {
-                    //
-                    // The ICE_TYPE constant will be missing from an instance of LocalObject
-                    // if it does not implement a user-defined type. This means the user
-                    // could potentially pass any kind of object; there isn't much we can do
-                    // since LocalObject maps to the base object type.
-                    //
-                    if(id == "::Ice::LocalObject")
-                    {
-                        info = this;
-                    }
-                    else
-                    {
-                        out << "<invalid value - expected " << id << ">";
-                        return;
-                    }
-                }
-                else
-                {
-                    throw;
-                }
-            }
+            type = callRuby(rb_const_get, cls, rb_intern("ICE_TYPE"));
+            info = dynamic_pointer_cast<ClassInfo>(getType(type));
             assert(info);
             out << "object #" << history->index << " (" << info->id << ')';
             history->objects.insert(map<VALUE, int>::value_type(value, history->index));
@@ -2221,11 +2103,11 @@ void
 IceRuby::ClassInfo::destroy()
 {
     const_cast<ClassInfoPtr&>(base) = 0;
-    if(!members.empty())
+    if (!members.empty())
     {
         DataMemberList ml = members;
         const_cast<DataMemberList&>(members).clear();
-        for(DataMemberList::iterator p = ml.begin(); p != ml.end(); ++p)
+        for (DataMemberList::iterator p = ml.begin(); p != ml.end(); ++p)
         {
             (*p)->type->destroy();
         }
@@ -2233,20 +2115,17 @@ IceRuby::ClassInfo::destroy()
 }
 
 void
-IceRuby::ClassInfo::printMembers(VALUE value, IceUtilInternal::Output& out, PrintObjectHistory* history)
+IceRuby::ClassInfo::printMembers(VALUE value, IceInternal::Output& out, PrintObjectHistory* history)
 {
-    if(base)
+    if (base)
     {
         base->printMembers(value, out, history);
     }
 
-    DataMemberList::const_iterator q;
-
-    for(q = members.begin(); q != members.end(); ++q)
+    for (const auto& member : members)
     {
-        DataMemberPtr member = *q;
         out << nl << member->name << " = ";
-        if(callRuby(rb_ivar_defined, value, member->rubyID) == Qfalse)
+        if (callRuby(rb_ivar_defined, value, member->rubyID) == Qfalse)
         {
             out << "<not defined>";
         }
@@ -2257,20 +2136,19 @@ IceRuby::ClassInfo::printMembers(VALUE value, IceUtilInternal::Output& out, Prin
         }
     }
 
-    for(q = optionalMembers.begin(); q != optionalMembers.end(); ++q)
+    for (const auto& member : optionalMembers)
     {
-        DataMemberPtr member = *q;
         out << nl << member->name << " = ";
-        if(callRuby(rb_ivar_defined, value, member->rubyID) == Qfalse)
+        if (callRuby(rb_ivar_defined, value, member->rubyID) == Qfalse)
         {
             out << "<not defined>";
         }
         else
         {
             volatile VALUE val = callRuby(rb_ivar_get, value, member->rubyID);
-            if(val == Unset)
+            if (val == Qnil)
             {
-                out << "<unset>";
+                out << "<nil>";
             }
             else
             {
@@ -2286,11 +2164,11 @@ IceRuby::ClassInfo::isA(const ClassInfoPtr& info)
     //
     // Return true if this class has an is-a relationship with info.
     //
-    if(info->isBase && isLocal == info->isLocal)
+    if (info->isBase)
     {
         return true;
     }
-    else if(this == info.get())
+    else if (this == info.get())
     {
         return true;
     }
@@ -2301,28 +2179,35 @@ IceRuby::ClassInfo::isA(const ClassInfoPtr& info)
 //
 // ProxyInfo implementation.
 //
-IceRuby::ProxyInfo::ProxyInfo(VALUE ident) :
-    isBase(false), rubyClass(Qnil), typeObj(Qnil)
+
+ProxyInfoPtr
+IceRuby::ProxyInfo::create(VALUE ident)
+{
+    shared_ptr<ProxyInfo> proxyInfo{new ProxyInfo{ident}};
+    const_cast<VALUE&>(proxyInfo->typeObj) = createType(proxyInfo);
+    return proxyInfo;
+}
+
+IceRuby::ProxyInfo::ProxyInfo(VALUE ident) : isBase(false), rubyClass(Qnil), typeObj(Qnil)
 {
     const_cast<string&>(id) = getString(ident);
-    const_cast<bool&>(isBase) = id == "::Ice::Object";
-    const_cast<VALUE&>(typeObj) = createType(this);
+    const_cast<bool&>(isBase) = id == Ice::Object::ice_staticId();
 }
 
 void
 IceRuby::ProxyInfo::define(VALUE t, VALUE b, VALUE i)
 {
-    if(!NIL_P(b))
+    if (!NIL_P(b))
     {
-        const_cast<ProxyInfoPtr&>(base) = ProxyInfoPtr::dynamicCast(getType(b));
+        const_cast<ProxyInfoPtr&>(base) = dynamic_pointer_cast<ProxyInfo>(getType(b));
         assert(base);
     }
 
     volatile VALUE arr = callRuby(rb_check_array_type, i);
     assert(!NIL_P(arr));
-    for(int n = 0; n < RARRAY_LEN(arr); ++n)
+    for (int n = 0; n < RARRAY_LEN(arr); ++n)
     {
-        ProxyInfoPtr iface = ProxyInfoPtr::dynamicCast(getType(RARRAY_AREF(arr, n)));
+        ProxyInfoPtr iface = dynamic_pointer_cast<ProxyInfo>(getType(RARRAY_AREF(arr, n)));
         assert(iface);
         const_cast<ProxyInfoList&>(interfaces).push_back(iface);
     }
@@ -2339,20 +2224,7 @@ IceRuby::ProxyInfo::getId() const
 bool
 IceRuby::ProxyInfo::validate(VALUE val)
 {
-    if(!NIL_P(val))
-    {
-        if(!checkProxy(val))
-        {
-            return false;
-        }
-        volatile VALUE cls = CLASS_OF(val);
-        volatile VALUE type = callRuby(rb_const_get, cls, rb_intern("ICE_TYPE"));
-        assert(!NIL_P(type));
-        ProxyInfoPtr info = ProxyInfoPtr::dynamicCast(getType(type));
-        assert(info);
-        return info->isA(this);
-    }
-    return true;
+    return NIL_P(val) || checkProxy(val);
 }
 
 bool
@@ -2370,71 +2242,74 @@ IceRuby::ProxyInfo::wireSize() const
 Ice::OptionalFormat
 IceRuby::ProxyInfo::optionalFormat() const
 {
-    return Ice::OptionalFormatFSize;
+    return Ice::OptionalFormat::FSize;
 }
 
 void
-IceRuby::ProxyInfo::marshal(VALUE p, Ice::OutputStream* os, ObjectMap*, bool optional)
+IceRuby::ProxyInfo::marshal(VALUE p, Ice::OutputStream* os, ValueMap*, bool optional)
 {
     Ice::OutputStream::size_type sizePos = 0;
-    if(optional)
+    if (optional)
     {
         sizePos = os->startSize();
     }
 
-    if(NIL_P(p))
-    {
-        os->write(Ice::ObjectPrx());
-    }
-    else
+    std::optional<Ice::ObjectPrx> proxy;
+
+    if (!NIL_P(p))
     {
         assert(checkProxy(p)); // validate() should have caught this.
-        os->write(getProxy(p));
+        proxy = getProxy(p);
     }
+    os->write(proxy);
 
-    if(optional)
+    if (optional)
     {
         os->endSize(sizePos);
     }
 }
 
 void
-IceRuby::ProxyInfo::unmarshal(Ice::InputStream* is, const UnmarshalCallbackPtr& cb, VALUE target,
-                              void* closure, bool optional)
+IceRuby::ProxyInfo::unmarshal(
+    Ice::InputStream* is,
+    const UnmarshalCallbackPtr& cb,
+    VALUE target,
+    void* closure,
+    bool optional)
 {
-    if(optional)
+    if (optional)
     {
         is->skip(4);
     }
 
-    Ice::ObjectPrx proxy;
+    std::optional<Ice::ObjectPrx> proxy;
     is->read(proxy);
 
-    if(!proxy)
+    if (!proxy)
     {
         cb->unmarshaled(Qnil, target, closure);
         return;
     }
 
-    if(NIL_P(rubyClass))
+    if (NIL_P(rubyClass))
     {
         throw RubyException(rb_eRuntimeError, "class %s is declared but not defined", id.c_str());
     }
 
-    volatile VALUE p = createProxy(proxy, rubyClass);
+    volatile VALUE p = createProxy(proxy.value(), rubyClass);
     cb->unmarshaled(p, target, closure);
 }
 
 void
-IceRuby::ProxyInfo::print(VALUE value, IceUtilInternal::Output& out, PrintObjectHistory*)
+IceRuby::ProxyInfo::print(VALUE value, IceInternal::Output& out, PrintObjectHistory*)
 {
-    if(!validate(value))
+    if (!validate(value))
     {
         out << "<invalid value - expected " << getId() << ">";
         return;
     }
 
-    if(NIL_P(value))
+    if (NIL_P(value))
     {
         out << "<nil>";
     }
@@ -2450,23 +2325,23 @@ IceRuby::ProxyInfo::isA(const ProxyInfoPtr& info)
     //
     // Return true if this class has an is-a relationship with info.
     //
-    if(info->isBase)
+    if (info->isBase)
     {
         return true;
     }
-    else if(this == info.get())
+    else if (this == info.get())
     {
         return true;
     }
-    else if(base && base->isA(info))
+    else if (base && base->isA(info))
     {
         return true;
     }
-    else if(!interfaces.empty())
+    else if (!interfaces.empty())
     {
-        for(ProxyInfoList::const_iterator p = interfaces.begin(); p != interfaces.end(); ++p)
+        for (ProxyInfoList::const_iterator p = interfaces.begin(); p != interfaces.end(); ++p)
         {
-            if((*p)->isA(info))
+            if ((*p)->isA(info))
             {
                 return true;
             }
@@ -2484,55 +2359,49 @@ IceRuby::ProxyInfo::destroy()
 }
 
 //
-// ObjectWriter implementation.
+// ValueWriter implementation.
 //
-IceRuby::ObjectWriter::ObjectWriter(VALUE object, ObjectMap* objectMap, const ClassInfoPtr& formal) :
-    _object(object), _map(objectMap), _formal(formal)
+IceRuby::ValueWriter::ValueWriter(VALUE object, ValueMap* valueMap, const ClassInfoPtr& formal)
+    : _object(object),
+      _map(valueMap),
+      _formal(formal)
 {
     //
     // Mark the object as in use for the lifetime of this wrapper.
     //
     rb_gc_register_address(&_object);
-    if(!_formal || !_formal->interface)
+    if (!_formal || !_formal->interface)
     {
         volatile VALUE cls = CLASS_OF(object);
         volatile VALUE type = callRuby(rb_const_get, cls, rb_intern("ICE_TYPE"));
         assert(!NIL_P(type));
-        _info = ClassInfoPtr::dynamicCast(getType(type));
+        _info = dynamic_pointer_cast<ClassInfo>(getType(type));
         assert(_info);
     }
 }
 
-IceRuby::ObjectWriter::~ObjectWriter()
-{
-    rb_gc_unregister_address(&_object);
-}
+IceRuby::ValueWriter::~ValueWriter() { rb_gc_unregister_address(&_object); }
 
 void
-IceRuby::ObjectWriter::ice_preMarshal()
+IceRuby::ValueWriter::ice_preMarshal()
 {
     ID id = rb_intern("ice_preMarshal");
-    if(callRuby(rb_respond_to, _object, id))
+    if (callRuby(rb_respond_to, _object, id))
     {
         callRuby(rb_funcall, _object, id, 0);
     }
 }
 
 void
-IceRuby::ObjectWriter::_iceWrite(Ice::OutputStream* os) const
+IceRuby::ValueWriter::_iceWrite(Ice::OutputStream* os) const
 {
-    Ice::SlicedDataPtr slicedData;
-
-    if(_info && _info->preserve)
-    {
-        //
-        // Retrieve the SlicedData object that we stored as a hidden member of the Ruby object.
-        //
-        slicedData = StreamUtil::getSlicedDataMember(_object, const_cast<ObjectMap*>(_map));
-    }
+    //
+    // Retrieve the SlicedData object that we stored as a hidden member of the Ruby object.
+    //
+    Ice::SlicedDataPtr slicedData = StreamUtil::getSlicedDataMember(_object, const_cast<ValueMap*>(_map));
 
     os->startValue(slicedData);
-    if(_formal && _formal->interface)
+    if (_formal && _formal->interface)
     {
         ID op = rb_intern("ice_id");
         string id = getString(callRuby(rb_funcall, _object, op, 0));
@@ -2541,10 +2410,10 @@ IceRuby::ObjectWriter::_iceWrite(Ice::OutputStream* os) const
     }
     else
     {
-        if(_info->id != "::Ice::UnknownSlicedValue")
+        if (_info->id != "::Ice::UnknownSlicedValue")
         {
             ClassInfoPtr info = _info;
-            while(info)
+            while (info)
             {
                 os->startSlice(info->id, info->compactId, !info->base);
 
@@ -2561,29 +2430,32 @@ IceRuby::ObjectWriter::_iceWrite(Ice::OutputStream* os) const
 }
 
 void
-IceRuby::ObjectWriter::_iceRead(Ice::InputStream*)
+IceRuby::ValueWriter::_iceRead(Ice::InputStream*)
 {
     assert(false);
 }
 
 void
-IceRuby::ObjectWriter::writeMembers(Ice::OutputStream* os, const DataMemberList& members) const
+IceRuby::ValueWriter::writeMembers(Ice::OutputStream* os, const DataMemberList& members) const
 {
-    for(DataMemberList::const_iterator q = members.begin(); q != members.end(); ++q)
+    for (DataMemberList::const_iterator q = members.begin(); q != members.end(); ++q)
     {
         DataMemberPtr member = *q;
 
         volatile VALUE val = callRuby(rb_ivar_get, _object, member->rubyID);
 
-        if(member->optional && (val == Unset || !os->writeOptional(member->tag, member->type->optionalFormat())))
+        if (member->optional && (val == Qnil || !os->writeOptional(member->tag, member->type->optionalFormat())))
         {
             continue;
         }
 
-        if(!member->type->validate(val))
+        if (!member->type->validate(val))
         {
-            throw RubyException(rb_eTypeError, "invalid value for %s member `%s'", _info->id.c_str(),
-                                member->name.c_str());
+            throw RubyException(
+                rb_eTypeError,
+                "invalid value for %s member `%s'",
+                _info->id.c_str(),
+                member->name.c_str());
         }
 
         member->type->marshal(val, os, _map, member->optional);
@@ -2591,10 +2463,9 @@ IceRuby::ObjectWriter::writeMembers(Ice::OutputStream* os, const DataMemberList&
 }
 
 //
-// ObjectReader implementation.
+// ValueReader implementation.
 //
-IceRuby::ObjectReader::ObjectReader(VALUE object, const ClassInfoPtr& info) :
-    _object(object), _info(info)
+IceRuby::ValueReader::ValueReader(VALUE object, const ClassInfoPtr& info) : _object(object), _info(info)
 {
     //
     // Mark the object as in use for the lifetime of this wrapper.
@@ -2602,29 +2473,26 @@ IceRuby::ObjectReader::ObjectReader(VALUE object, const ClassInfoPtr& info) :
     rb_gc_register_address(&_object);
 }
 
-IceRuby::ObjectReader::~ObjectReader()
-{
-    rb_gc_unregister_address(&_object);
-}
+IceRuby::ValueReader::~ValueReader() { rb_gc_unregister_address(&_object); }
 
 void
-IceRuby::ObjectReader::ice_postUnmarshal()
+IceRuby::ValueReader::ice_postUnmarshal()
 {
     ID id = rb_intern("ice_postUnmarshal");
-    if(callRuby(rb_respond_to, _object, id))
+    if (callRuby(rb_respond_to, _object, id))
     {
         callRuby(rb_funcall, _object, id, 0);
     }
 }
 
 void
-IceRuby::ObjectReader::_iceWrite(Ice::OutputStream*) const
+IceRuby::ValueReader::_iceWrite(Ice::OutputStream*) const
 {
     assert(false);
 }
 
 void
-IceRuby::ObjectReader::_iceRead(Ice::InputStream* is)
+IceRuby::ValueReader::_iceRead(Ice::InputStream* is)
 {
     is->startValue();
 
@@ -2633,16 +2501,16 @@ IceRuby::ObjectReader::_iceRead(Ice::InputStream* is)
     //
     // Unmarshal the slices of a user-defined class.
     //
-    if(!unknown && _info->id != Ice::Object::ice_staticId())
+    if (!unknown && _info->id != Ice::Value::ice_staticId())
     {
         ClassInfoPtr info = _info;
-        while(info)
+        while (info)
         {
             is->startSlice();
 
             DataMemberList::const_iterator p;
 
-            for(p = info->members.begin(); p != info->members.end(); ++p)
+            for (p = info->members.begin(); p != info->members.end(); ++p)
             {
                 DataMemberPtr member = *p;
                 member->type->unmarshal(is, member, _object, 0, false);
@@ -2651,16 +2519,16 @@ IceRuby::ObjectReader::_iceRead(Ice::InputStream* is)
             //
             // The optional members have already been sorted by tag.
             //
-            for(p = info->optionalMembers.begin(); p != info->optionalMembers.end(); ++p)
+            for (p = info->optionalMembers.begin(); p != info->optionalMembers.end(); ++p)
             {
                 DataMemberPtr member = *p;
-                if(is->readOptional(member->tag, member->type->optionalFormat()))
+                if (is->readOptional(member->tag, member->type->optionalFormat()))
                 {
                     member->type->unmarshal(is, member, _object, 0, true);
                 }
                 else
                 {
-                    callRuby(rb_ivar_set, _object, member->rubyID, Unset);
+                    callRuby(rb_ivar_set, _object, member->rubyID, Qnil);
                 }
             }
 
@@ -2670,18 +2538,18 @@ IceRuby::ObjectReader::_iceRead(Ice::InputStream* is)
         }
     }
 
-    _slicedData = is->endValue(_info->preserve);
+    _slicedData = is->endValue();
 
-    if(_slicedData)
+    if (_slicedData)
     {
         StreamUtil* util = reinterpret_cast<StreamUtil*>(is->getClosure());
         assert(util);
-        util->add(this);
+        util->add(shared_ptr<ValueReader>(shared_from_this()));
 
         //
         // Define the "unknownTypeId" member for an instance of UnknownSlicedValue.
         //
-        if(unknown)
+        if (unknown)
         {
             assert(!_slicedData->slices.empty());
 
@@ -2692,19 +2560,16 @@ IceRuby::ObjectReader::_iceRead(Ice::InputStream* is)
 }
 
 ClassInfoPtr
-IceRuby::ObjectReader::getInfo() const
+IceRuby::ValueReader::getInfo() const
 {
     return _info;
 }
 
 VALUE
-IceRuby::ObjectReader::getObject() const
-{
-    return _object;
-}
+IceRuby::ValueReader::getObject() const { return _object; }
 
 Ice::SlicedDataPtr
-IceRuby::ObjectReader::getSlicedData() const
+IceRuby::ValueReader::getSlicedData() const
 {
     return _slicedData;
 }
@@ -2715,49 +2580,54 @@ IceRuby::ObjectReader::getSlicedData() const
 IceRuby::InfoMapDestroyer::~InfoMapDestroyer()
 {
     {
-        for(ProxyInfoMap::iterator p = _proxyInfoMap.begin(); p != _proxyInfoMap.end(); ++p)
+        for (ProxyInfoMap::iterator p = _proxyInfoMap.begin(); p != _proxyInfoMap.end(); ++p)
         {
             p->second->destroy();
         }
     }
     {
-        for(ClassInfoMap::iterator p = _classInfoMap.begin(); p != _classInfoMap.end(); ++p)
+        for (ClassInfoMap::iterator p = _classInfoMap.begin(); p != _classInfoMap.end(); ++p)
         {
             p->second->destroy();
         }
     }
-    _compactIdMap.clear();
     _exceptionInfoMap.clear();
 }
 
 //
-// ReadObjectCallback implementation.
+// ReadValueCallback implementation.
 //
-IceRuby::ReadObjectCallback::ReadObjectCallback(const ClassInfoPtr& info, const UnmarshalCallbackPtr& cb,
-                                                VALUE target, void* closure) :
-    _info(info), _cb(cb), _target(target), _closure(closure)
+IceRuby::ReadValueCallback::ReadValueCallback(
+    const ClassInfoPtr& info,
+    const UnmarshalCallbackPtr& cb,
+    VALUE target,
+    void* closure)
+    : _info(info),
+      _cb(cb),
+      _target(target),
+      _closure(closure)
 {
 }
 
 void
-IceRuby::ReadObjectCallback::invoke(const Ice::ObjectPtr& p)
+IceRuby::ReadValueCallback::invoke(const shared_ptr<Ice::Value>& p)
 {
-    if(p)
+    if (p)
     {
-        ObjectReaderPtr reader = ObjectReaderPtr::dynamicCast(p);
+        auto reader = dynamic_pointer_cast<ValueReader>(p);
         assert(reader);
 
         //
         // Verify that the unmarshaled object is compatible with the formal type.
         //
         volatile VALUE obj = reader->getObject();
-        if(!_info->interface && !_info->validate(obj))
+        if (!_info->interface && !_info->validate(obj))
         {
-            Ice::UnexpectedObjectException ex(__FILE__, __LINE__);
-            ex.reason = "unmarshaled object is not an instance of " + _info->id;
-            ex.type = reader->getInfo()->getId();
-            ex.expectedType = _info->id;
-            throw ex;
+            throw MarshalException{
+                __FILE__,
+                __LINE__,
+                "failed to unmarshal class with type ID '" + _info->id +
+                    "': the Slice loader returned a class with type ID '" + reader->getInfo()->id + "'"};
         }
 #ifndef NDEBUG
         // With debug builds we force a GC to ensure that all data members are correctly keep alive.
@@ -2779,14 +2649,14 @@ IceRuby::ExceptionInfo::unmarshal(Ice::InputStream* is)
 {
     volatile VALUE obj = callRuby(rb_class_new_instance, 0, static_cast<VALUE*>(0), rubyClass);
 
-    ExceptionInfoPtr info = this;
-    while(info)
+    ExceptionInfoPtr info = shared_from_this();
+    while (info)
     {
         is->startSlice();
 
         DataMemberList::iterator q;
 
-        for(q = info->members.begin(); q != info->members.end(); ++q)
+        for (q = info->members.begin(); q != info->members.end(); ++q)
         {
             DataMemberPtr member = *q;
             member->type->unmarshal(is, member, obj, 0, false);
@@ -2795,16 +2665,16 @@ IceRuby::ExceptionInfo::unmarshal(Ice::InputStream* is)
         //
         // The optional members have already been sorted by tag.
         //
-        for(q = info->optionalMembers.begin(); q != info->optionalMembers.end(); ++q)
+        for (q = info->optionalMembers.begin(); q != info->optionalMembers.end(); ++q)
         {
             DataMemberPtr member = *q;
-            if(is->readOptional(member->tag, member->type->optionalFormat()))
+            if (is->readOptional(member->tag, member->type->optionalFormat()))
             {
                 member->type->unmarshal(is, member, obj, 0, true);
             }
             else
             {
-                callRuby(rb_ivar_set, obj, member->rubyID, Unset);
+                callRuby(rb_ivar_set, obj, member->rubyID, Qnil);
             }
         }
 
@@ -2817,9 +2687,9 @@ IceRuby::ExceptionInfo::unmarshal(Ice::InputStream* is)
 }
 
 void
-IceRuby::ExceptionInfo::print(VALUE value, IceUtilInternal::Output& out)
+IceRuby::ExceptionInfo::print(VALUE value, IceInternal::Output& out)
 {
-    if(callRuby(rb_obj_is_kind_of, value, rubyClass) == Qfalse)
+    if (callRuby(rb_obj_is_kind_of, value, rubyClass) == Qfalse)
     {
         out << "<invalid value - expected " << id << ">";
         return;
@@ -2835,20 +2705,17 @@ IceRuby::ExceptionInfo::print(VALUE value, IceUtilInternal::Output& out)
 }
 
 void
-IceRuby::ExceptionInfo::printMembers(VALUE value, IceUtilInternal::Output& out, PrintObjectHistory* history)
+IceRuby::ExceptionInfo::printMembers(VALUE value, IceInternal::Output& out, PrintObjectHistory* history)
 {
-    if(base)
+    if (base)
     {
         base->printMembers(value, out, history);
     }
 
-    DataMemberList::const_iterator q;
-
-    for(q = members.begin(); q != members.end(); ++q)
+    for (const auto& member : members)
     {
-        DataMemberPtr member = *q;
         out << nl << member->name << " = ";
-        if(callRuby(rb_ivar_defined, value, member->rubyID) == Qfalse)
+        if (callRuby(rb_ivar_defined, value, member->rubyID) == Qfalse)
         {
             out << "<not defined>";
         }
@@ -2859,20 +2726,19 @@ IceRuby::ExceptionInfo::printMembers(VALUE value, IceUtilInternal::Output& out,
         }
     }
 
-    for(q = optionalMembers.begin(); q != optionalMembers.end(); ++q)
+    for (const auto& member : optionalMembers)
     {
-        DataMemberPtr member = *q;
         out << nl << member->name << " = ";
-        if(callRuby(rb_ivar_defined, value, member->rubyID) == Qfalse)
+        if (callRuby(rb_ivar_defined, value, member->rubyID) == Qfalse)
         {
             out << "<not defined>";
         }
         else
         {
             volatile VALUE val = callRuby(rb_ivar_get, value, member->rubyID);
-            if(val == Unset)
+            if (val == Qnil)
             {
-                out << "<unset>";
+                out << "<nil>";
             }
             else
             {
@@ -2885,43 +2751,25 @@ IceRuby::ExceptionInfo::printMembers(VALUE value, IceUtilInternal::Output& out,
 //
 // ExceptionReader implementation.
 //
-IceRuby::ExceptionReader::ExceptionReader(const ExceptionInfoPtr& info) :
-    _info(info)
-{
-}
+IceRuby::ExceptionReader::ExceptionReader(const ExceptionInfoPtr& info) : _info(info) {}
 
-#if defined(__clang__)
-#   pragma clang diagnostic push
-#   pragma clang diagnostic ignored "-Wdeprecated-copy-with-user-provided-dtor"
-#   pragma clang diagnostic ignored "-Wdeprecated-dynamic-exception-spec"
-#endif
-IceRuby::ExceptionReader::~ExceptionReader() throw()
+IceRuby::ExceptionReader::ExceptionReader(const ExceptionReader& reader) : _info(reader._info), _ex(reader._ex)
 {
-    rb_gc_unregister_address(&_ex);
+    rb_gc_register_address(&_ex);
 }
-#if defined(__clang__)
-#   pragma clang diagnostic pop
-#endif
 
-string
-IceRuby::ExceptionReader::ice_id() const
-{
-    return _info->id;
-}
+IceRuby::ExceptionReader::~ExceptionReader() { rb_gc_unregister_address(&_ex); }
 
-#ifndef ICE_CPP11_MAPPING
-Ice::UserException*
-IceRuby::ExceptionReader::ice_clone() const
+const char*
+IceRuby::ExceptionReader::ice_id() const noexcept
 {
-    assert(false);
-    return 0;
+    return _info->id.c_str();
 }
-#endif
 
 void
 IceRuby::ExceptionReader::ice_throw() const
 {
-    throw *this;
+    assert(false);
 }
 
 void
@@ -2937,8 +2785,6 @@ IceRuby::ExceptionReader::_read(Ice::InputStream* is)
 
     const_cast<VALUE&>(_ex) = _info->unmarshal(is);
     rb_gc_register_address(&_ex);
-
-    const_cast<Ice::SlicedDataPtr&>(_slicedData) = is->endException(_info->preserve);
 }
 
 bool
@@ -2948,85 +2794,57 @@ IceRuby::ExceptionReader::_usesClasses() const
 }
 
 VALUE
-IceRuby::ExceptionReader::getException() const
-{
-    return _ex;
-}
-
-Ice::SlicedDataPtr
-IceRuby::ExceptionReader::getSlicedData() const
-{
-    return _slicedData;
-}
-
-//
-// IdResolver
-//
-string
-IceRuby::IdResolver::resolve(Ice::Int id) const
-{
-    CompactIdMap::iterator p = _compactIdMap.find(id);
-    if(p != _compactIdMap.end())
-    {
-        return p->second->id;
-    }
-    return string();
-}
+IceRuby::ExceptionReader::getException() const { return _ex; }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_defineEnum(VALUE /*self*/, VALUE id, VALUE type, VALUE enumerators)
 {
     ICE_RUBY_TRY
     {
-        EnumInfoPtr info = new EnumInfo(id, type, enumerators);
+        EnumInfoPtr info = make_shared<EnumInfo>(id, type, enumerators);
         return createType(info);
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_defineStruct(VALUE /*self*/, VALUE id, VALUE type, VALUE members)
 {
     ICE_RUBY_TRY
     {
-        StructInfoPtr info = new StructInfo(id, type, members);
+        StructInfoPtr info = make_shared<StructInfo>(id, type, members);
         return createType(info);
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_defineSequence(VALUE /*self*/, VALUE id, VALUE elementType)
 {
     ICE_RUBY_TRY
     {
-        SequenceInfoPtr info = new SequenceInfo(id, elementType);
+        SequenceInfoPtr info = make_shared<SequenceInfo>(id, elementType);
         return createType(info);
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_defineDictionary(VALUE /*self*/, VALUE id, VALUE keyType, VALUE valueType)
 {
     ICE_RUBY_TRY
     {
-        DictionaryInfoPtr info = new DictionaryInfo(id, keyType, valueType);
+        DictionaryInfoPtr info = make_shared<DictionaryInfo>(id, keyType, valueType);
         return createType(info);
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_declareProxy(VALUE /*self*/, VALUE id)
 {
     ICE_RUBY_TRY
@@ -3035,9 +2853,9 @@ IceRuby_declareProxy(VALUE /*self*/, VALUE id)
         proxyId += "Prx";
 
         ProxyInfoPtr info = lookupProxyInfo(proxyId);
-        if(!info)
+        if (!info)
         {
-            info = new ProxyInfo(id);
+            info = ProxyInfo::create(id);
             addProxyInfo(proxyId, info);
         }
 
@@ -3047,37 +2865,16 @@ IceRuby_declareProxy(VALUE /*self*/, VALUE id)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_declareClass(VALUE /*self*/, VALUE id)
 {
     ICE_RUBY_TRY
     {
         string idstr = getString(id);
         ClassInfoPtr info = lookupClassInfo(idstr);
-        if(!info)
-        {
-            info = new ClassInfo(id, false);
-            addClassInfo(idstr, info);
-        }
-
-        return info->typeObj;
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
-IceRuby_declareLocalClass(VALUE /*self*/, VALUE id)
-{
-    ICE_RUBY_TRY
-    {
-        string idstr = getString(id);
-        ClassInfoPtr info = lookupClassInfo(idstr);
-        if(!info)
+        if (!info)
         {
-            info = new ClassInfo(id, true);
+            info = ClassInfo::create(id);
             addClassInfo(idstr, info);
         }
 
@@ -3087,20 +2884,17 @@ IceRuby_declareLocalClass(VALUE /*self*/, VALUE id)
     return Qnil;
 }
 
-extern "C"
-VALUE
-IceRuby_defineException(VALUE /*self*/, VALUE id, VALUE type, VALUE preserve, VALUE base, VALUE members)
+extern "C" VALUE
+IceRuby_defineException(VALUE /*self*/, VALUE id, VALUE type, VALUE base, VALUE members)
 {
     ICE_RUBY_TRY
     {
-        ExceptionInfoPtr info = new ExceptionInfo;
+        ExceptionInfoPtr info = make_shared<ExceptionInfo>();
         info->id = getString(id);
 
-        info->preserve = preserve == Qtrue;
-
-        if(!NIL_P(base))
+        if (!NIL_P(base))
         {
-            info->base = ExceptionInfoPtr::dynamicCast(getException(base));
+            info->base = dynamic_pointer_cast<ExceptionInfo>(getException(base));
             assert(info->base);
         }
 
@@ -3111,11 +2905,11 @@ IceRuby_defineException(VALUE /*self*/, VALUE id, VALUE type, VALUE preserve, VA
         //
         // Only examine the required members to see if any use classes.
         //
-        for(DataMemberList::iterator p = info->members.begin(); p != info->members.end(); ++p)
+        for (const auto& dm : info->members)
         {
-            if(!info->usesClasses)
+            if (!info->usesClasses)
             {
-                info->usesClasses = (*p)->type->usesClasses();
+                info->usesClasses = dm->type->usesClasses();
             }
         }
 
@@ -3129,13 +2923,12 @@ IceRuby_defineException(VALUE /*self*/, VALUE id, VALUE type, VALUE preserve, VA
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_TypeInfo_defineProxy(VALUE self, VALUE type, VALUE base, VALUE interfaces)
 {
     ICE_RUBY_TRY
     {
-        ProxyInfoPtr info = ProxyInfoPtr::dynamicCast(getType(self));
+        ProxyInfoPtr info = dynamic_pointer_cast<ProxyInfo>(getType(self));
         assert(info);
 
         info->define(type, base, interfaces);
@@ -3146,29 +2939,22 @@ IceRuby_TypeInfo_defineProxy(VALUE self, VALUE type, VALUE base, VALUE interface
     return Qnil;
 }
 
-extern "C"
-VALUE
-IceRuby_TypeInfo_defineClass(VALUE self, VALUE type, VALUE compactId, VALUE preserve, VALUE interface, VALUE base,
-                             VALUE members)
+extern "C" VALUE
+IceRuby_TypeInfo_defineClass(VALUE self, VALUE type, VALUE compactId, VALUE interface, VALUE base, VALUE members)
 {
     ICE_RUBY_TRY
     {
-        ClassInfoPtr info = ClassInfoPtr::dynamicCast(getType(self));
+        ClassInfoPtr info = dynamic_pointer_cast<ClassInfo>(getType(self));
         assert(info);
 
-        info->define(type, compactId, preserve, interface, base, members);
+        info->define(type, compactId, interface, base, members);
 
-        if(info->compactId != -1)
+        if (info->compactId != -1)
         {
-            CompactIdMap::iterator q = _compactIdMap.find(info->compactId);
-            if(q != _compactIdMap.end())
-            {
-                _compactIdMap.erase(q);
-            }
-            _compactIdMap.insert(CompactIdMap::value_type(info->compactId, info));
+            addClassInfo(std::to_string(info->compactId), info);
         }
 
-        if(type != Qnil && !info->interface)
+        if (type != Qnil && !info->interface)
         {
             rb_define_const(type, "ICE_TYPE", self);
             rb_define_const(type, "ICE_ID", createString(info->id));
@@ -3178,8 +2964,7 @@ IceRuby_TypeInfo_defineClass(VALUE self, VALUE type, VALUE compactId, VALUE pres
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_stringify(VALUE /*self*/, VALUE obj, VALUE type)
 {
     ICE_RUBY_TRY
@@ -3187,7 +2972,7 @@ IceRuby_stringify(VALUE /*self*/, VALUE obj, VALUE type)
         TypeInfoPtr info = getType(type);
 
         ostringstream ostr;
-        IceUtilInternal::Output out(ostr);
+        IceInternal::Output out(ostr);
         PrintObjectHistory history;
         history.index = 0;
         info->print(obj, out, &history);
@@ -3199,8 +2984,7 @@ IceRuby_stringify(VALUE /*self*/, VALUE obj, VALUE type)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_stringifyException(VALUE /*self*/, VALUE exc)
 {
     ICE_RUBY_TRY
@@ -3210,7 +2994,7 @@ IceRuby_stringifyException(VALUE /*self*/, VALUE exc)
         ExceptionInfoPtr info = getException(type);
 
         ostringstream ostr;
-        IceUtilInternal::Output out(ostr);
+        IceInternal::Output out(ostr);
         info->print(exc, out);
 
         string str = ostr.str();
@@ -3224,10 +3008,10 @@ IceRuby_stringifyException(VALUE /*self*/, VALUE exc)
 // lookupClassInfo()
 //
 IceRuby::ClassInfoPtr
-IceRuby::lookupClassInfo(const string& id)
+IceRuby::lookupClassInfo(string_view id)
 {
     ClassInfoMap::iterator p = _classInfoMap.find(id);
-    if(p != _classInfoMap.end())
+    if (p != _classInfoMap.end())
     {
         return p->second;
     }
@@ -3238,10 +3022,10 @@ IceRuby::lookupClassInfo(const string& id)
 // lookupExceptionInfo()
 //
 IceRuby::ExceptionInfoPtr
-IceRuby::lookupExceptionInfo(const string& id)
+IceRuby::lookupExceptionInfo(string_view id)
 {
     ExceptionInfoMap::iterator p = _exceptionInfoMap.find(id);
-    if(p != _exceptionInfoMap.end())
+    if (p != _exceptionInfoMap.end())
     {
         return p->second;
     }
@@ -3259,14 +3043,14 @@ IceRuby::initTypes(VALUE iceModule)
     _exceptionInfoClass = rb_define_class_under(iceModule, "Internal_ExceptionInfo", rb_cObject);
     rb_undef_alloc_func(_exceptionInfoClass);
 
-    rb_define_const(iceModule, "T_bool", createType(new PrimitiveInfo(PrimitiveInfo::KindBool)));
-    rb_define_const(iceModule, "T_byte", createType(new PrimitiveInfo(PrimitiveInfo::KindByte)));
-    rb_define_const(iceModule, "T_short", createType(new PrimitiveInfo(PrimitiveInfo::KindShort)));
-    rb_define_const(iceModule, "T_int", createType(new PrimitiveInfo(PrimitiveInfo::KindInt)));
-    rb_define_const(iceModule, "T_long", createType(new PrimitiveInfo(PrimitiveInfo::KindLong)));
-    rb_define_const(iceModule, "T_float", createType(new PrimitiveInfo(PrimitiveInfo::KindFloat)));
-    rb_define_const(iceModule, "T_double", createType(new PrimitiveInfo(PrimitiveInfo::KindDouble)));
-    rb_define_const(iceModule, "T_string", createType(new PrimitiveInfo(PrimitiveInfo::KindString)));
+    rb_define_const(iceModule, "T_bool", createType(make_shared<PrimitiveInfo>(PrimitiveInfo::KindBool)));
+    rb_define_const(iceModule, "T_byte", createType(make_shared<PrimitiveInfo>(PrimitiveInfo::KindByte)));
+    rb_define_const(iceModule, "T_short", createType(make_shared<PrimitiveInfo>(PrimitiveInfo::KindShort)));
+    rb_define_const(iceModule, "T_int", createType(make_shared<PrimitiveInfo>(PrimitiveInfo::KindInt)));
+    rb_define_const(iceModule, "T_long", createType(make_shared<PrimitiveInfo>(PrimitiveInfo::KindLong)));
+    rb_define_const(iceModule, "T_float", createType(make_shared<PrimitiveInfo>(PrimitiveInfo::KindFloat)));
+    rb_define_const(iceModule, "T_double", createType(make_shared<PrimitiveInfo>(PrimitiveInfo::KindDouble)));
+    rb_define_const(iceModule, "T_string", createType(make_shared<PrimitiveInfo>(PrimitiveInfo::KindString)));
 
     rb_define_module_function(iceModule, "__defineEnum", CAST_METHOD(IceRuby_defineEnum), 3);
     rb_define_module_function(iceModule, "__defineStruct", CAST_METHOD(IceRuby_defineStruct), 3);
@@ -3274,19 +3058,16 @@ IceRuby::initTypes(VALUE iceModule)
     rb_define_module_function(iceModule, "__defineDictionary", CAST_METHOD(IceRuby_defineDictionary), 3);
     rb_define_module_function(iceModule, "__declareProxy", CAST_METHOD(IceRuby_declareProxy), 1);
     rb_define_module_function(iceModule, "__declareClass", CAST_METHOD(IceRuby_declareClass), 1);
-    rb_define_module_function(iceModule, "__declareLocalClass", CAST_METHOD(IceRuby_declareLocalClass), 1);
-    rb_define_module_function(iceModule, "__defineException", CAST_METHOD(IceRuby_defineException), 5);
+    rb_define_module_function(iceModule, "__defineException", CAST_METHOD(IceRuby_defineException), 4);
 
-    rb_define_method(_typeInfoClass, "defineClass", CAST_METHOD(IceRuby_TypeInfo_defineClass), 6);
+    rb_define_method(_typeInfoClass, "defineClass", CAST_METHOD(IceRuby_TypeInfo_defineClass), 5);
     rb_define_method(_typeInfoClass, "defineProxy", CAST_METHOD(IceRuby_TypeInfo_defineProxy), 3);
 
     rb_define_module_function(iceModule, "__stringify", CAST_METHOD(IceRuby_stringify), 2);
     rb_define_module_function(iceModule, "__stringifyException", CAST_METHOD(IceRuby_stringifyException), 1);
 
-    _unsetTypeClass = rb_define_class_under(iceModule, "Internal_UnsetType", rb_cObject);
-    Unset = callRuby(rb_class_new_instance, 0, static_cast<VALUE*>(0), _unsetTypeClass);
-    rb_undef_alloc_func(_unsetTypeClass);
-    rb_define_const(iceModule, "Unset", Unset);
+    // Keep Ice::Unset as an alias for nil, for backwards compatibility.
+    rb_define_const(iceModule, "Unset", Qnil);
 
     return true;
 }
@@ -3300,17 +3081,25 @@ IceRuby::getType(VALUE obj)
     return *p;
 }
 
-extern "C"
-void
-IceRuby_TypeInfo_free(TypeInfoPtr* p)
+extern "C" void
+IceRuby_TypeInfo_free(void* p)
 {
-    delete p;
+    delete static_cast<TypeInfoPtr*>(p);
 }
 
+static const rb_data_type_t IceRuby_TypeInfoType = {
+    .wrap_struct_name = "Ice::TypeInfo",
+    .function =
+        {
+            .dfree = IceRuby_TypeInfo_free,
+        },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 VALUE
 IceRuby::createType(const TypeInfoPtr& info)
 {
-    return Data_Wrap_Struct(_typeInfoClass, 0, IceRuby_TypeInfo_free, new TypeInfoPtr(info));
+    return TypedData_Wrap_Struct(_typeInfoClass, &IceRuby_TypeInfoType, new TypeInfoPtr(info));
 }
 
 IceRuby::ExceptionInfoPtr
@@ -3322,15 +3111,23 @@ IceRuby::getException(VALUE obj)
     return *p;
 }
 
-extern "C"
-void
-IceRuby_ExceptionInfo_free(ExceptionInfoPtr* p)
+extern "C" void
+IceRuby_ExceptionInfo_free(void* p)
 {
-    delete p;
+    delete static_cast<ExceptionInfoPtr*>(p);
 }
 
+static const rb_data_type_t IceRuby_ExceptionInfoType = {
+    .wrap_struct_name = "Ice::ExceptionInfo",
+    .function =
+        {
+            .dfree = IceRuby_ExceptionInfo_free,
+        },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 VALUE
 IceRuby::createException(const ExceptionInfoPtr& info)
 {
-    return Data_Wrap_Struct(_exceptionInfoClass, 0, IceRuby_ExceptionInfo_free, new ExceptionInfoPtr(info));
+    return TypedData_Wrap_Struct(_exceptionInfoClass, &IceRuby_ExceptionInfoType, new ExceptionInfoPtr(info));
 }