r2corba 1.5.1-universal-java

data/lib/corba/jbase/Values.rb

@@ -0,0 +1,173 @@
+#--------------------------------------------------------------------
+# Values.rb - Java/JacORB CORBA Value and ValueBox 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
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#--------------------------------------------------------------------
+
+module R2CORBA
+  module CORBA
+    module AbstractValueBase
+      def self.included(mod)
+        mod.module_eval do
+          def self.===(obj)
+            obj.kind_of?(self)
+          end
+        end
+      end
+    end
+    module ValueBase
+      def self.included(mod)
+        mod.module_eval do
+          include CORBA::Native::Portable::StreamableValue unless self.include?(CORBA::Native::Portable::StreamableValue)
+          # this defines the following methods to be implemented
+          # String[] _truncatable_ids();
+          # TypeCode _type();
+          # void _read(org.omg.CORBA.portable.InputStream is);
+          # void _write(org.omg.CORBA.portable.OutputStream os);
+          include CORBA::AbstractValueBase unless self.include?(CORBA::AbstractValueBase)
+
+          def _truncatable_ids
+            self.class::TRUNCATABLE_IDS.to_java(:string)
+          end
+
+          def _type
+            self.class._tc.tc_ # return Java TypeCode here
+          end
+
+          def _read(jis)
+            do_unmarshal(CORBA::Portable::InputStream._wrap_native(jis))
+          end
+
+          def _write(jos)
+            do_marshal(CORBA::Portable::OutputStream._wrap_native(jos))
+          end
+
+          def kind_of?(mod)
+            if mod < CORBA::AbstractValueBase && mod.const_defined?(:Intf)
+              super(mod::Intf)
+            else
+              super
+            end
+          end
+          alias :is_a? :kind_of?
+        end
+      end
+
+      def _marshal_with(os, &block)
+        self.instance_eval(&block)
+      end
+
+      def _unmarshal_with(is, &block)
+        self.instance_eval(&block)
+      end
+    end # ValueBase
+
+    module Portable
+      class ValueFactoryBase
+        include CORBA::Native::Portable::ValueFactory
+        ## defines: java.io.Serializable read_value(InputStream is)
+
+        def self.inherited(value_factory_base)
+          # value_factory_base is the <valuetype>Factory base class
+          # generated from IDL
+          value_factory_base.module_eval do
+            def self.value_id
+              self::VALUE_ID
+            end
+
+            # overload
+            def read_value(jis)
+              vt = self._create_default
+              vt._read(jis)
+              vt
+            end
+          end
+        end
+      end # ValueFactoryBase
+
+      module CustomValueBase
+        def self.included(mod)
+          mod.module_eval do
+            include CORBA::ValueBase unless self.include?(CORBA::ValueBase)
+
+            def do_marshal(os)
+              self.marshal(os)
+            end
+
+            def do_unmarshal(is)
+              self.unmarshal(is)
+            end
+          end
+        end
+      end # CustomValueBase
+
+      module BoxedValueBase
+        class FactoryBase < CORBA::Portable::ValueFactoryBase
+          ## generic factory base
+        end
+        def self.included(mod)
+          mod.module_eval do
+            include CORBA::ValueBase unless self.include?(CORBA::ValueBase)
+
+            def _write(jos)
+              CORBA::Portable::OutputStream._wrap_native(jos).write_member(
+                self.class._tc.content_type.resolved_tc, self.value)
+            end
+
+            def _read(jis)
+              self.value = CORBA::Portable::InputStream._wrap_native(jis).read_member(
+                self.class._tc.content_type.resolved_tc)
+            end
+
+            self.const_set(:Factory, Class.new(CORBA::Portable::BoxedValueBase::FactoryBase))
+            self::Factory.class_eval(%Q{
+              @@_reg = false
+              def self._check_factory(jorb)
+                return if @@_reg
+                self.get_factory(jorb)
+                @@_reg = true
+              end
+
+              def self.value_id
+                #{self.name}::TRUNCATABLE_IDS.first
+              end
+
+              def _create_default
+                #{self.name}.new
+              end
+            })
+
+            self.const_set(:Helper, Class.new)
+            self::Helper.class_eval(%Q{
+              include CORBA::Native::Portable::BoxedValueHelper unless self.include?(CORBA::Native::Portable::BoxedValueHelper)
+
+              def get_id()
+                #{self.name}::TRUNCATABLE_IDS.first
+              end
+
+              def read_value(jis)
+                #{self.name}.new._read(jis)
+              end
+
+              def write_value(jos, value)
+                value._write(jos)
+              end
+            })
+
+            def self.boxedvalue_helper
+              @@helper ||= Helper.new
+            end
+          end
+        end
+      end
+
+    end # Portable
+  end # CORBA
+end # R2CORBA

