zeroc-ice 3.7.11 → 3.8.1

data/dist/IceRuby/Types.h

@@ -1,604 +1,533 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_RUBY_TYPES_H
 #define ICE_RUBY_TYPES_H
 
-#include <Config.h>
-#include <Util.h>
-#include <Ice/FactoryTable.h>
-#include <Ice/Object.h>
-#include <Ice/SlicedData.h>
-#include <IceUtil/OutputUtil.h>
+#include "Config.h"
+#include "Util.h"
 
-namespace IceRuby
-{
-
-class ExceptionInfo;
-typedef IceUtil::Handle<ExceptionInfo> ExceptionInfoPtr;
-typedef std::vector<ExceptionInfoPtr> ExceptionInfoList;
-
-class ClassInfo;
-typedef IceUtil::Handle<ClassInfo> ClassInfoPtr;
+#include "Ice/Object.h"
+#include "Ice/OutputUtil.h"
+#include "Ice/SlicedData.h"
 
-class ProxyInfo;
-typedef IceUtil::Handle<ProxyInfo> ProxyInfoPtr;
-typedef std::vector<ProxyInfoPtr> ProxyInfoList;
-
-//
-// This class is raised as an exception when object marshaling needs to be aborted.
-//
-// TODO: Need an equivalent Ruby exception.
-//
-class AbortMarshaling
+namespace IceRuby
 {
-};
-
-typedef std::map<VALUE, Ice::ObjectPtr> ObjectMap;
+    class ExceptionInfo;
+    using ExceptionInfoPtr = std::shared_ptr<ExceptionInfo>;
+    using ExceptionInfoList = std::vector<ExceptionInfoPtr>;
 
-class ObjectReader;
-typedef IceUtil::Handle<ObjectReader> ObjectReaderPtr;
+    class ClassInfo;
+    using ClassInfoPtr = std::shared_ptr<ClassInfo>;
 
-struct PrintObjectHistory
-{
-    int index;
-    std::map<VALUE, int> objects;
-};
-
-//
-// The delayed nature of class unmarshaling in the Ice protocol requires us to
-// handle unmarshaling using a callback strategy. An instance of UnmarshalCallback
-// is supplied to each type's unmarshal() member function. For all types except
-// classes, the callback is invoked with the unmarshaled value before unmarshal()
-// returns. For class instances, however, the callback may not be invoked until
-// the stream's finished() function is called.
-//
-class UnmarshalCallback : public IceUtil::Shared
-{
-public:
-
-    virtual ~UnmarshalCallback();
+    class ProxyInfo;
+    using ProxyInfoPtr = std::shared_ptr<ProxyInfo>;
+    using ProxyInfoList = std::vector<ProxyInfoPtr>;
 
     //
-    // The unmarshaled() member function receives the unmarshaled value. The
-    // last two arguments are the values passed to unmarshal() for use by
-    // UnmarshalCallback implementations.
+    // This class is raised as an exception when object marshaling needs to be aborted.
     //
-    virtual void unmarshaled(VALUE, VALUE, void*) = 0;
-};
-typedef IceUtil::Handle<UnmarshalCallback> UnmarshalCallbackPtr;
-
-//
-// ReadObjectCallback retains all of the information necessary to store an unmarshaled
-// Slice value as a Ruby object.
-//
-class ReadObjectCallback : public IceUtil::Shared
-{
-public:
-
-    ReadObjectCallback(const ClassInfoPtr&, const UnmarshalCallbackPtr&, VALUE, void*);
-
-    void invoke(const ::Ice::ObjectPtr&);
-
-private:
+    // TODO: Need an equivalent Ruby exception.
+    //
+    class AbortMarshaling
+    {
+    };
 
-    ClassInfoPtr _info;
-    UnmarshalCallbackPtr _cb;
-    VALUE _target;
-    void* _closure;
-};
-typedef IceUtil::Handle<ReadObjectCallback> ReadObjectCallbackPtr;
+    using ValueMap = std::map<VALUE, std::shared_ptr<Ice::Value>>;
 
-//
-// This class assists during unmarshaling of Slice classes and exceptions.
-// We attach an instance to a stream.
-//
-class StreamUtil
-{
-public:
+    class ValueReader;
 
-    StreamUtil();
-    ~StreamUtil();
-
-    //
-    // Keep a reference to a ReadObjectCallback for patching purposes.
-    //
-    void add(const ReadObjectCallbackPtr&);
+    struct PrintObjectHistory
+    {
+        int index;
+        std::map<VALUE, int> objects;
+    };
 
     //
-    // Keep track of object instances that have preserved slices.
+    // The delayed nature of class unmarshaling in the Ice protocol requires us to
+    // handle unmarshaling using a callback strategy. An instance of UnmarshalCallback
+    // is supplied to each type's unmarshal() member function. For all types except
+    // classes, the callback is invoked with the unmarshaled value before unmarshal()
+    // returns. For class instances, however, the callback may not be invoked until
+    // the stream's finished() function is called.
     //
-    void add(const ObjectReaderPtr&);
+    class UnmarshalCallback
+    {
+    public:
+        virtual ~UnmarshalCallback();
+
+        //
+        // The unmarshaled() member function receives the unmarshaled value. The
+        // last two arguments are the values passed to unmarshal() for use by
+        // UnmarshalCallback implementations.
+        //
+        virtual void unmarshaled(VALUE, VALUE, void*) = 0;
+    };
+    using UnmarshalCallbackPtr = std::shared_ptr<UnmarshalCallback>;
 
     //
-    // Updated the sliced data information for all stored object instances.
+    // ReadValueCallback retains all of the information necessary to store an unmarshaled
+    // Slice value as a Ruby object.
     //
-    void updateSlicedData();
-
-    static void setSlicedDataMember(VALUE, const Ice::SlicedDataPtr&);
-    static Ice::SlicedDataPtr getSlicedDataMember(VALUE, ObjectMap*);
-
-private:
-
-    std::vector<ReadObjectCallbackPtr> _callbacks;
-    std::set<ObjectReaderPtr> _readers;
-    static VALUE _slicedDataType;
-    static VALUE _sliceInfoType;
-};
-
-//
-// Base class for type information.
-//
-class TypeInfo : public UnmarshalCallback
-{
-public:
-
-    virtual std::string getId() const = 0;
-
-    virtual bool validate(VALUE) = 0;
-
-    virtual bool variableLength() const = 0;
-    virtual int wireSize() const = 0;
-    virtual Ice::OptionalFormat optionalFormat() const = 0;
-
-    virtual bool usesClasses() const; // Default implementation returns false.
-
-    virtual void unmarshaled(VALUE, VALUE, void*); // Default implementation is assert(false).
-
-    virtual void destroy();
-
-protected:
+    class ReadValueCallback final
+    {
+    public:
+        ReadValueCallback(const ClassInfoPtr&, const UnmarshalCallbackPtr&, VALUE, void*);
 
-    TypeInfo();
+        void invoke(const std::shared_ptr<Ice::Value>&);
 
-public:
+    private:
+        ClassInfoPtr _info;
+        UnmarshalCallbackPtr _cb;
+        VALUE _target;
+        void* _closure;
+    };
+    using ReadValueCallbackPtr = std::shared_ptr<ReadValueCallback>;
 
     //
-    // The marshal and unmarshal functions can raise Ice exceptions, and may raise
-    // AbortMarshaling if an error occurs.
+    // This class assists during unmarshaling of Slice classes and exceptions.
+    // We attach an instance to a stream.
     //
-    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool) = 0;
-    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool) = 0;
-
-    virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*) = 0;
-};
-typedef IceUtil::Handle<TypeInfo> TypeInfoPtr;
-
-//
-// Primitive type information.
-//
-class PrimitiveInfo : public TypeInfo
-{
-public:
-
-    enum Kind
+    class StreamUtil
     {
-        KindBool,
-        KindByte,
-        KindShort,
-        KindInt,
-        KindLong,
-        KindFloat,
-        KindDouble,
-        KindString
+    public:
+        StreamUtil();
+        ~StreamUtil();
+
+        //
+        // Keep a reference to a ReadValueCallback for patching purposes.
+        //
+        void add(const ReadValueCallbackPtr&);
+
+        //
+        // Keep track of object instances that have preserved slices.
+        //
+        void add(const std::shared_ptr<ValueReader>&);
+
+        //
+        // Updated the sliced data information for all stored object instances.
+        //
+        void updateSlicedData();
+
+        static void setSlicedDataMember(VALUE, const Ice::SlicedDataPtr&);
+        static Ice::SlicedDataPtr getSlicedDataMember(VALUE, ValueMap*);
+
+    private:
+        std::vector<ReadValueCallbackPtr> _callbacks;
+        std::set<std::shared_ptr<ValueReader>> _readers;
+        static VALUE _slicedDataType;
+        static VALUE _sliceInfoType;
     };
 
-    PrimitiveInfo();
-    PrimitiveInfo(Kind);
-
-    virtual std::string getId() const;
-
-    virtual bool validate(VALUE);
+    //
+    // Base class for type information.
+    //
+    class TypeInfo : public UnmarshalCallback
+    {
+    public:
+        virtual std::string getId() const = 0;
 
-    virtual bool variableLength() const;
-    virtual int wireSize() const;
-    virtual Ice::OptionalFormat optionalFormat() const;
+        virtual bool validate(VALUE) = 0;
 
-    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
-    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
+        virtual bool variableLength() const = 0;
+        virtual int wireSize() const = 0;
+        virtual Ice::OptionalFormat optionalFormat() const = 0;
 
-    virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
+        virtual bool usesClasses() const; // Default implementation returns false.
 
-    static double toDouble(VALUE);
+        void unmarshaled(VALUE, VALUE, void*) override; // Default implementation is assert(false).
 
-    Kind kind;
-};
-typedef IceUtil::Handle<PrimitiveInfo> PrimitiveInfoPtr;
+        virtual void destroy();
 
-//
-// Enum information.
-//
-typedef std::map<Ice::Int, VALUE> EnumeratorMap;
+    protected:
+        TypeInfo();
 
-class EnumInfo : public TypeInfo
-{
-public:
+    public:
+        // The marshal and unmarshal functions can raise Ice exceptions, and may raise AbortMarshaling if an error
+        // occurs.
+        virtual void marshal(VALUE, Ice::OutputStream*, ValueMap*, bool) = 0;
+        virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool) = 0;
 
-    EnumInfo(VALUE, VALUE, VALUE);
+        virtual void print(VALUE, IceInternal::Output&, PrintObjectHistory*) = 0;
+    };
+    using TypeInfoPtr = std::shared_ptr<TypeInfo>;
 
