zeroc-ice 3.7.9.1 → 3.8.0

data/ext/Operation.cpp

@@ -1,661 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Operation.h>
-#include <Proxy.h>
-#include <Types.h>
-#include <Util.h>
-#include <Ice/Communicator.h>
-#include <Ice/Initialize.h>
-#include <Ice/LocalException.h>
-#include <Ice/Logger.h>
-#include <Ice/Properties.h>
-#include <Ice/Proxy.h>
-#include <Slice/RubyUtil.h>
-
-using namespace std;
-using namespace IceRuby;
-using namespace Slice::Ruby;
-
-static VALUE _operationClass;
-
-namespace IceRuby
-{
-
-class ParamInfo : public UnmarshalCallback
-{
-public:
-
-    virtual void unmarshaled(VALUE, VALUE, void*);
-
-    TypeInfoPtr type;
-    bool optional;
-    int tag;
-    int pos;
-};
-typedef IceUtil::Handle<ParamInfo> ParamInfoPtr;
-typedef list<ParamInfoPtr> ParamInfoList;
-
-class OperationI : public Operation
-{
-public:
-
-    OperationI(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
-
-    virtual VALUE invoke(const Ice::ObjectPrx&, VALUE, VALUE);
-    virtual void deprecate(const string&);
-
-private:
-
-    string _name;
-    Ice::OperationMode _mode;
-    Ice::OperationMode _sendMode;
-    bool _amd;
-    Ice::FormatType _format;
-    ParamInfoList _inParams;
-    ParamInfoList _optionalInParams;
-    ParamInfoList _outParams;
-    ParamInfoList _optionalOutParams;
-    ParamInfoPtr _returnType;
-    ExceptionInfoList _exceptions;
-    string _dispatchName;
-    bool _sendsClasses;
-    bool _returnsClasses;
-    string _deprecateMessage;
-
-    void convertParams(VALUE, ParamInfoList&, long, bool&);
-    ParamInfoPtr convertParam(VALUE, long);
-    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;
-    void checkTwowayOnly(const Ice::ObjectPrx&) const;
-};
-typedef IceUtil::Handle<OperationI> OperationIPtr;
-
-class UserExceptionFactory : public Ice::UserExceptionFactory
-{
-public:
-
-    virtual void createAndThrow(const string& id)
-    {
-        ExceptionInfoPtr info = lookupExceptionInfo(id);
-        if(info)
-        {
-            throw ExceptionReader(info);
-        }
-    }
-};
-
-}
-
-extern "C"
-void
-IceRuby_Operation_free(OperationPtr* p)
-{
-    delete p;
-}
-
-extern "C"
-VALUE
-IceRuby_defineOperation(VALUE /*self*/, VALUE name, VALUE mode, VALUE sendMode, VALUE amd, VALUE format, VALUE inParams,
-                        VALUE outParams, VALUE returnType, VALUE exceptions)
-{
-    ICE_RUBY_TRY
-    {
-        OperationIPtr op = new OperationI(name, mode, sendMode, amd, format, inParams, outParams, returnType,
-                                          exceptions);
-        return Data_Wrap_Struct(_operationClass, 0, IceRuby_Operation_free, new OperationPtr(op));
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
-IceRuby_Operation_invoke(VALUE self, VALUE proxy, VALUE opArgs, VALUE ctx)
-{
-    ICE_RUBY_TRY
-    {
-        assert(TYPE(opArgs) == T_ARRAY);
-
-        OperationPtr op = getOperation(self);
-        assert(op);
-        return op->invoke(getProxy(proxy), opArgs, ctx);
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-extern "C"
-VALUE
-IceRuby_Operation_deprecate(VALUE self, VALUE msg)
-{
-    ICE_RUBY_TRY
-    {
-        OperationPtr op = getOperation(self);
-        assert(op);
-        op->deprecate(getString(msg));
-    }
-    ICE_RUBY_CATCH
-    return Qnil;
-}
-
-//
-// Operation implementation.
-//
-IceRuby::Operation::~Operation()
-{
-}
-
-//
-// ParamInfo implementation.
-//
-void
-IceRuby::ParamInfo::unmarshaled(VALUE val, VALUE target, void* closure)
-{
-    assert(TYPE(target) == T_ARRAY);
-#ifdef ICE_64
-    long i = static_cast<long>(reinterpret_cast<long long>(closure));
-#else
-    long i = reinterpret_cast<long>(closure);
-#endif
-    RARRAY_ASET(target, i, val);
-}
-
-//
-// OperationI implementation.
-//
-IceRuby::OperationI::OperationI(VALUE name, VALUE mode, VALUE sendMode, VALUE amd, VALUE format, VALUE inParams,
-                                VALUE outParams, VALUE returnType, VALUE exceptions)
-{
-    _name = getString(name);
-    _amd = amd == Qtrue;
-    if(_amd)
-    {
-        _dispatchName = fixIdent(_name, IdentNormal) + "_async";
-    }
-    else
-    {
-        _dispatchName = fixIdent(_name, IdentNormal);
-    }
-
-    //
-    // mode
-    //
-    volatile VALUE modeValue = callRuby(rb_funcall, mode, rb_intern("to_i"), 0);
-    assert(TYPE(modeValue) == T_FIXNUM);
-    _mode = static_cast<Ice::OperationMode>(FIX2LONG(modeValue));
-
-    //
-    // sendMode
-    //
-    volatile VALUE sendModeValue = callRuby(rb_funcall, sendMode, rb_intern("to_i"), 0);
-    assert(TYPE(sendModeValue) == T_FIXNUM);
-    _sendMode = static_cast<Ice::OperationMode>(FIX2LONG(sendModeValue));
-
-    //
-    // format
-    //
-    if(format == Qnil)
-    {
-        _format = Ice::DefaultFormat;
-    }
-    else
-    {
-        volatile VALUE formatValue = callRuby(rb_funcall, format, rb_intern("to_i"), 0);
-        assert(TYPE(formatValue) == T_FIXNUM);
-        _format = static_cast<Ice::FormatType>(FIX2LONG(formatValue));
-    }
-
-    //
-    // returnType
-    //
-    _returnsClasses = false;
-    if(!NIL_P(returnType))
-    {
-        _returnType = convertParam(returnType, 0);
-        if(!_returnType->optional)
-        {
-            _returnsClasses = _returnType->type->usesClasses();
-        }
-    }
-
-    //
-    // inParams
-    //
-    _sendsClasses = false;
-    convertParams(inParams, _inParams, 0, _sendsClasses);
-
-    //
-    // outParams
-    //
-    convertParams(outParams, _outParams, NIL_P(returnType) ? 0 : 1, _returnsClasses);
-
-    class SortFn
-    {
-    public:
-        static bool compare(const ParamInfoPtr& lhs, const ParamInfoPtr& rhs)
-        {
-            return lhs->tag < rhs->tag;
-        }
-
-        static bool isRequired(const ParamInfoPtr& i)
-        {
-            return !i->optional;
-        }
-    };
-
-    //
-    // The inParams list represents the parameters in the order of declaration.
-    // We also need a sorted list of optional parameters.
-    //
-    ParamInfoList l = _inParams;
-    copy(l.begin(), remove_if(l.begin(), l.end(), SortFn::isRequired), back_inserter(_optionalInParams));
-    _optionalInParams.sort(SortFn::compare);
-
-    //
-    // The outParams list represents the parameters in the order of declaration.
-    // We also need a sorted list of optional parameters. If the return value is
-    // optional, we must include it in this list.
-    //
-    l = _outParams;
-    copy(l.begin(), remove_if(l.begin(), l.end(), SortFn::isRequired), back_inserter(_optionalOutParams));
-    if(_returnType && _returnType->optional)
-    {
-        _optionalOutParams.push_back(_returnType);
-    }
-    _optionalOutParams.sort(SortFn::compare);
-
-    //
-    // exceptions
-    //
-    for(long i = 0; i < RARRAY_LEN(exceptions); ++i)
-    {
-        _exceptions.push_back(getException(RARRAY_AREF(exceptions, i)));
-    }
-}
-
-VALUE
-IceRuby::OperationI::invoke(const Ice::ObjectPrx& proxy, VALUE args, VALUE hctx)
-{
-    Ice::CommunicatorPtr communicator = proxy->ice_getCommunicator();
-
-    //
-    // Marshal the input parameters to a byte sequence.
-    //
-    Ice::OutputStream os(communicator);
-    pair<const Ice::Byte*, const Ice::Byte*> params;
-    prepareRequest(proxy, args, &os, params);
-
-    if(!_deprecateMessage.empty())
-    {
-        rb_warning("%s", _deprecateMessage.c_str());
-        _deprecateMessage.clear(); // Only show the warning once.
-    }
-
-    checkTwowayOnly(proxy);
-
-    //
-    // Invoke the operation.
-    //
-    Ice::ByteSeq result;
-    bool status;
-
-    if(!NIL_P(hctx))
-    {
-        Ice::Context ctx;
-        if(!hashToContext(hctx, ctx))
-        {
-            throw RubyException(rb_eArgError, "context argument must be nil or a hash");
-        }
-
-        status = proxy->ice_invoke(_name, _sendMode, params, result, ctx);
-    }
-    else
-    {
-        status = proxy->ice_invoke(_name, _sendMode, params, result);
-    }
-
-    //
-    // Process the reply.
-    //
-    if(proxy->ice_isTwoway())
-    {
-        if(!status)
-        {
-            //
-            // Unmarshal a user exception.
-            //
-            volatile VALUE ex = unmarshalException(result, communicator);
-            throw RubyException(ex);
-        }
-        else if(_outParams.size() > 0 || _returnType)
-        {
-            //
-            // Unmarshal the results. If there is more than one value to be returned, then return them
-            // in an array of the form [result, outParam1, ...]. Otherwise just return the value.
-            //
-            volatile VALUE results = unmarshalResults(result, communicator);
-
-            if(RARRAY_LEN(results)> 1)
-            {
-                return results;
-            }
-            else
-            {
-                return RARRAY_AREF(results, 0);
-            }
-        }
-    }
-
-    return Qnil;
-}
-
-void
-IceRuby::OperationI::deprecate(const string& msg)
-{
-    if(!msg.empty())
-    {
-        _deprecateMessage = msg;
-    }
-    else
-    {
-        _deprecateMessage = "operation " + _name + " is deprecated";
-    }
-}
-
-void
-IceRuby::OperationI::convertParams(VALUE v, ParamInfoList& params, long posOffset, bool& usesClasses)
-{
-    assert(TYPE(v) == T_ARRAY);
-
-    for(long i = 0; i < RARRAY_LEN(v); ++i)
-    {
-        ParamInfoPtr param = convertParam(RARRAY_AREF(v, i), i + posOffset);
-        params.push_back(param);
-        if(!param->optional && !usesClasses)
-        {
-            usesClasses = param->type->usesClasses();
-        }
-    }
-}
-
-ParamInfoPtr
-IceRuby::OperationI::convertParam(VALUE v, long pos)
-{
-    assert(TYPE(v) == T_ARRAY);
-    ParamInfoPtr param = new ParamInfo;
-    param->type = getType(RARRAY_AREF(v, 0));
-    param->optional = static_cast<bool>(RTEST(RARRAY_AREF(v, 1)));
-    param->tag = static_cast<int>(getInteger(RARRAY_AREF(v, 2)));
-    param->pos = static_cast<int>(pos);
-    return param;
-}
-
-void
-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);
-
-    //
-    // Validate the number of arguments.
-    //
-    long argc = RARRAY_LEN(args);
-    long paramCount = static_cast<long>(_inParams.size());
-    if(argc != paramCount)
-    {
-        string fixedName = fixIdent(_name, IdentNormal);
-        throw RubyException(rb_eArgError, "%s expects %ld in parameters", fixedName.c_str(), paramCount);
-    }
-
-    if(!_inParams.empty())
-    {
-        //
-        // Marshal the in parameters.
-        //
-        os->startEncapsulation(proxy->ice_getEncodingVersion(), _format);
-
-        ObjectMap objectMap;
-        ParamInfoList::iterator p;
-
-        //
-        // Validate the supplied arguments.
-        //
-        for(p = _inParams.begin(); p != _inParams.end(); ++p)
-        {
-            ParamInfoPtr info = *p;
-            volatile VALUE arg = RARRAY_AREF(args, info->pos);
-            if((!info->optional || arg != Unset) && !info->type->validate(arg))
-            {
-                string opName = fixIdent(_name, IdentNormal);
-                throw RubyException(rb_eTypeError, "invalid value for argument %ld in operation `%s'", info->pos + 1,
-                                    opName.c_str());
-            }
-        }
-
-        //
-        // Marshal the required parameters.
-        //
-        for(p = _inParams.begin(); p != _inParams.end(); ++p)
-        {
-            ParamInfoPtr info = *p;
-            if(!info->optional)
-            {
-                volatile VALUE arg = RARRAY_AREF(args, info->pos);
-                info->type->marshal(arg, os, &objectMap, false);
-            }
-        }
-
-        //
-        // Marshal the optional parameters.
-        //
-        for(p = _optionalInParams.begin(); p != _optionalInParams.end(); ++p)
-        {
-            ParamInfoPtr info = *p;
-            volatile VALUE arg = RARRAY_AREF(args, info->pos);
-            if(arg != Unset && os->writeOptional(info->tag, info->type->optionalFormat()))
-            {
-                info->type->marshal(arg, os, &objectMap, true);
-            }
-        }
-
-        if(_sendsClasses)
-        {
-            os->writePendingValues();
-        }
-
-        os->endEncapsulation();
-        params = os->finished();
-    }
-}
-
-VALUE
-IceRuby::OperationI::unmarshalResults(const vector<Ice::Byte>& bytes, const Ice::CommunicatorPtr& communicator)
-{
-    int numResults = static_cast<int>(_outParams.size());
-    if(_returnType)
-    {
-        numResults++;
-    }
-    assert(numResults > 0);
-
-    volatile VALUE results = createArray(numResults);
-
-    //
-    // 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::InputStream is(communicator, bytes);
-
-    //
-    // Store a pointer to a local StreamUtil object as the stream's closure.
-    // This is necessary to support object unmarshaling (see ObjectReader).
-    //
-    StreamUtil util;
-    assert(!is.getClosure());
-    is.setClosure(&util);
-
-    is.startEncapsulation();
-
-    ParamInfoList::iterator p;
-
-    //
-    // Unmarshal the required out parameters.
-    //
-    for(p = _outParams.begin(); p != _outParams.end(); ++p)
-    {
-        ParamInfoPtr info = *p;
-        if(!info->optional)
-        {
-            void* closure = reinterpret_cast<void*>(info->pos);
-            info->type->unmarshal(&is, info, results, closure, false);
-        }
-    }
-
-    //
-    // Unmarshal the required return value, if any.
-    //
-    if(_returnType && !_returnType->optional)
-    {
-        assert(_returnType->pos == 0);
-        void* closure = reinterpret_cast<void*>(_returnType->pos);
-        _returnType->type->unmarshal(&is, _returnType, results, closure, false);
-    }
-
-    //
-    // Unmarshal the optional results. This includes an optional return value.
-    //
-    for(p = _optionalOutParams.begin(); p != _optionalOutParams.end(); ++p)
-    {
-        ParamInfoPtr info = *p;
-        if(is.readOptional(info->tag, info->type->optionalFormat()))
-        {
-            void* closure = reinterpret_cast<void*>(info->pos);
-            info->type->unmarshal(&is, info, results, closure, true);
-        }
-        else
-        {
-            RARRAY_ASET(results, info->pos, Unset);
-        }
-    }
-
-    if(_returnsClasses)
-    {
-        is.readPendingValues();
-    }
-
-    is.endEncapsulation();
-
-    util.updateSlicedData();
-
-    return results;
-}
-
-VALUE
-IceRuby::OperationI::unmarshalException(const vector<Ice::Byte>& bytes, const Ice::CommunicatorPtr& communicator)
-{
-    Ice::InputStream is(communicator, bytes);
-
-    //
-    // Store a pointer to a local StreamUtil object as the stream's closure.
-    // This is necessary to support object unmarshaling (see ObjectReader).
-    //
-    StreamUtil util;
-    assert(!is.getClosure());
-    is.setClosure(&util);
-
-    is.startEncapsulation();
-
-    try
-    {
-        Ice::UserExceptionFactoryPtr factory = new UserExceptionFactory;
-        is.throwException(factory);
-    }
-    catch(const ExceptionReader& r)
-    {
-        is.endEncapsulation();
-
-        volatile VALUE ex = r.getException();
-
-        if(validateException(ex))
-        {
-            util.updateSlicedData();
-
-            Ice::SlicedDataPtr slicedData = r.getSlicedData();
-            if(slicedData)
-            {
-                StreamUtil::setSlicedDataMember(ex, slicedData);
-            }
-
-            return ex;
-        }
-        else
-        {
-            volatile VALUE cls = CLASS_OF(ex);
-            volatile VALUE path = callRuby(rb_class_path, cls);
-            assert(TYPE(path) == T_STRING);
-            Ice::UnknownUserException e(__FILE__, __LINE__);
-            e.unknown = RSTRING_PTR(path);
-            throw e;
-        }
-    }
-
-    throw Ice::UnknownUserException(__FILE__, __LINE__, "unknown exception");
-#ifdef __SUNPRO_CC
-    return 0;
-#endif
-}
-
-bool
-IceRuby::OperationI::validateException(VALUE ex) const
-{
-    for(ExceptionInfoList::const_iterator p = _exceptions.begin(); p != _exceptions.end(); ++p)
-    {
-        if(callRuby(rb_obj_is_kind_of, ex, (*p)->rubyClass))
-        {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-void
-IceRuby::OperationI::checkTwowayOnly(const Ice::ObjectPrx& proxy) const
-{
-    if((_returnType != 0 || !_outParams.empty()) && !proxy->ice_isTwoway())
-    {
-        Ice::TwowayOnlyException ex(__FILE__, __LINE__);
-        ex.operation = _name;
-        throw ex;
-    }
-}
-
-bool
-IceRuby::initOperation(VALUE iceModule)
-{
-    rb_define_module_function(iceModule, "__defineOperation", CAST_METHOD(IceRuby_defineOperation), 9);
-
-    //
-    // Define a class to represent an operation.
-    //
-    _operationClass = rb_define_class_under(iceModule, "IceRuby_Operation", rb_cObject);
-    rb_undef_alloc_func(_operationClass);
-
-    rb_define_method(_operationClass, "invoke", CAST_METHOD(IceRuby_Operation_invoke), 3);
-    rb_define_method(_operationClass, "deprecate", CAST_METHOD(IceRuby_Operation_deprecate), 1);
-
-    return true;
-}
-
-IceRuby::OperationPtr
-IceRuby::getOperation(VALUE obj)
-{
-    assert(TYPE(obj) == T_DATA);
-    assert(rb_obj_is_instance_of(obj, _operationClass) == Qtrue);
-    OperationPtr* p = reinterpret_cast<OperationPtr*>(DATA_PTR(obj));
-    return *p;
-}

data/ext/Operation.h

@@ -1,31 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_RUBY_OPERATION_H
-#define ICE_RUBY_OPERATION_H
-
-#include <Config.h>
-#include <Ice/CommunicatorF.h>
-
-namespace IceRuby
-{
-
-class Operation : public IceUtil::Shared
-{
-public:
-
-    virtual ~Operation();
-
-    virtual VALUE invoke(const Ice::ObjectPrx&, VALUE, VALUE) = 0;
-    virtual void deprecate(const std::string&) = 0;
-};
-typedef IceUtil::Handle<Operation> OperationPtr;
-
-bool initOperation(VALUE);
-
-OperationPtr getOperation(VALUE);
-
-}
-
-#endif