py -> python

rb -> ruby
objc -> objective-c
cs -> csharp

1 files changed, 596 insertions, 0 deletions

diff --git a/ruby/src/IceRuby/Communicator.cpp b/ruby/src/IceRuby/Communicator.cpp
new file mode 100644
index 00000000000..24d9629a847
--- /dev/null
+++ b/ruby/src/IceRuby/Communicator.cpp
@@ -0,0 +1,596 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2015 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>
+#include <Logger.h>
+#include <ObjectFactory.h>
+#include <Properties.h>
+#include <Proxy.h>
+#include <Types.h>
+#include <Util.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>
+
+using namespace std;
+using namespace IceRuby;
+
+static VALUE _communicatorClass;
+
+typedef map<Ice::CommunicatorPtr, VALUE> CommunicatorMap;
+static CommunicatorMap _communicatorMap;
+
+extern "C"
+void
+IceRuby_Communicator_mark(Ice::CommunicatorPtr* p)
+{
+    assert(p);
+    try
+    {
+        ObjectFactoryPtr pof = ObjectFactoryPtr::dynamicCast((*p)->findObjectFactory(""));
+        assert(pof);
+        pof->mark();
+    }
+    catch(const Ice::CommunicatorDestroyedException&)
+    {
+        // Ignore. This is expected.
+    }
+}
+
+extern "C"
+void
+IceRuby_Communicator_free(Ice::CommunicatorPtr* p)
+{
+    assert(p);
+    delete p;
+}
+
+extern "C"
+VALUE
+IceRuby_initialize(int argc, VALUE* argv, VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        volatile VALUE initDataCls = callRuby(rb_path2class, "Ice::InitializationData");
+        volatile VALUE args = Qnil, initData = Qnil;
+        if(argc == 1)
+        {
+            if(isArray(argv[0]))
+            {
+                args = argv[0];
+            }
+            else if(callRuby(rb_obj_is_instance_of, argv[0], initDataCls) == Qtrue)
+            {
+                initData = argv[0];
+            }
+            else
+            {
+                throw RubyException(rb_eTypeError, "invalid argument to Ice::initialize");
+            }
+        }
+        else if(argc == 2)
+        {
+            if(!isArray(argv[0]) || callRuby(rb_obj_is_instance_of, argv[1], initDataCls) == Qfalse)
+            {
+                throw RubyException(rb_eTypeError, "invalid argument to Ice::initialize");
+            }
+            args = argv[0];
+            initData = argv[1];
+        }
+        else if(argc > 0)
+        {
+            throw RubyException(rb_eArgError, "invalid number of arguments to Ice::initialize");
+        }
+
+        Ice::StringSeq seq;
+        if(!NIL_P(args) && !arrayToStringSeq(args, seq))
+        {
+            throw RubyException(rb_eTypeError, "invalid array argument to Ice::initialize");
+        }
+
+        //
+        // Use the with-args or the without-args version of initialize()?
+        //
+        bool hasArgs = !NIL_P(args);
+
+        Ice::InitializationData data;
+        if(!NIL_P(initData))
+        {
+            volatile VALUE properties = callRuby(rb_iv_get, initData, "@properties");
+            volatile VALUE logger = callRuby(rb_iv_get, initData, "@logger");
+
+            if(!NIL_P(properties))
+            {
+                data.properties = getProperties(properties);
+            }
+
+            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;
+
+        if(hasArgs)
+        {
+            data.properties = Ice::createProperties(seq, data.properties);
+        }
+        else if(!data.properties)
+        {
+            data.properties = Ice::createProperties();
+        }
+        //
+        // Disable collocation optimization, otherwise an invocation on a
+        // collocated servant results in a CollocationOptimizationException
+        // (because Ruby uses the blobject API).
+        //
+        // TODO: Enable if a server mapping is added.
+        //
+        //data.properties->setProperty("Ice.Default.CollocationOptimization", "0");
+
+        //
+        // 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)
+        {
+            av[i] = strdup(s->c_str());
+        }
+        av[ac] = 0;
+
+        Ice::CommunicatorPtr communicator;
+        try
+        {
+            if(hasArgs)
+            {
+                communicator = Ice::initialize(ac, av, data);
+            }
+            else
+            {
+                communicator = Ice::initialize(data);
+            }
+        }
+        catch(...)
+        {
+            for(i = 0; i < ac + 1; ++i)
+            {
+                free(av[i]);
+            }
+            delete[] av;
+
+            throw;
+        }
+        
+        //
+        // Replace the contents of the given argument list with the filtered arguments.
+        //
+        if(!NIL_P(args))
+        {
+            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);
+            }
+        }
+
+        for(i = 0; i < ac + 1; ++i)
+        {
+            free(av[i]);
+        }
+        delete[] av;
+
+        ObjectFactoryPtr factory = new ObjectFactory;
+        communicator->addObjectFactory(factory, "");
+
+        VALUE result = Data_Wrap_Struct(_communicatorClass, IceRuby_Communicator_mark,
+                                        IceRuby_Communicator_free, new Ice::CommunicatorPtr(communicator));
+
+        CommunicatorMap::iterator p = _communicatorMap.find(communicator);
+        if(p != _communicatorMap.end())
+        {
+            _communicatorMap.erase(p);
+        }
+        _communicatorMap.insert(CommunicatorMap::value_type(communicator, reinterpret_cast<const VALUE&>(result)));
+
+        return result;
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+extern "C"
+VALUE
+IceRuby_Communicator_destroy(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::CommunicatorPtr p = getCommunicator(self);
+        p->destroy();
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+extern "C"
+VALUE
+IceRuby_Communicator_shutdown(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::CommunicatorPtr p = getCommunicator(self);
+        p->shutdown();
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+extern "C"
+VALUE
+IceRuby_Communicator_isShutdown(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::CommunicatorPtr p = getCommunicator(self);
+        return p->isShutdown() ? Qtrue : Qfalse;
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+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)
+        {
+            return createProxy(proxy);
+        }
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+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))
+        {
+            if(!checkProxy(proxy))
+            {
+                throw RubyException(rb_eTypeError, "argument must be a proxy");
+            }
+            prx = getProxy(proxy);
+        }
+        string str = p->proxyToString(prx);
+        return createString(str);
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+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)
+        {
+            return createProxy(proxy);
+        }
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+extern "C"
+VALUE
+IceRuby_Communicator_proxyToProperty(VALUE self, VALUE obj, VALUE str)
+{
+    ICE_RUBY_TRY
+    {
+        if(!checkProxy(obj))
+        {
+            throw RubyException(rb_eTypeError, "argument must be a proxy");
+        }
+        Ice::CommunicatorPtr p = getCommunicator(self);
+        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)
+        {
+            volatile VALUE key = createString(q->first);
+            volatile VALUE value = createString(q->second);
+            callRuby(rb_hash_aset, result, key, value);
+        }
+        return result; 
+    }
+    ICE_RUBY_CATCH
+    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
+IceRuby_Communicator_identityToString(VALUE self, VALUE id)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::CommunicatorPtr p = getCommunicator(self);
+        Ice::Identity ident = getIdentity(id);
+        string str = p->identityToString(ident);
+        return createString(str);
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+extern "C"
+VALUE
+IceRuby_Communicator_addObjectFactory(VALUE self, VALUE factory, VALUE id)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::CommunicatorPtr p = getCommunicator(self);
+        ObjectFactoryPtr pof = ObjectFactoryPtr::dynamicCast(p->findObjectFactory(""));
+        assert(pof);
+        string idstr = getString(id);
+        pof->add(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);
+        ObjectFactoryPtr pof = ObjectFactoryPtr::dynamicCast(p->findObjectFactory(""));
+        assert(pof);
+        string idstr = getString(id);
+        return pof->find(idstr);
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+extern "C"
+VALUE
+IceRuby_Communicator_getImplicitContext(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::CommunicatorPtr p = getCommunicator(self);
+        Ice::ImplicitContextPtr implicitContext = p->getImplicitContext();
+        return createImplicitContext(implicitContext);
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+
+extern "C"
+VALUE
+IceRuby_Communicator_getProperties(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::CommunicatorPtr p = getCommunicator(self);
+        Ice::PropertiesPtr props = p->getProperties();
+        return createProperties(props);
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+extern "C"
+VALUE
+IceRuby_Communicator_getLogger(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::CommunicatorPtr p = getCommunicator(self);
+        Ice::LoggerPtr logger = p->getLogger();
+        return createLogger(logger);
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+extern "C"
+VALUE
+IceRuby_Communicator_getDefaultRouter(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::CommunicatorPtr p = getCommunicator(self);
+        Ice::RouterPrx router = p->getDefaultRouter();
+        if(router)
+        {
+            volatile VALUE cls = callRuby(rb_path2class, "Ice::RouterPrx");
+            assert(!NIL_P(cls));
+            return createProxy(router, cls);
+        }
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+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))
+        {
+            if(!checkProxy(router))
+            {
+                throw RubyException(rb_eTypeError, "argument must be a proxy");
+            }
+            proxy = Ice::RouterPrx::uncheckedCast(getProxy(router));
+        }
+        p->setDefaultRouter(proxy);
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+extern "C"
+VALUE
+IceRuby_Communicator_getDefaultLocator(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::CommunicatorPtr p = getCommunicator(self);
+        Ice::LocatorPrx locator = p->getDefaultLocator();
+        if(locator)
+        {
+            volatile VALUE cls = callRuby(rb_path2class, "Ice::LocatorPrx");
+            assert(!NIL_P(cls));
+            return createProxy(locator, cls);
+        }
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+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))
+        {
+            if(!checkProxy(locator))
+            {
+                throw RubyException(rb_eTypeError, "argument must be a proxy");
+            }
+            proxy = Ice::LocatorPrx::uncheckedCast(getProxy(locator));
+        }
+        p->setDefaultLocator(proxy);
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+extern "C"
+VALUE
+IceRuby_Communicator_flushBatchRequests(VALUE self)
+{
+    ICE_RUBY_TRY
+    {
+        Ice::CommunicatorPtr p = getCommunicator(self);
+        p->flushBatchRequests();
+    }
+    ICE_RUBY_CATCH
+    return Qnil;
+}
+
+void
+IceRuby::initCommunicator(VALUE iceModule)
+{
+    rb_define_module_function(iceModule, "initialize", CAST_METHOD(IceRuby_initialize), -1);
+
+    _communicatorClass = rb_define_class_under(iceModule, "CommunicatorI", rb_cObject);
+    rb_define_method(_communicatorClass, "destroy", CAST_METHOD(IceRuby_Communicator_destroy), 0);
+    rb_define_method(_communicatorClass, "shutdown", CAST_METHOD(IceRuby_Communicator_shutdown), 0);
+    rb_define_method(_communicatorClass, "isShutdown", CAST_METHOD(IceRuby_Communicator_isShutdown), 0);
+    rb_define_method(_communicatorClass, "stringToProxy", CAST_METHOD(IceRuby_Communicator_stringToProxy), 1);
+    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, "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);
+    rb_define_method(_communicatorClass, "getDefaultRouter", CAST_METHOD(IceRuby_Communicator_getDefaultRouter), 0);
+    rb_define_method(_communicatorClass, "setDefaultRouter", CAST_METHOD(IceRuby_Communicator_setDefaultRouter), 1);
+    rb_define_method(_communicatorClass, "getDefaultLocator", CAST_METHOD(IceRuby_Communicator_getDefaultLocator), 0);
+    rb_define_method(_communicatorClass, "setDefaultLocator", CAST_METHOD(IceRuby_Communicator_setDefaultLocator), 1);
+    rb_define_method(_communicatorClass, "flushBatchRequests", CAST_METHOD(IceRuby_Communicator_flushBatchRequests), 0);
+}
+
+Ice::CommunicatorPtr
+IceRuby::getCommunicator(VALUE v)
+{
+    Ice::CommunicatorPtr* p = reinterpret_cast<Ice::CommunicatorPtr*>(DATA_PTR(v));
+    assert(p);
+    return *p;
+}
+
+VALUE
+IceRuby::lookupCommunicator(const Ice::CommunicatorPtr& p)
+{
+    CommunicatorMap::iterator q = _communicatorMap.find(p.get());
+    if(q != _communicatorMap.end())
+    {
+        return q->second;
+    }
+    return Qnil;
+}