r2corba 1.6.1-x64-mingw-ucrt

data/lib/corba/jbase/Request.rb

@@ -0,0 +1,225 @@
+#--------------------------------------------------------------------
+# Request.rb - Java/JacORB CORBA Request definitions
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the R2CORBA LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+#--------------------------------------------------------------------
+module R2CORBA
+  module CORBA
+
+    module Request
+      @@wrapper_klass = Class.new do
+        include CORBA::Request
+        def initialize(nreq, target)
+          @req_ = nreq
+          @target = target
+        end
+        attr_reader :req_
+        attr_reader :target
+      end
+
+      def self._wrap_native(nreq, target)
+        raise ArgumentError, 'Expected org.omg.CORBA.Request' unless nreq.nil? || nreq.is_a?(Native::Request)
+        nreq.nil?() ? nreq : @@wrapper_klass.new(nreq, target)
+      end
+
+      def operation
+        begin
+          self.req_.operation()
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      def add_in_arg(tc, val, nm = '')
+        begin
+          self.req_.arguments.add_value(nm, Any.to_any(val, tc).to_java(self.req_.target._orb), CORBA::ARG_IN)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+        self.req_.arguments.count
+      end
+
+      def add_out_arg(tc, nm = '')
+        begin
+          self.req_.arguments.add_value(nm, Any.to_any(nil, tc).to_java(self.req_.target._orb), CORBA::ARG_OUT)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+        self.req_.arguments.count
+      end
+
+      def add_inout_arg(tc, val, nm = '')
+        begin
+          self.req_.arguments.add_value(nm, Any.to_any(val, tc).to_java(self.req_.target._orb), CORBA::ARG_INOUT)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+        self.req_.arguments.count
+      end
+
+      def arguments
+        begin
+          nvl = self.req_.arguments
+          (0..nvl.count).to_a.collect do |i|
+            nv = nvl.item(i)
+            [nv.name,
+             nv.flags,
+             CORBA::TypeCode.from_java(nv.value.type),
+             Any.from_java(nv.value, self.req_.target._orb)]
+          end
+        rescue
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      def arguments=(*args)
+        if args.size == 1
+          raise ArgumentError, 'invalid argument list' unless ::Array === args.first && args.first.all? {|a| ::Array === a }
+          args = args.first
+        else
+          raise ArgumentError, 'invalid argument list' unless args.all? {|a| ::Array === a }
+        end
+        # clear current arguments
+        begin
+          nvl = self.req_.arguments
+          nvl.remove(0) while nvl.count > 0
+        rescue
+          CORBA::Exception.native2r($!)
+        end
+        # add new arguments
+        args.each do |nm, flag, tc, val|
+          case flag
+          when CORBA::ARG_IN
+            self.add_in_arg(tc, val, nm)
+          when CORBA::ARG_OUT
+            self.add_out_arg(tc, nm)
+          when CORBA::ARG_INOUT
+            self.add_inout_arg(tc, val, nm)
+          end
+        end
+      end
+
+      def exceptions
+        begin
+          exl = self.req_.exceptions
+          (0..exl.count).to_a.collect do |i|
+            CORBA::TypeCode.from_java(exl.item(i))
+          end
+        rescue
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      def exceptions=(exl)
+        begin
+          # clear current exceptions
+          jexl = self.req_.exceptions
+          jexl.remove(0) while jexl.count > 0
+          # add new exceptions
+          exl.each do |extc|
+            jexl.add(extc.tc_)
+          end
+        rescue
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      def set_return_type(tc)
+        @return_type = tc
+        begin
+          self.req_.set_return_type(tc.tc_)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      def return_value
+        begin
+          Any.from_java(self.req_.return_value, self.req_.target._orb, @return_type)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      def invoke
+        begin
+          self.req_.invoke
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+        jex = self.req_.env().exception()
+        unless jex.nil?
+          STDERR.puts "#{jex}\n#{jex.backtrace.join("\n")}" if $VERBOSE
+          if jex.is_a?(CORBA::Native::SystemException)
+            CORBA::SystemException._raise(jex)
+          elsif jex.is_a?(CORBA::Native::UnknownUserException)
+            CORBA::UserException._raise(jex)
+          else
+            raise CORBA::UNKNOWN.new(jex.getMessage(), 0, CORBA::COMPLETED_MAYBE)
+          end
+        end
+        self.result
+      end
+
+      def send_oneway
+        begin
+          self.req_.send_oneway
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      def send_deferred
+        begin
+          self.req_.send_deferred
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      def poll_response
+        begin
+          self.req_.poll_response
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      def get_response
+        begin
+          self.req_.get_response
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      protected
+
+      def result
+        rc = self.req_.return_value.type.kind.value == CORBA::TK_VOID ? [] : [self.return_value]
+        begin
+          nvl = self.req_.arguments
+          nvl.count.times do |i|
+            nv = nvl.item(i)
+            rc << Any.from_java(nv.value, self.req_.target._orb) unless nv.flags == CORBA::ARG_IN
+          end
+        rescue
+          CORBA::Exception.native2r($!)
+        end
+        if rc.size < 2
+          return rc.shift
+        else
+          return *rc
+        end
+      end
+
+    end
+
+  end # CORBA
+end # R2CORBA

