zeroc-ice 3.6.5 → 3.7.0

data/ext/Types.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.
@@ -12,7 +12,9 @@
 
 #include <Config.h>
 #include <Util.h>
-#include <Ice/Stream.h>
+#include <Ice/FactoryTable.h>
+#include <Ice/Object.h>
+#include <Ice/SlicedData.h>
 #include <IceUtil/OutputUtil.h>
 
 namespace IceRuby
@@ -24,7 +26,10 @@ typedef std::vector<ExceptionInfoPtr> ExceptionInfoList;
 
 class ClassInfo;
 typedef IceUtil::Handle<ClassInfo> ClassInfoPtr;
-typedef std::vector<ClassInfoPtr> ClassInfoList;
+
+class ProxyInfo;
+typedef IceUtil::Handle<ProxyInfo> ProxyInfoPtr;
+typedef std::vector<ProxyInfoPtr> ProxyInfoList;
 
 //
 // This class is raised as an exception when object marshaling needs to be aborted.
@@ -40,31 +45,6 @@ typedef std::map<VALUE, Ice::ObjectPtr> ObjectMap;
 class ObjectReader;
 typedef IceUtil::Handle<ObjectReader> ObjectReaderPtr;
 
-//
-// This class keeps track of Ruby objects (instances of Slice classes
-// and exceptions) that have preserved slices.
-//
-class SlicedDataUtil
-{
-public:
-
-    SlicedDataUtil();
-    ~SlicedDataUtil();
-
-    void add(const ObjectReaderPtr&);
-
-    void update();
-
-    static void setMember(VALUE, const Ice::SlicedDataPtr&);
-    static Ice::SlicedDataPtr getMember(VALUE, ObjectMap*);
-
-private:
-
-    std::set<ObjectReaderPtr> _readers;
-    static VALUE _slicedDataType;
-    static VALUE _sliceInfoType;
-};
-
 struct PrintObjectHistory
 {
     int index;
@@ -94,6 +74,64 @@ public:
 };
 typedef IceUtil::Handle<UnmarshalCallback> UnmarshalCallbackPtr;
 
+//
+// ReadObjectCallback retains all of the information necessary to store an unmarshaled
+// Slice value as a Ruby object.
+//
+class ReadObjectCallback : public IceUtil::Shared
+{
+public:
+
+    ReadObjectCallback(const ClassInfoPtr&, const UnmarshalCallbackPtr&, VALUE, void*);
+
+    void invoke(const ::Ice::ObjectPtr&);
+
+private:
+
+    ClassInfoPtr _info;
+    UnmarshalCallbackPtr _cb;
+    VALUE _target;
+    void* _closure;
+};
+typedef IceUtil::Handle<ReadObjectCallback> ReadObjectCallbackPtr;
+
+//
+// This class assists during unmarshaling of Slice classes and exceptions.
+// We attach an instance to a stream.
+//
+class StreamUtil
+{
+public:
+
+    StreamUtil();
+    ~StreamUtil();
+
+    //
+    // Keep a reference to a ReadObjectCallback for patching purposes.
+    //
+    void add(const ReadObjectCallbackPtr&);
+
+    //
+    // Keep track of object instances that have preserved slices.
+    //
+    void add(const ObjectReaderPtr&);
+
+    //
+    // Updated the sliced data information for all stored object instances.
+    //
+    void updateSlicedData();
+
+    static void setSlicedDataMember(VALUE, const Ice::SlicedDataPtr&);
+    static Ice::SlicedDataPtr getSlicedDataMember(VALUE, ObjectMap*);
+
+private:
+
+    std::vector<ReadObjectCallbackPtr> _callbacks;
+    std::set<ObjectReaderPtr> _readers;
+    static VALUE _slicedDataType;
+    static VALUE _sliceInfoType;
+};
+
 //
 // Base class for type information.
 //
@@ -125,8 +163,8 @@ public:
     // The marshal and unmarshal functions can raise Ice exceptions, and may raise
     // AbortMarshaling if an error occurs.
     //
-    virtual void marshal(VALUE, const Ice::OutputStreamPtr&, ObjectMap*, bool) = 0;
-    virtual void unmarshal(const Ice::InputStreamPtr&, const UnmarshalCallbackPtr&, VALUE, void*, bool) = 0;
+    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool) = 0;
+    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool) = 0;
 
     virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*) = 0;
 };
@@ -162,8 +200,8 @@ public:
     virtual int wireSize() const;
     virtual Ice::OptionalFormat optionalFormat() const;
 
