r2corba 1.6.1-x64-mingw-ucrt

data/lib/corba/cbase/ORB.rb

@@ -0,0 +1,239 @@
+#--------------------------------------------------------------------
+# ORB.rb - C++/TAO CORBA ORB 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
+#--------------------------------------------------------------------
+require 'monitor'
+
+module R2CORBA
+  module CORBA
+
+    module ORB
+
+      class << self
+        protected
+        def _singleton_orb_init
+          CORBA::Native::ORB.init
+        end
+      end
+
+      @@_default_args = []
+      unless R2CORBA::TAO::RUBY_THREAD_SUPPORT
+        # to prevent problems with "green threads" model of Ruby <=1.8.x run TAO
+        # without nested upcalls; preventing thread reuse and re-entrancy
+        @@_default_args << '-ORBSvcConfDirective'
+        @@_default_args << 'static Client_Strategy_Factory "-ORBClientConnectionHandler MT_NOUPCALL"'
+      end
+
+        ## init() or init(arg1, arg2, arg3[, ...]) or init(orb_id, prop = {}) or init(argv, orb_id, prop={}) or init(argv, prop={})
+      def self.init(*args)
+        n_orb = if args.empty? && @@_default_args.empty?
+          _singleton_orb_init
+        else
+          argv = []
+          orb_id = nil
+          prop = nil
+          a1, a2, a3 = args
+          if Array === a1
+            raise ArgumentError, "Incorrect nr. of arguments; #{args.size}" if args.size > 3
+            argv = a1
+            orb_id = (Hash === a2 ? nil : a2)
+            prop = (Hash === a2 ? a2 : a3)
+          elsif args.size == 1 || Hash === a2
+            raise ArgumentError, "Incorrect nr. of arguments; #{args.size}" if args.size > 2
+            orb_id = a1
+            prop = a2
+          else
+            argv = args
+          end
+          raise ArgumentError, "Invalid argument #{prop.class}; expected Hash" unless prop.nil? || Hash === prop
+          unless prop.nil?()
+            prop.inject(argv) {|a, (k, v)| a << k; a << v; a}
+          end
+          @@cached_orb = CORBA::Native::ORB.init(argv.collect {|a| a.to_s }.concat(@@_default_args), orb_id.nil?() ? nil : orb_id.to_s)
+        end
+        unless n_orb.nil?() || @@vf_queue.empty?()
+          @@vf_queue.process_all { |vfklass| vfklass._check_factory }
+        end
+        @@wrapper_klass.new(n_orb)
+      end
+
+=begin
+// Thread related operations
+=end
+
+      # ret [boolean, <time left>] if !timeout.nil? else boolean
+      def work_pending(timeout = nil)
+        begin
+          self.orb_.work_pending(timeout)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      # ret <time left> if !timeout.nil? else void
+      def perform_work(timeout = nil)
+        begin
+          self.orb_.perform_work(timeout)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      # safe to run in thread; even in pre-1.9 MRI Ruby
+      # ret <time left> if !timeout.nil? else void
+      def run(timeout = nil)
+        if R2CORBA::TAO::RUBY_THREAD_SUPPORT
+          begin
+            self.orb_.run(timeout)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        else
+          @running ||= true
+          raise CORBA::BAD_INV_ORDER.new('ORB has been shutdown', 0, CORBA::COMPLETED_NO) if @shutdown
+          while (timeout.nil? or timeout > 0) and !@shutdown
+            to = timeout || 0.05
+            f, to = self.work_pending(to)
+            timeout = to unless timeout.nil?
+            if f and !@shutdown and (timeout.nil? or timeout > 0)
+              to = timeout || 0.05
+              to = self.perform_work(to)
+              timeout = to unless timeout.nil?
+            end
+            Thread.pass unless @shutdown
+          end
+        end
+      end
+
+      unless R2CORBA::TAO::RUBY_THREAD_SUPPORT
+        # starts blocking ORB event loop in MRI Ruby 1.8, i.e. no thread support
+        # ret <time left> if !timeout.nil? else void
+        def run_blocked(timeout = nil)
+          begin
+            self.orb_.run(timeout)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+      end
+
+      # boolean wait_for_completion
+      # ret void
+      def shutdown(wait_for_completion = false)
+        if R2CORBA::TAO::RUBY_THREAD_SUPPORT or !@running
+          begin
+            self.orb_.shutdown(wait_for_completion)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        else
+          @shutdown = true
+        end
+      end
+
+      ## custom
+      @@vf_queue = (Class.new(Monitor) do
+        def initialize
+          @q_ = []
+          super
+        end
+
+        def push(vfklass)
+          synchronize do
+            @q_ << vfklass
+          end
+        end
+
+        def process_all(&block)
+          synchronize do
+            @q_.each { |vf| block.call(vf) }
+            @q_.clear
+          end
+        end
+
+        def empty?()
+          f = false
+          synchronize do
+            f = @q_.empty?
+          end
+          f
+        end
+      end).new
+
+      def self._check_value_factory(vfklass)
+        if @@cached_orb.nil?
+          @@vf_queue.push(vfklass)
+        else
+          vfklass._check_factory
+        end
+      end
+
+      # custom R2CORBA extension : IORMap
+
+      def ior_map
+        @iormap ||= R2CORBA::IORMap.new(self)
+      end
+
+    end # ORB
+
+=begin
+ Signal trapping
+=end
+   private
+     @@sigreg = {}
+     def CORBA.signal_numbers
+      ([1, # HUP
+        2, # INT
+        3, # QUIT
+        5, # TRAP
+        6, # ABRT
+        10, # USR1
+        12, # USR2
+        13, # SIGPIPE
+        14, # ALRM
+        15, # TERM
+        17, # CHLD
+        18, # CONT
+        23, # URG
+        30, # PWR
+        31  # SYS
+       ]) & Signal.list.values
+     end
+
+     def CORBA.handled_signals
+       @@sigreg.clear
+       sigs = self.signal_numbers.collect do |signum|
+         sigcmd = Signal.trap(signum, 'DEFAULT')
+         Signal.trap(signum, sigcmd)
+         @@sigreg[signum] = sigcmd
+         if sigcmd.respond_to?(:call) or ['IGNORE', 'SIG_IGN', 'EXIT'].include?(sigcmd.to_s)
+           signum
+         else
+           nil
+         end
+       end.compact
+       sigs
+     end
+
+     def CORBA.handle_signal(signum)
+       if @@sigreg.has_key?(signum)
+         if @@sigreg[signum].respond_to?(:call)
+           if @@sigreg[signum].respond_to?(:parameters) && @@sigreg[signum].parameters.size > 0
+             @@sigreg[signum].call(signum)
+           else
+             @@sigreg[signum].call
+           end
+         elsif @@sigreg[signum].to_s == 'EXIT'
+           Kernel.exit!(signum)
+         end
+       end
+     end
+  end # CORBA
+end # R2CORBA

