zeroc-ice 3.6.5 → 3.7.4

data/ext/Util.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_UTIL_H
 #define ICE_RUBY_UTIL_H
@@ -13,6 +8,14 @@
 #include <Config.h>
 #include <Ice/Ice.h>
 
+//
+// Avoid clang conversion warnings in "callRuby" calls
+//
+#if defined(__clang__)
+#   pragma clang diagnostic ignored "-Wconversion"
+#   pragma clang diagnostic ignored "-Wsign-conversion"
+#endif
+
 namespace IceRuby
 {
 
@@ -90,6 +93,12 @@ bool arrayToStringSeq(VALUE, std::vector&);
 //
 VALUE stringSeqToArray(const std::vector<std::string>&);
 
+//
+// Convert a vector of Ice::Byte into a Ruby array of numbers.
+// May raise RubyException.
+//
+VALUE createNumSeq(const std::vector<Ice::Byte>&);
+
 //
 // Convert a Ruby hash to Ice::Context. Returns true on success
 // and false if the value is not a hash. May raise RubyException.
@@ -166,6 +175,9 @@ VALUE callRuby(Fun fun, T1 t1, T2 t2, T3 t3);
 template<typename Fun, typename T1, typename T2, typename T3, typename T4>
 VALUE callRuby(Fun fun, T1 t1, T2 t2, T3 t3, T4 t4);
 
+template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+VALUE callRuby(Fun fun, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6);
+
 extern "C" typedef VALUE (*RubyFunction)(VALUE);
 
 VALUE callProtected(RubyFunction, VALUE);
@@ -177,7 +189,10 @@ public:
 
     RF_0(Fun f) : _f(f) {}
     inline VALUE operator()() { return _f(); }
-    static inline VALUE call(RF_0* f) { return (*f)(); }
+    static inline VALUE call(VALUE f)
+    {
+        return (*reinterpret_cast<RF_0*>(f))();
+    }
 
 private:
 
@@ -189,7 +204,7 @@ inline VALUE callRuby(Fun fun)
 {
     typedef RF_0<Fun> RF;
     RF f(fun);
-    return callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
+    return callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
 template<typename Fun, typename T1>
@@ -199,7 +214,10 @@ public:
 
     RF_1(Fun f, T1 t1) : _f(f), _t1(t1) {}
     inline VALUE operator()() { return _f(_t1); }
-    static inline VALUE call(RF_1* f) { return (*f)(); }
+    static inline VALUE call(VALUE f)
+    {
+        return (*reinterpret_cast<RF_1*>(f))();
+    }
 
 private:
 
@@ -212,7 +230,7 @@ inline VALUE callRuby(Fun fun, T1 t1)
 {
     typedef RF_1<Fun, T1> RF;
     RF f(fun, t1);
-    return callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
+    return callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
 template<typename Fun, typename T1, typename T2>
@@ -221,8 +239,11 @@ class RF_2
 public:
 
     RF_2(Fun f, T1 t1, T2 t2) : _f(f), _t1(t1), _t2(t2) {}
-    inline VALUE operator()() { return _f(_t1, _t2); }
-    static inline VALUE call(RF_2* f) { return (*f)(); }
+    inline VALUE operator()(){ return _f(_t1, _t2); }
+    static inline VALUE call(VALUE f)
+    {
+        return (*reinterpret_cast<RF_2*>(f))();
+    }
 
 private:
 
@@ -236,7 +257,7 @@ inline VALUE callRuby(Fun fun, T1 t1, T2 t2)
 {
     typedef RF_2<Fun, T1, T2> RF;
     RF f(fun, t1, t2);
-    return callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
+    return callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
 template<typename Fun, typename T1, typename T2, typename T3>
@@ -246,7 +267,10 @@ public:
 
     RF_3(Fun f, T1 t1, T2 t2, T3 t3) : _f(f), _t1(t1), _t2(t2), _t3(t3) {}
     inline VALUE operator()() { return _f(_t1, _t2, _t3); }
-    static inline VALUE call(RF_3* f) { return (*f)(); }
+    static inline VALUE call(VALUE f)
+    {
+        return (*reinterpret_cast<RF_3*>(f))();
+    }
 
 private:
 
@@ -261,7 +285,7 @@ inline VALUE callRuby(Fun fun, T1 t1, T2 t2, T3 t3)
 {
     typedef RF_3<Fun, T1, T2, T3> RF;
     RF f(fun, t1, t2, t3);
-    return callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
+    return callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
 template<typename Fun, typename T1, typename T2, typename T3, typename T4>
@@ -271,7 +295,10 @@ public:
 
     RF_4(Fun f, T1 t1, T2 t2, T3 t3, T4 t4) : _f(f), _t1(t1), _t2(t2), _t3(t3), _t4(t4) {}
     inline VALUE operator()() { return _f(_t1, _t2, _t3, _t4); }
-    static inline VALUE call(RF_4* f) { return (*f)(); }
+    static inline VALUE call(VALUE f)
+    {
+        return (*reinterpret_cast<RF_4*>(f))();
+    }
 
 private:
 
@@ -287,7 +314,40 @@ inline VALUE callRuby(Fun fun, T1 t1, T2 t2, T3 t3, T4 t4)
 {
     typedef RF_4<Fun, T1, T2, T3, T4> RF;
     RF f(fun, t1, t2, t3, t4);
-    return callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
+    return callProtected(RF::call, reinterpret_cast<VALUE>(&f));
+}
+
+template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+class RF_6
+{
+public:
+
+    RF_6(Fun f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) : _f(f), _t1(t1), _t2(t2), _t3(t3), _t4(t4), _t5(t5), _t6(t6)
+    {
+    }
+    inline VALUE operator()() { return _f(_t1, _t2, _t3, _t4, _t5, _t6); }
+    static inline VALUE call(VALUE f)
+    {
+        return (*reinterpret_cast<RF_6*>(f))();
+    }
+
+private:
+
+    Fun _f;
+    T1 _t1;
+    T2 _t2;
+    T3 _t3;
+    T4 _t4;
+    T5 _t5;
+    T6 _t6;
+};
+
+template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+inline VALUE callRuby(Fun fun, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
+{
+    typedef RF_6<Fun, T1, T2, T3, T4, T5, T6> RF;
+    RF f(fun, t1, t2, t3, t4, t5, t6);
+    return callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
 //
@@ -318,7 +378,12 @@ public:
 
     RFV_0(Fun f) : _f(f) {}
     inline void operator()() { _f(); }
-    static inline VALUE call(RFV_0* f) { (*f)(); return Qnil; }
+
+    static inline VALUE call(VALUE f)
+    {
+        (*reinterpret_cast<RFV_0*>(f))();
+        return Qnil;
+    }
 
 private:
 
@@ -330,7 +395,7 @@ inline void callRubyVoid(Fun fun)
 {
     typedef RFV_0<Fun> RF;
     RF f(fun);
-    callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
+    callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
 template<typename Fun, typename T1>
@@ -340,7 +405,11 @@ public:
 
     RFV_1(Fun f, T1 t1) : _f(f), _t1(t1) {}
     inline void operator()() { _f(_t1); }
-    static inline VALUE call(RFV_1* f) { (*f)(); return Qnil; }
+    static inline VALUE call(VALUE f)
+    {
+        (*reinterpret_cast<RFV_1*>(f))();
+        return Qnil;
+    }
 
 private:
 
@@ -353,7 +422,7 @@ inline void callRubyVoid(Fun fun, T1 t1)
 {
     typedef RFV_1<Fun, T1> RF;
     RF f(fun, t1);
-    callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
+    callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
 template<typename Fun, typename T1, typename T2>
@@ -363,7 +432,11 @@ public:
 
     RFV_2(Fun f, T1 t1, T2 t2) : _f(f), _t1(t1), _t2(t2) {}
     inline void operator()() { _f(_t1, _t2); }
-    static inline VALUE call(RFV_2* f) { (*f)(); return Qnil; }
+    static inline VALUE call(VALUE f)
+    {
+        (*reinterpret_cast<RFV_2*>(f))();
+        return Qnil;
+    }
 
 private:
 
@@ -377,7 +450,7 @@ inline void callRubyVoid(Fun fun, T1 t1, T2 t2)
 {
     typedef RFV_2<Fun, T1, T2> RF;
     RF f(fun, t1, t2);
-    callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
+    callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
 template<typename Fun, typename T1, typename T2, typename T3>
@@ -387,7 +460,11 @@ public:
 
     RFV_3(Fun f, T1 t1, T2 t2, T3 t3) : _f(f), _t1(t1), _t2(t2), _t3(t3) {}
     inline void operator()() { _f(_t1, _t2, _t3); }
-    static inline VALUE call(RFV_3* f) { (*f)(); return Qnil; }
+    static inline VALUE call(VALUE f)
+    {
+        (*reinterpret_cast<RFV_3*>(f))();
+        return Qnil;
+    }
 
 private:
 
@@ -402,7 +479,7 @@ inline void callRubyVoid(Fun fun, T1 t1, T2 t2, T3 t3)
 {
     typedef RFV_3<Fun, T1, T2, T3> RF;
     RF f(fun, t1, t2, t3);
-    callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
+    callProtected(RF::call, reinterpret_cast<VALUE>(&f));
 }
 
 template<typename Fun, typename T1, typename T2, typename T3, typename T4>
@@ -412,7 +489,11 @@ public:
 
     RFV_4(Fun f, T1 t1, T2 t2, T3 t3, T4 t4) : _f(f), _t1(t1), _t2(t2), _t3(t3), _t4(t4) {}
     inline void operator()() { _f(_t1, _t2, _t3, _t4); }
-    static inline VALUE call(RFV_4* f) { (*f)(); return Qnil; }
+    static inline VALUE call(VALUE f)
+    {
+        (*reinterpret_cast<RFV_4*>(f))();
+        return Qnil;
+    }
 
 private:
 
@@ -431,8 +512,6 @@ inline void callRubyVoid(Fun fun, T1 t1, T2 t2, T3 t3, T4 t4)
     callProtected(RubyFunction(RF::call), reinterpret_cast<VALUE>(&f));
 }
 
-VALUE createArrayHelper(long);
-
 //
 // Create an array with the given size. May raise RubyException.
 //
@@ -448,11 +527,7 @@ VALUE createArrayHelper(long);
 //     RARRAY_ASET(arr, i, val);
 // }
 //
-template<typename T>
-inline VALUE createArray(T sz)
-{
-    return createArrayHelper(static_cast<long>(sz));
-}
+VALUE createArray(long);
 
 //
 // Create the Ruby equivalent of an Ice local exception.
@@ -467,19 +542,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 +567,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) \
     { \

data/ext/ValueFactoryManager.cpp

@@ -0,0 +1,440 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#include <ValueFactoryManager.h>
+#include <Types.h>
+#include <Util.h>
+#include <Ice/LocalException.h>
+
+using namespace std;
+using namespace IceRuby;
+
+static VALUE _valueFactoryManagerClass;
+
+namespace
+{
+
+ClassInfoPtr
+getClassInfo(const string& id)
+{
+    ClassInfoPtr info;
+
+    if(id == Ice::Object::ice_staticId())
+    {
+        //
+        // When the ID is that of Ice::Object, it indicates that the stream has not
+        // found a factory and is providing us an opportunity to preserve the object.
+        //
+        info = lookupClassInfo("::Ice::UnknownSlicedValue");
+    }
+    else
+    {
+        info = lookupClassInfo(id);
+    }
+
+    return info;
+}
+
+}
+
+extern "C"
+void
+IceRuby_ValueFactoryManager_mark(ValueFactoryManagerPtr* p)
+{
+    assert(p);
+    (*p)->mark();
+}
+
+extern "C"
+void
+IceRuby_ValueFactoryManager_free(ValueFactoryManagerPtr* p)
+{
+    assert(p);
+    delete p;
+}
+
+IceRuby::ValueFactoryManager::ValueFactoryManager()
+{
+    //
+    // Create a Ruby wrapper around this object. Note that this is a cyclic reference.
+    //
+    _self = Data_Wrap_Struct(_valueFactoryManagerClass, IceRuby_ValueFactoryManager_mark,
+                             IceRuby_ValueFactoryManager_free, new ValueFactoryManagerPtr(this));
+
+    _defaultFactory = new DefaultValueFactory;
+}
+
+IceRuby::ValueFactoryManager::~ValueFactoryManager()
+{
+    assert(_factories.empty());
+}
+
+void
+IceRuby::ValueFactoryManager::add(const Ice::ValueFactoryPtr& f, const string& id)
+{
+    Lock lock(*this);
+
+    if(id.empty())
+    {
+        if(_defaultFactory->getDelegate())
+        {
+            throw Ice::AlreadyRegisteredException(__FILE__, __LINE__, "value factory", id);
+        }
+
+        _defaultFactory->setDelegate(f);
+    }
+    else
+    {
+        FactoryMap::iterator p = _factories.find(id);
+        if(p != _factories.end())
+        {
+            throw Ice::AlreadyRegisteredException(__FILE__, __LINE__, "value factory", id);
+        }
+
+        _factories.insert(FactoryMap::value_type(id, f));
+    }
+}
+
+Ice::ValueFactoryPtr
+IceRuby::ValueFactoryManager::find(const string& id) const ICE_NOEXCEPT
+{
+    Lock lock(*this);
+
+    if(id.empty())
+    {
+        return _defaultFactory;
+    }
+
+    FactoryMap::const_iterator p = _factories.find(id);
+    if(p != _factories.end())
+    {
+        return p->second;
+    }
+
+    return 0;
+}
+
+void
+IceRuby::ValueFactoryManager::addValueFactory(VALUE f, const string& id)
+{
+    ICE_RUBY_TRY
+    {
+        add(new FactoryWrapper(f, false), id);
+    }
+    ICE_RUBY_CATCH
+}
+
+VALUE
+IceRuby::ValueFactoryManager::findValueFactory(const string& id) const
+{
+    Ice::ValueFactoryPtr f = find(id);
+    if(f)
+    {
+        FactoryWrapperPtr w = FactoryWrapperPtr::dynamicCast(f);
+        if(w)
+        {
+            return w->getObject();
+        }
+    }
+
+    return Qnil;
+}
+
+void
+IceRuby::ValueFactoryManager::addObjectFactory(VALUE f, const string& id)
+{
+    ICE_RUBY_TRY
+    {
+        add(new FactoryWrapper(f, true), id);
+    }
+    ICE_RUBY_CATCH
+}
+
+VALUE
+IceRuby::ValueFactoryManager::findObjectFactory(const string& id) const
+{
+    Ice::ValueFactoryPtr f = find(id);
+    if(f)
+    {
+        FactoryWrapperPtr w = FactoryWrapperPtr::dynamicCast(f);
+        if(w && w->isObjectFactory())
+        {
+            return w->getObject();
+        }
+    }
+
+    return Qnil;
+}
+
+void
+IceRuby::ValueFactoryManager::mark()
+{
+    Lock lock(*this);
+
+    for(FactoryMap::iterator p = _factories.begin(); p != _factories.end(); ++p)
+    {
+        FactoryWrapperPtr w = FactoryWrapperPtr::dynamicCast(p->second);
+        if(w)
+        {
+            w->mark();
+        }
+    }
+
+    _defaultFactory->mark();
+}
+
+void
+IceRuby::ValueFactoryManager::markSelf()
+{
+    volatile VALUE self;
+
+    {
+        Lock lock(*this);
+
+        self = _self;
+    }
+
+    if(!NIL_P(self))
+    {
+        rb_gc_mark(self);
+    }
+}
+
+VALUE
+IceRuby::ValueFactoryManager::getObject() const
+{
+    return _self;
+}
+
+void
+IceRuby::ValueFactoryManager::destroy()
+{
+    FactoryMap factories;
+
+    {
+        Lock lock(*this);
+        if(_self == Qnil)
+        {
+            //
+            // Nothing to do if already destroyed (this can occur if communicator destroy is called multiple times)
+            //
+            return;
+        }
+
+        factories.swap(_factories);
+
+        _self = Qnil;
+    }
+
+    for(FactoryMap::iterator p = factories.begin(); p != factories.end(); ++p)
+    {
+        FactoryWrapperPtr w = FactoryWrapperPtr::dynamicCast(p->second);
+        if(w)
+        {
+            w->destroy();
+        }
+    }
+
+    _defaultFactory->destroy();
+}
+
+IceRuby::FactoryWrapper::FactoryWrapper(VALUE factory, bool isObjectFactory) :
+    _factory(factory),
+    _isObjectFactory(isObjectFactory)
+{
+}
+
+Ice::ValuePtr
+IceRuby::FactoryWrapper::create(const string& id)
+{
+    //
+    // Get the type information.
+    //
+    ClassInfoPtr info = getClassInfo(id);
+
+    if(!info)
+    {
+        return 0;
+    }
+
+    //
+    // Invoke the create method on the Ruby factory object.
+    //
+    volatile VALUE str = createString(id);
+    volatile VALUE obj = callRuby(rb_funcall, _factory, rb_intern("create"), 1, str);
+    if(NIL_P(obj))
+    {
+        return 0;
+    }
+
+    return new ObjectReader(obj, info);
+}
+
+VALUE
+IceRuby::FactoryWrapper::getObject() const
+{
+    return _factory;
+}
+
+bool
+IceRuby::FactoryWrapper::isObjectFactory() const
+{
+    return _isObjectFactory;
+}
+
+void
+IceRuby::FactoryWrapper::mark()
+{
+    rb_gc_mark(_factory);
+}
+
+void
+IceRuby::FactoryWrapper::destroy()
+{
+    if(_isObjectFactory)
+    {
+        callRuby(rb_funcall, _factory, rb_intern("destroy"), 0);
+    }
+}
+
+Ice::ValuePtr
+IceRuby::DefaultValueFactory::create(const string& id)
+{
+    Ice::ValuePtr v;
+
+    //
+    // Give the application-provided default factory a chance to create the object first.
+    //
+    if(_delegate)
+    {
+        v = _delegate->create(id);
+        if(v)
+        {
+            return v;
+        }
+    }
+
+    //
+    // Get the type information.
+    //
+    ClassInfoPtr info = getClassInfo(id);
+
+    if(!info)
+    {
+        return 0;
+    }
+
+    //
+    // NOTE: We don't do this in Ruby because a generated class can be re-opened to define operations.
+    //
+    ////
+    //// If the requested type is an abstract class, then we give up.
+    ////
+    //if(info->isAbstract)
+    //{
+    //    return 0;
+    //}
+
+    //
+    // Instantiate the object.
+    //
+    volatile VALUE obj = callRuby(rb_class_new_instance, 0, reinterpret_cast<VALUE*>(0), info->rubyClass);
+    assert(!NIL_P(obj));
+    return new ObjectReader(obj, info);
+}
+
+void
+IceRuby::DefaultValueFactory::setDelegate(const Ice::ValueFactoryPtr& d)
+{
+    _delegate = d;
+}
+
+VALUE
+IceRuby::DefaultValueFactory::getObject() const
+{
+    if(_delegate)
+    {
+        FactoryWrapperPtr w = FactoryWrapperPtr::dynamicCast(_delegate);
+        if(w)
+        {
+            return w->getObject();
+        }
+    }
+
+    return Qnil;
+}
+
+void
+IceRuby::DefaultValueFactory::mark()
+{
+    if(_delegate)
+    {
+        FactoryWrapperPtr w = FactoryWrapperPtr::dynamicCast(_delegate);
+        if(w)
+        {
+            w->mark();
+        }
+    }
+}
+
+void
+IceRuby::DefaultValueFactory::destroy()
+{
+    if(_delegate)
+    {
+        FactoryWrapperPtr w = FactoryWrapperPtr::dynamicCast(_delegate);
+        if(w)
+        {
+            w->destroy();
+        }
+    }
+
+    _delegate = 0;
+}
+
+extern "C"
+VALUE
+IceRuby_ValueFactoryManager_add(VALUE self, VALUE factory, VALUE id)
+{
+    ICE_RUBY_TRY
+    {
+        ValueFactoryManagerPtr* p = reinterpret_cast<ValueFactoryManagerPtr*>(DATA_PTR(self));
+        assert(p);
+
+        string type = getString(id);
+        (*p)->addValueFactory(factory, type);
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+extern "C"
+VALUE
+IceRuby_ValueFactoryManager_find(VALUE self, VALUE id)
+{
+    ICE_RUBY_TRY
+    {
+        ValueFactoryManagerPtr* p = reinterpret_cast<ValueFactoryManagerPtr*>(DATA_PTR(self));
+        assert(p);
+
+        string type = getString(id);
+        return (*p)->findValueFactory(type);
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+bool
+IceRuby::initValueFactoryManager(VALUE iceModule)
+{
+    _valueFactoryManagerClass = rb_define_class_under(iceModule, "ValueFactoryManagerI", rb_cObject);
+
+    //
+    // Instance methods.
+    //
+    rb_define_method(_valueFactoryManagerClass, "add", CAST_METHOD(IceRuby_ValueFactoryManager_add), 2);
+    rb_define_method(_valueFactoryManagerClass, "find", CAST_METHOD(IceRuby_ValueFactoryManager_find), 1);
+
+    return true;
+}