-    virtual void marshal(VALUE, const Ice::OutputStreamPtr&, ObjectMap*, bool);
-    virtual void unmarshal(const Ice::InputStreamPtr&, const UnmarshalCallbackPtr&, VALUE, void*, bool);
+    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
+    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
 
     virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
 
@@ -192,8 +230,8 @@ public:
     virtual int wireSize() const;
     virtual Ice::OptionalFormat optionalFormat() const;
 
-    virtual void marshal(VALUE, const Ice::OutputStreamPtr&, ObjectMap*, bool);
-    virtual void unmarshal(const Ice::InputStreamPtr&, const UnmarshalCallbackPtr&, VALUE, void*, bool);
+    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
+    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
 
     virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
 
@@ -238,8 +276,8 @@ public:
 
     virtual bool usesClasses() const; // Default implementation returns false.
 
-    virtual void marshal(VALUE, const Ice::OutputStreamPtr&, ObjectMap*, bool);
-    virtual void unmarshal(const Ice::InputStreamPtr&, const UnmarshalCallbackPtr&, VALUE, void*, bool);
+    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
+    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
 
     virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
 
@@ -276,8 +314,8 @@ public:
 
     virtual bool usesClasses() const; // Default implementation returns false.
 
-    virtual void marshal(VALUE, const Ice::OutputStreamPtr&, ObjectMap*, bool);
-    virtual void unmarshal(const Ice::InputStreamPtr&, const UnmarshalCallbackPtr&, VALUE, void*, bool);
+    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
+    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
     virtual void unmarshaled(VALUE, VALUE, void*);
 
     virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
@@ -289,8 +327,8 @@ public:
 
 private:
 
-    void marshalPrimitiveSequence(const PrimitiveInfoPtr&, VALUE, const Ice::OutputStreamPtr&);
-    void unmarshalPrimitiveSequence(const PrimitiveInfoPtr&, const Ice::InputStreamPtr&, const UnmarshalCallbackPtr&,
+    void marshalPrimitiveSequence(const PrimitiveInfoPtr&, VALUE, Ice::OutputStream*);
+    void unmarshalPrimitiveSequence(const PrimitiveInfoPtr&, Ice::InputStream*, const UnmarshalCallbackPtr&,
                                     VALUE, void*);
 };
 typedef IceUtil::Handle<SequenceInfo> SequenceInfoPtr;
@@ -314,9 +352,9 @@ public:
 
     virtual bool usesClasses() const; // Default implementation returns false.
 
-    virtual void marshal(VALUE, const Ice::OutputStreamPtr&, ObjectMap*, bool);
-    virtual void unmarshal(const Ice::InputStreamPtr&, const UnmarshalCallbackPtr&, VALUE, void*, bool);
-    void marshalElement(VALUE, VALUE, const Ice::OutputStreamPtr&, ObjectMap*);
+    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
+    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
+    void marshalElement(VALUE, VALUE, Ice::OutputStream*, ObjectMap*);
     virtual void unmarshaled(VALUE, VALUE, void*);
 
     virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
@@ -353,7 +391,7 @@ public:
 
     ClassInfo(VALUE, bool);
 
