zeroc-ice 3.7.11 → 3.8.1

data/dist/IceRuby/Operation.h

@@ -1,31 +1,28 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_RUBY_OPERATION_H
 #define ICE_RUBY_OPERATION_H
 
-#include <Config.h>
-#include <Ice/CommunicatorF.h>
+#include "Config.h"
+#include "Ice/ProxyF.h"
 
-namespace IceRuby
-{
+#include <memory>
 
-class Operation : public IceUtil::Shared
+namespace IceRuby
 {
-public:
-
-    virtual ~Operation();
-
-    virtual VALUE invoke(const Ice::ObjectPrx&, VALUE, VALUE) = 0;
-    virtual void deprecate(const std::string&) = 0;
-};
-typedef IceUtil::Handle<Operation> OperationPtr;
+    class Operation
+    {
+    public:
+        virtual ~Operation();
 
-bool initOperation(VALUE);
+        virtual VALUE invoke(const Ice::ObjectPrx&, VALUE, VALUE) = 0;
+        virtual void deprecate(const std::string&) = 0;
+    };
+    using OperationPtr = std::shared_ptr<Operation>;
 
-OperationPtr getOperation(VALUE);
+    bool initOperation(VALUE);
 
+    OperationPtr getOperation(VALUE);
 }
 
 #endif

data/dist/IceRuby/Properties.cpp

@@ -1,60 +1,53 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#if defined(__clang__)
-#   pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-#include <Properties.h>
-#include <Util.h>
-#include <Ice/Initialize.h>
-#include <Ice/Properties.h>
+#include "Properties.h"
+#include "Ice/Initialize.h"
+#include "Ice/Properties.h"
+#include "Util.h"
 
 using namespace std;
 using namespace IceRuby;
 
 static VALUE _propertiesClass;
 
-extern "C"
-void
-IceRuby_Properties_free(Ice::PropertiesPtr* p)
+extern "C" void
+IceRuby_Properties_free(void* p)
 {
-    assert(p);
-    delete p;
+    delete static_cast<Ice::PropertiesPtr*>(p);
 }
 