-    virtual std::string getId() const;
+    // Primitive type information.
+    class PrimitiveInfo final : public TypeInfo
+    {
+    public:
+        enum Kind
+        {
+            KindBool,
+            KindByte,
+            KindShort,
+            KindInt,
+            KindLong,
+            KindFloat,
+            KindDouble,
+            KindString
+        };
 
-    virtual bool validate(VALUE);
+        PrimitiveInfo();
+        PrimitiveInfo(Kind);
 
-    virtual bool variableLength() const;
-    virtual int wireSize() const;
-    virtual Ice::OptionalFormat optionalFormat() const;
+        std::string getId() const final;
 
-    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
-    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
+        bool validate(VALUE) final;
 
-    virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
+        bool variableLength() const;
+        int wireSize() const final;
+        Ice::OptionalFormat optionalFormat() const final;
 
-    const std::string id;
-    const VALUE rubyClass;
-    const Ice::Int maxValue;
-    const EnumeratorMap enumerators;
-};
-typedef IceUtil::Handle<EnumInfo> EnumInfoPtr;
+        void marshal(VALUE, Ice::OutputStream*, ValueMap*, bool) final;
+        void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool) final;
 
-class DataMember : public UnmarshalCallback
-{
-public:
-
-    virtual void unmarshaled(VALUE, VALUE, void*);
-
-    std::string name;
-    TypeInfoPtr type;
-    ID rubyID;
-    bool optional;
-    int tag;
-};
-typedef IceUtil::Handle<DataMember> DataMemberPtr;
-typedef std::vector<DataMemberPtr> DataMemberList;
-
-//
-// Struct information.
-//
-class StructInfo : public TypeInfo
-{
-public:
+        void print(VALUE, IceInternal::Output&, PrintObjectHistory*) final;
 
-    StructInfo(VALUE, VALUE, VALUE);
+        static double toDouble(VALUE);
 
-    virtual std::string getId() const;
+        Kind kind;
+    };
+    using PrimitiveInfoPtr = std::shared_ptr<PrimitiveInfo>;
 