-    void define(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
+    void define(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
 
     virtual std::string getId() const;
 
@@ -365,8 +403,8 @@ public:
 
     virtual bool usesClasses() const; // Default implementation returns false.
 
-    virtual void marshal(VALUE, const Ice::OutputStreamPtr&, ObjectMap*, bool);
-    virtual void unmarshal(const Ice::InputStreamPtr&, const UnmarshalCallbackPtr&, VALUE, void*, bool);
+    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
+    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
 
     virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
 
@@ -380,10 +418,9 @@ public:
     const Ice::Int compactId;
     const bool isBase; // Is this the ClassInfo for Ice::Object or Ice::LocalObject?
     const bool isLocal;
-    const bool isAbstract;
     const bool preserve;
+    const bool interface;
     const ClassInfoPtr base;
-    const ClassInfoList interfaces;
     const DataMemberList members;
     const DataMemberList optionalMembers;
     const VALUE rubyClass;
@@ -400,7 +437,7 @@ public:
 
     ProxyInfo(VALUE);
 
-    void define(VALUE, VALUE);
+    void define(VALUE, VALUE, VALUE);
 
     virtual std::string getId() const;
 
@@ -410,19 +447,22 @@ public:
     virtual int wireSize() const;
     virtual Ice::OptionalFormat optionalFormat() const;
 
-    virtual void marshal(VALUE, const Ice::OutputStreamPtr&, ObjectMap*, bool);
-    virtual void unmarshal(const Ice::InputStreamPtr&, const UnmarshalCallbackPtr&, VALUE, void*, bool);
+    virtual void marshal(VALUE, Ice::OutputStream*, ObjectMap*, bool);
+    virtual void unmarshal(Ice::InputStream*, const UnmarshalCallbackPtr&, VALUE, void*, bool);
 
     virtual void print(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
 
     virtual void destroy();
 
+    bool isA(const ProxyInfoPtr&);
+
     const std::string id;
+    const bool isBase; // Is this the ClassInfo for Ice::ObjectPrx?
+    const ProxyInfoPtr base;
+    const ProxyInfoList interfaces;
     const VALUE rubyClass;
-    const ClassInfoPtr classInfo;
     const VALUE typeObj;
 };
-typedef IceUtil::Handle<ProxyInfo> ProxyInfoPtr;
 
 //
 // Exception information.
@@ -431,7 +471,7 @@ class ExceptionInfo : public IceUtil::Shared
 {
 public:
 
-    VALUE unmarshal(const Ice::InputStreamPtr&);
+    VALUE unmarshal(Ice::InputStream*);
 
     void print(VALUE, IceUtilInternal::Output&);
     void printMembers(VALUE, IceUtilInternal::Output&, PrintObjectHistory*);
@@ -448,30 +488,32 @@ public:
 //
 // ObjectWriter wraps a Ruby object for marshaling.
 //
-class ObjectWriter : public Ice::ObjectWriter
+class ObjectWriter : public Ice::Object
 {
 public:
 
-    ObjectWriter(VALUE, ObjectMap*);
+    ObjectWriter(VALUE, ObjectMap*, const ClassInfoPtr&);
     virtual ~ObjectWriter();
 
     virtual void ice_preMarshal();
 
-    virtual void write(const Ice::OutputStreamPtr&) const;
+    virtual void _iceWrite(Ice::OutputStream*) const;
+    virtual void _iceRead(Ice::InputStream*);
 
 private:
 
-    void writeMembers(const Ice::OutputStreamPtr&, const DataMemberList&) const;
+    void writeMembers(Ice::OutputStream*, const DataMemberList&) const;
 
     VALUE _object;
     ObjectMap* _map;
     ClassInfoPtr _info;
+    ClassInfoPtr _formal;
 };
 
 //
 // ObjectReader unmarshals the state of an Ice object.
 //
-class ObjectReader : public Ice::ObjectReader
+class ObjectReader : public Ice::Object
 {
 public:
 
@@ -480,7 +522,8 @@ public:
 
     virtual void ice_postUnmarshal();
 
-    virtual void read(const Ice::InputStreamPtr&);
+    virtual void _iceWrite(Ice::OutputStream*) const;
+    virtual void _iceRead(Ice::InputStream*);
 
     virtual ClassInfoPtr getInfo() const;
 
@@ -498,24 +541,33 @@ private:
 //
 // ExceptionReader creates a Ruby user exception and unmarshals it.
 //
-class ExceptionReader : public Ice::UserExceptionReader
+class ExceptionReader : public Ice::UserException
 {
 public:
 
-    ExceptionReader(const Ice::CommunicatorPtr&, const ExceptionInfoPtr&);
+    ExceptionReader(const ExceptionInfoPtr&);
     ~ExceptionReader() throw();
 
-    virtual void read(const Ice::InputStreamPtr&) const;
-    virtual bool usesClasses() const;
-
-    virtual std::string ice_name() const;
+    virtual std::string ice_id() const;
+#ifndef ICE_CPP11_MAPPING
     virtual Ice::UserException* ice_clone() const;
+#endif
     virtual void ice_throw() const;
 
+    virtual void _write(Ice::OutputStream*) const;
+    virtual void _read(Ice::InputStream*);
+
+    virtual bool _usesClasses() const;
+
     VALUE getException() const;
 
     Ice::SlicedDataPtr getSlicedData() const;
 
+protected:
+
+    virtual void _writeImpl(Ice::OutputStream*) const {}
+    virtual void _readImpl(Ice::InputStream*) {}
+
 private:
 
     ExceptionInfoPtr _info;

data/ext/Util.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.
@@ -311,7 +311,7 @@ IceRuby::createString(const string& str)
 namespace
 {
 
-template <typename T> 
+template <typename T>
 struct RubyCallArgs
 {
     volatile VALUE val;
@@ -442,8 +442,8 @@ IceRuby::contextToHash(const Ice::Context& ctx)
     volatile VALUE result = callRuby(rb_hash_new);
     for(Ice::Context::const_iterator p = ctx.begin(); p != ctx.end(); ++p)
     {
-        volatile VALUE key = callRuby(rb_str_new, p->first.c_str(), static_cast<long>(p->first.size()));
-        volatile VALUE value = callRuby(rb_str_new, p->second.c_str(), static_cast<long>(p->second.size()));
+        volatile VALUE key = createString(p->first);
+        volatile VALUE value = createString(p->second);
         callRuby(rb_hash_aset, result, key, value);
     }
     return result;
@@ -522,8 +522,8 @@ IceRuby::createIdentity(const Ice::Identity& id)
     assert(!NIL_P(cls));
 
     volatile VALUE result = callRuby(rb_class_new_instance, 0, reinterpret_cast<VALUE*>(0), cls);
-    volatile VALUE name = callRuby(rb_str_new, id.name.c_str(), static_cast<long>(id.name.size()));
-    volatile VALUE category = callRuby(rb_str_new, id.category.c_str(), static_cast<long>(id.category.size()));
+    volatile VALUE name = createString(id.name);
+    volatile VALUE category = createString(id.category);
     callRuby(rb_iv_set, result, "@name", name);
     callRuby(rb_iv_set, result, "@category", category);
     return result;
@@ -699,7 +699,7 @@ setExceptionMembers(const Ice::LocalException& ex, VALUE p)
         m = createEncodingVersion(e.supported);
         callRuby(rb_iv_set, p, "@supported", m);
     }
-    catch(const Ice::NoObjectFactoryException& e)
+    catch(const Ice::NoValueFactoryException& e)
     {
         volatile VALUE v;
         v = createString(e.reason);
@@ -732,6 +732,10 @@ setExceptionMembers(const Ice::LocalException& ex, VALUE p)
         volatile VALUE v = createString(e.reason);
         callRuby(rb_iv_set, p, "@reason", v);
     }
+    catch(const Ice::ConnectionManuallyClosedException& e)
+    {
+        callRuby(rb_iv_set, p, "@graceful", e.graceful ? Qtrue : Qfalse);
+    }
     catch(const Ice::LocalException&)
     {
         //
@@ -761,7 +765,7 @@ IceRuby::convertLocalException(const Ice::LocalException& ex)
     //
     try
     {
-        string name = ex.ice_name();
+        string name = ex.ice_id().substr(2);
         volatile VALUE cls = callRuby(rb_path2class, name.c_str());
         if(NIL_P(cls))
         {
@@ -777,7 +781,7 @@ IceRuby::convertLocalException(const Ice::LocalException& ex)
     }
     catch(...)
     {
-        string msg = "failure occurred while converting exception " + ex.ice_name();
+        string msg = "failure occurred while converting exception " + ex.ice_id();
         return rb_exc_new2(rb_eRuntimeError, msg.c_str());
     }
 }

data/ext/Util.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.
@@ -467,19 +467,19 @@ VALUE convertLocalException(const Ice::LocalException&);
 // exceptions into Ruby exceptions and ensure that C++ objects are cleaned up properly.
 //
 #define ICE_RUBY_TRY \
-    volatile VALUE __ice_ex = Qnil; \
+    volatile VALUE ex_ = Qnil; \
     \
-    goto __ice_start; \
+    goto ice_start; \
     \
-    __ice_handle_exception: \
-        rb_exc_raise(__ice_ex); \
+    ice_handle_exception: \
+        rb_exc_raise(ex_); \
     \
-    __ice_start: \
+    ice_start: \
     try
 
 #define ICE_RUBY_RETHROW(ex) \
-    __ice_ex = ex; \
-    goto __ice_handle_exception;
+    ex_ = ex; \
+    goto ice_handle_exception;
 
 #define ICE_RUBY_CATCH \
     catch(const ::IceRuby::RubyException& ex) \
@@ -492,8 +492,8 @@ VALUE convertLocalException(const Ice::LocalException&);
     } \
     catch(const ::Ice::Exception& ex) \
     { \
-        string __ice_msg = "unknown Ice exception: " + ex.ice_name(); \
-        ICE_RUBY_RETHROW(rb_exc_new2(rb_eRuntimeError, __ice_msg.c_str())); \
+        string msg_ = "unknown Ice exception: " + ex.ice_id(); \
+        ICE_RUBY_RETHROW(rb_exc_new2(rb_eRuntimeError, msg_.c_str())); \
     } \
     catch(const std::bad_alloc& ex) \
     { \