zeroc-ice 3.7.11 → 3.8.1

data/dist/IceRuby/Communicator.cpp

@@ -1,323 +1,188 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Communicator.h>
-#include <ImplicitContext.h>
-#include <Logger.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>
-#include <Ice/ObjectFactory.h>
-#include <Ice/Properties.h>
-#include <Ice/Router.h>
+// Copyright (c) ZeroC, Inc.
+
+#include "Communicator.h"
+#include "DefaultSliceLoader.h"
+#include "IceDiscovery/IceDiscovery.h"
+#include "IceLocatorDiscovery/IceLocatorDiscovery.h"
+#include "ImplicitContext.h"
+#include "Logger.h"
+#include "Properties.h"
+#include "Proxy.h"
+#include "RubySliceLoader.h"
+#include "Types.h"
+#include "Util.h"
 
 using namespace std;
 using namespace IceRuby;
 
-static VALUE _communicatorClass;
+namespace
+{
+    VALUE _communicatorClass;
 
-typedef map<Ice::CommunicatorPtr, VALUE> CommunicatorMap;
-static CommunicatorMap _communicatorMap;
+    using CommunicatorMap = map<Ice::CommunicatorPtr, VALUE>;
+    CommunicatorMap _communicatorMap;
 
-extern "C"
-void
-IceRuby_Communicator_mark(Ice::CommunicatorPtr* p)
-{
-    assert(p);
-    try
-    {
-        ValueFactoryManagerPtr vfm = ValueFactoryManagerPtr::dynamicCast((*p)->getValueFactoryManager());
-        assert(vfm);
-        vfm->markSelf();
-    }
-    catch(const Ice::CommunicatorDestroyedException&)
-    {
-        // Ignore. This is expected.
-    }
+    map<Ice::CommunicatorPtr, Ice::SliceLoaderPtr> _sliceLoaderMap;
 }
 
-extern "C"
-void
-IceRuby_Communicator_free(Ice::CommunicatorPtr* p)
+extern "C" void
+IceRuby_Communicator_free(void* p)
 {
-    assert(p);
-    delete p;
+    delete static_cast<Ice::CommunicatorPtr*>(p);
 }
 
-namespace
-{
-
-class CommunicatorDestroyer
-{
-public:
-
-    CommunicatorDestroyer(const Ice::CommunicatorPtr& c) : _communicator(c) {}
-
-    ~CommunicatorDestroyer()
-    {
-        _communicator->destroy();
-    }
-
-private:
-
-    Ice::CommunicatorPtr _communicator;
+static const rb_data_type_t IceRuby_CommunicatorType = {
+    .wrap_struct_name = "Ice::Communicator",
+    .function =
+        {
+            .dfree = IceRuby_Communicator_free,
+        },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
-}
-
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_initialize(int argc, VALUE* argv, VALUE /*self*/)
 {
+    // This is the implementation of the Ice.initialize module method. There is no Ruby wrapper.
+
     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)
         //
         // An implicit block is optional.
-        //
 
-        if(argc > 2)
+        if (argc > 1)
         {
             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, configFile = Qnil;
+        volatile VALUE args = Qnil, rbInitData = Qnil;
 
-        if(argc >= 1)
+        if (argc == 1)
         {
-            if(isArray(argv[0]))
+            if (isArray(argv[0]))
             {
                 args = argv[0];
             }
-            else if(callRuby(rb_obj_is_instance_of, argv[0], initDataCls) == Qtrue)
-            {
-                initData = argv[0];
-            }
-            else if(TYPE(argv[0]) == T_STRING)
+            else if (callRuby(rb_obj_is_instance_of, argv[0], initDataCls) == Qtrue)
             {
-                configFile = argv[0];
+                rbInitData = argv[0];
             }
             else
             {
-                throw RubyException(rb_eTypeError,
-                    "initialize expects an argument list, InitializationData or a configuration filename");
+                throw RubyException(rb_eTypeError, "initialize expects an argument list or an InitializationData");
             }
         }
 
-        if(argc >= 2)
+        Ice::InitializationData initData;
+        Ice::SliceLoaderPtr sliceLoader = DefaultSliceLoader::instance();
+
+        if (!NIL_P(rbInitData))
         {
-            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)
+            VALUE properties = callRuby(rb_iv_get, rbInitData, "@properties");
+            if (!NIL_P(properties))
             {
-                if(!NIL_P(configFile))
-                {
-                    throw RubyException(rb_eTypeError, "unexpected string argument to initialize");
-                }
-                configFile = argv[1];
+                initData.properties = getProperties(properties);
             }
-            else
+
+            VALUE initDataSliceLoader = callRuby(rb_iv_get, rbInitData, "@sliceLoader");
+            if (!NIL_P(initDataSliceLoader))
             {
-                throw RubyException(rb_eTypeError,
-                    "initialize expects an argument list, InitializationData or a configuration filename");
+                auto compositeSliceLoader = make_shared<Ice::CompositeSliceLoader>();
+                compositeSliceLoader->add(make_shared<RubySliceLoader>(initDataSliceLoader));
+                compositeSliceLoader->add(std::move(sliceLoader));
+                sliceLoader = std::move(compositeSliceLoader);
             }
         }
-
-        if(!NIL_P(initData) && !NIL_P(configFile))
-        {
-            throw RubyException(rb_eTypeError,
-                "initialize accepts either Ice.InitializationData or a configuration filename");
-        }
-
-        Ice::StringSeq seq;
-        if(!NIL_P(args) && !arrayToStringSeq(args, seq))
-        {
-            throw RubyException(rb_eTypeError, "invalid array argument to Ice::initialize");
-        }
-
-        Ice::InitializationData data;
-        if(!NIL_P(initData))
+        else if (!NIL_P(args))
         {
-            volatile VALUE properties = callRuby(rb_iv_get, initData, "@properties");
-            volatile VALUE logger = callRuby(rb_iv_get, initData, "@logger");
-
-            if(!NIL_P(properties))
+            Ice::StringSeq seq;
+            if (!arrayToStringSeq(args, seq))
             {
-                data.properties = getProperties(properties);
+                throw RubyException(rb_eTypeError, "invalid array argument to Ice::initialize");
             }
 
-            if(!NIL_P(logger))
-            {
-                throw RubyException(rb_eArgError, "custom logger is not supported");
-            }
-        }
-
-        //
-        // Insert the program name (stored in the Ruby global variable $0) as the first
-        // element of the sequence.
-        //
-        volatile VALUE progName = callRuby(rb_gv_get, "$0");
-        seq.insert(seq.begin(), getString(progName));
-
-        data.compactIdResolver = new IdResolver;
-        data.valueFactoryManager = new ValueFactoryManager;
-
-        if(!data.properties)
-        {
-            data.properties = Ice::createProperties();
-        }
+            initData.properties = Ice::createProperties(seq);
 
-        if(!NIL_P(configFile))
-        {
-            data.properties->load(getString(configFile));
-        }
+            // Replace the contents of the given argument list with the filtered arguments.
+            callRuby(rb_ary_clear, args);
 
-        if(!NIL_P(args))
-        {
-            data.properties = Ice::createProperties(seq, data.properties);
+            for (const auto& arg : seq)
+            {
+                volatile VALUE str = createString(arg);
+                callRuby(rb_ary_push, args, str);
+            }
         }
 
-        // Always accept cycles in Ruby
-        data.properties->setProperty("Ice.AcceptClassCycles", "1");
-
-        //
-        // Remaining command line options are passed to the communicator
-        // as an argument vector in case they contain plugin properties.
-        //
-        int ac = static_cast<int>(seq.size());
-        char** av = new char*[ac + 1];
-        int i = 0;
-        for(Ice::StringSeq::const_iterator s = seq.begin(); s != seq.end(); ++s, ++i)
+        if (!initData.properties)
         {
-            av[i] = strdup(s->c_str());
+            initData.properties = Ice::createProperties();
         }
-        av[ac] = 0;
 
-        Ice::CommunicatorPtr communicator;
-        try
+        // Insert the program name (stored in the Ruby global variable $0) unless already set.
+        if (initData.properties->getProperty("Ice.ProgramName").empty())
         {
-            if(!NIL_P(args))
+            volatile VALUE programNameValue = callRuby(rb_gv_get, "$0");
+            string programName = getString(programNameValue);
+            size_t pos = programName.find_last_of("/\\");
+            if (pos != string::npos)
             {
-                communicator = Ice::initialize(ac, av, data);
-            }
-            else
-            {
-                communicator = Ice::initialize(data);
+                programName = programName.substr(pos + 1);
             }
+            initData.properties->setProperty("Ice.ProgramName", programName);
         }
-        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)
-            {
-                free(av[i]);
-            }
-            delete[] av;
-
-            throw;
-        }
+        // Always accept class cycles during the unmarshaling of Ruby objects by the C++ code.
+        initData.properties->setProperty("Ice.AcceptClassCycles", "1");
 
-        //
-        // Replace the contents of the given argument list with the filtered arguments.
-        //
-        if(!NIL_P(args))
+        // Add IceDiscovery/IceLocatorDiscovery if these plug-ins are configured via Ice.Plugin.name.
+        if (!initData.properties->getIceProperty("Ice.Plugin.IceDiscovery").empty())
         {
-            callRuby(rb_ary_clear, args);
-
-            //
-            // We start at index 1 in order to skip the element that we inserted earlier.
-            //
-            for(i = 1; i < ac; ++i)
-            {
-                volatile VALUE str = createString(av[i]);
-                callRuby(rb_ary_push, args, str);
-            }
+            initData.pluginFactories.push_back(IceDiscovery::discoveryPluginFactory());
         }
 
-        for(i = 0; i < ac + 1; ++i)
+        if (!initData.properties->getIceProperty("Ice.Plugin.IceLocatorDiscovery").empty())
         {
-            free(av[i]);
+            initData.pluginFactories.push_back(IceLocatorDiscovery::locatorDiscoveryPluginFactory());
         }
-        delete[] av;
 
-        VALUE result = Data_Wrap_Struct(_communicatorClass, IceRuby_Communicator_mark,
-                                        IceRuby_Communicator_free, new Ice::CommunicatorPtr(communicator));
+        Ice::CommunicatorPtr communicator = Ice::initialize(initData);
+
+        VALUE result = TypedData_Wrap_Struct(
+            _communicatorClass,
+            &IceRuby_CommunicatorType,
+            new Ice::CommunicatorPtr(communicator));
 
         CommunicatorMap::iterator p = _communicatorMap.find(communicator);
-        if(p != _communicatorMap.end())
+        if (p != _communicatorMap.end())
         {
             _communicatorMap.erase(p);
         }
         _communicatorMap.insert(CommunicatorMap::value_type(communicator, reinterpret_cast<const VALUE&>(result)));
 
+        _sliceLoaderMap[communicator] = sliceLoader;
+
         //
         // If an implicit block was provided, yield to the block and pass it the communicator instance.
         // We destroy the communicator after the block is finished, and return the result of the block.
         //
-        if(rb_block_given_p())
+        if (rb_block_given_p())
         {
-            CommunicatorDestroyer destroyer(communicator);
-            //
-            // Examine the arity of the block procedure. If it accepts one argument, pass it the
-            // communicator. If it accepts two arguments, pass it the communicator and the
-            // argument vector.
-            //
+            Ice::CommunicatorHolder communicatorHolder{communicator};
             VALUE proc = callRuby(rb_block_proc);
             int arity = rb_proc_arity(proc);
-            if(arity == 1)
+            if (arity == 1)
             {
                 return callRuby(rb_yield, result);
             }
-            else if(arity == 2)
-            {
-                VALUE blockArgs = createArray(2);
-                RARRAY_ASET(blockArgs, 0, result);
-                RARRAY_ASET(blockArgs, 1, args);
-                return callRuby(rb_yield, blockArgs);
-            }
             else
             {
-                throw RubyException(rb_eArgError, "block must accept one or two arguments");
+                throw RubyException(rb_eArgError, "block must accept a single argument (the communicator)");
             }
         }
         else
@@ -329,8 +194,7 @@ IceRuby_initialize(int argc, VALUE* argv, VALUE /*self*/)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_stringToIdentity(VALUE /*self*/, VALUE str)
 {
     ICE_RUBY_TRY
@@ -343,21 +207,20 @@ IceRuby_stringToIdentity(VALUE /*self*/, VALUE str)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_identityToString(int argc, VALUE* argv, VALUE /*self*/)
 {
     ICE_RUBY_TRY
     {
-        if(argc < 1 || argc > 2)
+        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)
+        Ice::ToStringMode toStringMode = Ice::ToStringMode::Unicode;
+        if (argc == 2)
         {
             volatile VALUE modeValue = callRuby(rb_funcall, argv[1], rb_intern("to_i"), 0);
             assert(TYPE(modeValue) == T_FIXNUM);
@@ -371,28 +234,20 @@ IceRuby_identityToString(int argc, VALUE* argv, VALUE /*self*/)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Communicator_destroy(VALUE self)
 {
     Ice::CommunicatorPtr p = getCommunicator(self);
 
-    ValueFactoryManagerPtr vfm = ValueFactoryManagerPtr::dynamicCast(p->getValueFactoryManager());
-    assert(vfm);
-
-    ICE_RUBY_TRY
-    {
-        p->destroy();
-    }
+    ICE_RUBY_TRY { p->destroy(); }
     ICE_RUBY_CATCH
 
-    vfm->destroy();
+    _sliceLoaderMap.erase(p);
 
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Communicator_shutdown(VALUE self)
 {
     ICE_RUBY_TRY
@@ -404,8 +259,7 @@ IceRuby_Communicator_shutdown(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Communicator_isShutdown(VALUE self)
 {
     ICE_RUBY_TRY
@@ -417,8 +271,7 @@ IceRuby_Communicator_isShutdown(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Communicator_waitForShutdown(VALUE self)
 {
     ICE_RUBY_TRY
@@ -430,35 +283,33 @@ IceRuby_Communicator_waitForShutdown(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Communicator_stringToProxy(VALUE self, VALUE str)
 {
     ICE_RUBY_TRY
     {
         Ice::CommunicatorPtr p = getCommunicator(self);
         string s = getString(str);
-        Ice::ObjectPrx proxy = p->stringToProxy(s);
-        if(proxy)
+        optional<Ice::ObjectPrx> proxy = p->stringToProxy(s);
+        if (proxy)
         {
-            return createProxy(proxy);
+            return createProxy(proxy.value());
         }
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Communicator_proxyToString(VALUE self, VALUE proxy)
 {
     ICE_RUBY_TRY
     {
         Ice::CommunicatorPtr p = getCommunicator(self);
-        Ice::ObjectPrx prx;
-        if(!NIL_P(proxy))
+        optional<Ice::ObjectPrx> prx;
+        if (!NIL_P(proxy))
         {
-            if(!checkProxy(proxy))
+            if (!checkProxy(proxy))
             {
                 throw RubyException(rb_eTypeError, "argument must be a proxy");
             }
@@ -471,40 +322,38 @@ IceRuby_Communicator_proxyToString(VALUE self, VALUE proxy)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Communicator_propertyToProxy(VALUE self, VALUE str)
 {
     ICE_RUBY_TRY
     {
         Ice::CommunicatorPtr p = getCommunicator(self);
         string s = getString(str);
-        Ice::ObjectPrx proxy = p->propertyToProxy(s);
-        if(proxy)
+        optional<Ice::ObjectPrx> proxy = p->propertyToProxy(s);
+        if (proxy)
         {
-            return createProxy(proxy);
+            return createProxy(proxy.value());
         }
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Communicator_proxyToProperty(VALUE self, VALUE obj, VALUE str)
 {
     ICE_RUBY_TRY
     {
-        if(!checkProxy(obj))
+        if (!checkProxy(obj))
         {
             throw RubyException(rb_eTypeError, "argument must be a proxy");
         }
         Ice::CommunicatorPtr p = getCommunicator(self);
-        Ice::ObjectPrx o = getProxy(obj);
+        optional<Ice::ObjectPrx> o = getProxy(obj);
         string s = getString(str);
         Ice::PropertyDict dict = p->proxyToProperty(o, s);
         volatile VALUE result = callRuby(rb_hash_new);
-        for(Ice::PropertyDict::const_iterator q = dict.begin(); q != dict.end(); ++q)
+        for (Ice::PropertyDict::const_iterator q = dict.begin(); q != dict.end(); ++q)
         {
             volatile VALUE key = createString(q->first);
             volatile VALUE value = createString(q->second);
@@ -516,23 +365,7 @@ IceRuby_Communicator_proxyToProperty(VALUE self, VALUE obj, VALUE str)
     return Qnil;
 }
 
-extern "C"
-VALUE
-IceRuby_Communicator_stringToIdentity(VALUE self, VALUE str)
-{
-    ICE_RUBY_TRY
-    {
-        Ice::CommunicatorPtr p = getCommunicator(self);
-        string s = getString(str);
-        Ice::Identity ident = p->stringToIdentity(s);
-        return createIdentity(ident);
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Communicator_identityToString(VALUE self, VALUE id)
 {
     ICE_RUBY_TRY
@@ -546,55 +379,7 @@ IceRuby_Communicator_identityToString(VALUE self, VALUE id)
     return Qnil;
 }
 
-extern "C"
-VALUE
-IceRuby_Communicator_addObjectFactory(VALUE self, VALUE factory, VALUE id)
-{
-    ICE_RUBY_TRY
-    {
-        Ice::CommunicatorPtr p = getCommunicator(self);
-        ValueFactoryManagerPtr vfm = ValueFactoryManagerPtr::dynamicCast(p->getValueFactoryManager());
-        assert(vfm);
-        string idstr = getString(id);
-        vfm->addObjectFactory(factory, idstr);
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
-IceRuby_Communicator_findObjectFactory(VALUE self, VALUE id)
-{
-    ICE_RUBY_TRY
-    {
-        Ice::CommunicatorPtr p = getCommunicator(self);
-        ValueFactoryManagerPtr vfm = ValueFactoryManagerPtr::dynamicCast(p->getValueFactoryManager());
-        assert(vfm);
-        string idstr = getString(id);
-        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;
-}
-
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Communicator_getImplicitContext(VALUE self)
 {
     ICE_RUBY_TRY
@@ -607,22 +392,20 @@ IceRuby_Communicator_getImplicitContext(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Communicator_getProperties(VALUE self)
 {
     ICE_RUBY_TRY
     {
         Ice::CommunicatorPtr p = getCommunicator(self);
         Ice::PropertiesPtr props = p->getProperties();
-        return createProperties(props);
+        return IceRuby::createProperties(props);
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Communicator_getLogger(VALUE self)
 {
     ICE_RUBY_TRY
@@ -635,40 +418,38 @@ IceRuby_Communicator_getLogger(VALUE self)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Communicator_getDefaultRouter(VALUE self)
 {
     ICE_RUBY_TRY
     {
         Ice::CommunicatorPtr p = getCommunicator(self);
-        Ice::RouterPrx router = p->getDefaultRouter();
-        if(router)
+        optional<Ice::RouterPrx> router = p->getDefaultRouter();
+        if (router)
         {
             volatile VALUE cls = callRuby(rb_path2class, "Ice::RouterPrx");
             assert(!NIL_P(cls));
-            return createProxy(router, cls);
+            return createProxy(router.value(), cls);
         }
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Communicator_setDefaultRouter(VALUE self, VALUE router)
 {
     ICE_RUBY_TRY
     {
         Ice::CommunicatorPtr p = getCommunicator(self);
-        Ice::RouterPrx proxy;
-        if(!NIL_P(router))
+        optional<Ice::RouterPrx> proxy;
+        if (!NIL_P(router))
         {
-            if(!checkProxy(router))
+            if (!checkProxy(router))
             {
                 throw RubyException(rb_eTypeError, "argument must be a proxy");
             }
-            proxy = Ice::RouterPrx::uncheckedCast(getProxy(router));
+            proxy = Ice::uncheckedCast<Ice::RouterPrx>(getProxy(router));
         }
         p->setDefaultRouter(proxy);
     }
@@ -676,40 +457,38 @@ IceRuby_Communicator_setDefaultRouter(VALUE self, VALUE router)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Communicator_getDefaultLocator(VALUE self)
 {
     ICE_RUBY_TRY
     {
         Ice::CommunicatorPtr p = getCommunicator(self);
-        Ice::LocatorPrx locator = p->getDefaultLocator();
-        if(locator)
+        optional<Ice::LocatorPrx> locator = p->getDefaultLocator();
+        if (locator)
         {
             volatile VALUE cls = callRuby(rb_path2class, "Ice::LocatorPrx");
             assert(!NIL_P(cls));
-            return createProxy(locator, cls);
+            return createProxy(locator.value(), cls);
         }
     }
     ICE_RUBY_CATCH
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Communicator_setDefaultLocator(VALUE self, VALUE locator)
 {
     ICE_RUBY_TRY
     {
         Ice::CommunicatorPtr p = getCommunicator(self);
-        Ice::LocatorPrx proxy;
-        if(!NIL_P(locator))
+        optional<Ice::LocatorPrx> proxy;
+        if (!NIL_P(locator))
         {
-            if(!checkProxy(locator))
+            if (!checkProxy(locator))
             {
                 throw RubyException(rb_eTypeError, "argument must be a proxy");
             }
-            proxy = Ice::LocatorPrx::uncheckedCast(getProxy(locator));
+            proxy = Ice::uncheckedCast<Ice::LocatorPrx>(getProxy(locator));
         }
         p->setDefaultLocator(proxy);
     }
@@ -717,8 +496,7 @@ IceRuby_Communicator_setDefaultLocator(VALUE self, VALUE locator)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_Communicator_flushBatchRequests(VALUE self, VALUE compress)
 {
     ICE_RUBY_TRY
@@ -726,9 +504,10 @@ IceRuby_Communicator_flushBatchRequests(VALUE self, VALUE compress)
         Ice::CommunicatorPtr p = getCommunicator(self);
 
         volatile VALUE type = callRuby(rb_path2class, "Ice::CompressBatch");
-        if(callRuby(rb_obj_is_instance_of, compress, type) != Qtrue)
+        if (callRuby(rb_obj_is_instance_of, compress, type) != Qtrue)
         {
-            throw RubyException(rb_eTypeError,
+            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);
@@ -757,11 +536,7 @@ IceRuby::initCommunicator(VALUE iceModule)
     rb_define_method(_communicatorClass, "proxyToString", CAST_METHOD(IceRuby_Communicator_proxyToString), 1);
     rb_define_method(_communicatorClass, "propertyToProxy", CAST_METHOD(IceRuby_Communicator_propertyToProxy), 1);
     rb_define_method(_communicatorClass, "proxyToProperty", CAST_METHOD(IceRuby_Communicator_proxyToProperty), 2);
-    rb_define_method(_communicatorClass, "stringToIdentity", CAST_METHOD(IceRuby_Communicator_stringToIdentity), 1);
     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);
@@ -783,10 +558,18 @@ IceRuby::getCommunicator(VALUE v)
 VALUE
 IceRuby::lookupCommunicator(const Ice::CommunicatorPtr& p)
 {
-    CommunicatorMap::iterator q = _communicatorMap.find(p.get());
-    if(q != _communicatorMap.end())
+    CommunicatorMap::iterator q = _communicatorMap.find(p);
+    if (q != _communicatorMap.end())
     {
         return q->second;
     }
     return Qnil;
 }
+
+Ice::SliceLoaderPtr
+IceRuby::lookupSliceLoader(const Ice::CommunicatorPtr& communicator)
+{
+    auto p = _sliceLoaderMap.find(communicator);
+    assert(p != _sliceLoaderMap.end());
+    return p->second;
+}