zeroc-ice 3.6.5 → 3.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: b3351774d1fc4a049f9ebf75d9ed941294c7e3f5
-  data.tar.gz: 79e26cd9998bd1c6b6972ff790ad5f33e5e48194
+SHA256:
+  metadata.gz: d93f67fc8d2871e7db0614a3cbb091e947e73c7c6b506ceeec3ad10f433be4d6
+  data.tar.gz: c144208e37d3a3aa47a47d70b3769058d2f9f8668199cc5f1f6de468b82011e5
 SHA512:
-  metadata.gz: 9a8dda80e3b032afa62535039d09197c98440bda53f9a99fcff655dff7c5352ac4fca343076e1eb65b71c1daf3aadee64b3b80ad5245a43f6ea4f35ea0dc8be9
-  data.tar.gz: a6622f0699de26d18c283662cbc74a91b0cd56e513dd7c3ff4353e162ade338e825d5f036c2f3fbdb29941da07b7d5156e4ff30efff53e24ae9e3919795aab2a
+  metadata.gz: b2ca8b593b06bce4e1bc7d6ab493365ab422feb97bfcef84a5ff67ff20e30f80f610e9b7156e32ab69ab1420f536a9a948d4d4ae939013c371edc7ba2273a980
+  data.tar.gz: 15b47e5d5821f42efc77897d52a85f91e37fddf698b13ca3651bb47aaa0c536efa0d770c919fae9febbe222f91b96dd7d1e2f1a912a91b137677a27b0fe7902a

data/ICE_LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+Copyright (c) ZeroC, Inc. All rights reserved.
 
 This copy of Ice is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License version 2 as
@@ -12,37 +12,37 @@ details.
 You should have received a copy of the GNU General Public License version
 2 along with this program; if not, see http://www.gnu.org/licenses.
 
-Linking Ice statically or dynamically with other software (such as a 
-library, module or application) is making a combined work based on Ice. 
+Linking Ice statically or dynamically with other software (such as a
+library, module or application) is making a combined work based on Ice.
 Thus, the terms and conditions of the GNU General Public License version
 2 cover this combined work.
 
-If such software can only be used together with Ice, then not only the 
+If such software can only be used together with Ice, then not only the
 combined work but the software itself is a work derived from Ice and as
-such shall be licensed under the terms of the GNU General Public License 
-version 2. This includes the situation where Ice is only being used 
+such shall be licensed under the terms of the GNU General Public License
+version 2. This includes the situation where Ice is only being used
 through an abstraction layer.
 