data/lib/corba/jbase/Servant.rb

@@ -0,0 +1,247 @@
+#--------------------------------------------------------------------
+# Servant.rb - R2TAO CORBA Servant support
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the R2CORBA LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+#--------------------------------------------------------------------
+
+module R2CORBA
+
+  module PortableServer
+
+    module DSI
+
+      class Servant < PortableServer::Native::DynamicImplementation
+        def self.new_instance(rsrv)
+          srv = PortableServer::DSI::Servant.new
+          srv.__send__(:init, rsrv)
+          srv
+        end
+
+        private
+        def init(rsrv)
+          @rsrv = rsrv
+        end
+
+        public
+        def rbServant
+          @rsrv
+        end
+
+        def detach_rbServant()
+          @rsrv = nil
+        end
+
+        def invoke(jsrvreq)
+          begin
+            raise CORBA::NO_IMPLEMENT.new('', 0, CORBA::COMPLETED_NO) unless @rsrv
+            rsrvreq = CORBA::ServerRequest._wrap_native(jsrvreq, self._orb())
+            begin
+              case rsrvreq.srvreq_.operation()
+              when '_is_a'
+                rsrvreq.describe({:arg_list => [['', CORBA::ARG_IN, CORBA._tc_string]], :result_type => CORBA._tc_boolean})
+                rc = self._is_a(*rsrvreq.arguments)
+                jany = rsrvreq.orb_.create_any()
+                jany.insert_boolean(rc == true)
+                jsrvreq.set_result(jany)
+              when '_non_existent'
+                rsrvreq.describe({:arg_list => [], :result_type => CORBA._tc_boolean})
+                rc = self._non_existent(*rsrvreq.arguments)
+                jany = rsrvreq.orb_.create_any()
+                jany.insert_boolean(rc == true)
+                jsrvreq.set_result(jany)
+              when '_repository_id'
+                rsrvreq.describe({:arg_list => [], :result_type => CORBA._tc_string})
+                rc = self._repository_id(*rsrvreq.arguments)
+                jany = rsrvreq.orb_.create_any()
+                jany.insert_string(rc)
+                jsrvreq.set_result(jany)
+              when '_component'
+                rsrvreq.describe({:arg_list => [], :result_type => CORBA._tc_Object})
+                rc = self._get_component(*rsrvreq.arguments)
+                jany = rsrvreq.orb_.create_any()
+                jany.insert_Object(rc)
+                jsrvreq.set_result(jany)
+              else
+                @rsrv.is_a?(PortableServer::DynamicImplementation) ? self.invoke_DSI(rsrvreq) : self.invoke_SI(rsrvreq)
+              end
+            rescue NativeException => ex_
+              CORBA::Exception.native2r(ex_)
+            end
+          rescue CORBA::UserException => ex_
+            STDERR.puts "#{ex_}\n#{ex_.backtrace.join("\n")}" if $VERBOSE
+            if rsrvreq.exc_list_.nil? || rsrvreq.exc_list_.any? {|extc| extc.id == ex_.class._tc.id }
+              jsrvreq.set_exception(CORBA::Any.to_any(ex_).to_java(self._orb()))
+            else
+              STDERR.puts "#{ex_}\n#{ex_.backtrace.join("\n")}" unless $VERBOSE
+              if jsrvreq.respond_to?(:setSystemException) # JacORB special
+                jsrvreq.setSystemException(CORBA::Native::UNKNOWN.new("#{ex_}", 0, CORBA::Native::CompletionStatus.from_int(CORBA::COMPLETED_MAYBE)))
+              else
+                jsrvreq.set_exception(CORBA::Any.to_any(CORBA::UNKNOWN.new("#{ex_}", 0, CORBA::COMPLETED_MAYBE)).to_java(self._orb()))
+              end
+            end
+          rescue CORBA::SystemException => ex_
+            STDERR.puts "#{ex_}\n#{ex_.backtrace.join("\n")}" if $VERBOSE
+            if jsrvreq.respond_to?(:setSystemException) # JacORB special
+              jex_klass = CORBA::Native.const_get(ex_.class::Name)
+              jsrvreq.setSystemException(jex_klass.new(ex_.reason, ex_.minor, CORBA::Native::CompletionStatus.from_int(ex_.completed)))
+            else
+              jsrvreq.set_exception(CORBA::Any.to_any(ex_).to_java(self._orb()))
+            end
+          rescue Exception => ex_
+            STDERR.puts "#{ex_}\n#{ex_.backtrace.join("\n")}"
+            if jsrvreq.respond_to?(:setSystemException) # JacORB special
+              jsrvreq.setSystemException(CORBA::Native::UNKNOWN.new("#{ex_}", 0, CORBA::Native::CompletionStatus.from_int(CORBA::COMPLETED_MAYBE)))
+            else
+              jsrvreq.set_exception(CORBA::Any.to_any(CORBA::UNKNOWN.new("#{ex_}", 0, CORBA::COMPLETED_MAYBE)).to_java(self._orb()))
+            end
+          end
+        end
+
+        def _all_interfaces(poa, oid)
+          if @rsrv.nil?
+            return [].to_java(:string)
+          elsif @rsrv.respond_to?(:_ids)
+            return @rsrv._ids.to_java(:string)
+          elsif @rsrv.class.constants.any? {|c| c.to_sym == :Ids }
+            return @rsrv.class::Ids.to_java(:string)
+          elsif @rsrv.respond_to?(:_primary_interface)
+            return [@rsrv._primary_interface(oid, poa)].to_java(:string)
+          else
+            return [].to_java(:string)
+          end
+        end
+
+        def _is_a(repo_id)
+          if @rsrv.nil?
+            return false
+          elsif @rsrv.respond_to?('_is_a?'.to_sym)
+            return @rsrv._is_a?(repo_id)
+          else
+            begin
+              return @rsrv.class::Ids.include?(repo_id)
+            rescue
+              return super
+            end
+          end
+        end
+
+        def _repository_id
+          if @rsrv.nil?
+            return ''
+          elsif @rsrv.respond_to?(:_repository_id)
+            return @rsrv._repository_id
+          else
+            return (@rsrv.class.const_get(:Id) rescue '')
+          end
+        end
+
+        def _non_existent()
+          if @rsrv.nil?
+            return true
+          elsif @rsrv.respond_to?(:_non_existent)
+            return @rsrv._non_existent
+          else
+            return super
+          end
+        end
+
+        def _get_component()
+          if @rsrv.nil?
+            return nil
+          elsif @rsrv.respond_to?(:_get_component)
+            obj = @rsrv._get_component
+            return obj ? obj.objref_ : nil
+          else
+            return super
+          end
+        end
+        protected
+        def invoke_SI(rsrvreq)
+          opsym = rsrvreq.srvreq_.operation().to_sym
+          opsig = @rsrv.get_operation_signature(opsym)
+          # explicitly define empty (but not nil) exceptionlist if not yet specified
+          opsig[:exc_list] = [] if (Hash === opsig) && !opsig.has_key?(:exc_list)
+          rsrvreq.describe(opsig)
+          alt_opsym = opsig[:op_sym]
+          opsym = alt_opsym if alt_opsym && alt_opsym.is_a?(Symbol)
+          results = @rsrv.__send__(opsym, *rsrvreq.arguments)
+          unless rsrvreq.result_type_.nil?
+            result_value = (rsrvreq.arg_out_ > 0 ? results.shift : results) unless rsrvreq.result_type_.kind == CORBA::TK_VOID
+            if rsrvreq.arg_out_ > 0
+              rsrvreq.nvlist_.count().times do |i|
+                jnv = rsrvreq.nvlist_.item(i)
+                if [CORBA::ARG_OUT, CORBA::ARG_INOUT].include?(jnv.flags)
+                  rval = results.shift
+                  rtc = rsrvreq.arg_list_[i][2]
+                  CORBA::Any.to_any(rval, rtc).to_java(self._orb(), jnv.value())
+                end
+              end
+            end
+            unless rsrvreq.result_type_.kind == CORBA::TK_VOID
+              rsrvreq.srvreq_.set_result(CORBA::Any.to_any(result_value, rsrvreq.result_type_).to_java(self._orb()))
+            end
+          end
+        end
+
+        def invoke_DSI(rsrvreq)
+          results = @rsrv.invoke(rsrvreq)
+          unless rsrvreq.result_type_.nil?
+            result_value = (rsrvreq.arg_out_ > 0 ? results.shift : results) unless rsrvreq.result_type_.kind == CORBA::TK_VOID
+            if rsrvreq.arg_out_ > 0
+              rsrvreq.nvlist_.count().times do |i|
+                jnv = rsrvreq.nvlist_.item(i)
+                if [CORBA::ARG_OUT, CORBA::ARG_INOUT].include?(jnv.flags)
+                  rval = results.shift
+                  rtc = rsrvreq.arg_list_[i][2]
+                  CORBA::Any.to_any(rval, rtc).to_java(self._orb(), jnv.value())
+                end
+              end
+            end
+            unless rsrvreq.result_type_.kind == CORBA::TK_VOID
+              rsrvreq.srvreq_.set_result(CORBA::Any.to_any(result_value, rsrvreq.result_type_).to_java(self._orb()))
+            end
+          end
+        end
+      end # Servant
+
+    end # DSI
+
+    class Servant
+      def srvref_
+        @srvref_ ||= PortableServer::DSI::Servant.new_instance(self)
+      end
+
+      def _default_POA()
+        begin
+          return PortableServer::POA._narrow(CORBA::Object._wrap_native(self.srvref_._default_POA()))
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      def _this()
+        unless @srvref_.nil?
+          begin
+            return CORBA::Object._wrap_native(self.srvref_._this_object())
+          rescue NativeException
+            # not in call context or not associated with ORB yet
+          end
+        end
+        raise CORBA::BAD_INV_ORDER.new('no ORB initialized', 0, CORBA::COMPLETED_NO) if CORBA::ORB._orb.nil?
+        begin
+          return CORBA::Object._wrap_native(self.srvref_._this_object(CORBA::ORB._orb))
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+    end # Servant
+
+  end # PortableServer
+
+end # R2CORBA

