zeroc-ice 3.7.11 → 3.8.1

data/dist/IceRuby/Endpoint.cpp

@@ -1,15 +1,9 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#if defined(__clang__)
-#   pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-#include <Endpoint.h>
-#include <Util.h>
-#include <Ice/Object.h>
-#include <IceSSL/EndpointInfo.h>
+#include "Endpoint.h"
+#include "Ice/Ice.h"
+#include "Ice/TargetCompare.h"
+#include "Util.h"
 
 using namespace std;
 using namespace IceRuby;
@@ -26,22 +20,28 @@ static VALUE _sslEndpointInfoClass;
 
 // Endpoint
 
-extern "C"
-void
-IceRuby_Endpoint_free(Ice::EndpointPtr* p)
+extern "C" void
+IceRuby_Endpoint_free(void* p)
 {
-    assert(p);
-    delete p;
+    delete static_cast<Ice::EndpointPtr*>(p);
 }
 
+static const rb_data_type_t IceRuby_EndpointType = {
+    .wrap_struct_name = "Ice::Endpoint",
+    .function =
+        {
+            .dfree = IceRuby_Endpoint_free,
+        },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 VALUE
 IceRuby::createEndpoint(const Ice::EndpointPtr& p)
 {
-    return Data_Wrap_Struct(_endpointClass, 0, IceRuby_Endpoint_free, new Ice::EndpointPtr(p));
+    return TypedData_Wrap_Struct(_endpointClass, &IceRuby_EndpointType, new Ice::EndpointPtr(p));
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Endpoint_toString(VALUE self)
 {
     ICE_RUBY_TRY
@@ -56,8 +56,7 @@ IceRuby_Endpoint_toString(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Endpoint_getInfo(VALUE self)
 {
     ICE_RUBY_TRY
@@ -72,27 +71,26 @@ IceRuby_Endpoint_getInfo(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Endpoint_cmp(VALUE self, VALUE other)
 {
     ICE_RUBY_TRY
     {
-        if(NIL_P(other))
+        if (NIL_P(other))
         {
             return INT2NUM(1);
         }
-        if(!checkEndpoint(other))
+        if (!checkEndpoint(other))
         {
             throw RubyException(rb_eTypeError, "argument must be a endpoint");
         }
         Ice::EndpointPtr p1 = Ice::EndpointPtr(*reinterpret_cast<Ice::EndpointPtr*>(DATA_PTR(self)));
         Ice::EndpointPtr p2 = Ice::EndpointPtr(*reinterpret_cast<Ice::EndpointPtr*>(DATA_PTR(other)));
-        if(p1 < p2)
+        if (Ice::targetLess(p1, p2))
         {
             return INT2NUM(-1);
         }
-        else if(p1 == p2)
+        else if (Ice::targetEqualTo(p1, p1))
         {
             return INT2NUM(0);
         }
@@ -105,8 +103,7 @@ IceRuby_Endpoint_cmp(VALUE self, VALUE other)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Endpoint_equals(VALUE self, VALUE other)
 {
     return IceRuby_Endpoint_cmp(self, other) == INT2NUM(0) ? Qtrue : Qfalse;
@@ -114,81 +111,86 @@ IceRuby_Endpoint_equals(VALUE self, VALUE other)
 
 // EndpointInfo
 
-extern "C"
-void
-IceRuby_EndpointInfo_free(Ice::EndpointPtr* p)
+extern "C" void
+IceRuby_EndpointInfo_free(void* p)
 {
-    assert(p);
-    delete p;
+    delete static_cast<Ice::EndpointInfoPtr*>(p);
 }
 
+static const rb_data_type_t IceRuby_EndpointInfoType = {
+    .wrap_struct_name = "Ice::EndpointInfo",
+    .function =
+        {
+            .dfree = IceRuby_EndpointInfo_free,
+        },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 VALUE
 IceRuby::createEndpointInfo(const Ice::EndpointInfoPtr& p)
 {
-    if(!p)
+    if (!p)
     {
         return Qnil;
     }
 
     VALUE info;
-    if(Ice::WSEndpointInfoPtr::dynamicCast(p))
+    if (dynamic_pointer_cast<Ice::WSEndpointInfo>(p))
     {
-        info = Data_Wrap_Struct(_wsEndpointInfoClass, 0, IceRuby_EndpointInfo_free, new Ice::EndpointInfoPtr(p));
+        info = TypedData_Wrap_Struct(_wsEndpointInfoClass, &IceRuby_EndpointInfoType, new Ice::EndpointInfoPtr(p));
 
-        Ice::WSEndpointInfoPtr ws = Ice::WSEndpointInfoPtr::dynamicCast(p);
+        Ice::WSEndpointInfoPtr ws = dynamic_pointer_cast<Ice::WSEndpointInfo>(p);
         rb_ivar_set(info, rb_intern("@resource"), createString(ws->resource));
     }
-    else if(Ice::TCPEndpointInfoPtr::dynamicCast(p))
+    else if (dynamic_pointer_cast<Ice::TCPEndpointInfo>(p))
     {
-        info = Data_Wrap_Struct(_tcpEndpointInfoClass, 0, IceRuby_EndpointInfo_free, new Ice::EndpointInfoPtr(p));
+        info = TypedData_Wrap_Struct(_tcpEndpointInfoClass, &IceRuby_EndpointInfoType, new Ice::EndpointInfoPtr(p));
     }
-    else if(Ice::UDPEndpointInfoPtr::dynamicCast(p))
+    else if (dynamic_pointer_cast<Ice::UDPEndpointInfo>(p))
     {
-        info = Data_Wrap_Struct(_udpEndpointInfoClass, 0, IceRuby_EndpointInfo_free, new Ice::EndpointInfoPtr(p));
+        info = TypedData_Wrap_Struct(_udpEndpointInfoClass, &IceRuby_EndpointInfoType, new Ice::EndpointInfoPtr(p));
 
-        Ice::UDPEndpointInfoPtr udp = Ice::UDPEndpointInfoPtr::dynamicCast(p);
+        Ice::UDPEndpointInfoPtr udp = dynamic_pointer_cast<Ice::UDPEndpointInfo>(p);
         rb_ivar_set(info, rb_intern("@mcastInterface"), createString(udp->mcastInterface));
         rb_ivar_set(info, rb_intern("@mcastTtl"), INT2FIX(udp->mcastTtl));
     }
-    else if(Ice::OpaqueEndpointInfoPtr::dynamicCast(p))
+    else if (dynamic_pointer_cast<Ice::OpaqueEndpointInfo>(p))
     {
-        info = Data_Wrap_Struct(_opaqueEndpointInfoClass, 0, IceRuby_EndpointInfo_free, new Ice::EndpointInfoPtr(p));
+        info = TypedData_Wrap_Struct(_opaqueEndpointInfoClass, &IceRuby_EndpointInfoType, new Ice::EndpointInfoPtr(p));
 
-        Ice::OpaqueEndpointInfoPtr opaque = Ice::OpaqueEndpointInfoPtr::dynamicCast(p);
-        Ice::ByteSeq b = opaque->rawBytes;
+        Ice::OpaqueEndpointInfoPtr opaque = dynamic_pointer_cast<Ice::OpaqueEndpointInfo>(p);
+        auto b = opaque->rawBytes;
         volatile VALUE v = callRuby(rb_str_new, reinterpret_cast<const char*>(&b[0]), static_cast<long>(b.size()));
         rb_ivar_set(info, rb_intern("@rawBytes"), v);
         rb_ivar_set(info, rb_intern("@rawEncoding"), createEncodingVersion(opaque->rawEncoding));
     }
-    else if(IceSSL::EndpointInfoPtr::dynamicCast(p))
+    else if (dynamic_pointer_cast<Ice::SSL::EndpointInfo>(p))
     {
-        info = Data_Wrap_Struct(_sslEndpointInfoClass, 0, IceRuby_EndpointInfo_free, new Ice::EndpointInfoPtr(p));
+        info = TypedData_Wrap_Struct(_sslEndpointInfoClass, &IceRuby_EndpointInfoType, new Ice::EndpointInfoPtr(p));
     }
-    else if(Ice::IPEndpointInfoPtr::dynamicCast(p))
+    else if (dynamic_pointer_cast<Ice::IPEndpointInfo>(p))
     {
-        info = Data_Wrap_Struct(_ipEndpointInfoClass, 0, IceRuby_EndpointInfo_free, new Ice::EndpointInfoPtr(p));
+        info = TypedData_Wrap_Struct(_ipEndpointInfoClass, &IceRuby_EndpointInfoType, new Ice::EndpointInfoPtr(p));
     }
     else
     {
-        info = Data_Wrap_Struct(_endpointInfoClass, 0, IceRuby_EndpointInfo_free, new Ice::EndpointInfoPtr(p));
+        info = TypedData_Wrap_Struct(_endpointInfoClass, &IceRuby_EndpointInfoType, new Ice::EndpointInfoPtr(p));
     }
 
-    if(Ice::IPEndpointInfoPtr::dynamicCast(p))
+    if (dynamic_pointer_cast<Ice::IPEndpointInfo>(p))
     {
-        Ice::IPEndpointInfoPtr ip = Ice::IPEndpointInfoPtr::dynamicCast(p);
+        Ice::IPEndpointInfoPtr ip = dynamic_pointer_cast<Ice::IPEndpointInfo>(p);
         rb_ivar_set(info, rb_intern("@host"), createString(ip->host));
         rb_ivar_set(info, rb_intern("@port"), INT2FIX(ip->port));
         rb_ivar_set(info, rb_intern("@sourceAddress"), createString(ip->sourceAddress));
     }
 
     rb_ivar_set(info, rb_intern("@underlying"), createEndpointInfo(p->underlying));
-    rb_ivar_set(info, rb_intern("@timeout"), INT2FIX(p->timeout));
     rb_ivar_set(info, rb_intern("@compress"), p->compress ? Qtrue : Qfalse);
     return info;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_EndpointInfo_type(VALUE self)
 {
     ICE_RUBY_TRY
@@ -196,15 +198,14 @@ IceRuby_EndpointInfo_type(VALUE self)
         Ice::EndpointInfoPtr* p = reinterpret_cast<Ice::EndpointInfoPtr*>(DATA_PTR(self));
         assert(p);
 
-        Ice::Short type = (*p)->type();
+        int16_t type = (*p)->type();
         return INT2FIX(type);
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_EndpointInfo_datagram(VALUE self)
 {
     ICE_RUBY_TRY
@@ -219,8 +220,7 @@ IceRuby_EndpointInfo_datagram(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_EndpointInfo_secure(VALUE self)
 {
     ICE_RUBY_TRY
@@ -271,9 +271,7 @@ IceRuby::initEndpoint(VALUE iceModule)
     //
     // Instance members.
     //
-    rb_define_attr(_endpointInfoClass, "protocol", 1, 0);
-    rb_define_attr(_endpointInfoClass, "encoding", 1, 0);
-    rb_define_attr(_endpointInfoClass, "timeout", 1, 0);
+    rb_define_attr(_endpointInfoClass, "underlying", 1, 0);
     rb_define_attr(_endpointInfoClass, "compress", 1, 0);
 
     //

data/dist/IceRuby/Endpoint.h

@@ -1,22 +1,18 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_RUBY_ENDPOINT_H
 #define ICE_RUBY_ENDPOINT_H
 
-#include <Config.h>
-#include <Ice/Connection.h>
+#include "Config.h"
+#include "Ice/Connection.h"
 
 namespace IceRuby
 {
+    void initEndpoint(VALUE);
 
-void initEndpoint(VALUE);
-
-VALUE createEndpoint(const Ice::EndpointPtr&);
-VALUE createEndpointInfo(const Ice::EndpointInfoPtr&);
-bool checkEndpoint(VALUE);
-
+    VALUE createEndpoint(const Ice::EndpointPtr&);
+    VALUE createEndpointInfo(const Ice::EndpointInfoPtr&);
+    bool checkEndpoint(VALUE);
 }
 
 #endif

data/dist/IceRuby/ImplicitContext.cpp

@@ -1,31 +1,31 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#if defined(__clang__)
-#   pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-#include <ImplicitContext.h>
-#include <Util.h>
-#include <Ice/Initialize.h>
-#include <Ice/ImplicitContext.h>
+#include "ImplicitContext.h"
+#include "Ice/ImplicitContext.h"
+#include "Ice/Initialize.h"
+#include "Util.h"
 
 using namespace std;
 using namespace IceRuby;
 
 static VALUE _implicitContextClass;
 
-extern "C"
-void
-IceRuby_ImplicitContext_free(Ice::ImplicitContextPtr* p)
+extern "C" void
+IceRuby_ImplicitContext_free(void* p)
 {
-    assert(p);
-    delete p;
+    delete static_cast<Ice::ImplicitContextPtr*>(p);
 }
 
-extern "C"
-VALUE
+static const rb_data_type_t IceRuby_ImplicitContextType = {
+    .wrap_struct_name = "Ice::ImplicitContext",
+    .function =
+        {
+            .dfree = IceRuby_ImplicitContext_free,
+        },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+extern "C" VALUE
 IceRuby_ImplicitContext_getContext(VALUE self)
 {
     ICE_RUBY_TRY
@@ -37,14 +37,13 @@ IceRuby_ImplicitContext_getContext(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ImplicitContext_setContext(VALUE self, VALUE context)
 {
     ICE_RUBY_TRY
     {
         Ice::Context ctx;
-        if(!hashToContext(context, ctx))
+        if (!hashToContext(context, ctx))
         {
             throw RubyException(rb_eTypeError, "argument must be a hash");
         }
@@ -55,15 +54,14 @@ IceRuby_ImplicitContext_setContext(VALUE self, VALUE context)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ImplicitContext_containsKey(VALUE self, VALUE key)
 {
     ICE_RUBY_TRY
     {
         Ice::ImplicitContextPtr p = getImplicitContext(self);
         string k = getString(key);
-        if(p->containsKey(k))
+        if (p->containsKey(k))
         {
             return Qtrue;
         }
@@ -76,8 +74,7 @@ IceRuby_ImplicitContext_containsKey(VALUE self, VALUE key)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ImplicitContext_get(VALUE self, VALUE key)
 {
     ICE_RUBY_TRY
@@ -91,8 +88,7 @@ IceRuby_ImplicitContext_get(VALUE self, VALUE key)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ImplicitContext_put(VALUE self, VALUE key, VALUE value)
 {
     ICE_RUBY_TRY
@@ -106,8 +102,7 @@ IceRuby_ImplicitContext_put(VALUE self, VALUE key, VALUE value)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_ImplicitContext_remove(VALUE self, VALUE key)
 {
     ICE_RUBY_TRY
@@ -144,5 +139,5 @@ IceRuby::getImplicitContext(VALUE v)
 VALUE
 IceRuby::createImplicitContext(const Ice::ImplicitContextPtr& p)
 {
-    return Data_Wrap_Struct(_implicitContextClass, 0, IceRuby_ImplicitContext_free, new Ice::ImplicitContextPtr(p));
+    return TypedData_Wrap_Struct(_implicitContextClass, &IceRuby_ImplicitContextType, new Ice::ImplicitContextPtr(p));
 }

data/dist/IceRuby/ImplicitContext.h

@@ -1,20 +1,16 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_RUBY_IMPLICIT_CONTEXT_H
 #define ICE_RUBY_IMPLICIT_CONTEXT_H
 
-#include <Config.h>
-#include <Ice/ImplicitContext.h>
+#include "Config.h"
+#include "Ice/ImplicitContext.h"
 
 namespace IceRuby
 {
-
-void initImplicitContext(VALUE);
-Ice::ImplicitContextPtr getImplicitContext(VALUE);
-VALUE createImplicitContext(const Ice::ImplicitContextPtr&);
-
+    void initImplicitContext(VALUE);
+    Ice::ImplicitContextPtr getImplicitContext(VALUE);
+    VALUE createImplicitContext(const Ice::ImplicitContextPtr&);
 }
 
 #endif

data/dist/IceRuby/Init.cpp

@@ -1,20 +1,15 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Communicator.h>
-#include <ImplicitContext.h>
-#include <Logger.h>
-#include <Operation.h>
-#include <Properties.h>
-#include <Proxy.h>
-#include <Slice.h>
-#include <Types.h>
-#include <Connection.h>
-#include <Endpoint.h>
-#include <ValueFactoryManager.h>
-
-#include <Ice/RegisterPlugins.h>
+// Copyright (c) ZeroC, Inc.
+
+#include "Communicator.h"
+#include "Connection.h"
+#include "Endpoint.h"
+#include "ImplicitContext.h"
+#include "Logger.h"
+#include "Operation.h"
+#include "Properties.h"
+#include "Proxy.h"
+#include "Slice.h"
+#include "Types.h"
 
 using namespace std;
 using namespace IceRuby;
@@ -23,27 +18,19 @@ static VALUE iceModule;
 
 extern "C"
 {
-
-void
-ICE_DECLSPEC_EXPORT Init_IceRuby()
-{
-    Ice::registerIceSSL(false);
-    Ice::registerIceDiscovery(false);
-    Ice::registerIceLocatorDiscovery(false);
-
-    iceModule = rb_define_module("Ice");
-    initCommunicator(iceModule);
-    initLogger(iceModule);
-    initOperation(iceModule);
-    initProperties(iceModule);
-    initProxy(iceModule);
-    initSlice(iceModule);
-    initTypes(iceModule);
-    initImplicitContext(iceModule);
-    initUtil(iceModule);
-    initConnection(iceModule);
-    initEndpoint(iceModule);
-    initValueFactoryManager(iceModule);
-}
-
+    ICE_DECLSPEC_EXPORT void Init_IceRuby()
+    {
+        iceModule = rb_define_module("Ice");
+        initCommunicator(iceModule);
+        initLogger(iceModule);
+        initOperation(iceModule);
+        initProperties(iceModule);
+        initProxy(iceModule);
+        initSlice(iceModule);
+        initTypes(iceModule);
+        initImplicitContext(iceModule);
+        initUtil(iceModule);
+        initConnection(iceModule);
+        initEndpoint(iceModule);
+    }
 }

data/dist/IceRuby/Logger.cpp

@@ -1,36 +1,36 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#if defined(__clang__)
-#   pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-#include <Logger.h>
-#include <Util.h>
-#include <Ice/Initialize.h>
+#include "Logger.h"
+#include "Ice/Initialize.h"
+#include "Util.h"
 
 using namespace std;
 using namespace IceRuby;
 
 static VALUE _loggerClass;
 
-extern "C"
-void
-IceRuby_Logger_free(Ice::LoggerPtr* p)
+extern "C" void
+IceRuby_Logger_free(void* p)
 {
-    assert(p);
-    delete p;
+    delete static_cast<Ice::LoggerPtr*>(p);
 }
 
+static const rb_data_type_t IceRuby_LoggerType = {
+    .wrap_struct_name = "Ice::Logger",
+    .function =
+        {
+            .dfree = IceRuby_Logger_free,
+        },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 VALUE
 IceRuby::createLogger(const Ice::LoggerPtr& p)
 {
-    return Data_Wrap_Struct(_loggerClass, 0, IceRuby_Logger_free, new Ice::LoggerPtr(p));
+    return TypedData_Wrap_Struct(_loggerClass, &IceRuby_LoggerType, new Ice::LoggerPtr(p));
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Logger_print(VALUE self, VALUE message)
 {
     ICE_RUBY_TRY
@@ -45,8 +45,7 @@ IceRuby_Logger_print(VALUE self, VALUE message)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Logger_trace(VALUE self, VALUE category, VALUE message)
 {
     ICE_RUBY_TRY
@@ -62,8 +61,7 @@ IceRuby_Logger_trace(VALUE self, VALUE category, VALUE message)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Logger_warning(VALUE self, VALUE message)
 {
     ICE_RUBY_TRY
@@ -78,8 +76,7 @@ IceRuby_Logger_warning(VALUE self, VALUE message)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Logger_error(VALUE self, VALUE message)
 {
     ICE_RUBY_TRY
@@ -94,8 +91,7 @@ IceRuby_Logger_error(VALUE self, VALUE message)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Logger_cloneWithPrefix(VALUE self, VALUE prefix)
 {
     ICE_RUBY_TRY
@@ -111,8 +107,7 @@ IceRuby_Logger_cloneWithPrefix(VALUE self, VALUE prefix)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_getProcessLogger()
 {
     ICE_RUBY_TRY

data/dist/IceRuby/Logger.h

@@ -1,23 +1,19 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_RUBY_LOGGER_H
 #define ICE_RUBY_LOGGER_H
 
-#include <Config.h>
-#include <Ice/Logger.h>
+#include "Config.h"
+#include "Ice/Logger.h"
 
 namespace IceRuby
 {
+    bool initLogger(VALUE);
 
-bool initLogger(VALUE);
-
-//
-// Create an object that delegates to a C++ implementation.
-//
-VALUE createLogger(const Ice::LoggerPtr&);
-
+    //
+    // Create an object that delegates to a C++ implementation.
+    //
+    VALUE createLogger(const Ice::LoggerPtr&);
 }
 
 #endif