data/lib/corba/jbase/exception.rb

@@ -0,0 +1,106 @@
+#--------------------------------------------------------------------
+# exception.rb - Java/JacORB specific CORBA Exception 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
+#--------------------------------------------------------------------
+
+# import all java CORBA exceptions into the R2CORBA::CORBA namespace
+module R2CORBA
+  module CORBA
+    class Exception
+      def self.native2r(jex)
+        if ::NativeException === jex
+          if jex.cause.is_a? Native::SystemException
+            SystemException._raise(jex)
+          elsif jex.cause.is_a? Native::UserException
+            UserException._raise(jex)
+          else
+            raise CORBA::InternalError.new(jex)
+          end
+        else
+          raise jex
+        end
+      end
+    end
+
+    class UserException
+      def self._raise(jex)
+        STDERR.puts "#{jex}\n#{jex.backtrace.join("\n")}" if $VERBOSE and (NativeException === jex)
+        if (NativeException === jex and jex.cause.is_a?(Native::UnknownUserException)) or jex.is_a?(Native::UnknownUserException)
+          java_ex = jex.is_a?(Native::UnknownUserException) ? jex : jex.cause
+          ex = Any.from_java(java_ex.except)
+          ex.set_backtrace(jex.backtrace) if NativeException === jex
+          raise ex
+        elsif (NativeException === jex and jex.cause.is_a?(Native::UserException)) or jex.is_a?(Native::UserException)
+          java_ex = jex.is_a?(Native::UserException) ? jex : jex.cause
+          exname = java_ex.class.name.split('::').last
+          tcs = CORBA::TypeCode.typecodes_for_name(exname) || []
+          extc = tcs.detect {|tc| tc.is_a?(TypeCode::Except) && tc.is_compatible?(java_ex)}
+          if extc
+            ex = extc.from_java(java_ex)
+            ex.set_backtrace(jex.backtrace) if NativeException === jex
+            raise ex
+          end
+        end
+        raise CORBA::UNKNOWN.new("#{jex}", 0, CORBA::COMPLETED_MAYBE)
+      end
+    end
+
+    class InternalError
+      def initialize(jex)
+        @ex_ = jex
+        super(@ex_.message)
+        self.set_backtrace(@ex_.backtrace)
+      end
+    end
+
+    class SystemException
+      def self._raise(jex)
+        raise ArgumentError unless (NativeException === jex and jex.cause.is_a?(Native::SystemException)) or jex.is_a?(Native::SystemException)
+        java_ex = jex.is_a?(Native::SystemException) ? jex : jex.cause
+        exname = java_ex.class.name.split('::').last
+        exklass = CORBA.const_get(exname.to_sym)
+        unless exklass
+          # define hitherto unknown CORBA system exception
+          CORBA.define_system_exception(exname)
+          CORBA.const_get(exname.to_sym) || InternalError
+        end
+        raise exklass.new(jex)
+      end
+      def initialize(*args)
+        if (NativeException === args.first and args.first.cause.is_a? Native::SystemException) or args.first.is_a?(Native::SystemException)
+          java_ex = args.first.is_a?(Native::SystemException) ? args.first : args.first.cause
+          super(java_ex.getMessage)
+          @minor = java_ex.minor
+          @completed = java_ex.completed.value
+          self.set_backtrace(args.first.backtrace) if NativeException === args.first
+        else
+          super(args.shift.to_s)
+          @minor, @completed = (args + [0,0][args.size..2])
+        end
+      end
+    end
+  end # CORBA
+end # R2CORBA
+
+# extend Ruby wrapper for Native java exceptions
+class NativeException
+  alias method_missing_corba_backup method_missing
+  def method_missing(method, *args)
+    if self.cause.is_a?(R2CORBA::CORBA::Native::SystemException) and args.empty?
+        return self.cause.minor if method == :minor
+        return self.cause.completed.value if method == :completed
+        return self.cause.getMessage if method == :reason
+    elsif self.cause.is_a? R2CORBA::CORBA::Native::UserException
+        return self.cause.send(method, *args)
+    end
+    self.method_missing_corba_backup
+  end
+end

data/lib/corba/jbase/poa.rb

