zeroc-ice 3.6.5 → 3.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b3351774d1fc4a049f9ebf75d9ed941294c7e3f5
-  data.tar.gz: 79e26cd9998bd1c6b6972ff790ad5f33e5e48194
+  metadata.gz: 93920645e2f018c3dde695ab7e7857aff1ce8253
+  data.tar.gz: b525f62af73aa729b8f44467b708bf65cabb9fb4
 SHA512:
-  metadata.gz: 9a8dda80e3b032afa62535039d09197c98440bda53f9a99fcff655dff7c5352ac4fca343076e1eb65b71c1daf3aadee64b3b80ad5245a43f6ea4f35ea0dc8be9
-  data.tar.gz: a6622f0699de26d18c283662cbc74a91b0cd56e513dd7c3ff4353e162ade338e825d5f036c2f3fbdb29941da07b7d5156e4ff30efff53e24ae9e3919795aab2a
+  metadata.gz: b0d76be8430a9956ec88239efa35a1e2d7c22f6c46fc07c524e712a0cc34d853c6086461220531239c071c85e55cc66aa47905ee5ade2ef596954c8b4c4969e6
+  data.tar.gz: c8890aa3f0aed7994d20a2e410ec903d58c86bc62c4b74f24c9eb2db58fa8b83d983b4cd7fd5d87889af94e1adc09c064a740597af6c897f54ec44e7e2ae2b8f

data/BZIP2_LICENSE

@@ -0,0 +1,42 @@
+
+--------------------------------------------------------------------------
+
+This program, "bzip2", the associated library "libbzip2", and all
+documentation, are copyright (C) 1996-2010 Julian R Seward.  All
+rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. The origin of this software must not be misrepresented; you must 
+   not claim that you wrote the original software.  If you use this 
+   software in a product, an acknowledgment in the product 
+   documentation would be appreciated but is not required.
+
+3. Altered source versions must be plainly marked as such, and must
+   not be misrepresented as being the original software.
+
+4. The name of the author may not be used to endorse or promote 
+   products derived from this software without specific prior written 
+   permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Julian Seward, jseward@bzip.org
+bzip2/libbzip2 version 1.0.6 of 6 September 2010
+
+--------------------------------------------------------------------------

data/ICE_LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+Copyright (c) 2003-2017 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,7 +1,7 @@
 #!/usr/bin/env ruby
 # **********************************************************************
 #
-# Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+# Copyright (c) 2003-2017 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.

data/ext/Communicator.cpp

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -10,11 +10,12 @@
 #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 +38,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&)
     {
@@ -61,9 +62,26 @@ 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)
+        //
+
+        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 +91,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)
+            {
+                if(!NIL_P(configFile))
+                {
+                    throw RubyException(rb_eTypeError, "unexpected string argument to initialize");
+                }
+                configFile = argv[1];
+            }
+            else
             {
-                throw RubyException(rb_eTypeError, "invalid argument to Ice::initialize");
+                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 +147,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 +172,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 +205,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 +214,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 +235,7 @@ IceRuby_initialize(int argc, VALUE* argv, VALUE self)
 
             throw;
         }
-        
+
         //
         // Replace the contents of the given argument list with the filtered arguments.
         //
@@ -205,9 +259,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));
 
@@ -240,12 +291,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 +321,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;
 }
 
@@ -371,7 +443,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 +486,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 +502,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 +540,6 @@ IceRuby_Communicator_getImplicitContext(VALUE self)
     return Qnil;
 }
 
-
 extern "C"
 VALUE
 IceRuby_Communicator_getProperties(VALUE self)
@@ -566,12 +652,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,7 +677,7 @@ 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);
@@ -596,6 +692,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 +700,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