zeroc-ice 3.6.5 → 3.7.4

data/ext/Endpoint.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// 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.
-//
-// **********************************************************************
 
 #ifndef ICE_RUBY_ENDPOINT_H
 #define ICE_RUBY_ENDPOINT_H

data/ext/ImplicitContext.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// 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 <ImplicitContext.h>
 #include <Util.h>
@@ -25,7 +20,6 @@ IceRuby_ImplicitContext_free(Ice::ImplicitContextPtr* p)
     delete p;
 }
 
-
 extern "C"
 VALUE
 IceRuby_ImplicitContext_getContext(VALUE self)
@@ -78,7 +72,6 @@ IceRuby_ImplicitContext_containsKey(VALUE self, VALUE key)
     return Qnil;
 }
 
-
 extern "C"
 VALUE
 IceRuby_ImplicitContext_get(VALUE self, VALUE key)
@@ -94,7 +87,6 @@ IceRuby_ImplicitContext_get(VALUE self, VALUE key)
     return Qnil;
 }
 
-
 extern "C"
 VALUE
 IceRuby_ImplicitContext_put(VALUE self, VALUE key, VALUE value)
@@ -124,7 +116,6 @@ IceRuby_ImplicitContext_remove(VALUE self, VALUE key)
     return Qnil;
 }
 
-
 void
 IceRuby::initImplicitContext(VALUE iceModule)
 {

data/ext/ImplicitContext.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// 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.
-//
-// **********************************************************************
 
 #ifndef ICE_RUBY_IMPLICIT_CONTEXT_H
 #define ICE_RUBY_IMPLICIT_CONTEXT_H

data/ext/Init.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// 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>
@@ -17,6 +12,8 @@
 #include <Types.h>
 #include <Connection.h>
 #include <Endpoint.h>
+#include <ValueFactoryManager.h>
+
 #include <Ice/RegisterPlugins.h>
 
 using namespace std;
@@ -46,6 +43,7 @@ ICE_DECLSPEC_EXPORT Init_IceRuby()
     initUtil(iceModule);
     initConnection(iceModule);
     initEndpoint(iceModule);
+    initValueFactoryManager(iceModule);
 }
 
 }

data/ext/Logger.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// 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 <Logger.h>
 #include <Util.h>

data/ext/Logger.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// 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.
-//
-// **********************************************************************
 
 #ifndef ICE_RUBY_LOGGER_H
 #define ICE_RUBY_LOGGER_H

data/ext/Operation.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// 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 <Operation.h>
 #include <Proxy.h>
@@ -69,9 +64,9 @@ private:
     bool _returnsClasses;
     string _deprecateMessage;
 
-    void convertParams(VALUE, ParamInfoList&, int, bool&);
-    ParamInfoPtr convertParam(VALUE, int);
-    void prepareRequest(const Ice::ObjectPrx&, VALUE, Ice::OutputStreamPtr&, pair<const Ice::Byte*, const Ice::Byte*>&);
+    void convertParams(VALUE, ParamInfoList&, long, bool&);
+    ParamInfoPtr convertParam(VALUE, long);
+    void prepareRequest(const Ice::ObjectPrx&, VALUE, Ice::OutputStream*, pair<const Ice::Byte*, const Ice::Byte*>&);
     VALUE unmarshalResults(const vector<Ice::Byte>&, const Ice::CommunicatorPtr&);
     VALUE unmarshalException(const vector<Ice::Byte>&, const Ice::CommunicatorPtr&);
     bool validateException(VALUE) const;
@@ -79,27 +74,18 @@ private:
 };
 typedef IceUtil::Handle<OperationI> OperationIPtr;
 
-class UserExceptionReaderFactoryI : public Ice::UserExceptionReaderFactory
+class UserExceptionFactory : public Ice::UserExceptionFactory
 {
 public:
 
-    UserExceptionReaderFactoryI(const Ice::CommunicatorPtr& communicator) :
-        _communicator(communicator)
-    {
-    }
-
-    virtual void createAndThrow(const string& id) const
+    virtual void createAndThrow(const string& id)
     {
         ExceptionInfoPtr info = lookupExceptionInfo(id);
         if(info)
         {
-            throw ExceptionReader(_communicator, info);
+            throw ExceptionReader(info);
         }
     }
-
-private:
-
-    const Ice::CommunicatorPtr _communicator;
 };
 
 }