-    virtual bool validate(VALUE);
+    // Enum information.
+    using EnumeratorMap = std::map<std::int32_t, VALUE>;
 
-    virtual bool variableLength() const;
-    virtual int wireSize() const;
-    virtual Ice::OptionalFormat optionalFormat() const;
+    class EnumInfo final : public TypeInfo
+    {
+    public:
+        EnumInfo(VALUE, VALUE, VALUE);
 
-    virtual bool usesClasses() const; // Default implementation returns false.
+        std::string getId() const final;
 
-    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
-    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
+        bool validate(VALUE) final;
 
-    virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
+        bool variableLength() const final;
+        int wireSize() const final;
+        Ice::OptionalFormat optionalFormat() const final;
 
-    virtual void destroy();
+        void marshal(VALUE, Ice::OutputStream*, ValueMap*, bool) final;
+        void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool) final;
 
-    const std::string id;
-    const DataMemberList members;
-    const VALUE rubyClass;
+        void print(VALUE, IceInternal::Output&, PrintObjectHistory*) final;
 
-private:
+        const std::string id;
+        const VALUE rubyClass;
+        const std::int32_t maxValue;
+        const EnumeratorMap enumerators;
+    };
+    using EnumInfoPtr = std::shared_ptr<EnumInfo>;
 