data/lib/corba/jbase/ServerRequest.rb

@@ -0,0 +1,127 @@
+#--------------------------------------------------------------------
+# ServerRequest.rb - R2TAO CORBA ServerRequest support
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the R2CORBA LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+#--------------------------------------------------------------------
+
+module R2CORBA
+
+  module CORBA
+
+    module ServerRequest
+      @@wrapper_klass = Class.new do
+        include CORBA::ServerRequest
+        def initialize(jsrvreq, jorb)
+          @srvreq_ = jsrvreq
+          @orb_ = jorb
+          @nvlist_ = nil
+          @result_type_ = nil
+          @arg_list_ = nil
+          @exc_list_ = nil
+          @arg_ = nil
+          @arg_index_ = nil
+          @arg_out_ = 0
+        end
+        attr_reader :srvreq_
+        attr_reader :orb_
+        attr_reader :arg_list_
+        attr_reader :result_type_
+        attr_reader :exc_list_
+        attr_reader :nvlist_
+        attr_reader :arg_out_
+      end
+
+      def self._wrap_native(jsrvreq, jorb)
+        raise ArgumentError, 'Expected org.omg.CORBA.ServerRequest' unless jsrvreq.is_a?(Native::ServerRequest)
+        raise ArgumentError, 'Expected org.omg.CORBA.ORB' unless jorb.is_a?(Native::ORB)
+        @@wrapper_klass.new(jsrvreq, jorb)
+      end
+
+      def operation
+        begin
+          self.srvreq_.operation
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      def describe(opsig)
+        raise CORBA::BAD_INV_ORDER.new('', 0, CORBA::COMPLETED_NO) if @nvlist_
+        raise CORBA::NO_IMPLEMENT.new('', 0, CORBA::COMPLETED_NO) unless opsig && (Hash === opsig)
+        @arg_list_ = opsig[:arg_list]
+        @result_type_ = opsig[:result_type]
+        @exc_list_ = opsig[:exc_list]
+        raise CORBA::BAD_PARAM.new('', 0, CORBA::COMPLETED_NO) unless (@arg_list_.nil? || @arg_list_.is_a?(Array)) &&
+                                                                    (@result_type_.nil? || @result_type_.is_a?(CORBA::TypeCode)) &&
+                                                                    (@exc_list_.nil? || @exc_list_.is_a?(Array))
+        @nvlist_ = extract_arguments_(@arg_list_)
+        self
+      end
+
+      def arguments
+        raise CORBA::BAD_INV_ORDER.new('', 0, CORBA::COMPLETED_NO) unless @nvlist_
+        unless @arg_
+          @arg_ = []
+          @nvlist_.count().times do |i|
+            jnv = @nvlist_.item(i)
+            @arg_ << CORBA::Any.from_java(jnv.value, self.orb_, @arg_list_[i][2]) if [CORBA::ARG_IN, CORBA::ARG_INOUT].include?(jnv.flags)
+            @arg_out_ += 1 if [CORBA::ARG_OUT, CORBA::ARG_INOUT].include?(jnv.flags)
+          end
+        end
+        @arg_
+      end
+
+      def [](key)
+        self.arguments # make sure the @arg_ member has been initialized
+        key = arg_index_from_name(key) if String === key
+        key = key.to_i if key
+        raise CORBA::BAD_PARAM.new('', 0, CORBA::COMPLETD_NO) unless key && (key >= 0) && (key < @arg_.size)
+        @arg_[key]
+      end
+
+      def []=(key, val)
+        self.arguments # make sure the @arg_ member has been initialized
+        key = arg_index_from_name(key) if String === key
+        key = key.to_i if key
+        raise CORBA::BAD_PARAM.new('', 0, CORBA::COMPLETD_NO) unless key && (key >= 0) && (key < @arg_.size)
+        jnv = @nvlist_.item(key)
+        rtc = @arg_list_[key][2]
+        CORBA::Any.to_any(val, rtc).to_java(self.orb_, jnv.value())
+        @arg_[key] = val
+      end
+
+      protected
+      def arg_index_from_name(arg_name)
+        unless @arg_index_
+          @arg_index_ = {}
+          @nvlist_.count().times do |i|
+            jnv = @nvlist_.item(i)
+            @arg_index_[jnv.name] = i
+          end
+        end
+        @arg_index_[arg_name]
+      end
+
+      def extract_arguments_(arg_list)
+        jnvlist = self.orb_.create_list(0)
+        unless arg_list.nil?
+          arg_list.each do |argnm, argf, argtc|
+            raise CORBA::BAD_PARAM.new('', 0, CORBA::COMPLETED_NO) if argf.nil? || argtc.nil? || !argtc.is_a?(CORBA::TypeCode)
+            jnvlist.add_value(argnm.to_s, Any.to_any(nil, argtc).to_java(@orb_), argf.to_i)
+          end
+          self.srvreq_.arguments(jnvlist)
+        end
+        jnvlist
+      end
+
+    end # ServerRequest
+
+  end # CORBA
+
+end # R2CORBA