@@ -299,9 +285,9 @@ IceRuby::OperationI::invoke(const Ice::ObjectPrx& proxy, VALUE args, VALUE hctx)
     //
     // Marshal the input parameters to a byte sequence.
     //
-    Ice::OutputStreamPtr os;
+    Ice::OutputStream os(communicator);
     pair<const Ice::Byte*, const Ice::Byte*> params;
-    prepareRequest(proxy, args, os, params);
+    prepareRequest(proxy, args, &os, params);
 
     if(!_deprecateMessage.empty())
     {
@@ -381,7 +367,7 @@ IceRuby::OperationI::deprecate(const string& msg)
 }
 
 void
-IceRuby::OperationI::convertParams(VALUE v, ParamInfoList& params, int posOffset, bool& usesClasses)
+IceRuby::OperationI::convertParams(VALUE v, ParamInfoList& params, long posOffset, bool& usesClasses)
 {
     assert(TYPE(v) == T_ARRAY);
 
@@ -397,19 +383,19 @@ IceRuby::OperationI::convertParams(VALUE v, ParamInfoList& params, int posOffset
 }
 
 ParamInfoPtr
-IceRuby::OperationI::convertParam(VALUE v, int pos)
+IceRuby::OperationI::convertParam(VALUE v, long pos)
 {
     assert(TYPE(v) == T_ARRAY);
     ParamInfoPtr param = new ParamInfo;
     param->type = getType(RARRAY_AREF(v, 0));
     param->optional = static_cast<bool>(RTEST(RARRAY_AREF(v, 1)));
     param->tag = static_cast<int>(getInteger(RARRAY_AREF(v, 2)));
-    param->pos = pos;
+    param->pos = static_cast<int>(pos);
     return param;
 }
 
 void
-IceRuby::OperationI::prepareRequest(const Ice::ObjectPrx& proxy, VALUE args, Ice::OutputStreamPtr& os,
+IceRuby::OperationI::prepareRequest(const Ice::ObjectPrx& proxy, VALUE args, Ice::OutputStream* os,
                                     pair<const Ice::Byte*, const Ice::Byte*>& params)
 {
     params.first = params.second = static_cast<const Ice::Byte*>(0);
@@ -430,7 +416,6 @@ IceRuby::OperationI::prepareRequest(const Ice::ObjectPrx& proxy, VALUE args, Ice
         //
         // Marshal the in parameters.
         //
-        os = Ice::createOutputStream(proxy->ice_getCommunicator());
         os->startEncapsulation(proxy->ice_getEncodingVersion(), _format);
 
         ObjectMap objectMap;
@@ -479,7 +464,7 @@ IceRuby::OperationI::prepareRequest(const Ice::ObjectPrx& proxy, VALUE args, Ice
 
         if(_sendsClasses)
         {
-            os->writePendingObjects();
+            os->writePendingValues();
         }
 
         os->endEncapsulation();
@@ -503,17 +488,17 @@ IceRuby::OperationI::unmarshalResults(const vector& bytes, const Ice:
     // Unmarshal the results. If there is more than one value to be returned, then return them
     // in a tuple of the form (result, outParam1, ...). Otherwise just return the value.
     //
-    Ice::InputStreamPtr is = Ice::wrapInputStream(communicator, bytes);
+    Ice::InputStream is(communicator, bytes);
 
     //
-    // Store a pointer to a local SlicedDataUtil object as the stream's closure.
+    // Store a pointer to a local StreamUtil object as the stream's closure.
     // This is necessary to support object unmarshaling (see ObjectReader).
     //
-    SlicedDataUtil util;
-    assert(!is->closure());
-    is->closure(&util);
+    StreamUtil util;
+    assert(!is.getClosure());
+    is.setClosure(&util);
 
-    is->startEncapsulation();
+    is.startEncapsulation();
 
     ParamInfoList::iterator p;
 
@@ -526,7 +511,7 @@ IceRuby::OperationI::unmarshalResults(const vector& bytes, const Ice:
         if(!info->optional)
         {
             void* closure = reinterpret_cast<void*>(info->pos);
-            info->type->unmarshal(is, info, results, closure, false);
+            info->type->unmarshal(&is, info, results, closure, false);
         }
     }
 
@@ -537,7 +522,7 @@ IceRuby::OperationI::unmarshalResults(const vector& bytes, const Ice:
     {
         assert(_returnType->pos == 0);
         void* closure = reinterpret_cast<void*>(_returnType->pos);
-        _returnType->type->unmarshal(is, _returnType, results, closure, false);
+        _returnType->type->unmarshal(&is, _returnType, results, closure, false);
     }
 
     //
@@ -546,10 +531,10 @@ IceRuby::OperationI::unmarshalResults(const vector& bytes, const Ice:
     for(p = _optionalOutParams.begin(); p != _optionalOutParams.end(); ++p)
     {
         ParamInfoPtr info = *p;
-        if(is->readOptional(info->tag, info->type->optionalFormat()))
+        if(is.readOptional(info->tag, info->type->optionalFormat()))
         {
             void* closure = reinterpret_cast<void*>(info->pos);
-            info->type->unmarshal(is, info, results, closure, true);
+            info->type->unmarshal(&is, info, results, closure, true);
         }
         else
         {
@@ -559,12 +544,12 @@ IceRuby::OperationI::unmarshalResults(const vector& bytes, const Ice:
 
     if(_returnsClasses)
     {
-        is->readPendingObjects();
+        is.readPendingValues();
     }
 
-    is->endEncapsulation();
+    is.endEncapsulation();
 
-    util.update();
+    util.updateSlicedData();
 
     return results;
 }
@@ -572,37 +557,37 @@ IceRuby::OperationI::unmarshalResults(const vector& bytes, const Ice:
 VALUE
 IceRuby::OperationI::unmarshalException(const vector<Ice::Byte>& bytes, const Ice::CommunicatorPtr& communicator)
 {
-    Ice::InputStreamPtr is = Ice::wrapInputStream(communicator, bytes);
+    Ice::InputStream is(communicator, bytes);
 
     //
-    // Store a pointer to a local SlicedDataUtil object as the stream's closure.
+    // Store a pointer to a local StreamUtil object as the stream's closure.
     // This is necessary to support object unmarshaling (see ObjectReader).
     //
-    SlicedDataUtil util;
-    assert(!is->closure());
-    is->closure(&util);
+    StreamUtil util;
+    assert(!is.getClosure());
+    is.setClosure(&util);
 
-    is->startEncapsulation();
+    is.startEncapsulation();
 
     try
     {
-        Ice::UserExceptionReaderFactoryPtr factory = new UserExceptionReaderFactoryI(communicator);
-        is->throwException(factory);
+        Ice::UserExceptionFactoryPtr factory = new UserExceptionFactory;
+        is.throwException(factory);
     }
     catch(const ExceptionReader& r)
     {
-        is->endEncapsulation();
+        is.endEncapsulation();
 
         volatile VALUE ex = r.getException();
 
         if(validateException(ex))
         {
-            util.update();
+            util.updateSlicedData();
 
             Ice::SlicedDataPtr slicedData = r.getSlicedData();
             if(slicedData)
             {
-                SlicedDataUtil::setMember(ex, slicedData);
+                StreamUtil::setSlicedDataMember(ex, slicedData);
             }
 
             return ex;
@@ -622,7 +607,6 @@ IceRuby::OperationI::unmarshalException(const vector& bytes, const Ic
 #ifdef __SUNPRO_CC
     return 0;
 #endif
-
 }
 
 bool

data/ext/Operation.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// 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.
-//
-// **********************************************************************
 
 #ifndef ICE_RUBY_OPERATION_H
 #define ICE_RUBY_OPERATION_H

data/ext/Properties.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// 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 <Properties.h>
 #include <Util.h>
@@ -27,7 +22,7 @@ IceRuby_Properties_free(Ice::PropertiesPtr* p)
 
 extern "C"
 VALUE
-IceRuby_createProperties(int argc, VALUE* argv, VALUE self)
+IceRuby_createProperties(int argc, VALUE* argv, VALUE /*self*/)
 {
     ICE_RUBY_TRY
     {
@@ -141,7 +136,7 @@ IceRuby_Properties_getPropertyAsIntWithDefault(VALUE self, VALUE key, VALUE def)
     {
         Ice::PropertiesPtr p = getProperties(self);
         string k = getString(key);
-        Ice::Int d = getInteger(def);
+        Ice::Int d = static_cast<Ice::Int>(getInteger(def));
         Ice::Int v = p->getPropertyAsIntWithDefault(k, d);
         return INT2FIX(v);
     }

data/ext/Properties.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// 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.
-//
-// **********************************************************************
 
 #ifndef ICE_RUBY_PROPERTIES_H
 #define ICE_RUBY_PROPERTIES_H

data/ext/Proxy.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// 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 <IceUtil/DisableWarnings.h>
 #include <Proxy.h>
@@ -13,6 +8,7 @@
 #include <Connection.h>
 #include <Endpoint.h>
 #include <Util.h>
+#include <Types.h>
 #include <Ice/LocalException.h>
 #include <Ice/Locator.h>
 #include <Ice/Proxy.h>
@@ -23,9 +19,7 @@ using namespace IceRuby;
 
 static VALUE _proxyClass;
 
-// **********************************************************************
 // ObjectPrx
-// **********************************************************************
 
 extern "C"
 void
@@ -49,9 +43,9 @@ IceRuby_ObjectPrx_free(Ice::ObjectPrx* p)
 }
 
 //
-// Returns true if a context was provided.
+// If a context was provided set it to ::Ice::noExplicitContext.
 //
-static bool
+static void
 checkArgs(const char* name, int numArgs, int argc, VALUE* argv, Ice::Context& ctx)
 {
     if(argc < numArgs || argc > numArgs + 1)
@@ -65,9 +59,11 @@ checkArgs(const char* name, int numArgs, int argc, VALUE* argv, Ice::Context& ct
         {
             throw RubyException(rb_eArgError, "%s: invalid context hash", name);
         }
-        return true;
     }
-    return false;
+    else
+    {
+        ctx = ::Ice::noExplicitContext;
+    }
 }
 
 extern "C"
@@ -77,7 +73,7 @@ IceRuby_ObjectPrx_hash(VALUE self)
     ICE_RUBY_TRY
     {
         Ice::ObjectPrx p = getProxy(self);
-        return INT2FIX(p->__hash());
+        return INT2FIX(p->_hash());
     }
     ICE_RUBY_CATCH
     return Qnil;
@@ -120,20 +116,10 @@ IceRuby_ObjectPrx_ice_isA(int argc, VALUE* argv, VALUE self)
         Ice::ObjectPrx p = getProxy(self);
 
         Ice::Context ctx;
-        bool haveContext = checkArgs("ice_isA", 1, argc, argv, ctx);
-
+        checkArgs("ice_isA", 1, argc, argv, ctx);
         string id = getString(argv[0]);
 
-        bool result;
-        if(haveContext)
-        {
-            result = p->ice_isA(id, ctx);
-        }
-        else
-        {
-            result = p->ice_isA(id);
-        }
-        return result ? Qtrue : Qfalse;
+        return p->ice_isA(id, ctx) ? Qtrue : Qfalse;
     }
     ICE_RUBY_CATCH
     return Qnil;
@@ -148,16 +134,8 @@ IceRuby_ObjectPrx_ice_ping(int argc, VALUE* argv, VALUE self)
         Ice::ObjectPrx p = getProxy(self);
 
         Ice::Context ctx;
-        bool haveContext = checkArgs("ice_ping", 0, argc, argv, ctx);
-
-        if(haveContext)
-        {
-            p->ice_ping(ctx);
-        }
-        else
-        {
-            p->ice_ping();
-        }
+        checkArgs("ice_ping", 0, argc, argv, ctx);
+        p->ice_ping(ctx);
     }
     ICE_RUBY_CATCH
     return Qnil;
@@ -172,19 +150,10 @@ IceRuby_ObjectPrx_ice_ids(int argc, VALUE* argv, VALUE self)
         Ice::ObjectPrx p = getProxy(self);
 
         Ice::Context ctx;
-        bool haveContext = checkArgs("ice_ids", 0, argc, argv, ctx);
-
-        vector<string> ids;
-        if(haveContext)
-        {
-            ids = p->ice_ids(ctx);
-        }
-        else
-        {
-            ids = p->ice_ids();
-        }
+        checkArgs("ice_ids", 0, argc, argv, ctx);
 
-        volatile VALUE result = createArray(ids.size());
+        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)
         {
@@ -206,18 +175,8 @@ IceRuby_ObjectPrx_ice_id(int argc, VALUE* argv, VALUE self)
         Ice::ObjectPrx p = getProxy(self);
 
         Ice::Context ctx;
-        bool haveContext = checkArgs("ice_id", 0, argc, argv, ctx);
-
-        string id;
-        if(haveContext)
-        {
-            id = p->ice_id(ctx);
-        }
-        else
-        {
-            id = p->ice_id();
-        }
-
+        checkArgs("ice_id", 0, argc, argv, ctx);
+        string id = p->ice_id(ctx);
         return createString(id);
     }
     ICE_RUBY_CATCH
@@ -348,7 +307,7 @@ IceRuby_ObjectPrx_ice_getEndpoints(VALUE self)
         Ice::ObjectPrx p = getProxy(self);
 
         Ice::EndpointSeq seq = p->ice_getEndpoints();
-        volatile VALUE result = createArray(seq.size());
+        volatile VALUE result = createArray(static_cast<long>(seq.size()));
         long i = 0;
         for(Ice::EndpointSeq::iterator q = seq.begin(); q != seq.end(); ++q, ++i)
         {
@@ -860,6 +819,27 @@ IceRuby_ObjectPrx_ice_compress(VALUE self, VALUE b)
     return Qnil;
 }
 
+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)
+        {
+            return *c ? Qtrue : Qfalse;
+        }
+        else
+        {
+            return Unset;
+        }
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
 extern "C"
 VALUE
 IceRuby_ObjectPrx_ice_timeout(VALUE self, VALUE t)
@@ -881,6 +861,27 @@ IceRuby_ObjectPrx_ice_timeout(VALUE self, VALUE t)
     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;
+        }
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
 extern "C"
 VALUE
 IceRuby_ObjectPrx_ice_connectionId(VALUE self, VALUE id)
@@ -895,6 +896,42 @@ IceRuby_ObjectPrx_ice_connectionId(VALUE self, VALUE id)
     return Qnil;
 }
 
+extern "C"
+VALUE
+IceRuby_ObjectPrx_ice_fixed(VALUE self, VALUE con)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::ObjectPrx p = getProxy(self);
+
+        Ice::ConnectionPtr connection;
+        if(!NIL_P(con))
+        {
+            if(!checkConnection(con))
+            {
+                throw RubyException(rb_eTypeError, "argument must be an Ice.Connection");
+            }
+            connection = getConnection(con);
+        }
+        return createProxy(p->ice_fixed(connection), rb_class_of(self));
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+extern "C"
+VALUE
+IceRuby_ObjectPrx_ice_isFixed(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::ObjectPrx p = getProxy(self);
+        return p->ice_isFixed() ? Qtrue : Qfalse;
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
 extern "C"
 VALUE
 IceRuby_ObjectPrx_ice_getConnection(VALUE self)
@@ -1026,7 +1063,7 @@ checkedCastImpl(const Ice::ObjectPrx& p, const string& id, VALUE facet, VALUE ct
 
 extern "C"
 VALUE
-IceRuby_ObjectPrx_checkedCast(int argc, VALUE* args, VALUE self)
+IceRuby_ObjectPrx_checkedCast(int argc, VALUE* args, VALUE /*self*/)
 {
     //
     // ice_checkedCast is called from generated code, therefore we always expect
@@ -1092,7 +1129,7 @@ IceRuby_ObjectPrx_checkedCast(int argc, VALUE* args, VALUE self)
 
 extern "C"
 VALUE
-IceRuby_ObjectPrx_uncheckedCast(int argc, VALUE* args, VALUE self)
+IceRuby_ObjectPrx_uncheckedCast(int argc, VALUE* args, VALUE /*self*/)
 {
     ICE_RUBY_TRY
     {
@@ -1134,7 +1171,7 @@ IceRuby_ObjectPrx_uncheckedCast(int argc, VALUE* args, VALUE self)
 
 extern "C"
 VALUE
-IceRuby_ObjectPrx_ice_checkedCast(VALUE self, VALUE obj, VALUE id, VALUE facetOrCtx, VALUE ctx)
+IceRuby_ObjectPrx_ice_checkedCast(VALUE self, VALUE obj, VALUE id, VALUE facetOrContext, VALUE ctx)
 {
     //
     // ice_checkedCast is called from generated code, therefore we always expect
@@ -1157,19 +1194,19 @@ IceRuby_ObjectPrx_ice_checkedCast(VALUE self, VALUE obj, VALUE id, VALUE facetOr
         string idstr = getString(id);
 
         volatile VALUE facet = Qnil;
-        if(isString(facetOrCtx))
+        if(isString(facetOrContext))
         {
-            facet = facetOrCtx;
+            facet = facetOrContext;
         }
-        else if(isHash(facetOrCtx))
+        else if(isHash(facetOrContext))
         {
             if(!NIL_P(ctx))
             {
                 throw RubyException(rb_eArgError, "facet argument to checkedCast must be a string");
             }
-            ctx = facetOrCtx;
+            ctx = facetOrContext;
         }
-        else if(!NIL_P(facetOrCtx))
+        else if(!NIL_P(facetOrContext))
         {
             throw RubyException(rb_eArgError, "second argument to checkedCast must be a facet or context");
         }
@@ -1218,7 +1255,7 @@ IceRuby_ObjectPrx_ice_uncheckedCast(VALUE self, VALUE obj, VALUE facet)
 
 extern "C"
 VALUE
-IceRuby_ObjectPrx_ice_staticId(VALUE self)
+IceRuby_ObjectPrx_ice_staticId(VALUE /*self*/)
 {
     ICE_RUBY_TRY
     {
@@ -1230,7 +1267,7 @@ IceRuby_ObjectPrx_ice_staticId(VALUE self)
 
 extern "C"
 VALUE
-IceRuby_ObjectPrx_new(int /*argc*/, VALUE* /*args*/, VALUE self)
+IceRuby_ObjectPrx_new(int /*argc*/, VALUE* /*args*/, VALUE /*self*/)
 {
     ICE_RUBY_TRY
     {
@@ -1300,8 +1337,12 @@ IceRuby::initProxy(VALUE iceModule)
     rb_define_method(_proxyClass, "ice_batchDatagram", CAST_METHOD(IceRuby_ObjectPrx_ice_batchDatagram), 0);
     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);
     rb_define_method(_proxyClass, "ice_getConnection", CAST_METHOD(IceRuby_ObjectPrx_ice_getConnection), 0);
     rb_define_method(_proxyClass, "ice_getCachedConnection", CAST_METHOD(IceRuby_ObjectPrx_ice_getCachedConnection), 0);
     rb_define_method(_proxyClass, "ice_flushBatchRequests", CAST_METHOD(IceRuby_ObjectPrx_ice_flushBatchRequests), 0);