-    bool _variableLength;
-    int _wireSize;
-    VALUE _nullMarshalValue;
-};
-typedef IceUtil::Handle<StructInfo> StructInfoPtr;
+    class DataMember final : public UnmarshalCallback
+    {
+    public:
+        void unmarshaled(VALUE, VALUE, void*) final;
 
-//
-// Sequence information.
-//
-class SequenceInfo : public TypeInfo
-{
-public:
+        std::string name;
+        TypeInfoPtr type;
+        ID rubyID;
+        bool optional;
+        int tag;
+    };
+    using DataMemberPtr = std::shared_ptr<DataMember>;
+    using DataMemberList = std::vector<DataMemberPtr>;
 
-    SequenceInfo(VALUE, VALUE);
+    // Struct information.
+    class StructInfo final : public TypeInfo
+    {
+    public:
+        StructInfo(VALUE, VALUE, VALUE);
 
-    virtual std::string getId() const;
+        std::string getId() const final;
 
-    virtual bool validate(VALUE);
+        bool validate(VALUE) final;
 
-    virtual bool variableLength() const;
-    virtual int wireSize() const;
-    virtual Ice::OptionalFormat optionalFormat() const;
+        bool variableLength() const final;
+        int wireSize() const final;
+        Ice::OptionalFormat optionalFormat() const final;
 
-    virtual bool usesClasses() const; // Default implementation returns false.
+        bool usesClasses() const final; // Default implementation returns false.
 
-    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
-    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
-    virtual void unmarshaled(VALUE, VALUE, void*);
+        void marshal(VALUE, Ice::OutputStream*, ValueMap*, bool) final;
+        void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool) final;
 
-    virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
+        void print(VALUE, IceInternal::Output&, PrintObjectHistory*) final;
 
-    virtual void destroy();
+        void destroy() final;
 
-    const std::string id;
-    const TypeInfoPtr elementType;
+        const std::string id;
+        const DataMemberList members;
+        const VALUE rubyClass;
 
-private:
+    private:
+        bool _variableLength;
+        int _wireSize;
+    };
+    using StructInfoPtr = std::shared_ptr<StructInfo>;
 
