zeroc-ice 3.6.5 → 3.7.0

data/ext/Endpoint.h

@@ -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.

data/ext/ImplicitContext.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.
@@ -25,7 +25,6 @@ IceRuby_ImplicitContext_free(Ice::ImplicitContextPtr* p)
     delete p;
 }
 
-
 extern "C"
 VALUE
 IceRuby_ImplicitContext_getContext(VALUE self)
@@ -78,7 +77,6 @@ IceRuby_ImplicitContext_containsKey(VALUE self, VALUE key)
     return Qnil;
 }
 
-
 extern "C"
 VALUE
 IceRuby_ImplicitContext_get(VALUE self, VALUE key)
@@ -94,7 +92,6 @@ IceRuby_ImplicitContext_get(VALUE self, VALUE key)
     return Qnil;
 }
 
-
 extern "C"
 VALUE
 IceRuby_ImplicitContext_put(VALUE self, VALUE key, VALUE value)
@@ -124,7 +121,6 @@ IceRuby_ImplicitContext_remove(VALUE self, VALUE key)
     return Qnil;
 }
 
-
 void
 IceRuby::initImplicitContext(VALUE iceModule)
 {

data/ext/ImplicitContext.h

@@ -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.

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

data/ext/Logger.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.

data/ext/Logger.h

@@ -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.

data/ext/Operation.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.
@@ -71,7 +71,7 @@ private:
 
     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 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 +79,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 +290,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())
     {
@@ -409,7 +400,7 @@ IceRuby::OperationI::convertParam(VALUE v, int pos)
 }
 
 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 +421,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 +469,7 @@ IceRuby::OperationI::prepareRequest(const Ice::ObjectPrx& proxy, VALUE args, Ice
 
         if(_sendsClasses)
         {
-            os->writePendingObjects();
+            os->writePendingValues();
         }
 
         os->endEncapsulation();
@@ -503,17 +493,17 @@ IceRuby::OperationI::unmarshalResults(const vector<Ice::Byte>& 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 +516,7 @@ IceRuby::OperationI::unmarshalResults(const vector<Ice::Byte>& 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 +527,7 @@ IceRuby::OperationI::unmarshalResults(const vector<Ice::Byte>& 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 +536,10 @@ IceRuby::OperationI::unmarshalResults(const vector<Ice::Byte>& 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 +549,12 @@ IceRuby::OperationI::unmarshalResults(const vector<Ice::Byte>& bytes, const Ice:
 
     if(_returnsClasses)
     {
-        is->readPendingObjects();
+        is.readPendingValues();
     }
 
-    is->endEncapsulation();
+    is.endEncapsulation();
 
-    util.update();
+    util.updateSlicedData();
 
     return results;
 }
@@ -572,37 +562,37 @@ IceRuby::OperationI::unmarshalResults(const vector<Ice::Byte>& 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 +612,6 @@ IceRuby::OperationI::unmarshalException(const vector<Ice::Byte>& bytes, const Ic
 #ifdef __SUNPRO_CC
     return 0;
 #endif
-
 }
 
 bool

data/ext/Operation.h

@@ -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.

data/ext/Properties.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.

data/ext/Properties.h

@@ -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.

data/ext/Proxy.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.
@@ -49,9 +49,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 +65,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 +79,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 +122,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 +140,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,18 +156,9 @@ 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);
 
+        vector<string> ids = p->ice_ids(ctx);
         volatile VALUE result = createArray(ids.size());
         long i = 0;
         for(vector<string>::iterator q = ids.begin(); q != ids.end(); ++q, ++i)
@@ -206,18 +181,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
@@ -1134,7 +1099,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 +1122,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");
         }