zeroc-ice 3.7.11 → 3.8.1

data/dist/IceRuby/Connection.cpp

@@ -1,17 +1,11 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#if defined(__clang__)
-#   pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-#include <Connection.h>
-#include <Endpoint.h>
-#include <Types.h>
-#include <Util.h>
-#include <Ice/Object.h>
-#include <IceSSL/ConnectionInfo.h>
+#include "Connection.h"
+#include "../../cpp/src/Ice/SSL/SSLUtil.h"
+#include "Endpoint.h"
+#include "Ice/Ice.h"
+#include "Types.h"
+#include "Util.h"
 
 using namespace std;
 using namespace IceRuby;
@@ -25,178 +19,83 @@ static VALUE _udpConnectionInfoClass;
 static VALUE _wsConnectionInfoClass;
 static VALUE _sslConnectionInfoClass;
 
-// Connection
-
-extern "C"
-void
-IceRuby_Connection_free(Ice::ConnectionPtr* p)
+extern "C" void
+IceRuby_Connection_free(void* p)
 {
-    assert(p);
-    delete p;
+    delete static_cast<Ice::ConnectionPtr*>(p);
 }
 
+static const rb_data_type_t IceRuby_ConnectionType = {
+    .wrap_struct_name = "Ice::Connection",
+    .function =
+        {
+            .dfree = IceRuby_Connection_free,
+        },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 VALUE
 IceRuby::createConnection(const Ice::ConnectionPtr& p)
 {
-    return Data_Wrap_Struct(_connectionClass, 0, IceRuby_Connection_free, new Ice::ConnectionPtr(p));
+    return TypedData_Wrap_Struct(_connectionClass, &IceRuby_ConnectionType, new Ice::ConnectionPtr(p));
 }
 
-extern "C"
-VALUE
-IceRuby_Connection_close(VALUE self, VALUE mode)
+extern "C" VALUE
+IceRuby_Connection_abort(VALUE self)
 {
-    ICE_RUBY_TRY
-    {
-        Ice::ConnectionPtr* p = reinterpret_cast<Ice::ConnectionPtr*>(DATA_PTR(self));
-        assert(p);
-
-        volatile VALUE type = callRuby(rb_path2class, "Ice::ConnectionClose");
-        if(callRuby(rb_obj_is_instance_of, mode, type) != Qtrue)
-        {
-            throw RubyException(rb_eTypeError,
-                "value for 'mode' argument must be an enumerator of Ice::ConnectionClose");
-        }
-        volatile VALUE modeValue = callRuby(rb_funcall, mode, rb_intern("to_i"), 0);
-        assert(TYPE(modeValue) == T_FIXNUM);
-        Ice::ConnectionClose cc = static_cast<Ice::ConnectionClose>(FIX2LONG(modeValue));
-        (*p)->close(cc);
-    }
-    ICE_RUBY_CATCH
+    Ice::ConnectionPtr* p = reinterpret_cast<Ice::ConnectionPtr*>(DATA_PTR(self));
+    assert(p);
+    (*p)->abort();
     return Qnil;
 }
 
-extern "C"
-VALUE
-IceRuby_Connection_flushBatchRequests(VALUE self, VALUE compress)
+extern "C" VALUE
+IceRuby_Connection_close(VALUE self)
 {
     ICE_RUBY_TRY
     {
         Ice::ConnectionPtr* p = reinterpret_cast<Ice::ConnectionPtr*>(DATA_PTR(self));
         assert(p);
-
-        volatile VALUE type = callRuby(rb_path2class, "Ice::CompressBatch");
-        if(callRuby(rb_obj_is_instance_of, compress, type) != Qtrue)
-        {
-            throw RubyException(rb_eTypeError,
-                "value for 'compress' argument must be an enumerator of Ice::CompressBatch");
-        }
-        volatile VALUE compressValue = callRuby(rb_funcall, compress, rb_intern("to_i"), 0);
-        assert(TYPE(compressValue) == T_FIXNUM);
-        Ice::CompressBatch cb = static_cast<Ice::CompressBatch>(FIX2LONG(compressValue));
-        (*p)->flushBatchRequests(cb);
+        (*p)->close().get();
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
-IceRuby_Connection_heartbeat(VALUE self)
+extern "C" VALUE
+IceRuby_Connection_disableInactivityCheck(VALUE self)
 {
-    ICE_RUBY_TRY
-    {
-        Ice::ConnectionPtr* p = reinterpret_cast<Ice::ConnectionPtr*>(DATA_PTR(self));
-        assert(p);
-
-        (*p)->heartbeat();
-    }
-    ICE_RUBY_CATCH
+    Ice::ConnectionPtr* p = reinterpret_cast<Ice::ConnectionPtr*>(DATA_PTR(self));
+    assert(p);
+    (*p)->disableInactivityCheck();
     return Qnil;
 }
 
-extern "C"
-VALUE
-IceRuby_Connection_setACM(VALUE self, VALUE t, VALUE c, VALUE h)
+extern "C" VALUE
+IceRuby_Connection_flushBatchRequests(VALUE self, VALUE compress)
 {
     ICE_RUBY_TRY
     {
         Ice::ConnectionPtr* p = reinterpret_cast<Ice::ConnectionPtr*>(DATA_PTR(self));
         assert(p);
 
-        IceUtil::Optional<Ice::Int> timeout;
-        IceUtil::Optional<Ice::ACMClose> close;
-        IceUtil::Optional<Ice::ACMHeartbeat> heartbeat;
-
-        if(t != Unset)
-        {
-            timeout = static_cast<Ice::Int>(getInteger(t));
-        }
-
-        if(c != Unset)
-        {
-            volatile VALUE type = callRuby(rb_path2class, "Ice::ACMClose");
-            if(callRuby(rb_obj_is_instance_of, c, type) != Qtrue)
-            {
-                throw RubyException(rb_eTypeError,
-                    "value for 'close' argument must be Unset or an enumerator of Ice.ACMClose");
-            }
-            volatile VALUE closeValue = callRuby(rb_funcall, c, rb_intern("to_i"), 0);
-            assert(TYPE(closeValue) == T_FIXNUM);
-            close = static_cast<Ice::ACMClose>(FIX2LONG(closeValue));
-        }
-
-        if(h != Unset)
-        {
-            volatile VALUE type = callRuby(rb_path2class, "Ice::ACMHeartbeat");
-            if(callRuby(rb_obj_is_instance_of, h, type) != Qtrue)
-            {
-                throw RubyException(rb_eTypeError,
-                    "value for 'heartbeat' argument must be Unset or an enumerator of Ice.ACMHeartbeat");
-            }
-            volatile VALUE heartbeatValue = callRuby(rb_funcall, h, rb_intern("to_i"), 0);
-            assert(TYPE(heartbeatValue) == T_FIXNUM);
-            heartbeat = static_cast<Ice::ACMHeartbeat>(FIX2LONG(heartbeatValue));
-        }
-
-        try
-        {
-            (*p)->setACM(timeout, close, heartbeat);
-        }
-        catch(const IceUtil::IllegalArgumentException& ex)
+        volatile VALUE type = callRuby(rb_path2class, "Ice::CompressBatch");
+        if (callRuby(rb_obj_is_instance_of, compress, type) != Qtrue)
         {
-            throw RubyException(rb_eArgError, ex.reason().c_str());
+            throw RubyException(
+                rb_eTypeError,
+                "value for 'compress' argument must be an enumerator of Ice::CompressBatch");
         }
+        volatile VALUE compressValue = callRuby(rb_funcall, compress, rb_intern("to_i"), 0);
+        assert(TYPE(compressValue) == T_FIXNUM);
+        Ice::CompressBatch cb = static_cast<Ice::CompressBatch>(FIX2LONG(compressValue));
+        (*p)->flushBatchRequests(cb);
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
-IceRuby_Connection_getACM(VALUE self)
-{
-    ICE_RUBY_TRY
-    {
-        Ice::ConnectionPtr* p = reinterpret_cast<Ice::ConnectionPtr*>(DATA_PTR(self));
-        assert(p);
-
-        Ice::ACM acm = (*p)->getACM();
-        volatile VALUE type = callRuby(rb_path2class, "Ice::ACM");
-        assert(type != Qnil);
-        volatile VALUE r = callRuby(rb_class_new_instance, 0, static_cast<VALUE*>(0), type);
-        assert(r != Qnil);
-
-        callRuby(rb_ivar_set, r, rb_intern("@timeout"), LONG2FIX(acm.timeout));
-
-        type = callRuby(rb_path2class, "Ice::ACMClose");
-        assert(type != Qnil);
-        volatile VALUE c = callRuby(rb_funcall, type, rb_intern("from_int"), 1, LONG2NUM(static_cast<int>(acm.close)));
-        callRuby(rb_ivar_set, r, rb_intern("@close"), c);
-
-        type = callRuby(rb_path2class, "Ice::ACMHeartbeat");
-        assert(type != Qnil);
-        volatile VALUE h =
-            callRuby(rb_funcall, type, rb_intern("from_int"), 1, LONG2NUM(static_cast<int>(acm.heartbeat)));
-        callRuby(rb_ivar_set, r, rb_intern("@heartbeat"), h);
-
-        return r;
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Connection_type(VALUE self)
 {
     ICE_RUBY_TRY
@@ -211,24 +110,7 @@ IceRuby_Connection_type(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
-IceRuby_Connection_timeout(VALUE self)
-{
-    ICE_RUBY_TRY
-    {
-        Ice::ConnectionPtr* p = reinterpret_cast<Ice::ConnectionPtr*>(DATA_PTR(self));
-        assert(p);
-
-        Ice::Int timeout = (*p)->timeout();
-        return INT2FIX(timeout);
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Connection_getInfo(VALUE self)
 {
     ICE_RUBY_TRY
@@ -243,8 +125,7 @@ IceRuby_Connection_getInfo(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Connection_getEndpoint(VALUE self)
 {
     ICE_RUBY_TRY
@@ -259,8 +140,7 @@ IceRuby_Connection_getEndpoint(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Connection_setBufferSize(VALUE self, VALUE r, VALUE s)
 {
     ICE_RUBY_TRY
@@ -277,8 +157,7 @@ IceRuby_Connection_setBufferSize(VALUE self, VALUE r, VALUE s)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Connection_throwException(VALUE self)
 {
     ICE_RUBY_TRY
@@ -292,8 +171,7 @@ IceRuby_Connection_throwException(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Connection_toString(VALUE self)
 {
     ICE_RUBY_TRY
@@ -308,17 +186,16 @@ IceRuby_Connection_toString(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Connection_equals(VALUE self, VALUE other)
 {
     ICE_RUBY_TRY
     {
-        if(NIL_P(other))
+        if (NIL_P(other))
         {
             return Qfalse;
         }
-        if(callRuby(rb_obj_is_kind_of, other, _connectionClass) != Qtrue)
+        if (callRuby(rb_obj_is_kind_of, other, _connectionClass) != Qtrue)
         {
             throw RubyException(rb_eTypeError, "argument must be a connection");
         }
@@ -332,30 +209,38 @@ IceRuby_Connection_equals(VALUE self, VALUE other)
 
 // ConnectionInfo
 
-extern "C"
-void
-IceRuby_ConnectionInfo_free(Ice::ConnectionInfoPtr* p)
+extern "C" void
+IceRuby_ConnectionInfo_free(void* p)
 {
-    assert(p);
-    delete p;
+    delete static_cast<Ice::ConnectionInfoPtr*>(p);
 }
 
+static const rb_data_type_t IceRuby_ConnectionInfoType = {
+    .wrap_struct_name = "Ice::ConnectionInfo",
+    .function =
+        {
+            .dfree = IceRuby_ConnectionInfo_free,
+        },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 VALUE
 IceRuby::createConnectionInfo(const Ice::ConnectionInfoPtr& p)
 {
-    if(!p)
+    if (!p)
     {
         return Qnil;
     }
 
     VALUE info;
-    if(Ice::WSConnectionInfoPtr::dynamicCast(p))
+    if (dynamic_pointer_cast<Ice::WSConnectionInfo>(p))
     {
-        info = Data_Wrap_Struct(_wsConnectionInfoClass, 0, IceRuby_ConnectionInfo_free, new Ice::ConnectionInfoPtr(p));
+        info =
+            TypedData_Wrap_Struct(_wsConnectionInfoClass, &IceRuby_ConnectionInfoType, new Ice::ConnectionInfoPtr(p));
 
-        Ice::WSConnectionInfoPtr ws = Ice::WSConnectionInfoPtr::dynamicCast(p);
+        Ice::WSConnectionInfoPtr ws = dynamic_pointer_cast<Ice::WSConnectionInfo>(p);
         volatile VALUE result = callRuby(rb_hash_new);
-        for(Ice::HeaderDict::const_iterator q = ws->headers.begin(); q != ws->headers.end(); ++q)
+        for (Ice::HeaderDict::const_iterator q = ws->headers.begin(); q != ws->headers.end(); ++q)
         {
             volatile VALUE key = createString(q->first);
             volatile VALUE value = createString(q->second);
@@ -363,53 +248,52 @@ IceRuby::createConnectionInfo(const Ice::ConnectionInfoPtr& p)
         }
         rb_ivar_set(info, rb_intern("@headers"), result);
     }
-    else if(Ice::TCPConnectionInfoPtr::dynamicCast(p))
+    else if (dynamic_pointer_cast<Ice::TCPConnectionInfo>(p))
     {
-        info = Data_Wrap_Struct(_tcpConnectionInfoClass, 0, IceRuby_ConnectionInfo_free, new Ice::ConnectionInfoPtr(p));
+        info =
+            TypedData_Wrap_Struct(_tcpConnectionInfoClass, &IceRuby_ConnectionInfoType, new Ice::ConnectionInfoPtr(p));
 
-        Ice::TCPConnectionInfoPtr tcp = Ice::TCPConnectionInfoPtr::dynamicCast(p);
+        Ice::TCPConnectionInfoPtr tcp = dynamic_pointer_cast<Ice::TCPConnectionInfo>(p);
         rb_ivar_set(info, rb_intern("@rcvSize"), INT2FIX(tcp->rcvSize));
         rb_ivar_set(info, rb_intern("@sndSize"), INT2FIX(tcp->sndSize));
     }
-    else if(Ice::UDPConnectionInfoPtr::dynamicCast(p))
+    else if (dynamic_pointer_cast<Ice::UDPConnectionInfo>(p))
     {
-        info = Data_Wrap_Struct(_udpConnectionInfoClass, 0, IceRuby_ConnectionInfo_free, new Ice::ConnectionInfoPtr(p));
+        info =
+            TypedData_Wrap_Struct(_udpConnectionInfoClass, &IceRuby_ConnectionInfoType, new Ice::ConnectionInfoPtr(p));
 
-        Ice::UDPConnectionInfoPtr udp = Ice::UDPConnectionInfoPtr::dynamicCast(p);
+        Ice::UDPConnectionInfoPtr udp = dynamic_pointer_cast<Ice::UDPConnectionInfo>(p);
         rb_ivar_set(info, rb_intern("@mcastAddress"), createString(udp->mcastAddress));
         rb_ivar_set(info, rb_intern("@mcastPort"), INT2FIX(udp->mcastPort));
         rb_ivar_set(info, rb_intern("@rcvSize"), INT2FIX(udp->rcvSize));
         rb_ivar_set(info, rb_intern("@sndSize"), INT2FIX(udp->sndSize));
     }
-    else if(IceSSL::ConnectionInfoPtr::dynamicCast(p))
+    else if (dynamic_pointer_cast<Ice::SSL::ConnectionInfo>(p))
     {
-        info = Data_Wrap_Struct(_sslConnectionInfoClass, 0, IceRuby_ConnectionInfo_free, new Ice::ConnectionInfoPtr(p));
-
-        IceSSL::ConnectionInfoPtr ssl = IceSSL::ConnectionInfoPtr::dynamicCast(p);
-        rb_ivar_set(info, rb_intern("@cipher"), createString(ssl->cipher));
+        info =
+            TypedData_Wrap_Struct(_sslConnectionInfoClass, &IceRuby_ConnectionInfoType, new Ice::ConnectionInfoPtr(p));
 
-        Ice::StringSeq encoded;
-        for(vector<IceSSL::CertificatePtr>::const_iterator i = ssl->certs.begin(); i != ssl->certs.end(); ++i)
+        Ice::SSL::ConnectionInfoPtr ssl = dynamic_pointer_cast<Ice::SSL::ConnectionInfo>(p);
+        string encoded;
+        if (ssl->peerCertificate)
         {
-            encoded.push_back((*i)->encode());
+            encoded = Ice::SSL::encodeCertificate(ssl->peerCertificate);
         }
-
-        rb_ivar_set(info, rb_intern("@certs"), stringSeqToArray(encoded));
-        rb_ivar_set(info, rb_intern("@verified"), ssl->verified ? Qtrue : Qfalse);
+        rb_ivar_set(info, rb_intern("@peerCertificate"), createString(encoded));
     }
-    else if(Ice::IPConnectionInfoPtr::dynamicCast(p))
+    else if (dynamic_pointer_cast<Ice::IPConnectionInfo>(p))
     {
-        info = Data_Wrap_Struct(_ipConnectionInfoClass, 0, IceRuby_ConnectionInfo_free, new Ice::ConnectionInfoPtr(p));
-
+        info =
+            TypedData_Wrap_Struct(_ipConnectionInfoClass, &IceRuby_ConnectionInfoType, new Ice::ConnectionInfoPtr(p));
     }
     else
     {
-        info = Data_Wrap_Struct(_connectionInfoClass, 0, IceRuby_ConnectionInfo_free, new Ice::ConnectionInfoPtr(p));
+        info = TypedData_Wrap_Struct(_connectionInfoClass, &IceRuby_ConnectionInfoType, new Ice::ConnectionInfoPtr(p));
     }
 
-    if(Ice::IPConnectionInfoPtr::dynamicCast(p))
+    if (dynamic_pointer_cast<Ice::IPConnectionInfo>(p))
     {
-        Ice::IPConnectionInfoPtr ip = Ice::IPConnectionInfoPtr::dynamicCast(p);
+        Ice::IPConnectionInfoPtr ip = dynamic_pointer_cast<Ice::IPConnectionInfo>(p);
         rb_ivar_set(info, rb_intern("@localAddress"), createString(ip->localAddress));
         rb_ivar_set(info, rb_intern("@localPort"), INT2FIX(ip->localPort));
         rb_ivar_set(info, rb_intern("@remoteAddress"), createString(ip->remoteAddress));
@@ -434,13 +318,15 @@ IceRuby::initConnection(VALUE iceModule)
     //
     // Instance methods.
     //
-    rb_define_method(_connectionClass, "close", CAST_METHOD(IceRuby_Connection_close), 1);
+    rb_define_method(_connectionClass, "abort", CAST_METHOD(IceRuby_Connection_abort), 0);
+    rb_define_method(_connectionClass, "close", CAST_METHOD(IceRuby_Connection_close), 0);
+    rb_define_method(
+        _connectionClass,
+        "disableInactivityCheck",
+        CAST_METHOD(IceRuby_Connection_disableInactivityCheck),
+        0);
     rb_define_method(_connectionClass, "flushBatchRequests", CAST_METHOD(IceRuby_Connection_flushBatchRequests), 1);
-    rb_define_method(_connectionClass, "heartbeat", CAST_METHOD(IceRuby_Connection_heartbeat), 0);
-    rb_define_method(_connectionClass, "setACM", CAST_METHOD(IceRuby_Connection_setACM), 3);
-    rb_define_method(_connectionClass, "getACM", CAST_METHOD(IceRuby_Connection_getACM), 0);
     rb_define_method(_connectionClass, "type", CAST_METHOD(IceRuby_Connection_type), 0);
-    rb_define_method(_connectionClass, "timeout", CAST_METHOD(IceRuby_Connection_timeout), 0);
     rb_define_method(_connectionClass, "getInfo", CAST_METHOD(IceRuby_Connection_getInfo), 0);
     rb_define_method(_connectionClass, "getEndpoint", CAST_METHOD(IceRuby_Connection_getEndpoint), 0);
     rb_define_method(_connectionClass, "setBufferSize", CAST_METHOD(IceRuby_Connection_setBufferSize), 2);
@@ -460,10 +346,10 @@ IceRuby::initConnection(VALUE iceModule)
     //
     // Instance members.
     //
+    rb_define_attr(_connectionInfoClass, "underlying", 1, 0);
     rb_define_attr(_connectionInfoClass, "incoming", 1, 0);
     rb_define_attr(_connectionInfoClass, "adapterName", 1, 0);
-    rb_define_attr(_connectionInfoClass, "rcvSize", 1, 0);
-    rb_define_attr(_connectionInfoClass, "sndSize", 1, 0);
+    rb_define_attr(_connectionInfoClass, "connectionId", 1, 0);
 
     //
     // IPConnectionInfo
@@ -485,6 +371,12 @@ IceRuby::initConnection(VALUE iceModule)
     _tcpConnectionInfoClass = rb_define_class_under(iceModule, "TCPConnectionInfo", _ipConnectionInfoClass);
     rb_undef_alloc_func(_tcpConnectionInfoClass);
 
+    //
+    // Instance members.
+    //
+    rb_define_attr(_tcpConnectionInfoClass, "rcvSize", 1, 0);
+    rb_define_attr(_tcpConnectionInfoClass, "sndSize", 1, 0);
+
     //
     // UDPConnectionInfo
     //
@@ -496,6 +388,8 @@ IceRuby::initConnection(VALUE iceModule)
     //
     rb_define_attr(_udpConnectionInfoClass, "mcastAddress", 1, 0);
     rb_define_attr(_udpConnectionInfoClass, "mcastPort", 1, 0);
+    rb_define_attr(_udpConnectionInfoClass, "rcvSize", 1, 0);
+    rb_define_attr(_udpConnectionInfoClass, "sndSize", 1, 0);
 
     //
     // WSConnectionInfo
@@ -517,9 +411,7 @@ IceRuby::initConnection(VALUE iceModule)
     //
     // Instance members.
     //
-    rb_define_attr(_sslConnectionInfoClass, "cipher", 1, 0);
-    rb_define_attr(_sslConnectionInfoClass, "certs", 1, 0);
-    rb_define_attr(_sslConnectionInfoClass, "verified", 1, 0);
+    rb_define_attr(_sslConnectionInfoClass, "peerCertificate", 1, 0);
 }
 
 Ice::ConnectionPtr

data/dist/IceRuby/Connection.h

@@ -1,24 +1,20 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_RUBY_CONNECTION_H
 #define ICE_RUBY_CONNECTION_H
 
-#include <Config.h>
-#include <Ice/Connection.h>
+#include "Config.h"
+#include "Ice/Connection.h"
 
 namespace IceRuby
 {
+    void initConnection(VALUE);
 
-void initConnection(VALUE);
-
-VALUE createConnection(const Ice::ConnectionPtr&);
-VALUE createConnectionInfo(const Ice::ConnectionInfoPtr&);
-
-Ice::ConnectionPtr getConnection(VALUE);
-bool checkConnection(VALUE);
+    VALUE createConnection(const Ice::ConnectionPtr&);
+    VALUE createConnectionInfo(const Ice::ConnectionInfoPtr&);
 
+    Ice::ConnectionPtr getConnection(VALUE);
+    bool checkConnection(VALUE);
 }
 
 #endif

data/dist/IceRuby/DefaultSliceLoader.cpp

@@ -0,0 +1,45 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "DefaultSliceLoader.h"
+#include "Types.h"
+#include "Util.h"
+
+using namespace std;
+using namespace IceRuby;
+
+Ice::SliceLoaderPtr
+IceRuby::DefaultSliceLoader::instance()
+{
+    static Ice::SliceLoaderPtr instance{new DefaultSliceLoader()};
+    return instance;
+}
+
+Ice::ValuePtr
+IceRuby::DefaultSliceLoader::newClassInstance(string_view typeId) const
+{
+    // When the type ID is ::Ice::Object, it indicates that the stream has not found a factory and is providing us an
+    // opportunity to preserve the object.
+    ClassInfoPtr info =
+        typeId == Ice::Value::ice_staticId() ? lookupClassInfo("::Ice::UnknownSlicedValue") : lookupClassInfo(typeId);
+
+    if (!info)
+    {
+        return nullptr;
+    }
+
+    VALUE obj = callRuby(rb_class_new_instance, 0, reinterpret_cast<VALUE*>(0), info->rubyClass);
+    assert(!NIL_P(obj));
+
+    return make_shared<ValueReader>(obj, info);
+}
+
+std::exception_ptr
+IceRuby::DefaultSliceLoader::newExceptionInstance(string_view typeId) const
+{
+    ExceptionInfoPtr info = lookupExceptionInfo(typeId);
+    if (info)
+    {
+        return make_exception_ptr(ExceptionReader{info});
+    }
+    return nullptr;
+}

data/dist/IceRuby/DefaultSliceLoader.h

@@ -0,0 +1,25 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_RUBY_DEFAULT_SLICE_LOADER_H
+#define ICE_RUBY_DEFAULT_SLICE_LOADER_H
+
+#include "Config.h"
+#include "Ice/Ice.h"
+
+namespace IceRuby
+{
+    /// Instantiates generated Python classes/exceptions based on the Slice type ID.
+    class DefaultSliceLoader final : public Ice::SliceLoader
+    {
+    public:
+        static Ice::SliceLoaderPtr instance();
+
+        [[nodiscard]] Ice::ValuePtr newClassInstance(std::string_view typeId) const final;
+        [[nodiscard]] std::exception_ptr newExceptionInstance(std::string_view typeId) const final;
+
+    private:
+        DefaultSliceLoader() = default;
+    };
+}
+
+#endif