-    void marshalPrimitiveSequence(const PrimitiveInfoPtr&, VALUE, Ice::OutputStream*);
-    void unmarshalPrimitiveSequence(const PrimitiveInfoPtr&, Ice::InputStream*, const UnmarshalCallbackPtr&,
-                                    VALUE, void*);
-};
-typedef IceUtil::Handle<SequenceInfo> SequenceInfoPtr;
+    // Sequence information.
+    class SequenceInfo final : public TypeInfo, public std::enable_shared_from_this<SequenceInfo>
+    {
+    public:
+        SequenceInfo(VALUE, VALUE);
 
-//
-// Dictionary information.
-//
-class DictionaryInfo : public TypeInfo
-{
-public:
+        std::string getId() const final;
 
-    DictionaryInfo(VALUE, VALUE, VALUE);
+        bool validate(VALUE) final;
 
-    virtual std::string getId() const;
+        bool variableLength() const final;
+        int wireSize() const final;
+        Ice::OptionalFormat optionalFormat() const final;
 
-    virtual bool validate(VALUE);
+        bool usesClasses() const final; // Default implementation returns false.
 
-    virtual bool variableLength() const;
-    virtual int wireSize() const;
-    virtual Ice::OptionalFormat optionalFormat() const;
+        void marshal(VALUE, Ice::OutputStream*, ValueMap*, bool) final;
+        void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool) final;
+        void unmarshaled(VALUE, VALUE, void*) final;
 
-    virtual bool usesClasses() const; // Default implementation returns false.
+        void print(VALUE, IceInternal::Output&, PrintObjectHistory*) final;
 
-    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
-    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
-    void marshalElement(VALUE, VALUE, Ice::OutputStream*, ObjectMap*);
-    virtual void unmarshaled(VALUE, VALUE, void*);
+        void destroy() final;
 
-    virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
-    void printElement(VALUE, VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
+        const std::string id;
+        const TypeInfoPtr elementType;
 
-    virtual void destroy();
+    private:
+        void marshalPrimitiveSequence(const PrimitiveInfoPtr&, VALUE, Ice::OutputStream*);
+        void unmarshalPrimitiveSequence(
+            const PrimitiveInfoPtr&,
+            Ice::InputStream*,
+            const UnmarshalCallbackPtr&,
+            VALUE,
+            void*);
+    };
+    using SequenceInfoPtr = std::shared_ptr<SequenceInfo>;
 
-    class KeyCallback : public UnmarshalCallback
+    // Dictionary information.
+    class DictionaryInfo final : public TypeInfo, public std::enable_shared_from_this<DictionaryInfo>
     {
     public:
+        DictionaryInfo(VALUE, VALUE, VALUE);
 
-        virtual void unmarshaled(VALUE, VALUE, void*);
-
-        VALUE key;
-    };
-    typedef IceUtil::Handle<KeyCallback> KeyCallbackPtr;
-
-    const std::string id;
-    const TypeInfoPtr keyType;
-    const TypeInfoPtr valueType;
+        std::string getId() const final;
 
-private:
+        bool validate(VALUE) final;
 
-    bool _variableLength;
-    int _wireSize;
-};
-typedef IceUtil::Handle<DictionaryInfo> DictionaryInfoPtr;
+        bool variableLength() const final;
+        int wireSize() const final;
+        Ice::OptionalFormat optionalFormat() const final;
 
-typedef std::vector<TypeInfoPtr> TypeInfoList;
+        bool usesClasses() const final; // Default implementation returns false.
 