data/lib/corba/cbase/Request.rb

@@ -0,0 +1,133 @@
+#--------------------------------------------------------------------
+# Request.rb - C++/TAO 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
+
+      def add_in_arg(tc, val, nm = '')
+        self._arguments << [nm, CORBA::ARG_IN, tc, val]
+        self._arguments.size
+      end
+
+      def add_out_arg(tc, nm = '')
+        self._arguments << [nm, CORBA::ARG_OUT, tc]
+        self._arguments.size
+      end
+
+      def add_inout_arg(tc, val, nm = '')
+        self._arguments << [nm, CORBA::ARG_INOUT, tc, val]
+        self._arguments.size
+      end
+
+      def arguments
+        self._arguments
+      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
+        self._arguments.clear
+        # 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
+        self._exceptions
+      end
+
+      def exceptions=(exl)
+        self._exceptions.clear
+        begin
+          self._exceptions.concat(exl)
+        rescue
+          raise CORBA::BAD_PARAM.new(0, CORBA::COMPLETED_NO)
+        end
+      end
+
+      def set_return_type(tc)
+        @_rettc = tc
+      end
+
+      def return_value
+        return nil if @_rettc.nil? || @_rettc.kind == CORBA::TK_VOID || @_rettc.kind == CORBA::TK_NULL
+        self._return_value(@_rettc)
+      end
+
+      def invoke
+        self._invoke({
+          :arg_list => self._arguments,
+          :result_type => @_rettc,
+          :exc_list => self._exceptions
+          })
+      end
+
+      def send_oneway
+        self._send_oneway(self._arguments)
+      end
+
+      def send_deferred
+        self._send_deferred({
+          :arg_list => self._arguments,
+          :result_type => @_rettc,
+          :exc_list => self._exceptions
+          })
+      end
+
+      def poll_response
+        begin
+          ret = self._poll_response
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+        @_args = self._get_arguments(@_args || []) if ret
+        ret
+      end
+
+      def get_response
+        begin
+          ret = self._get_response
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+        @_args = self._get_arguments(@_args || [])
+        ret
+      end
+
+      protected
+
+      def _arguments
+        @_args ||= []
+      end
+
+      def _exceptions
+        @_excl ||= []
+      end
+
+    end
+
+  end # CORBA
+end # R2CORBA