-extern "C"
-VALUE
+static const rb_data_type_t IceRuby_PropertiesType = {
+    .wrap_struct_name = "Ice::Properties",
+    .function =
+        {
+            .dfree = IceRuby_Properties_free,
+        },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+extern "C" VALUE
 IceRuby_createProperties(int argc, VALUE* argv, VALUE /*self*/)
 {
     ICE_RUBY_TRY
     {
         Ice::StringSeq seq;
-        if(argc >= 1 && !NIL_P(argv[0]) && !arrayToStringSeq(argv[0], seq))
+        if (argc >= 1 && !NIL_P(argv[0]) && !arrayToStringSeq(argv[0], seq))
         {
             throw RubyException(rb_eTypeError, "invalid array argument to Ice::createProperties");
         }
 
         Ice::PropertiesPtr defaults;
-        if(argc == 2)
+        if (argc == 2)
         {
-            if(!NIL_P(argv[1]) && callRuby(rb_obj_is_instance_of, argv[1], _propertiesClass) == Qfalse)
+            if (!NIL_P(argv[1]) && callRuby(rb_obj_is_instance_of, argv[1], _propertiesClass) == Qfalse)
             {
                 throw RubyException(rb_eTypeError, "invalid properties argument to Ice::createProperties");
             }
             defaults = getProperties(argv[1]);
         }
 
-        //
-        // Insert the program name (stored in the Ruby global variable $0) as the first
-        // element of the sequence.
-        //
-        volatile VALUE progName = callRuby(rb_gv_get, "$0");
-        seq.insert(seq.begin(), getString(progName));
-
         Ice::PropertiesPtr obj;
-        if(argc >= 1)
+        if (argc >= 1)
         {
             obj = Ice::createProperties(seq, defaults);
         }
@@ -66,28 +59,26 @@ IceRuby_createProperties(int argc, VALUE* argv, VALUE /*self*/)
         //
         // Replace the contents of the given argument list with the filtered arguments.
         //
-        if(argc > 0 && !NIL_P(argv[0]))
+        if (argc > 0 && !NIL_P(argv[0]))
         {
+            // Clear the argv array.
             callRuby(rb_ary_clear, argv[0]);
 
-            //
-            // We start at index 1 in order to skip the element that we inserted earlier.
-            //
-            for(Ice::StringSeq::size_type i = 1; i < seq.size(); ++i)
+            // Populate argv with the remaining arguments.
+            for (const auto& arg : seq)
             {
-                volatile VALUE str = createString(seq[i]);
+                volatile VALUE str = createString(arg);
                 callRuby(rb_ary_push, argv[0], str);
             }
         }
 
-        return createProperties(obj);
+        return IceRuby::createProperties(obj);
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Properties_getProperty(VALUE self, VALUE key)
 {
     ICE_RUBY_TRY
@@ -101,8 +92,21 @@ IceRuby_Properties_getProperty(VALUE self, VALUE key)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
+IceRuby_Properties_getIceProperty(VALUE self, VALUE key)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::PropertiesPtr p = getProperties(self);
+        string k = getString(key);
+        string v = p->getIceProperty(k);
+        return createString(v);
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+extern "C" VALUE
 IceRuby_Properties_getPropertyWithDefault(VALUE self, VALUE key, VALUE def)
 {
     ICE_RUBY_TRY
@@ -117,39 +121,50 @@ IceRuby_Properties_getPropertyWithDefault(VALUE self, VALUE key, VALUE def)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Properties_getPropertyAsInt(VALUE self, VALUE key)
 {
     ICE_RUBY_TRY
     {
         Ice::PropertiesPtr p = getProperties(self);
         string k = getString(key);
-        Ice::Int v = p->getPropertyAsInt(k);
+        int32_t v = p->getPropertyAsInt(k);
         return INT2FIX(v);
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
+IceRuby_Properties_getIcePropertyAsInt(VALUE self, VALUE key)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::PropertiesPtr p = getProperties(self);
+        string k = getString(key);
+        int32_t v = p->getIcePropertyAsInt(k);
+        return INT2FIX(v);
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+extern "C" VALUE
 IceRuby_Properties_getPropertyAsIntWithDefault(VALUE self, VALUE key, VALUE def)
 {
     ICE_RUBY_TRY
     {
         Ice::PropertiesPtr p = getProperties(self);
         string k = getString(key);
-        Ice::Int d = static_cast<Ice::Int>(getInteger(def));
-        Ice::Int v = p->getPropertyAsIntWithDefault(k, d);
+        int32_t d = static_cast<int32_t>(getInteger(def));
+        int32_t v = p->getPropertyAsIntWithDefault(k, d);
         return INT2FIX(v);
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Properties_getPropertyAsList(VALUE self, VALUE key)
 {
     ICE_RUBY_TRY
@@ -163,8 +178,21 @@ IceRuby_Properties_getPropertyAsList(VALUE self, VALUE key)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
+IceRuby_Properties_getIcePropertyAsList(VALUE self, VALUE key)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::PropertiesPtr p = getProperties(self);
+        string k = getString(key);
+        Ice::StringSeq v = p->getIcePropertyAsList(k);
+        return stringSeqToArray(v);
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+extern "C" VALUE
 IceRuby_Properties_getPropertyAsListWithDefault(VALUE self, VALUE key, VALUE def)
 {
     ICE_RUBY_TRY
@@ -172,7 +200,7 @@ IceRuby_Properties_getPropertyAsListWithDefault(VALUE self, VALUE key, VALUE def
         Ice::PropertiesPtr p = getProperties(self);
         string k = getString(key);
         Ice::StringSeq d;
-        if(!arrayToStringSeq(def, d))
+        if (!arrayToStringSeq(def, d))
         {
             throw RubyException(rb_eTypeError, "invalid array argument to Ice::getPropertyAsListWithDefault");
         }
@@ -183,8 +211,7 @@ IceRuby_Properties_getPropertyAsListWithDefault(VALUE self, VALUE key, VALUE def
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Properties_getPropertiesForPrefix(VALUE self, VALUE prefix)
 {
     ICE_RUBY_TRY
@@ -193,7 +220,7 @@ IceRuby_Properties_getPropertiesForPrefix(VALUE self, VALUE prefix)
         string pfx = getString(prefix);
         Ice::PropertyDict dict = p->getPropertiesForPrefix(pfx);
         volatile VALUE result = callRuby(rb_hash_new);
-        for(Ice::PropertyDict::const_iterator q = dict.begin(); q != dict.end(); ++q)
+        for (Ice::PropertyDict::const_iterator q = dict.begin(); q != dict.end(); ++q)
         {
             volatile VALUE key = createString(q->first);
             volatile VALUE value = createString(q->second);
@@ -205,8 +232,7 @@ IceRuby_Properties_getPropertiesForPrefix(VALUE self, VALUE prefix)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Properties_setProperty(VALUE self, VALUE key, VALUE value)
 {
     ICE_RUBY_TRY
@@ -220,8 +246,7 @@ IceRuby_Properties_setProperty(VALUE self, VALUE key, VALUE value)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Properties_getCommandLineOptions(VALUE self)
 {
     ICE_RUBY_TRY
@@ -234,8 +259,7 @@ IceRuby_Properties_getCommandLineOptions(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Properties_parseCommandLineOptions(VALUE self, VALUE prefix, VALUE options)
 {
     ICE_RUBY_TRY
@@ -243,7 +267,7 @@ IceRuby_Properties_parseCommandLineOptions(VALUE self, VALUE prefix, VALUE optio
         Ice::PropertiesPtr p = getProperties(self);
         string pfx = getString(prefix);
         Ice::StringSeq seq;
-        if(!arrayToStringSeq(options, seq))
+        if (!arrayToStringSeq(options, seq))
         {
             throw RubyException(rb_eTypeError, "invalid array argument to Ice::parseCommandLineOptions");
         }
@@ -254,15 +278,14 @@ IceRuby_Properties_parseCommandLineOptions(VALUE self, VALUE prefix, VALUE optio
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Properties_parseIceCommandLineOptions(VALUE self, VALUE options)
 {
     ICE_RUBY_TRY
     {
         Ice::PropertiesPtr p = getProperties(self);
         Ice::StringSeq seq;
-        if(!arrayToStringSeq(options, seq))
+        if (!arrayToStringSeq(options, seq))
         {
             throw RubyException(rb_eTypeError, "invalid array argument to Ice::parseIceCommandLineOptions");
         }
@@ -273,8 +296,7 @@ IceRuby_Properties_parseIceCommandLineOptions(VALUE self, VALUE options)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Properties_load(VALUE self, VALUE file)
 {
     ICE_RUBY_TRY
@@ -287,22 +309,20 @@ IceRuby_Properties_load(VALUE self, VALUE file)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Properties_clone(VALUE self)
 {
     ICE_RUBY_TRY
     {
         Ice::PropertiesPtr p = getProperties(self);
         Ice::PropertiesPtr props = p->clone();
-        return createProperties(props);
+        return IceRuby::createProperties(props);
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Properties_to_s(VALUE self)
 {
     ICE_RUBY_TRY
@@ -310,9 +330,9 @@ IceRuby_Properties_to_s(VALUE self)
         Ice::PropertiesPtr p = getProperties(self);
         Ice::PropertyDict dict = p->getPropertiesForPrefix("");
         string str;
-        for(Ice::PropertyDict::const_iterator q = dict.begin(); q != dict.end(); ++q)
+        for (Ice::PropertyDict::const_iterator q = dict.begin(); q != dict.end(); ++q)
         {
-            if(q != dict.begin())
+            if (q != dict.begin())
             {
                 str.append("\n");
             }
@@ -332,23 +352,47 @@ IceRuby::initProperties(VALUE iceModule)
     _propertiesClass = rb_define_class_under(iceModule, "PropertiesI", rb_cObject);
     rb_undef_alloc_func(_propertiesClass);
     rb_define_method(_propertiesClass, "getProperty", CAST_METHOD(IceRuby_Properties_getProperty), 1);
-    rb_define_method(_propertiesClass, "getPropertyWithDefault",
-                     CAST_METHOD(IceRuby_Properties_getPropertyWithDefault), 2);
+    rb_define_method(_propertiesClass, "getIceProperty", CAST_METHOD(IceRuby_Properties_getIceProperty), 1);
+    rb_define_method(
+        _propertiesClass,
+        "getPropertyWithDefault",
+        CAST_METHOD(IceRuby_Properties_getPropertyWithDefault),
+        2);
     rb_define_method(_propertiesClass, "getPropertyAsInt", CAST_METHOD(IceRuby_Properties_getPropertyAsInt), 1);
-    rb_define_method(_propertiesClass, "getPropertyAsIntWithDefault",
-                     CAST_METHOD(IceRuby_Properties_getPropertyAsIntWithDefault), 2);
+    rb_define_method(_propertiesClass, "getIcePropertyAsInt", CAST_METHOD(IceRuby_Properties_getIcePropertyAsInt), 1);
+    rb_define_method(
+        _propertiesClass,
+        "getPropertyAsIntWithDefault",
+        CAST_METHOD(IceRuby_Properties_getPropertyAsIntWithDefault),
+        2);
     rb_define_method(_propertiesClass, "getPropertyAsList", CAST_METHOD(IceRuby_Properties_getPropertyAsList), 1);
-    rb_define_method(_propertiesClass, "getPropertyAsListWithDefault",
-                     CAST_METHOD(IceRuby_Properties_getPropertyAsListWithDefault), 2);
-    rb_define_method(_propertiesClass, "getPropertiesForPrefix",
-                     CAST_METHOD(IceRuby_Properties_getPropertiesForPrefix), 1);
+    rb_define_method(_propertiesClass, "getIcePropertyAsList", CAST_METHOD(IceRuby_Properties_getIcePropertyAsList), 1);
+    rb_define_method(
+        _propertiesClass,
+        "getPropertyAsListWithDefault",
+        CAST_METHOD(IceRuby_Properties_getPropertyAsListWithDefault),
+        2);
+    rb_define_method(
+        _propertiesClass,
+        "getPropertiesForPrefix",
+        CAST_METHOD(IceRuby_Properties_getPropertiesForPrefix),
+        1);
     rb_define_method(_propertiesClass, "setProperty", CAST_METHOD(IceRuby_Properties_setProperty), 2);
-    rb_define_method(_propertiesClass, "getCommandLineOptions", CAST_METHOD(IceRuby_Properties_getCommandLineOptions),
-                     0);
-    rb_define_method(_propertiesClass, "parseCommandLineOptions",
-                     CAST_METHOD(IceRuby_Properties_parseCommandLineOptions), 2);
-    rb_define_method(_propertiesClass, "parseIceCommandLineOptions",
-                     CAST_METHOD(IceRuby_Properties_parseIceCommandLineOptions), 1);
+    rb_define_method(
+        _propertiesClass,
+        "getCommandLineOptions",
+        CAST_METHOD(IceRuby_Properties_getCommandLineOptions),
+        0);
+    rb_define_method(
+        _propertiesClass,
+        "parseCommandLineOptions",
+        CAST_METHOD(IceRuby_Properties_parseCommandLineOptions),
+        2);
+    rb_define_method(
+        _propertiesClass,
+        "parseIceCommandLineOptions",
+        CAST_METHOD(IceRuby_Properties_parseIceCommandLineOptions),
+        1);
     rb_define_method(_propertiesClass, "load", CAST_METHOD(IceRuby_Properties_load), 1);
     rb_define_method(_propertiesClass, "clone", CAST_METHOD(IceRuby_Properties_clone), 0);
     rb_define_method(_propertiesClass, "to_s", CAST_METHOD(IceRuby_Properties_to_s), 0);
@@ -365,5 +409,5 @@ IceRuby::getProperties(VALUE v)
 VALUE
 IceRuby::createProperties(const Ice::PropertiesPtr& p)
 {
-    return Data_Wrap_Struct(_propertiesClass, 0, IceRuby_Properties_free, new Ice::PropertiesPtr(p));
+    return TypedData_Wrap_Struct(_propertiesClass, &IceRuby_PropertiesType, new Ice::PropertiesPtr(p));
 }

data/dist/IceRuby/Properties.h

@@ -1,20 +1,16 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_RUBY_PROPERTIES_H
 #define ICE_RUBY_PROPERTIES_H
 
-#include <Config.h>
-#include <Ice/PropertiesF.h>
+#include "Config.h"
+#include "Ice/PropertiesF.h"
 
 namespace IceRuby
 {
-
-void initProperties(VALUE);
-Ice::PropertiesPtr getProperties(VALUE);
-VALUE createProperties(const Ice::PropertiesPtr&);
-
+    void initProperties(VALUE);
+    Ice::PropertiesPtr getProperties(VALUE);
+    VALUE createProperties(const Ice::PropertiesPtr&);
 }
 
 #endif