-class ClassInfo : public TypeInfo
-{
-public:
-
-    ClassInfo(VALUE, bool);
+        void marshal(VALUE, Ice::OutputStream*, ValueMap*, bool) final;
+        void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool) final;
+        void marshalElement(VALUE, VALUE, Ice::OutputStream*, ValueMap*);
+        void unmarshaled(VALUE, VALUE, void*) final;
 
-    void define(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
+        void print(VALUE, IceInternal::Output&, PrintObjectHistory*) final;
+        void printElement(VALUE, VALUE, IceInternal::Output&, PrintObjectHistory*);
 
-    virtual std::string getId() const;
+        void destroy() final;
 
-    virtual bool validate(VALUE);
+        class KeyCallback final : public UnmarshalCallback
+        {
+        public:
+            void unmarshaled(VALUE, VALUE, void*) final;
 
-    virtual bool variableLength() const;
-    virtual int wireSize() const;
-    virtual Ice::OptionalFormat optionalFormat() const;
+            VALUE key;
+        };
+        using KeyCallbackPtr = std::shared_ptr<KeyCallback>;
 
-    virtual bool usesClasses() const; // Default implementation returns false.
+        const std::string id;
+        const TypeInfoPtr keyType;
+        const TypeInfoPtr valueType;
 
-    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
-    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
-
-    virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
+    private:
+        bool _variableLength;
+        int _wireSize;
+    };
+    using DictionaryInfoPtr = std::shared_ptr<DictionaryInfo>;
+    using TypeInfoList = std::vector<TypeInfoPtr>;
 
-    virtual void destroy();
+    class ClassInfo final : public TypeInfo, public std::enable_shared_from_this<ClassInfo>
+    {
+    public:
+        static ClassInfoPtr create(VALUE);
 
-    void printMembers(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
+        void define(VALUE, VALUE, VALUE, VALUE, VALUE);
 
-    bool isA(const ClassInfoPtr&);
+        std::string getId() const final;
 
-    const std::string id;
-    const Ice::Int compactId;
-    const bool isBase; // Is this the ClassInfo for Ice::Object or Ice::LocalObject?
-    const bool isLocal;
-    const bool preserve;
-    const bool interface;
-    const ClassInfoPtr base;
-    const DataMemberList members;
-    const DataMemberList optionalMembers;
-    const VALUE rubyClass;
-    const VALUE typeObj;
-    const bool defined;
-};
+        bool validate(VALUE) final;
 
-//
-// Proxy information.
-//
-class ProxyInfo : public TypeInfo
-{
-public:
+        bool variableLength() const final;
+        int wireSize() const final;
+        Ice::OptionalFormat optionalFormat() const final;
 
-    ProxyInfo(VALUE);
+        bool usesClasses() const final; // Default implementation returns false.
 
-    void define(VALUE, VALUE, VALUE);
+        void marshal(VALUE, Ice::OutputStream*, ValueMap*, bool) final;
+        void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool) final;
 
-    virtual std::string getId() const;
+        void print(VALUE, IceInternal::Output&, PrintObjectHistory*) final;
 
-    virtual bool validate(VALUE);
+        void destroy() final;
 
-    virtual bool variableLength() const;
-    virtual int wireSize() const;
-    virtual Ice::OptionalFormat optionalFormat() const;
+        void printMembers(VALUE, IceInternal::Output&, PrintObjectHistory*);
 
-    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
-    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
+        bool isA(const ClassInfoPtr&);
 
-    virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
+        const std::string id;
+        const std::int32_t compactId;
+        const bool isBase; // Is this the ClassInfo for Value?
+        const bool interface;
+        const ClassInfoPtr base;
+        const DataMemberList members;
+        const DataMemberList optionalMembers;
+        const VALUE rubyClass;
+        const VALUE typeObj;
+        const bool defined;
 
-    virtual void destroy();
+    private:
+        ClassInfo(VALUE);
+    };
 