@@ -0,0 +1,229 @@
+#--------------------------------------------------------------------
+# poa.rb - Java/JacORB R2CORBA POA loader
+#
+# 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 PortableServer
+    module Native
+      include_package 'org.omg.PortableServer'
+    end
+  end
+end
+
+require 'corba/common/Servant.rb'
+require 'corba/idl/POAC.rb'
+require 'corba/jbase/Servant.rb'
+require 'corba/jbase/ServerRequest.rb'
+
+module R2CORBA
+  module PortableServer
+    def self.string_to_ObjectId(s)
+      raise CORBA::NO_IMPLEMENT
+    end
+
+    def self.ObjectId_to_string(oid)
+      raise CORBA::NO_IMPLEMENT
+    end
+
+    module POA
+      def destroy(etherealize_objects, wait_for_completion)
+        begin
+          self.objref_.destroy(etherealize_objects!=false, wait_for_completion!=false)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end #of operation destroy
+
+      def the_name()
+        begin
+          self.objref_.the_name()
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end #of attribute get_the_name
+
+      def the_POAManager()
+        begin
+          PortableServer::POAManager._narrow(CORBA::Object._wrap_native(self.objref_.the_POAManager()))
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end #of attribute get_the_POAManager
+
+      def the_parent()
+        begin
+          PortableServer::POA._narrow(CORBA::Object._wrap_native(self.objref_.the_parent()))
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end #of attribute get_the_parent
+
+      def the_children()
+        begin
+          self.objref_.the_children().collect {|c| PortableServer::POA._narrow(CORBA::Object._wrap_native(c)) }
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end #of attribute get_the_children
+
+      def activate_object(p_servant)
+        begin
+          String.from_java_bytes(self.objref_.activate_object(p_servant.srvref_))
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end #of operation activate_object
+
+      def activate_object_with_id(r_id, p_servant)
+        begin
+          self.objref_.activate_object_with_id(r_id.to_s.to_java_bytes, p_servant.srvref_)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end #of operation activate_object_with_id
+
+      def deactivate_object(oid)
+        begin
+          self.objref_.deactivate_object(oid.to_s.to_java_bytes)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end #of operation deactivate_object
+
+      def create_reference(intf)
+        begin
+          CORBA::Object._wrap_native(self.objref_.create_reference(intf.to_s))
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end #of operation create_reference
+
+      def create_reference_with_id(oid, intf)
+        begin
+          CORBA::Object._wrap_native(self.objref_.create_reference_with_id(oid.to_s.to_java_bytes, intf.to_s))
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end #of operation create_reference_with_id
+
+      def servant_to_id(p_servant)
+        begin
+          String.from_java_bytes(self.objref_.servant_to_id(p_servant.srvref_))
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end #of operation servant_to_id
+
+      def servant_to_reference(p_servant)
+        begin
+          CORBA::Object._wrap_native(self.objref_.servant_to_reference(p_servant.srvref_))
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end #of operation servant_to_reference
+
+      def reference_to_servant(reference)
+        begin
+          self.objref_.reference_to_servant(reference.objref_).rbServant
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end #of operation reference_to_servant
+
+      def reference_to_id(reference)
+        begin
+          String.from_java_bytes(self.objref_.reference_to_id(reference.objref_))
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end #of operation reference_to_id
+
+      def id_to_servant(oid)
+        begin
+          self.objref_.id_to_servant(oid.to_s.to_java_bytes).rbServant
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end #of operation id_to_servant
+
+      def id_to_reference(oid)
+        begin
+          CORBA::Object._wrap_native(self.objref_.id_to_reference(oid.to_s.to_java_bytes))
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end #of operation id_to_reference
+
+      def create_POA(adapter_name, a_POAManager, policies)
+        raise CORBA::BAD_PARAM.new('expected POAManager', 0, CORBA::COMPLETED_NO) unless a_POAManager.is_a?(PortableServer::POAManager)
+        CORBA::PolicyList._tc.validate(policies) unless policies.nil? || policies.empty?
+        jpolicies = CORBA::Native::Reflect::Array.newInstance(CORBA::Native::Policy.java_class, policies.nil? ? 0 : policies.size)
+        policies.each_with_index {|p,i| jpolicies[i] = p.objref_ } unless policies.nil?
+        begin
+          PortableServer::POA._narrow(CORBA::Object._wrap_native(self.objref_.create_POA(adapter_name, a_POAManager.objref_, jpolicies)))
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end #of operation create_POA
+
+      def find_POA(adapter_name, activate_it)
+        begin
+          PortableServer::POA._narrow(CORBA::Object._wrap_native(self.objref_.find_POA(adapter_name, activate_it)))
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end #of operation find_POA
+    end # POA
+
+    module POAManager
+      def activate()
+        begin
+          self.objref_.activate()
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end # activate
+
+      def hold_requests(wait_for_completion)
+        begin
+          self.objref_.hold_requests(wait_for_completion)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end # hold_requests
+
+      def discard_requests(wait_for_completion)
+        begin
+          self.objref_.discard_requests(wait_for_completion)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end # discard_requests
+
+      def deactivate(etherealize_objects, wait_for_completion)
+        begin
+          self.objref_.deactivate(etherealize_objects, wait_for_completion)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end # deactivate
+
+      def get_state()
+        begin
+          self.objref_.get_state().value()
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end # get_state
+    end # POAManager
+  end
+end