zeroc-ice 3.7.11 → 3.8.1

data/dist/IceRuby/Proxy.cpp

@@ -1,18 +1,16 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <IceUtil/DisableWarnings.h>
-#include <Proxy.h>
-#include <Communicator.h>
-#include <Connection.h>
-#include <Endpoint.h>
-#include <Util.h>
-#include <Types.h>
-#include <Ice/LocalException.h>
-#include <Ice/Locator.h>
-#include <Ice/Proxy.h>
-#include <Ice/Router.h>
+// Copyright (c) ZeroC, Inc.
+
+#include "Proxy.h"
+#include "Communicator.h"
+#include "Connection.h"
+#include "Endpoint.h"
+#include "Ice/DisableWarnings.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/Locator.h"
+#include "Ice/Proxy.h"
+#include "Ice/Router.h"
+#include "Types.h"
+#include "Util.h"
 
 using namespace std;
 using namespace IceRuby;
@@ -21,66 +19,45 @@ static VALUE _proxyClass;
 
 // ObjectPrx
 
-extern "C"
-void
-IceRuby_ObjectPrx_mark(Ice::ObjectPrx* p)
+extern "C" void
+IceRuby_ObjectPrx_mark(void* p)
 {
-    //
     // We need to mark the communicator associated with this proxy.
-    //
-    assert(p);
-    volatile VALUE communicator = lookupCommunicator((*p)->ice_getCommunicator());
+    auto proxy = static_cast<Ice::ObjectPrx*>(p);
+    volatile VALUE communicator = lookupCommunicator((*proxy)->ice_getCommunicator());
     assert(!NIL_P(communicator));
     rb_gc_mark(communicator);
 }
 
-extern "C"
-void
-IceRuby_ObjectPrx_free(Ice::ObjectPrx* p)
+extern "C" void
+IceRuby_ObjectPrx_free(void* p)
 {
-    assert(p);
-    delete p;
+    delete static_cast<Ice::ObjectPrx*>(p);
 }
 