-    bool isA(const ProxyInfoPtr&);
+    // Proxy information.
+    class ProxyInfo final : public TypeInfo
+    {
+    public:
+        static ProxyInfoPtr create(VALUE);
 
-    const std::string id;
-    const bool isBase; // Is this the ClassInfo for Ice::ObjectPrx?
-    const ProxyInfoPtr base;
-    const ProxyInfoList interfaces;
-    const VALUE rubyClass;
-    const VALUE typeObj;
-};
+        void define(VALUE, VALUE, VALUE);
 
-//
-// Exception information.
-//
-class ExceptionInfo : public IceUtil::Shared
-{
-public:
-
-    VALUE unmarshal(Ice::InputStream*);
-
-    void print(VALUE, IceUtilInternal::Output&);
-    void printMembers(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
-
-    std::string id;
-    bool preserve;
-    ExceptionInfoPtr base;
-    DataMemberList members;
-    DataMemberList optionalMembers;
-    bool usesClasses;
-    VALUE rubyClass;
-};
-
-//
-// ObjectWriter wraps a Ruby object for marshaling.
-//
-class ObjectWriter : public Ice::Object
-{
-public:
-
-    ObjectWriter(VALUE, ObjectMap*, const ClassInfoPtr&);
-    virtual ~ObjectWriter();
+        std::string getId() const final;
 
-    virtual void ice_preMarshal();
+        bool validate(VALUE) final;
 
-    virtual void _iceWrite(Ice::OutputStream*) const;
-    virtual void _iceRead(Ice::InputStream*);
+        bool variableLength() const final;
+        int wireSize() const final;
+        Ice::OptionalFormat optionalFormat() const final;
 
-private:
+        void marshal(VALUE, Ice::OutputStream*, ValueMap*, bool) final;
+        void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool) final;
 
-    void writeMembers(Ice::OutputStream*, const DataMemberList&) const;
+        void print(VALUE, IceInternal::Output&, PrintObjectHistory*) final;
 
-    VALUE _object;
-    ObjectMap* _map;
-    ClassInfoPtr _info;
-    ClassInfoPtr _formal;
-};
+        void destroy() final;
 
-//
-// ObjectReader unmarshals the state of an Ice object.
-//
-class ObjectReader : public Ice::Object
-{
-public:
+        bool isA(const ProxyInfoPtr&);
 
-    ObjectReader(VALUE, const ClassInfoPtr&);
-    virtual ~ObjectReader();
+        const std::string id;
+        const bool isBase; // Is this the ClassInfo for Ice::ObjectPrx?
+        const ProxyInfoPtr base;
+        const ProxyInfoList interfaces;
+        const VALUE rubyClass;
+        const VALUE typeObj;
 
-    virtual void ice_postUnmarshal();
+    private:
+        ProxyInfo(VALUE);
+    };
 
-    virtual void _iceWrite(Ice::OutputStream*) const;
-    virtual void _iceRead(Ice::InputStream*);
+    // Exception information.
+    class ExceptionInfo final : public std::enable_shared_from_this<ExceptionInfo>
+    {
+    public:
+        VALUE unmarshal(Ice::InputStream*);
 
-    virtual ClassInfoPtr getInfo() const;
+        void print(VALUE, IceInternal::Output&);
+        void printMembers(VALUE, IceInternal::Output&, PrintObjectHistory*);
 
-    VALUE getObject() const; // Borrowed reference.
+        std::string id;
+        ExceptionInfoPtr base;
+        DataMemberList members;
+        DataMemberList optionalMembers;
+        bool usesClasses;
+        VALUE rubyClass;
+    };
 
-    Ice::SlicedDataPtr getSlicedData() const;
+    // ValueWriter wraps a Ruby object for marshaling.
+    class ValueWriter final : public Ice::Value
+    {
+    public:
+        ValueWriter(VALUE, ValueMap*, const ClassInfoPtr&);
+        ~ValueWriter();
 
-private:
+        void ice_preMarshal() final;
 
-    VALUE _object;
-    ClassInfoPtr _info;
-    Ice::SlicedDataPtr _slicedData;
-};
+        void _iceWrite(Ice::OutputStream*) const final;
+        void _iceRead(Ice::InputStream*) final;
 