data/lib/corba/cbase/Streams.rb

@@ -0,0 +1,128 @@
+#--------------------------------------------------------------------
+# Streams.rb - C++/TAO Definition of CORBA CDR Streams
+#
+# 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 Portable
+      module InputStream
+        def read_member(tc)
+          tc = tc.resolved_tc # takes care of recursive typecodes
+          v = case tc.kind
+          when TK_ANY
+            read_any()
+          when TK_BOOLEAN
+            read_boolean()
+          when TK_SHORT
+            read_short()
+          when TK_LONG
+            read_long()
+          when TK_USHORT
+            read_ushort()
+          when TK_WCHAR
+            read_wchar()
+          when TK_ULONG
+            read_ulong()
+          when TK_LONGLONG
+            read_longlong()
+          when TK_ULONGLONG
+            read_ulonglong()
+          when TK_OCTET
+            read_octet()
+          when TK_FLOAT
+            read_float()
+          when TK_DOUBLE
+            read_double()
+          when TK_LONGDOUBLE
+            raise CORBA::NO_IMPLEMENT.new('LongDouble not supported', 0, CORBA::COMPLETED_NO)
+          when TK_FIXED
+            read_fixed()
+          when TK_CHAR
+            read_char()
+          when TK_STRING
+            read_string()
+          when TK_WSTRING
+            read_wstring()
+          when TK_OBJREF
+            read_Object()
+          when TK_TYPECODE
+            read_TypeCode()
+          when TK_ARRAY, TK_SEQUENCE,
+               TK_ENUM, TK_STRUCT, TK_EXCEPT, TK_UNION,
+               TK_PRINCIPAL
+            read_construct(tc)
+          when TK_ABSTRACT_INTERFACE
+            read_Abstract()
+          when TK_VALUE, TK_VALUE_BOX, TK_EVENT
+            read_Value()
+            ## TODO: TK_NATIVE
+          end
+          v
+        end
+      end
+
+      module OutputStream
+        def write_member(tc, value)
+          tc = tc.resolved_tc # takes care of recursive typecodes
+          case tc.kind
+          when TK_ANY
+            write_any(value)
+          when TK_BOOLEAN
+            write_boolean(value)
+          when TK_SHORT
+            write_short(value)
+          when TK_LONG
+            write_long(value)
+          when TK_USHORT
+            write_ushort(value)
+          when TK_WCHAR
+            write_wchar(value)
+          when TK_ULONG
+            write_ulong(value)
+          when TK_LONGLONG
+            write_longlong(value)
+          when TK_ULONGLONG
+            write_ulonglong(value)
+          when TK_OCTET
+            write_octet(value)
+          when TK_FLOAT
+            write_float(value)
+          when TK_DOUBLE
+            write_double(value)
+          when TK_LONGDOUBLE
+            raise CORBA::NO_IMPLEMENT.new('LongDouble not supported', 0, CORBA::COMPLETED_NO)
+          when TK_FIXED
+            write_fixed(value)
+          when TK_CHAR
+            write_char(value)
+          when TK_STRING
+            write_string(value)
+          when TK_WSTRING
+            write_wstring(value)
+          when TK_OBJREF
+            write_Object(value)
+          when TK_TYPECODE
+            write_TypeCode(value)
+          when TK_ARRAY, TK_SEQUENCE,
+               TK_ENUM, TK_STRUCT, TK_EXCEPT, TK_UNION,
+               TK_PRINCIPAL
+            write_construct(value, tc)
+          when TK_ABSTRACT_INTERFACE
+            write_Abstract(value)
+          when TK_VALUE, TK_VALUE_BOX, TK_EVENT
+            write_Value(value)
+            ## TODO: TK_NATIVE
+          end
+        end
+      end
+    end
+  end
+end

data/lib/corba/cbase/Stub.rb

@@ -0,0 +1,18 @@
+#--------------------------------------------------------------------
+# Stub.rb - C++/TAO CORBA Stub 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 Stub
+      include R2CORBA::CORBA::Portable::Stub
+    end # Stub
+  end # CORBA
+end # R2CORBA