-//
-// If a context was provided set it to ::Ice::noExplicitContext.
-//
-static void
-checkArgs(const char* name, int numArgs, int argc, VALUE* argv, Ice::Context& ctx)
-{
-    if(argc < numArgs || argc > numArgs + 1)
-    {
-        throw RubyException(rb_eArgError, "%s expects %d argument%s including an optional context hash", name,
-                            numArgs + 1, numArgs + 1 == 1 ? "" : "s");
-    }
-    if(argc == numArgs + 1)
-    {
-        if(!hashToContext(argv[numArgs], ctx))
+static const rb_data_type_t IceRuby_ObjectPrxType = {
+    .wrap_struct_name = "Ice::ObjectPrx",
+    .function =
         {
-            throw RubyException(rb_eArgError, "%s: invalid context hash", name);
-        }
-    }
-    else
-    {
-        ctx = ::Ice::noExplicitContext;
-    }
-}
+            .dmark = IceRuby_ObjectPrx_mark,
+            .dfree = IceRuby_ObjectPrx_free,
+        },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_hash(VALUE self)
 {
     ICE_RUBY_TRY
     {
         Ice::ObjectPrx p = getProxy(self);
-        return INT2FIX(p->_hash());
+        return INT2FIX(std::hash<Ice::ObjectPrx>{}(p));
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_getCommunicator(VALUE self)
 {
     ICE_RUBY_TRY
@@ -93,8 +70,7 @@ IceRuby_ObjectPrx_ice_getCommunicator(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_toString(VALUE self)
 {
     ICE_RUBY_TRY
@@ -107,111 +83,43 @@ IceRuby_ObjectPrx_ice_toString(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
-IceRuby_ObjectPrx_ice_isA(int argc, VALUE* argv, VALUE self)
-{
-    ICE_RUBY_TRY
-    {
-        Ice::ObjectPrx p = getProxy(self);
-
-        Ice::Context ctx;
-        checkArgs("ice_isA", 1, argc, argv, ctx);
-        string id = getString(argv[0]);
-
-        return p->ice_isA(id, ctx) ? Qtrue : Qfalse;
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
-IceRuby_ObjectPrx_ice_ping(int argc, VALUE* argv, VALUE self)
+extern "C" VALUE
+IceRuby_ObjectPrx_ice_getIdentity(VALUE self)
 {
     ICE_RUBY_TRY
     {
         Ice::ObjectPrx p = getProxy(self);
-
-        Ice::Context ctx;
-        checkArgs("ice_ping", 0, argc, argv, ctx);
-        p->ice_ping(ctx);
+        return createIdentity(p->ice_getIdentity());
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
-IceRuby_ObjectPrx_ice_ids(int argc, VALUE* argv, VALUE self)
+extern "C" VALUE
+IceRuby_ObjectPrx_ice_identity(VALUE self, VALUE args)
 {
     ICE_RUBY_TRY
     {
-        Ice::ObjectPrx p = getProxy(self);
-
-        Ice::Context ctx;
-        checkArgs("ice_ids", 0, argc, argv, ctx);
-
-        vector<string> ids = p->ice_ids(ctx);
-        volatile VALUE result = createArray(static_cast<long>(ids.size()));
-        long i = 0;
-        for(vector<string>::iterator q = ids.begin(); q != ids.end(); ++q, ++i)
+        VALUE cls = Qnil;
+        long len = RARRAY_LEN(args);
+        if (len > 2 || len == 0)
         {
-            RARRAY_ASET(result, i, createString(*q));
+            throw RubyException(rb_eArgError, "ice_identity requires one or two arguments");
+        }
+        if (len == 2)
+        {
+            cls = rb_ary_entry(args, 1);
         }
 
-        return result;
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
-IceRuby_ObjectPrx_ice_id(int argc, VALUE* argv, VALUE self)
-{
-    ICE_RUBY_TRY
-    {
-        Ice::ObjectPrx p = getProxy(self);
-
-        Ice::Context ctx;
-        checkArgs("ice_id", 0, argc, argv, ctx);
-        string id = p->ice_id(ctx);
-        return createString(id);
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
-IceRuby_ObjectPrx_ice_getIdentity(VALUE self)
-{
-    ICE_RUBY_TRY
-    {
-        Ice::ObjectPrx p = getProxy(self);
-        return createIdentity(p->ice_getIdentity());
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
-IceRuby_ObjectPrx_ice_identity(VALUE self, VALUE id)
-{
-    ICE_RUBY_TRY
-    {
         Ice::ObjectPrx p = getProxy(self);
-        Ice::Identity ident = getIdentity(id);
-        return createProxy(p->ice_identity(ident));
+        Ice::Identity ident = getIdentity(rb_ary_entry(args, 0));
+        return createProxy(p->ice_identity(ident), cls);
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_getContext(VALUE self)
 {
     ICE_RUBY_TRY
@@ -223,8 +131,7 @@ IceRuby_ObjectPrx_ice_getContext(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_context(VALUE self, VALUE ctx)
 {
     ICE_RUBY_TRY
@@ -232,7 +139,7 @@ IceRuby_ObjectPrx_ice_context(VALUE self, VALUE ctx)
         Ice::ObjectPrx p = getProxy(self);
 
         Ice::Context context;
-        if(!NIL_P(ctx) && !hashToContext(ctx, context))
+        if (!NIL_P(ctx) && !hashToContext(ctx, context))
         {
             throw RubyException(rb_eTypeError, "argument is not a context hash");
         }
@@ -242,8 +149,7 @@ IceRuby_ObjectPrx_ice_context(VALUE self, VALUE ctx)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_getFacet(VALUE self)
 {
     ICE_RUBY_TRY
@@ -256,22 +162,31 @@ IceRuby_ObjectPrx_ice_getFacet(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
-IceRuby_ObjectPrx_ice_facet(VALUE self, VALUE facet)
+extern "C" VALUE
+IceRuby_ObjectPrx_ice_facet(VALUE self, VALUE args)
 {
     ICE_RUBY_TRY
     {
+        VALUE cls = Qnil;
+        long len = RARRAY_LEN(args);
+        if (len > 2 || len == 0)
+        {
+            throw RubyException(rb_eArgError, "ice_facet requires one or two arguments");
+        }
+        if (len == 2)
+        {
+            cls = rb_ary_entry(args, 1);
+        }
+
         Ice::ObjectPrx p = getProxy(self);
-        string f = getString(facet);
-        return createProxy(p->ice_facet(f));
+        string f = getString(rb_ary_entry(args, 0));
+        return createProxy(p->ice_facet(f), cls);
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_getAdapterId(VALUE self)
 {
     ICE_RUBY_TRY
@@ -284,8 +199,7 @@ IceRuby_ObjectPrx_ice_getAdapterId(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_adapterId(VALUE self, VALUE id)
 {
     ICE_RUBY_TRY
@@ -298,8 +212,7 @@ IceRuby_ObjectPrx_ice_adapterId(VALUE self, VALUE id)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_getEndpoints(VALUE self)
 {
     ICE_RUBY_TRY
@@ -309,7 +222,7 @@ IceRuby_ObjectPrx_ice_getEndpoints(VALUE self)
         Ice::EndpointSeq seq = p->ice_getEndpoints();
         volatile VALUE result = createArray(static_cast<long>(seq.size()));
         long i = 0;
-        for(Ice::EndpointSeq::iterator q = seq.begin(); q != seq.end(); ++q, ++i)
+        for (Ice::EndpointSeq::iterator q = seq.begin(); q != seq.end(); ++q, ++i)
         {
             RARRAY_ASET(result, i, createEndpoint(*q));
         }
@@ -319,30 +232,29 @@ IceRuby_ObjectPrx_ice_getEndpoints(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_endpoints(VALUE self, VALUE seq)
 {
     ICE_RUBY_TRY
     {
         Ice::ObjectPrx p = getProxy(self);
 
-        if(!NIL_P(seq) && !isArray(seq))
+        if (!NIL_P(seq) && !isArray(seq))
         {
             throw RubyException(rb_eTypeError, "ice_endpoints requires an array of endpoints");
         }
 
         Ice::EndpointSeq endpoints;
-        if(!NIL_P(seq))
+        if (!NIL_P(seq))
         {
             volatile VALUE arr = callRuby(rb_check_array_type, seq);
-            if(NIL_P(seq))
+            if (NIL_P(seq))
             {
                 throw RubyException(rb_eTypeError, "unable to convert value to an array of endpoints");
             }
-            for(long i = 0; i < RARRAY_LEN(arr); ++i)
+            for (long i = 0; i < RARRAY_LEN(arr); ++i)
             {
-                if(!checkEndpoint(RARRAY_AREF(arr, i)))
+                if (!checkEndpoint(RARRAY_AREF(arr, i)))
                 {
                     throw RubyException(rb_eTypeError, "array element is not an Ice::Endpoint");
                 }
@@ -357,36 +269,33 @@ IceRuby_ObjectPrx_ice_endpoints(VALUE self, VALUE seq)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_getLocatorCacheTimeout(VALUE self)
 {
     ICE_RUBY_TRY
     {
         Ice::ObjectPrx p = getProxy(self);
-        Ice::Int t = p->ice_getLocatorCacheTimeout();
-        return INT2FIX(t);
+        chrono::seconds timeout = chrono::duration_cast<chrono::seconds>(p->ice_getLocatorCacheTimeout());
+        return INT2FIX(static_cast<int32_t>(timeout.count()));
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_getInvocationTimeout(VALUE self)
 {
     ICE_RUBY_TRY
     {
         Ice::ObjectPrx p = getProxy(self);
-        Ice::Int t = p->ice_getInvocationTimeout();
-        return INT2FIX(t);
+        chrono::milliseconds timeout = p->ice_getInvocationTimeout();
+        return INT2FIX(static_cast<int32_t>(timeout.count()));
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_getConnectionId(VALUE self)
 {
     ICE_RUBY_TRY
@@ -399,8 +308,7 @@ IceRuby_ObjectPrx_ice_getConnectionId(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_locatorCacheTimeout(VALUE self, VALUE timeout)
 {
     ICE_RUBY_TRY
@@ -409,19 +317,18 @@ IceRuby_ObjectPrx_ice_locatorCacheTimeout(VALUE self, VALUE timeout)
         {
             Ice::ObjectPrx p = getProxy(self);
             long t = getInteger(timeout);
-            return createProxy(p->ice_locatorCacheTimeout(static_cast<Ice::Int>(t)), rb_class_of(self));
+            return createProxy(p->ice_locatorCacheTimeout(static_cast<int32_t>(t)), rb_class_of(self));
         }
-        catch(const IceUtil::IllegalArgumentException& ex)
+        catch (const invalid_argument& ex)
         {
-            throw RubyException(rb_eArgError, ex.reason().c_str());
+            throw RubyException(rb_eArgError, ex.what());
         }
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_invocationTimeout(VALUE self, VALUE timeout)
 {
     ICE_RUBY_TRY
@@ -430,19 +337,18 @@ IceRuby_ObjectPrx_ice_invocationTimeout(VALUE self, VALUE timeout)
         {
             Ice::ObjectPrx p = getProxy(self);
             long t = getInteger(timeout);
-            return createProxy(p->ice_invocationTimeout(static_cast<Ice::Int>(t)), rb_class_of(self));
+            return createProxy(p->ice_invocationTimeout(static_cast<int32_t>(t)), rb_class_of(self));
         }
-        catch(const IceUtil::IllegalArgumentException& ex)
+        catch (const invalid_argument& ex)
         {
-            throw RubyException(rb_eArgError, ex.reason().c_str());
+            throw RubyException(rb_eArgError, ex.what());
         }
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_isConnectionCached(VALUE self)
 {
     ICE_RUBY_TRY
@@ -454,8 +360,7 @@ IceRuby_ObjectPrx_ice_isConnectionCached(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_connectionCached(VALUE self, VALUE b)
 {
     ICE_RUBY_TRY
@@ -467,8 +372,7 @@ IceRuby_ObjectPrx_ice_connectionCached(VALUE self, VALUE b)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_getEndpointSelection(VALUE self)
 {
     ICE_RUBY_TRY
@@ -484,8 +388,7 @@ IceRuby_ObjectPrx_ice_getEndpointSelection(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_endpointSelection(VALUE self, VALUE type)
 {
     ICE_RUBY_TRY
@@ -494,7 +397,7 @@ IceRuby_ObjectPrx_ice_endpointSelection(VALUE self, VALUE type)
 
         volatile VALUE cls = callRuby(rb_path2class, "Ice::EndpointSelectionType");
         assert(!NIL_P(cls));
-        if(callRuby(rb_obj_is_instance_of, type, cls) == Qfalse)
+        if (callRuby(rb_obj_is_instance_of, type, cls) == Qfalse)
         {
             throw RubyException(rb_eTypeError, "argument must be an Ice::EndpointSelectionType enumerator");
         }
@@ -507,34 +410,7 @@ IceRuby_ObjectPrx_ice_endpointSelection(VALUE self, VALUE type)
     return Qnil;
 }
 
-extern "C"
-VALUE
-IceRuby_ObjectPrx_ice_isSecure(VALUE self)
-{
-    ICE_RUBY_TRY
-    {
-        Ice::ObjectPrx p = getProxy(self);
-        return p->ice_isSecure() ? Qtrue : Qfalse;
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
-IceRuby_ObjectPrx_ice_secure(VALUE self, VALUE b)
-{
-    ICE_RUBY_TRY
-    {
-        Ice::ObjectPrx p = getProxy(self);
-        return createProxy(p->ice_secure(RTEST(b)), rb_class_of(self));
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_getEncodingVersion(VALUE self)
 {
     ICE_RUBY_TRY
@@ -546,12 +422,11 @@ IceRuby_ObjectPrx_ice_getEncodingVersion(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_encodingVersion(VALUE self, VALUE v)
 {
     Ice::EncodingVersion val;
-    if(getEncodingVersion(v, val))
+    if (getEncodingVersion(v, val))
     {
         ICE_RUBY_TRY
         {
@@ -564,68 +439,40 @@ IceRuby_ObjectPrx_ice_encodingVersion(VALUE self, VALUE v)
     return Qnil;
 }
 
-extern "C"
-VALUE
-IceRuby_ObjectPrx_ice_isPreferSecure(VALUE self)
-{
-    ICE_RUBY_TRY
-    {
-        Ice::ObjectPrx p = getProxy(self);
-        return p->ice_isPreferSecure() ? Qtrue : Qfalse;
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
-IceRuby_ObjectPrx_ice_preferSecure(VALUE self, VALUE b)
-{
-    ICE_RUBY_TRY
-    {
-        Ice::ObjectPrx p = getProxy(self);
-        return createProxy(p->ice_preferSecure(RTEST(b)), rb_class_of(self));
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_getRouter(VALUE self)
 {
     ICE_RUBY_TRY
     {
         Ice::ObjectPrx p = getProxy(self);
 
-        Ice::RouterPrx router = p->ice_getRouter();
-        if(router)
+        optional<Ice::RouterPrx> router = p->ice_getRouter();
+        if (router)
         {
             volatile VALUE cls = callRuby(rb_path2class, "Ice::RouterPrx");
             assert(!NIL_P(cls));
-            return createProxy(router, cls);
+            return createProxy(router.value(), cls);
         }
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_router(VALUE self, VALUE router)
 {
     ICE_RUBY_TRY
     {
         Ice::ObjectPrx p = getProxy(self);
 
-        Ice::RouterPrx proxy;
-        if(!NIL_P(router))
+        optional<Ice::RouterPrx> proxy;
+        if (!NIL_P(router))
         {
-            if(!checkProxy(router))
+            if (!checkProxy(router))
             {
                 throw RubyException(rb_eTypeError, "argument must be a proxy");
             }
-            proxy = Ice::RouterPrx::uncheckedCast(getProxy(router));
+            proxy = Ice::uncheckedCast<Ice::RouterPrx>(getProxy(router));
         }
         return createProxy(p->ice_router(proxy), rb_class_of(self));
     }
@@ -633,42 +480,40 @@ IceRuby_ObjectPrx_ice_router(VALUE self, VALUE router)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_getLocator(VALUE self)
 {
     ICE_RUBY_TRY
     {
         Ice::ObjectPrx p = getProxy(self);
 
-        Ice::LocatorPrx locator = p->ice_getLocator();
-        if(locator)
+        optional<Ice::LocatorPrx> locator = p->ice_getLocator();
+        if (locator)
         {
             volatile VALUE cls = callRuby(rb_path2class, "Ice::LocatorPrx");
             assert(!NIL_P(cls));
-            return createProxy(locator, cls);
+            return createProxy(locator.value(), cls);
         }
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_locator(VALUE self, VALUE locator)
 {
     ICE_RUBY_TRY
     {
         Ice::ObjectPrx p = getProxy(self);
 
-        Ice::LocatorPrx proxy;
-        if(!NIL_P(locator))
+        optional<Ice::LocatorPrx> proxy;
+        if (!NIL_P(locator))
         {
-            if(!checkProxy(locator))
+            if (!checkProxy(locator))
             {
                 throw RubyException(rb_eTypeError, "argument must be a proxy");
             }
-            proxy = Ice::LocatorPrx::uncheckedCast(getProxy(locator));
+            proxy = Ice::uncheckedCast<Ice::LocatorPrx>(getProxy(locator));
         }
         return createProxy(p->ice_locator(proxy), rb_class_of(self));
     }
@@ -676,8 +521,7 @@ IceRuby_ObjectPrx_ice_locator(VALUE self, VALUE locator)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_twoway(VALUE self)
 {
     ICE_RUBY_TRY
@@ -689,8 +533,7 @@ IceRuby_ObjectPrx_ice_twoway(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_isTwoway(VALUE self)
 {
     ICE_RUBY_TRY
@@ -702,8 +545,7 @@ IceRuby_ObjectPrx_ice_isTwoway(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_oneway(VALUE self)
 {
     ICE_RUBY_TRY
@@ -715,8 +557,7 @@ IceRuby_ObjectPrx_ice_oneway(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_isOneway(VALUE self)
 {
     ICE_RUBY_TRY
@@ -728,8 +569,7 @@ IceRuby_ObjectPrx_ice_isOneway(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_batchOneway(VALUE self)
 {
     ICE_RUBY_TRY
@@ -741,8 +581,7 @@ IceRuby_ObjectPrx_ice_batchOneway(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_isBatchOneway(VALUE self)
 {
     ICE_RUBY_TRY
@@ -754,8 +593,7 @@ IceRuby_ObjectPrx_ice_isBatchOneway(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_datagram(VALUE self)
 {
     ICE_RUBY_TRY
@@ -767,8 +605,7 @@ IceRuby_ObjectPrx_ice_datagram(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_isDatagram(VALUE self)
 {
     ICE_RUBY_TRY
@@ -780,8 +617,7 @@ IceRuby_ObjectPrx_ice_isDatagram(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_batchDatagram(VALUE self)
 {
     ICE_RUBY_TRY
@@ -793,8 +629,7 @@ IceRuby_ObjectPrx_ice_batchDatagram(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_isBatchDatagram(VALUE self)
 {
     ICE_RUBY_TRY
@@ -806,8 +641,7 @@ IceRuby_ObjectPrx_ice_isBatchDatagram(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_compress(VALUE self, VALUE b)
 {
     ICE_RUBY_TRY
@@ -819,71 +653,27 @@ IceRuby_ObjectPrx_ice_compress(VALUE self, VALUE b)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_getCompress(VALUE self)
 {
     ICE_RUBY_TRY
     {
         Ice::ObjectPrx p = getProxy(self);
-        IceUtil::Optional<bool> c = p->ice_getCompress();
-        if(c)
+        optional<bool> c = p->ice_getCompress();
+        if (c)
         {
             return *c ? Qtrue : Qfalse;
         }
         else
         {
-            return Unset;
-        }
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
-IceRuby_ObjectPrx_ice_timeout(VALUE self, VALUE t)
-{
-    ICE_RUBY_TRY
-    {
-        try
-        {
-            Ice::ObjectPrx p = getProxy(self);
-            Ice::Int timeout = static_cast<Ice::Int>(getInteger(t));
-            return createProxy(p->ice_timeout(timeout), rb_class_of(self));
-        }
-        catch(const IceUtil::IllegalArgumentException& ex)
-        {
-            throw RubyException(rb_eArgError, ex.reason().c_str());
-        }
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
-IceRuby_ObjectPrx_ice_getTimeout(VALUE self)
-{
-    ICE_RUBY_TRY
-    {
-        Ice::ObjectPrx p = getProxy(self);
-        IceUtil::Optional<int> t = p->ice_getTimeout();
-        if(t)
-        {
-            return INT2FIX(*t);
-        }
-        else
-        {
-            return Unset;
+            return Qnil;
         }
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_connectionId(VALUE self, VALUE id)
 {
     ICE_RUBY_TRY
@@ -896,8 +686,7 @@ IceRuby_ObjectPrx_ice_connectionId(VALUE self, VALUE id)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_fixed(VALUE self, VALUE con)
 {
     ICE_RUBY_TRY
@@ -905,9 +694,9 @@ IceRuby_ObjectPrx_ice_fixed(VALUE self, VALUE con)
         Ice::ObjectPrx p = getProxy(self);
 
         Ice::ConnectionPtr connection;
-        if(!NIL_P(con))
+        if (!NIL_P(con))
         {
-            if(!checkConnection(con))
+            if (!checkConnection(con))
             {
                 throw RubyException(rb_eTypeError, "argument must be an Ice.Connection");
             }
@@ -919,8 +708,7 @@ IceRuby_ObjectPrx_ice_fixed(VALUE self, VALUE con)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_isFixed(VALUE self)
 {
     ICE_RUBY_TRY
@@ -932,8 +720,7 @@ IceRuby_ObjectPrx_ice_isFixed(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_getConnection(VALUE self)
 {
     ICE_RUBY_TRY
@@ -946,15 +733,14 @@ IceRuby_ObjectPrx_ice_getConnection(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_getCachedConnection(VALUE self)
 {
     ICE_RUBY_TRY
     {
         Ice::ObjectPrx p = getProxy(self);
         Ice::ConnectionPtr conn = p->ice_getCachedConnection();
-        if(conn)
+        if (conn)
         {
             return createConnection(conn);
         }
@@ -963,8 +749,7 @@ IceRuby_ObjectPrx_ice_getCachedConnection(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_ice_flushBatchRequests(VALUE self)
 {
     ICE_RUBY_TRY
@@ -976,27 +761,26 @@ IceRuby_ObjectPrx_ice_flushBatchRequests(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_cmp(VALUE self, VALUE other)
 {
     ICE_RUBY_TRY
     {
-        if(NIL_P(other))
+        if (NIL_P(other))
         {
             return INT2NUM(1);
         }
-        if(!checkProxy(other))
+        if (!checkProxy(other))
         {
             throw RubyException(rb_eTypeError, "argument must be a proxy");
         }
         Ice::ObjectPrx p1 = getProxy(self);
         Ice::ObjectPrx p2 = getProxy(other);
-        if(p1 < p2)
+        if (p1 < p2)
         {
             return INT2NUM(-1);
         }
-        else if(p1 == p2)
+        else if (p1 == p2)
         {
             return INT2NUM(0);
         }
@@ -1009,270 +793,28 @@ IceRuby_ObjectPrx_cmp(VALUE self, VALUE other)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ObjectPrx_equals(VALUE self, VALUE other)
 {
     return IceRuby_ObjectPrx_cmp(self, other) == INT2NUM(0) ? Qtrue : Qfalse;
 }
 
-static VALUE
-checkedCastImpl(const Ice::ObjectPrx& p, const string& id, VALUE facet, VALUE ctx, VALUE type)
-{
-    Ice::ObjectPrx target;
-    if(NIL_P(facet))
-    {
-        target = p;
-    }
-    else
-    {
-        target = p->ice_facet(getString(facet));
-    }
-
-    try
-    {
-        if(NIL_P(ctx))
-        {
-            if(target->ice_isA(id))
-            {
-                return createProxy(target, type);
-            }
-        }
-        else
-        {
-            Ice::Context c;
-#ifndef NDEBUG
-            bool b =
-#endif
-            hashToContext(ctx, c);
-            assert(b);
-
-            if(target->ice_isA(id, c))
-            {
-                return createProxy(target, type);
-            }
-        }
-    }
-    catch(const Ice::FacetNotExistException&)
-    {
-        // Ignore.
-    }
-
-    return Qnil;
-}
-
-extern "C"
-VALUE
-IceRuby_ObjectPrx_checkedCast(int argc, VALUE* args, VALUE /*self*/)
-{
-    //
-    // ice_checkedCast is called from generated code, therefore we always expect
-    // to receive all four arguments.
-    //
-    ICE_RUBY_TRY
-    {
-        if(argc < 1 || argc > 3)
-        {
-            throw RubyException(rb_eArgError, "checkedCast requires a proxy argument and optional facet and context");
-        }
-
-        if(NIL_P(args[0]))
-        {
-            return Qnil;
-        }
-
-        if(!checkProxy(args[0]))
-        {
-            throw RubyException(rb_eArgError, "checkedCast requires a proxy argument");
-        }
-
-        Ice::ObjectPrx p = getProxy(args[0]);
-
-        volatile VALUE facet = Qnil;
-        volatile VALUE ctx = Qnil;
-
-        if(argc == 3)
-        {
-            if(!NIL_P(args[1]) && !isString(args[1]))
-            {
-                throw RubyException(rb_eArgError, "facet argument to checkedCast must be a string");
-            }
-            facet = args[1];
-
-            if(!NIL_P(args[2]) && !isHash(args[2]))
-            {
-                throw RubyException(rb_eArgError, "context argument to checkedCast must be a hash");
-            }
-            ctx = args[2];
-        }
-        else if(argc == 2)
-        {
-            if(isString(args[1]))
-            {
-                facet = args[1];
-            }
-            else if(isHash(args[1]))
-            {
-                ctx = args[1];
-            }
-            else
-            {
-                throw RubyException(rb_eArgError, "second argument to checkedCast must be a facet or context");
-            }
-        }
-
-        return checkedCastImpl(p, "::Ice::Object", facet, ctx, Qnil);
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
-IceRuby_ObjectPrx_uncheckedCast(int argc, VALUE* args, VALUE /*self*/)
-{
-    ICE_RUBY_TRY
-    {
-        if(argc < 1 || argc > 2)
-        {
-            throw RubyException(rb_eArgError, "uncheckedCast requires a proxy argument and an optional facet");
-        }
-
-        if(NIL_P(args[0]))
-        {
-            return Qnil;
-        }
-
-        if(!checkProxy(args[0]))
-        {
-            throw RubyException(rb_eArgError, "uncheckedCast requires a proxy argument");
-        }
-
-        volatile VALUE facet = Qnil;
-        if(argc == 2)
-        {
-            facet = args[1];
-        }
-
-        Ice::ObjectPrx p = getProxy(args[0]);
-
-        if(!NIL_P(facet))
-        {
-            return createProxy(p->ice_facet(getString(facet)));
-        }
-        else
-        {
-            return createProxy(p);
-        }
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
-IceRuby_ObjectPrx_ice_checkedCast(VALUE self, VALUE obj, VALUE id, VALUE facetOrContext, VALUE ctx)
+extern "C" VALUE
+IceRuby_ObjectPrx_new(VALUE self, VALUE communicator, VALUE proxyString)
 {
-    //
-    // ice_checkedCast is called from generated code, therefore we always expect
-    // to receive all four arguments.
-    //
     ICE_RUBY_TRY
     {
-        if(NIL_P(obj))
-        {
-            return Qnil;
-        }
-
-        if(!checkProxy(obj))
-        {
-            throw RubyException(rb_eArgError, "checkedCast requires a proxy argument");
-        }
-
-        Ice::ObjectPrx p = getProxy(obj);
-
-        string idstr = getString(id);
-
-        volatile VALUE facet = Qnil;
-        if(isString(facetOrContext))
-        {
-            facet = facetOrContext;
-        }
-        else if(isHash(facetOrContext))
-        {
-            if(!NIL_P(ctx))
-            {
-                throw RubyException(rb_eArgError, "facet argument to checkedCast must be a string");
-            }
-            ctx = facetOrContext;
-        }
-        else if(!NIL_P(facetOrContext))
-        {
-            throw RubyException(rb_eArgError, "second argument to checkedCast must be a facet or context");
-        }
-
-        if(!NIL_P(ctx) && !isHash(ctx))
-        {
-            throw RubyException(rb_eArgError, "context argument to checkedCast must be a hash");
-        }
-
-        return checkedCastImpl(p, idstr, facet, ctx, self);
+        Ice::ObjectPrx proxy{getCommunicator(communicator), getString(proxyString)};
+        return createProxy(proxy, self);
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
-IceRuby_ObjectPrx_ice_uncheckedCast(VALUE self, VALUE obj, VALUE facet)
+extern "C" VALUE
+IceRuby_ObjectPrx_create(VALUE self, VALUE proxy)
 {
-    ICE_RUBY_TRY
-    {
-        if(NIL_P(obj))
-        {
-            return Qnil;
-        }
-
-        if(!checkProxy(obj))
-        {
-            throw RubyException(rb_eArgError, "uncheckedCast requires a proxy argument");
-        }
-
-        Ice::ObjectPrx p = getProxy(obj);
-
-        if(!NIL_P(facet))
-        {
-            return createProxy(p->ice_facet(getString(facet)), self);
-        }
-        else
-        {
-            return createProxy(p, self);
-        }
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
-IceRuby_ObjectPrx_ice_staticId(VALUE /*self*/)
-{
-    ICE_RUBY_TRY
-    {
-        return createString(Ice::Object::ice_staticId());
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
-IceRuby_ObjectPrx_new(int /*argc*/, VALUE* /*args*/, VALUE /*self*/)
-{
-    ICE_RUBY_TRY
-    {
-        throw RubyException(rb_eRuntimeError, "a proxy cannot be created via new");
-    }
+    ICE_RUBY_TRY { return createProxy(getProxy(proxy), self); }
     ICE_RUBY_CATCH
     return Qnil;
 }
@@ -1291,38 +833,39 @@ IceRuby::initProxy(VALUE iceModule)
     //
     rb_define_method(_proxyClass, "ice_getCommunicator", CAST_METHOD(IceRuby_ObjectPrx_ice_getCommunicator), 0);
     rb_define_method(_proxyClass, "ice_toString", CAST_METHOD(IceRuby_ObjectPrx_ice_toString), 0);
-    rb_define_method(_proxyClass, "ice_isA", CAST_METHOD(IceRuby_ObjectPrx_ice_isA), -1);
-    rb_define_method(_proxyClass, "ice_ping", CAST_METHOD(IceRuby_ObjectPrx_ice_ping), -1);
-    rb_define_method(_proxyClass, "ice_ids", CAST_METHOD(IceRuby_ObjectPrx_ice_ids), -1);
-    rb_define_method(_proxyClass, "ice_id", CAST_METHOD(IceRuby_ObjectPrx_ice_id), -1);
     rb_define_method(_proxyClass, "ice_getIdentity", CAST_METHOD(IceRuby_ObjectPrx_ice_getIdentity), 0);
-    rb_define_method(_proxyClass, "ice_identity", CAST_METHOD(IceRuby_ObjectPrx_ice_identity), 1);
+    rb_define_method(_proxyClass, "ice_identity", CAST_METHOD(IceRuby_ObjectPrx_ice_identity), -2);
     rb_define_method(_proxyClass, "ice_getContext", CAST_METHOD(IceRuby_ObjectPrx_ice_getContext), 0);
     rb_define_method(_proxyClass, "ice_context", CAST_METHOD(IceRuby_ObjectPrx_ice_context), 1);
     rb_define_method(_proxyClass, "ice_getFacet", CAST_METHOD(IceRuby_ObjectPrx_ice_getFacet), 0);
-    rb_define_method(_proxyClass, "ice_facet", CAST_METHOD(IceRuby_ObjectPrx_ice_facet), 1);
+    rb_define_method(_proxyClass, "ice_facet", CAST_METHOD(IceRuby_ObjectPrx_ice_facet), -2);
     rb_define_method(_proxyClass, "ice_getAdapterId", CAST_METHOD(IceRuby_ObjectPrx_ice_getAdapterId), 0);
     rb_define_method(_proxyClass, "ice_adapterId", CAST_METHOD(IceRuby_ObjectPrx_ice_adapterId), 1);
     rb_define_method(_proxyClass, "ice_getEndpoints", CAST_METHOD(IceRuby_ObjectPrx_ice_getEndpoints), 0);
     rb_define_method(_proxyClass, "ice_endpoints", CAST_METHOD(IceRuby_ObjectPrx_ice_endpoints), 1);
-    rb_define_method(_proxyClass, "ice_getLocatorCacheTimeout",
-                     CAST_METHOD(IceRuby_ObjectPrx_ice_getLocatorCacheTimeout), 0);
-    rb_define_method(_proxyClass, "ice_getInvocationTimeout",
-                     CAST_METHOD(IceRuby_ObjectPrx_ice_getInvocationTimeout), 0);
+    rb_define_method(
+        _proxyClass,
+        "ice_getLocatorCacheTimeout",
+        CAST_METHOD(IceRuby_ObjectPrx_ice_getLocatorCacheTimeout),
+        0);
+    rb_define_method(
+        _proxyClass,
+        "ice_getInvocationTimeout",
+        CAST_METHOD(IceRuby_ObjectPrx_ice_getInvocationTimeout),
+        0);
     rb_define_method(_proxyClass, "ice_getConnectionId", CAST_METHOD(IceRuby_ObjectPrx_ice_getConnectionId), 0);
     rb_define_method(_proxyClass, "ice_locatorCacheTimeout", CAST_METHOD(IceRuby_ObjectPrx_ice_locatorCacheTimeout), 1);
     rb_define_method(_proxyClass, "ice_invocationTimeout", CAST_METHOD(IceRuby_ObjectPrx_ice_invocationTimeout), 1);
     rb_define_method(_proxyClass, "ice_isConnectionCached", CAST_METHOD(IceRuby_ObjectPrx_ice_isConnectionCached), 0);
     rb_define_method(_proxyClass, "ice_connectionCached", CAST_METHOD(IceRuby_ObjectPrx_ice_connectionCached), 1);
-    rb_define_method(_proxyClass, "ice_getEndpointSelection",
-                     CAST_METHOD(IceRuby_ObjectPrx_ice_getEndpointSelection), 0);
+    rb_define_method(
+        _proxyClass,
+        "ice_getEndpointSelection",
+        CAST_METHOD(IceRuby_ObjectPrx_ice_getEndpointSelection),
+        0);
     rb_define_method(_proxyClass, "ice_endpointSelection", CAST_METHOD(IceRuby_ObjectPrx_ice_endpointSelection), 1);
-    rb_define_method(_proxyClass, "ice_isSecure", CAST_METHOD(IceRuby_ObjectPrx_ice_isSecure), 0);
-    rb_define_method(_proxyClass, "ice_secure", CAST_METHOD(IceRuby_ObjectPrx_ice_secure), 1);
     rb_define_method(_proxyClass, "ice_getEncodingVersion", CAST_METHOD(IceRuby_ObjectPrx_ice_getEncodingVersion), 0);
     rb_define_method(_proxyClass, "ice_encodingVersion", CAST_METHOD(IceRuby_ObjectPrx_ice_encodingVersion), 1);
-    rb_define_method(_proxyClass, "ice_isPreferSecure", CAST_METHOD(IceRuby_ObjectPrx_ice_isPreferSecure), 0);
-    rb_define_method(_proxyClass, "ice_preferSecure", CAST_METHOD(IceRuby_ObjectPrx_ice_preferSecure), 1);
     rb_define_method(_proxyClass, "ice_getRouter", CAST_METHOD(IceRuby_ObjectPrx_ice_getRouter), 0);
     rb_define_method(_proxyClass, "ice_router", CAST_METHOD(IceRuby_ObjectPrx_ice_router), 1);
     rb_define_method(_proxyClass, "ice_getLocator", CAST_METHOD(IceRuby_ObjectPrx_ice_getLocator), 0);
@@ -1339,8 +882,6 @@ IceRuby::initProxy(VALUE iceModule)
     rb_define_method(_proxyClass, "ice_isBatchDatagram", CAST_METHOD(IceRuby_ObjectPrx_ice_isBatchDatagram), 0);
     rb_define_method(_proxyClass, "ice_compress", CAST_METHOD(IceRuby_ObjectPrx_ice_compress), 1);
     rb_define_method(_proxyClass, "ice_getCompress", CAST_METHOD(IceRuby_ObjectPrx_ice_getCompress), 0);
-    rb_define_method(_proxyClass, "ice_timeout", CAST_METHOD(IceRuby_ObjectPrx_ice_timeout), 1);
-    rb_define_method(_proxyClass, "ice_getTimeout", CAST_METHOD(IceRuby_ObjectPrx_ice_getTimeout), 0);
     rb_define_method(_proxyClass, "ice_connectionId", CAST_METHOD(IceRuby_ObjectPrx_ice_connectionId), 1);
     rb_define_method(_proxyClass, "ice_fixed", CAST_METHOD(IceRuby_ObjectPrx_ice_fixed), 1);
     rb_define_method(_proxyClass, "ice_isFixed", CAST_METHOD(IceRuby_ObjectPrx_ice_isFixed), 0);
@@ -1358,35 +899,24 @@ IceRuby::initProxy(VALUE iceModule)
     //
     // Static methods.
     //
-    rb_define_singleton_method(_proxyClass, "checkedCast", CAST_METHOD(IceRuby_ObjectPrx_checkedCast), -1);
-    rb_define_singleton_method(_proxyClass, "uncheckedCast", CAST_METHOD(IceRuby_ObjectPrx_uncheckedCast), -1);
-    rb_define_singleton_method(_proxyClass, "ice_checkedCast", CAST_METHOD(IceRuby_ObjectPrx_ice_checkedCast), 4);
-    rb_define_singleton_method(_proxyClass, "ice_uncheckedCast", CAST_METHOD(IceRuby_ObjectPrx_ice_uncheckedCast), 2);
-    rb_define_singleton_method(_proxyClass, "ice_staticId", CAST_METHOD(IceRuby_ObjectPrx_ice_staticId), 0);
-    rb_define_singleton_method(_proxyClass, "new", CAST_METHOD(IceRuby_ObjectPrx_new), -1);
+    rb_define_singleton_method(_proxyClass, "new", CAST_METHOD(IceRuby_ObjectPrx_new), 2);
+    rb_define_singleton_method(_proxyClass, "create", CAST_METHOD(IceRuby_ObjectPrx_create), 1);
 }
 
 VALUE
-IceRuby::createProxy(const Ice::ObjectPrx& p, VALUE cls)
+IceRuby::createProxy(Ice::ObjectPrx p, VALUE cls)
 {
-    //
     // If cls is nil then the proxy has the base type Ice::ObjectPrx.
-    //
-    if(NIL_P(cls))
-    {
-        return Data_Wrap_Struct(_proxyClass, IceRuby_ObjectPrx_mark, IceRuby_ObjectPrx_free, new Ice::ObjectPrx(p));
-    }
-    else
-    {
-        return Data_Wrap_Struct(cls, IceRuby_ObjectPrx_mark, IceRuby_ObjectPrx_free, new Ice::ObjectPrx(p));
-    }
+    return TypedData_Wrap_Struct(
+        NIL_P(cls) ? _proxyClass : cls,
+        &IceRuby_ObjectPrxType,
+        new Ice::ObjectPrx(std::move(p)));
 }
 
 Ice::ObjectPrx
 IceRuby::getProxy(VALUE v)
 {
-    Ice::ObjectPrx* p = reinterpret_cast<Ice::ObjectPrx*>(DATA_PTR(v));
-    return *p;
+    return *static_cast<Ice::ObjectPrx*>(DATA_PTR(v));
 }
 
 bool