-//
-// ExceptionReader creates a Ruby user exception and unmarshals it.
-//
-class ExceptionReader : public Ice::UserException
-{
-public:
+    private:
+        void writeMembers(Ice::OutputStream*, const DataMemberList&) const;
 
-    ExceptionReader(const ExceptionInfoPtr&);
-#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
-    ~ExceptionReader() throw();
-#if defined(__clang__)
-#   pragma clang diagnostic pop
-#endif
+        VALUE _object;
+        ValueMap* _map;
+        ClassInfoPtr _info;
+        ClassInfoPtr _formal;
+    };
 
+    //
+    // ValueReader unmarshals the state of an Ice object.
+    //
+    class ValueReader final : public std::enable_shared_from_this<ValueReader>, public Ice::Value
+    {
+    public:
+        ValueReader(VALUE, const ClassInfoPtr&);
+        ~ValueReader();
 
-    virtual std::string ice_id() const;
-#ifndef ICE_CPP11_MAPPING
-    virtual Ice::UserException* ice_clone() const;
-#endif
-    virtual void ice_throw() const;
+        void ice_postUnmarshal() final;
 
-    virtual void _write(Ice::OutputStream*) const;
-    virtual void _read(Ice::InputStream*);
+        void _iceWrite(Ice::OutputStream*) const final;
+        void _iceRead(Ice::InputStream*) final;
 
-    virtual bool _usesClasses() const;
+        ClassInfoPtr getInfo() const;
 
-    VALUE getException() const;
+        VALUE getObject() const; // Borrowed reference.
 
-    Ice::SlicedDataPtr getSlicedData() const;
+        Ice::SlicedDataPtr getSlicedData() const;
 
-protected:
+    private:
+        VALUE _object;
+        ClassInfoPtr _info;
+        Ice::SlicedDataPtr _slicedData;
+    };
 
-    virtual void _writeImpl(Ice::OutputStream*) const {}
-    virtual void _readImpl(Ice::InputStream*) {}
+    // ExceptionReader creates a Ruby user exception and unmarshals it.
+    class ExceptionReader final : public Ice::UserException
+    {
+    public:
+        ExceptionReader(const ExceptionInfoPtr&);
+        ExceptionReader(const ExceptionReader&);
+        ~ExceptionReader();
 
-private:
+        const char* ice_id() const noexcept final;
+        void ice_throw() const final;
 
-    ExceptionInfoPtr _info;
-    VALUE _ex;
-    Ice::SlicedDataPtr _slicedData;
-};
+        void _write(Ice::OutputStream*) const final;
+        void _read(Ice::InputStream*) final;
 
-class IdResolver : public Ice::CompactIdResolver
-{
-public:
+        bool _usesClasses() const final;
 
-    virtual ::std::string resolve(Ice::Int) const;
-};
+        VALUE getException() const;
 
-ClassInfoPtr lookupClassInfo(const std::string&);
-ExceptionInfoPtr lookupExceptionInfo(const std::string&);
+    protected:
+        void _writeImpl(Ice::OutputStream*) const final {}
+        void _readImpl(Ice::InputStream*) final {}
 
-extern VALUE Unset;
+    private:
+        ExceptionInfoPtr _info;
+        VALUE _ex;
+    };
 
-bool initTypes(VALUE);
+    ClassInfoPtr lookupClassInfo(std::string_view);
+    ExceptionInfoPtr lookupExceptionInfo(std::string_view);
 
-VALUE createType(const TypeInfoPtr&);
-TypeInfoPtr getType(VALUE);
+    bool initTypes(VALUE);
 
-VALUE createException(const ExceptionInfoPtr&);
-ExceptionInfoPtr getException(VALUE);
+    VALUE createType(const TypeInfoPtr&);
+    TypeInfoPtr getType(VALUE);
 
+    VALUE createException(const ExceptionInfoPtr&);
+    ExceptionInfoPtr getException(VALUE);
 }
 
 #endif