-As a special exception to the above, ZeroC grants to the copyright 
-holders and contributors of the Mumble project (http://www.mumble.info) 
-the permission to license the Ice-based software they contribute to 
+As a special exception to the above, ZeroC grants to the copyright
+holders and contributors of the Mumble project (http://www.mumble.info)
+the permission to license the Ice-based software they contribute to
 Mumble under the terms of the BSD license. This exception does not extend
-to the parts of Ice used by Mumble, or to any other derived work: as a 
-whole, any work based on Ice shall be licensed under the terms and 
+to the parts of Ice used by Mumble, or to any other derived work: as a
+whole, any work based on Ice shall be licensed under the terms and
 conditions of the GNU General Public License version 2.
 
 You may also combine Ice with any software not derived from Ice, provided
-the license of such software is compatible with the GNU General Public 
+the license of such software is compatible with the GNU General Public
 License version 2. In addition, as a special exception, ZeroC grants you
 permission to combine Ice with:
- 
+
  - the OpenSSL library, or with a modified version of the OpenSSL library
    that uses the same license as OpenSSL
 
  - any library not derived from Ice and licensed under the terms of
-   the Apache License, version 2.0 
-   (http://www.apache.org/licenses/LICENSE-2.0.html) 
+   the Apache License, version 2.0
+   (http://www.apache.org/licenses/LICENSE-2.0.html)
 
-If you modify this copy of Ice, you may extend any of the exceptions 
-provided above to your version of Ice, but you are not obligated to 
+If you modify this copy of Ice, you may extend any of the exceptions
+provided above to your version of Ice, but you are not obligated to
 do so.

data/LICENSE

@@ -1,5 +1,5 @@
-		    GNU GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
 
  Copyright (C) 1989, 1991 Free Software Foundation, Inc.
  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
@@ -7,7 +7,7 @@
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
-			    Preamble
+                            Preamble
 
   The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
@@ -56,8 +56,8 @@ patent must be licensed for everyone's free use or not licensed at all.
 
   The precise terms and conditions for copying, distribution and
 modification follow.
-
-		    GNU GENERAL PUBLIC LICENSE
+
+                    GNU GENERAL PUBLIC LICENSE
    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 
   0. This License applies to any program or other work which contains
@@ -111,7 +111,7 @@ above, provided that you also meet all of these conditions:
     License.  (Exception: if the Program itself is interactive but
     does not normally print such an announcement, your work based on
     the Program is not required to print an announcement.)
-
+
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Program,
 and can be reasonably considered independent and separate works in
@@ -169,7 +169,7 @@ access to copy from a designated place, then offering equivalent
 access to copy the source code from the same place counts as
 distribution of the source code, even though third parties are not
 compelled to copy the source along with the object code.
-
+
   4. You may not copy, modify, sublicense, or distribute the Program
 except as expressly provided under this License.  Any attempt
 otherwise to copy, modify, sublicense or distribute the Program is
@@ -226,7 +226,7 @@ impose that choice.
 
 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
-
+
   8. If the distribution and/or use of the Program is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Program under this License
@@ -256,7 +256,7 @@ make exceptions for this.  Our decision will be guided by the two goals
 of preserving the free status of all derivatives of our free software and
 of promoting the sharing and reuse of software generally.
 
-			    NO WARRANTY
+                            NO WARRANTY
 
   11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
@@ -278,9 +278,9 @@ YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
 PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 
-		     END OF TERMS AND CONDITIONS
-
-	    How to Apply These Terms to Your New Programs
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
 
   If you develop a new program, and you want it to be of the greatest
 possible use to the public, the best way to achieve this is to make it

data/bin/slice2rb

@@ -1,12 +1,7 @@
 #!/usr/bin/env ruby
-# **********************************************************************
 #
-# Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+# Copyright (c) ZeroC, Inc. All rights reserved.
 #
-# This copy of Ice is licensed to you under the terms described in the
-# ICE_LICENSE file included in this distribution.
-#
-# **********************************************************************
 
 require 'Ice'
 sliceDir = Ice.getSliceDir()

data/ext/Communicator.cpp

@@ -1,20 +1,16 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <Communicator.h>
 #include <ImplicitContext.h>
 #include <Logger.h>
-#include <ObjectFactory.h>
 #include <Properties.h>
 #include <Proxy.h>
 #include <Types.h>
 #include <Util.h>
+#include <ValueFactoryManager.h>
+#include <IceUtil/DisableWarnings.h>
 #include <Ice/Communicator.h>
 #include <Ice/Initialize.h>
 #include <Ice/Locator.h>
@@ -37,9 +33,9 @@ IceRuby_Communicator_mark(Ice::CommunicatorPtr* p)
     assert(p);
     try
     {
-        ObjectFactoryPtr pof = ObjectFactoryPtr::dynamicCast((*p)->findObjectFactory(""));
-        assert(pof);
-        pof->mark();
+        ValueFactoryManagerPtr vfm = ValueFactoryManagerPtr::dynamicCast((*p)->getValueFactoryManager());
+        assert(vfm);
+        vfm->markSelf();
     }
     catch(const Ice::CommunicatorDestroyedException&)
     {
@@ -55,15 +51,55 @@ IceRuby_Communicator_free(Ice::CommunicatorPtr* p)
     delete p;
 }
 
+namespace
+{
+
+class CommunicatorDestroyer
+{
+public:
+
+    CommunicatorDestroyer(const Ice::CommunicatorPtr& c) : _communicator(c) {}
+
+    ~CommunicatorDestroyer()
+    {
+        _communicator->destroy();
+    }
+
+private:
+
+    Ice::CommunicatorPtr _communicator;
+};
+
+}
+
 extern "C"
 VALUE
-IceRuby_initialize(int argc, VALUE* argv, VALUE self)
+IceRuby_initialize(int argc, VALUE* argv, VALUE /*self*/)
 {
     ICE_RUBY_TRY
     {
+        //
+        // The argument options are:
+        //
+        // Ice::initialize()
+        // Ice::initialize(args)
+        // Ice::initialize(initData)
+        // Ice::initialize(configFile)
+        // Ice::initialize(args, initData)
+        // Ice::initialize(args, configFile)
+        //
+        // An implicit block is optional.
+        //
+
+        if(argc > 2)
+        {
+            throw RubyException(rb_eArgError, "invalid number of arguments to Ice::initialize");
+        }
+
         volatile VALUE initDataCls = callRuby(rb_path2class, "Ice::InitializationData");
-        volatile VALUE args = Qnil, initData = Qnil;
-        if(argc == 1)
+        volatile VALUE args = Qnil, initData = Qnil, configFile = Qnil;
+
+        if(argc >= 1)
         {
             if(isArray(argv[0]))
             {
@@ -73,23 +109,54 @@ IceRuby_initialize(int argc, VALUE* argv, VALUE self)
             {
                 initData = argv[0];
             }
+            else if(TYPE(argv[0]) == T_STRING)
+            {
+                configFile = argv[0];
+            }
             else
             {
-                throw RubyException(rb_eTypeError, "invalid argument to Ice::initialize");
+                throw RubyException(rb_eTypeError,
+                    "initialize expects an argument list, InitializationData or a configuration filename");
             }
         }
-        else if(argc == 2)
+
+        if(argc >= 2)
         {
-            if(!isArray(argv[0]) || callRuby(rb_obj_is_instance_of, argv[1], initDataCls) == Qfalse)
+            if(isArray(argv[1]))
+            {
+                if(!NIL_P(args))
+                {
+                    throw RubyException(rb_eTypeError, "unexpected array argument to initialize");
+                }
+                args = argv[1];
+            }
+            else if(callRuby(rb_obj_is_instance_of, argv[1], initDataCls) == Qtrue)
+            {
+                if(!NIL_P(initData))
+                {
+                    throw RubyException(rb_eTypeError, "unexpected InitializationData argument to initialize");
+                }
+                initData = argv[1];
+            }
+            else if(TYPE(argv[1]) == T_STRING)
             {
-                throw RubyException(rb_eTypeError, "invalid argument to Ice::initialize");
+                if(!NIL_P(configFile))
+                {
+                    throw RubyException(rb_eTypeError, "unexpected string argument to initialize");
+                }
+                configFile = argv[1];
+            }
+            else
+            {
+                throw RubyException(rb_eTypeError,
+                    "initialize expects an argument list, InitializationData or a configuration filename");
             }
-            args = argv[0];
-            initData = argv[1];
         }
-        else if(argc > 0)
+
+        if(!NIL_P(initData) && !NIL_P(configFile))
         {
-            throw RubyException(rb_eArgError, "invalid number of arguments to Ice::initialize");
+            throw RubyException(rb_eTypeError,
+                "initialize accepts either Ice.InitializationData or a configuration filename");
         }
 
         Ice::StringSeq seq;
@@ -98,11 +165,6 @@ IceRuby_initialize(int argc, VALUE* argv, VALUE self)
             throw RubyException(rb_eTypeError, "invalid array argument to Ice::initialize");
         }
 
-        //
-        // Use the with-args or the without-args version of initialize()?
-        //
-        bool hasArgs = !NIL_P(args);
-
         Ice::InitializationData data;
         if(!NIL_P(initData))
         {
@@ -128,23 +190,22 @@ IceRuby_initialize(int argc, VALUE* argv, VALUE self)
         seq.insert(seq.begin(), getString(progName));
 
         data.compactIdResolver = new IdResolver;
+        data.valueFactoryManager = new ValueFactoryManager;
 
-        if(hasArgs)
+        if(!data.properties)
         {
-            data.properties = Ice::createProperties(seq, data.properties);
+            data.properties = Ice::createProperties();
         }
-        else if(!data.properties)
+
+        if(!NIL_P(configFile))
         {
-            data.properties = Ice::createProperties();
+            data.properties->load(getString(configFile));
+        }
+
+        if(!NIL_P(args))
+        {
+            data.properties = Ice::createProperties(seq, data.properties);
         }
-        //
-        // Disable collocation optimization, otherwise an invocation on a
-        // collocated servant results in a CollocationOptimizationException
-        // (because Ruby uses the blobject API).
-        //
-        // TODO: Enable if a server mapping is added.
-        //
-        //data.properties->setProperty("Ice.Default.CollocationOptimization", "0");
 
         //
         // Remaining command line options are passed to the communicator
@@ -162,7 +223,7 @@ IceRuby_initialize(int argc, VALUE* argv, VALUE self)
         Ice::CommunicatorPtr communicator;
         try
         {
-            if(hasArgs)
+            if(!NIL_P(args))
             {
                 communicator = Ice::initialize(ac, av, data);
             }
@@ -171,6 +232,17 @@ IceRuby_initialize(int argc, VALUE* argv, VALUE self)
                 communicator = Ice::initialize(data);
             }
         }
+        catch(const Ice::LocalException& ex)
+        {
+            cerr << ex << endl;
+            for(i = 0; i < ac + 1; ++i)
+            {
+                free(av[i]);
+            }
+            delete[] av;
+
+            throw;
+        }
         catch(...)
         {
             for(i = 0; i < ac + 1; ++i)
@@ -181,7 +253,7 @@ IceRuby_initialize(int argc, VALUE* argv, VALUE self)
 
             throw;
         }
-        
+
         //
         // Replace the contents of the given argument list with the filtered arguments.
         //
@@ -205,9 +277,6 @@ IceRuby_initialize(int argc, VALUE* argv, VALUE self)
         }
         delete[] av;
 
-        ObjectFactoryPtr factory = new ObjectFactory;
-        communicator->addObjectFactory(factory, "");
-
         VALUE result = Data_Wrap_Struct(_communicatorClass, IceRuby_Communicator_mark,
                                         IceRuby_Communicator_free, new Ice::CommunicatorPtr(communicator));
 
@@ -218,7 +287,40 @@ IceRuby_initialize(int argc, VALUE* argv, VALUE self)
         }
         _communicatorMap.insert(CommunicatorMap::value_type(communicator, reinterpret_cast<const VALUE&>(result)));
 
-        return result;
+        //
+        // If an implicit block was provided, yield to the block and pass it the communicator instance.
+        // We destroy the communicator after the block is finished, and return the result of the block.
+        //
+        if(rb_block_given_p())
+        {
+            CommunicatorDestroyer destroyer(communicator);
+            //
+            // Examine the arity of the block procedure. If it accepts one argument, pass it the
+            // communicator. If it accepts two arguments, pass it the communicator and the
+            // argument vector.
+            //
+            VALUE proc = callRuby(rb_block_proc);
+            int arity = rb_proc_arity(proc);
+            if(arity == 1)
+            {
+                return callRuby(rb_yield, result);
+            }
+            else if(arity == 2)
+            {
+                VALUE blockArgs = createArray(2);
+                RARRAY_ASET(blockArgs, 0, result);
+                RARRAY_ASET(blockArgs, 1, args);
+                return callRuby(rb_yield, blockArgs);
+            }
+            else
+            {
+                throw RubyException(rb_eArgError, "block must accept one or two arguments");
+            }
+        }
+        else
+        {
+            return result;
+        }
     }
     ICE_RUBY_CATCH
     return Qnil;
@@ -226,7 +328,7 @@ IceRuby_initialize(int argc, VALUE* argv, VALUE self)
 
 extern "C"
 VALUE
-IceRuby_stringToIdentity(VALUE self, VALUE str)
+IceRuby_stringToIdentity(VALUE /*self*/, VALUE str)
 {
     ICE_RUBY_TRY
     {
@@ -240,12 +342,26 @@ IceRuby_stringToIdentity(VALUE self, VALUE str)
 
 extern "C"
 VALUE
-IceRuby_identityToString(VALUE self, VALUE id)
+IceRuby_identityToString(int argc, VALUE* argv, VALUE /*self*/)
 {
     ICE_RUBY_TRY
     {
-        Ice::Identity ident = getIdentity(id);
-        string str = Ice::identityToString(ident);
+        if(argc < 1 || argc > 2)
+        {
+            throw RubyException(rb_eArgError, "wrong number of arguments");
+        }
+
+        Ice::Identity ident = getIdentity(argv[0]);
+
+        Ice::ToStringMode toStringMode = Ice::Unicode;
+        if(argc == 2)
+        {
+            volatile VALUE modeValue = callRuby(rb_funcall, argv[1], rb_intern("to_i"), 0);
+            assert(TYPE(modeValue) == T_FIXNUM);
+            toStringMode = static_cast<Ice::ToStringMode>(FIX2LONG(modeValue));
+        }
+
+        string str = Ice::identityToString(ident, toStringMode);
         return createString(str);
     }
     ICE_RUBY_CATCH
@@ -256,12 +372,19 @@ extern "C"
 VALUE
 IceRuby_Communicator_destroy(VALUE self)
 {
+    Ice::CommunicatorPtr p = getCommunicator(self);
+
+    ValueFactoryManagerPtr vfm = ValueFactoryManagerPtr::dynamicCast(p->getValueFactoryManager());
+    assert(vfm);
+
     ICE_RUBY_TRY
     {
-        Ice::CommunicatorPtr p = getCommunicator(self);
         p->destroy();
     }
     ICE_RUBY_CATCH
+
+    vfm->destroy();
+
     return Qnil;
 }
 
@@ -291,6 +414,19 @@ IceRuby_Communicator_isShutdown(VALUE self)
     return Qnil;
 }
 
+extern "C"
+VALUE
+IceRuby_Communicator_waitForShutdown(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::CommunicatorPtr p = getCommunicator(self);
+        p->waitForShutdown();
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
 extern "C"
 VALUE
 IceRuby_Communicator_stringToProxy(VALUE self, VALUE str)
@@ -371,7 +507,7 @@ IceRuby_Communicator_proxyToProperty(VALUE self, VALUE obj, VALUE str)
             volatile VALUE value = createString(q->second);
             callRuby(rb_hash_aset, result, key, value);
         }
-        return result; 
+        return result;
     }
     ICE_RUBY_CATCH
     return Qnil;
@@ -414,10 +550,10 @@ IceRuby_Communicator_addObjectFactory(VALUE self, VALUE factory, VALUE id)
     ICE_RUBY_TRY
     {
         Ice::CommunicatorPtr p = getCommunicator(self);
-        ObjectFactoryPtr pof = ObjectFactoryPtr::dynamicCast(p->findObjectFactory(""));
-        assert(pof);
+        ValueFactoryManagerPtr vfm = ValueFactoryManagerPtr::dynamicCast(p->getValueFactoryManager());
+        assert(vfm);
         string idstr = getString(id);
-        pof->add(factory, idstr);
+        vfm->addObjectFactory(factory, idstr);
     }
     ICE_RUBY_CATCH
     return Qnil;
@@ -430,10 +566,25 @@ IceRuby_Communicator_findObjectFactory(VALUE self, VALUE id)
     ICE_RUBY_TRY
     {
         Ice::CommunicatorPtr p = getCommunicator(self);
-        ObjectFactoryPtr pof = ObjectFactoryPtr::dynamicCast(p->findObjectFactory(""));
-        assert(pof);
+        ValueFactoryManagerPtr vfm = ValueFactoryManagerPtr::dynamicCast(p->getValueFactoryManager());
+        assert(vfm);
         string idstr = getString(id);
-        return pof->find(idstr);
+        return vfm->findObjectFactory(idstr);
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+extern "C"
+VALUE
+IceRuby_Communicator_getValueFactoryManager(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::CommunicatorPtr p = getCommunicator(self);
+        ValueFactoryManagerPtr vfm = ValueFactoryManagerPtr::dynamicCast(p->getValueFactoryManager());
+        assert(vfm);
+        return vfm->getObject();
     }
     ICE_RUBY_CATCH
     return Qnil;
@@ -453,7 +604,6 @@ IceRuby_Communicator_getImplicitContext(VALUE self)
     return Qnil;
 }
 
-
 extern "C"
 VALUE
 IceRuby_Communicator_getProperties(VALUE self)
@@ -566,12 +716,22 @@ IceRuby_Communicator_setDefaultLocator(VALUE self, VALUE locator)
 
 extern "C"
 VALUE
-IceRuby_Communicator_flushBatchRequests(VALUE self)
+IceRuby_Communicator_flushBatchRequests(VALUE self, VALUE compress)
 {
     ICE_RUBY_TRY
     {
         Ice::CommunicatorPtr p = getCommunicator(self);
-        p->flushBatchRequests();
+
+        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);
     }
     ICE_RUBY_CATCH
     return Qnil;
@@ -581,13 +741,14 @@ void
 IceRuby::initCommunicator(VALUE iceModule)
 {
     rb_define_module_function(iceModule, "initialize", CAST_METHOD(IceRuby_initialize), -1);
-    rb_define_module_function(iceModule, "identityToString", CAST_METHOD(IceRuby_identityToString), 1);
+    rb_define_module_function(iceModule, "identityToString", CAST_METHOD(IceRuby_identityToString), -1);
     rb_define_module_function(iceModule, "stringToIdentity", CAST_METHOD(IceRuby_stringToIdentity), 1);
 
     _communicatorClass = rb_define_class_under(iceModule, "CommunicatorI", rb_cObject);
     rb_define_method(_communicatorClass, "destroy", CAST_METHOD(IceRuby_Communicator_destroy), 0);
     rb_define_method(_communicatorClass, "shutdown", CAST_METHOD(IceRuby_Communicator_shutdown), 0);
     rb_define_method(_communicatorClass, "isShutdown", CAST_METHOD(IceRuby_Communicator_isShutdown), 0);
+    rb_define_method(_communicatorClass, "waitForShutdown", CAST_METHOD(IceRuby_Communicator_waitForShutdown), 0);
     rb_define_method(_communicatorClass, "stringToProxy", CAST_METHOD(IceRuby_Communicator_stringToProxy), 1);
     rb_define_method(_communicatorClass, "proxyToString", CAST_METHOD(IceRuby_Communicator_proxyToString), 1);
     rb_define_method(_communicatorClass, "propertyToProxy", CAST_METHOD(IceRuby_Communicator_propertyToProxy), 1);
@@ -596,6 +757,7 @@ IceRuby::initCommunicator(VALUE iceModule)
     rb_define_method(_communicatorClass, "identityToString", CAST_METHOD(IceRuby_Communicator_identityToString), 1);
     rb_define_method(_communicatorClass, "addObjectFactory", CAST_METHOD(IceRuby_Communicator_addObjectFactory), 2);
     rb_define_method(_communicatorClass, "findObjectFactory", CAST_METHOD(IceRuby_Communicator_findObjectFactory), 1);
+    rb_define_method(_communicatorClass, "getValueFactoryManager", CAST_METHOD(IceRuby_Communicator_getValueFactoryManager), 0);
     rb_define_method(_communicatorClass, "getImplicitContext", CAST_METHOD(IceRuby_Communicator_getImplicitContext), 0);
     rb_define_method(_communicatorClass, "getProperties", CAST_METHOD(IceRuby_Communicator_getProperties), 0);
     rb_define_method(_communicatorClass, "getLogger", CAST_METHOD(IceRuby_Communicator_getLogger), 0);
@@ -603,7 +765,7 @@ IceRuby::initCommunicator(VALUE iceModule)
     rb_define_method(_communicatorClass, "setDefaultRouter", CAST_METHOD(IceRuby_Communicator_setDefaultRouter), 1);
     rb_define_method(_communicatorClass, "getDefaultLocator", CAST_METHOD(IceRuby_Communicator_getDefaultLocator), 0);
     rb_define_method(_communicatorClass, "setDefaultLocator", CAST_METHOD(IceRuby_Communicator_setDefaultLocator), 1);
-    rb_define_method(_communicatorClass, "flushBatchRequests", CAST_METHOD(IceRuby_Communicator_flushBatchRequests), 0);
+    rb_define_method(_communicatorClass, "flushBatchRequests", CAST_METHOD(IceRuby_Communicator_flushBatchRequests), 1);
 }
 
 Ice::CommunicatorPtr