r2corba 1.4.1-universal-java-1.7

data/README

@@ -0,0 +1,62 @@
+
+* What is Ruby2CORBA
+
+Ruby2CORBA (R2CORBA) is a CORBA mapping implementation for the Ruby
+programming language (see http://www.ruby-lang.org).
+Instead of going for a complete native Ruby mapping implementing a native
+Ruby ORB, R2CORBA aims at providing CORBA functionality through a Ruby
+extension using the DII and DSI interfaces of an existing CORBA ORB 
+implementation.
+There are currently two flavors of this extension available:
+	o an MRI Ruby extension written in Ruby and C/C++ using TAO 
+	  (The ACE ORB; see http://www.cs.wustl.edu/~schmidt/TAO.html).
+	o a JRuby extension written in Ruby and Java using JacORB 
+	  (http://www.jacorb.org/index.html).
+A native Ruby implementation of an OMG IDL compiler supplements this
+extension and provides powerful features like direct inclusion of IDL
+language modules into your Ruby programs without the need of explicit, 
+separate stub generation.
+
+Both flavors of R2CORBA fully implement the official OMG Ruby CORBA 
+Language Mapping (RCLM) specification which can be downloaded here:
+http://www.omg.org/spec/RCLM.
+
+* How to get R2CORBA
+
+Execute
+
+gem install r2corba
+
+to install R2CORBA as a gem.
+
+or
+
+Go to https://osportal.remedy.nl/projects/r2corba/files to
+download the latest source package and build your own.
+
+or
+
+Go to https://osportal.remedy.nl/projects/r2corba/wiki and read how
+to checkout the latest source code from the version repository.
+
+* How to compile and install
+
+See the file INSTALL
+
+* Copying/License
+
+See the file LICENSE
+
+* Acknowledgments
+
+See the file THANKS
+
+* The author(s)
+
+R2CORBA has been created by staff of Remedy IT.
+(http://www.remedy.nl | http://www.theaceorb.nl)
+
+Feel free to send comments and bug reports to:
+
+   r2corba@remedy.nl
+

data/THANKS

@@ -0,0 +1,52 @@
+
+Our thanks go to:
+
+* Yukihiro Matsumoto, aka “Matz”, for creating the wonderfully
+  powerful and elegant programming language named Ruby.
+  With him we also thank all those who have contributed to the
+  Ruby programming tool and have made Ruby what it is today.
+
+* Charles Oliver Nutter, aka "headius", and the other people of
+  the JRuby core development team for bringing that wonderful
+  programming language that Matz created to Java.
+
+* Prof. Douglas Schmidt for (and all his collaborators) for creating
+  a high-quality OpenSource CORBA compliant ORB. The high level of
+  OS abstraction and multiplatform compatibility of this software
+  make it an ideal ingredient for a Ruby CORBA implementation.
+
+* The people of the JacORB development team (a.o. Gerald Brose and 
+  Andre Spiegel) and all their collaborators for creating a high-
+  performance, multi threaded and spec compliant ORB for the
+  Java environment.
+
+* Minero Aoki for creating the original 'setup.rb' install script.
+
+* Daisuke Kanda for his initial work on CORBA bindings for Ruby from
+  2001 (incl. RINN and Ruby-Orbit) which has helped us in many ways
+  to create R2CORBA.
+
+* Paul Brannan of Automated Trading Desk, LLC for his insightfull
+  comments on the first release of the Ruby CORBA language mapping.
+
+* Renato Lucindo and Eider Oliveira for their remarks and fixes for
+  the IDL compiler.
+
+* Ragnar Dahlen for his tests and comments.
+
+* William Otte for his patches for the Mac OSX port.
+
+* David MacMahon for his comments and tests, especially with regard to 
+  omniORBpy interoperability.
+
+* David MacMahon for his Multi_Threading/Threads test.
+
+* Joel Hahn for reporting the union implicit default bug and
+  providing partial patches.
+
+* Karsten Richter for reporting a bug in union implicit default
+  handling and providing a partial patch and regression test.
+  
+* Grant Birchmeier for reporting the RIDL logger bug (triggered
+  by an unknown pragma)
+ 

data/bin/r2corba

@@ -0,0 +1,8 @@
+#!/bin/env jruby
+#---------------------------------
+# This file is generated
+#---------------------------------
+unless defined? Gem
+  require 'rubygems' rescue nil
+end
+require 'corba/cmds/base'

data/bin/r2corba.bat

@@ -0,0 +1,20 @@
+@echo off
+if not "%~f0" == "~f0" goto WinNT
+jruby -Sx "%0" %1 %2 %3 %4 %5 %6 %7 %8 %9
+goto endofruby
+:WinNT
+if not exist "%~d0%~p0jruby" goto rubyfrompath
+if exist "%~d0%~p0jruby" "%~d0%~p0jruby" -x "%~f0" %*
+goto endofruby
+:rubyfrompath
+jruby -x "%~f0" %*
+goto endofruby
+#!/bin/jruby
+#
+unless defined? Gem
+  require 'rubygems' rescue nil
+end
+require 'corba/cmds/base'
+
+__END__
+:endofruby

data/bin/ridlc

@@ -0,0 +1,11 @@
+#!/bin/env jruby
+#---------------------------------
+# This file is generated
+#---------------------------------
+ENV['RIDL_BE_SELECT'] = 'ruby'
+unless defined? Gem
+  require 'rubygems' rescue nil
+end
+require 'ridl/ridl'
+
+IDL.run

data/bin/ridlc.bat

@@ -0,0 +1,23 @@
+@echo off
+if not "%~f0" == "~f0" goto WinNT
+jruby -Sx "%0" %1 %2 %3 %4 %5 %6 %7 %8 %9
+goto endofruby
+:WinNT
+if not exist "%~d0%~p0jruby" goto rubyfrompath
+if exist "%~d0%~p0jruby" "%~d0%~p0jruby" -x "%~f0" %*
+goto endofruby
+:rubyfrompath
+jruby -x "%~f0" %*
+goto endofruby
+#!/bin/jruby
+#
+ENV['RIDL_BE_SELECT'] = 'ruby'
+unless defined? Gem
+  require 'rubygems' rescue nil
+end
+require 'ridl/ridl'
+
+IDL.run
+
+__END__
+:endofruby

data/bin/rins

@@ -0,0 +1,7 @@
+#!/bin/env jruby
+#---------------------------------
+# This file is generated
+#---------------------------------
+require 'corba/svcs/ins/ins'
+
+INS.run

data/bin/rins.bat

@@ -0,0 +1,19 @@
+@echo off
+if not "%~f0" == "~f0" goto WinNT
+jruby -Sx "%0" %1 %2 %3 %4 %5 %6 %7 %8 %9
+goto endofruby
+:WinNT
+if not exist "%~d0%~p0jruby" goto rubyfrompath
+if exist "%~d0%~p0jruby" "%~d0%~p0jruby" -x "%~f0" %*
+goto endofruby
+:rubyfrompath
+jruby -x "%~f0" %*
+goto endofruby
+#!/bin/jruby
+#
+require 'corba/svcs/ins/ins'
+
+INS.run
+
+__END__
+:endofruby

data/lib/corba/cbase/IORMap.rb

@@ -0,0 +1,33 @@
+#--------------------------------------------------------------------
+# iormap.rb - C++/TAO IORMap 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
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#--------------------------------------------------------------------
+require 'corba/idl/IORTableC'
+
+module R2CORBA
+  class IORMap
+    def initialize(orb)
+      obj = orb.resolve_initial_references('IORTable')
+      @iortbl = IORTable::Table._narrow(obj)
+    end
+
+    def map_ior(object_key, ior)
+      @iortbl.rebind(object_key, ior)
+    end
+
+    def unmap_ior(object_key)
+      begin
+        @iortbl.unbind(object_key)
+      rescue IORTable::NotFound
+      end
+    end
+  end
+end

data/lib/corba/cbase/ORB.rb

@@ -0,0 +1,231 @@
+#--------------------------------------------------------------------
+# 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
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#--------------------------------------------------------------------
+require 'monitor'
+
+module R2CORBA
+  module CORBA
+
+    module ORB
+
+      @@_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?
+          @@cached_orb = CORBA::Native::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
+         19, # STOP
+         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,134 @@
+#--------------------------------------------------------------------
+# 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
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#--------------------------------------------------------------------
+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