r2corba 1.5.1-universal-java

data/lib/corba/jbase/ServerRequest.rb

@@ -0,0 +1,128 @@
+#--------------------------------------------------------------------
+# 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
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#--------------------------------------------------------------------
+
+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

data/lib/corba/jbase/Streams.rb

@@ -0,0 +1,671 @@
+#--------------------------------------------------------------------
+# Streams.rb - Java/JacORB 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
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#--------------------------------------------------------------------
+
+module R2CORBA
+  module CORBA
+    module Portable
+      module InputStream
+        @@wrapper_klass = Class.new do
+          include CORBA::Portable::InputStream
+          def initialize(jobj)
+            @stream_ = jobj
+          end
+          attr_reader :stream_
+        end
+
+        def self._wrap_native(jobj)
+          if jobj.nil? || !jobj.is_a?(Native::V2_3::Portable::InputStream)
+            raise ArgumentError, 'Expected org.omg.CORBA.portable.InputStream'
+          end
+          @@wrapper_klass.new(jobj)
+        end
+
+        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
+            read_value()
+          when TK_VALUE_BOX
+            read_valuebox(tc.get_type.boxedvalue_helper)
+            ## TODO: TK_NATIVE
+          end
+          v
+        end
+
+        def read_any()
+          begin
+            self.stream_.read_any()
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def read_boolean()
+          begin
+            self.stream_.read_boolean()
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def read_boolean_array(arr, offset, length)
+          jarr = Array.new(arr.size).to_java(:boolean)
+          begin
+            self.stream_.read_boolean_array(jarr, offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+          arr.fill(offset, length) {|i| jarr[i]}
+        end
+        def read_char()
+          begin
+            self.stream_.read_char().chr
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def read_char_array(arr, offset, length)
+          jarr = Array.new(arr.size).to_java(:char)
+          begin
+            self.stream_.read_char_array(jarr, offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+          arr.fill(offset, length) {|i| jarr[i].chr }
+        end
+        def read_wchar()
+          begin
+            self.stream_.read_wchar()
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def read_wchar_array(arr, offset, length)
+          jarr = Array.new(arr.size).to_java(:char)
+          begin
+            self.stream_.read_char_array(jarr, offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+          arr.fill(offset, length) {|i| jarr[i] }
+        end
+        def read_octet(value)
+          begin
+            [self.stream_.read_octet()].pack('c').unpack('C').first
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def read_octet_array(arr, offset, length)
+          jarr = Array.new(arr.size).to_java(:byte)
+          begin
+            self.stream_.read_octet_array(jarr, offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+          jarr = jarr.pack('c*').unpack('C*')
+          arr.fill(offset, length) {|i| jarr[i] }
+        end
+        def read_short()
+          begin
+            self.stream_.read_short()
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def read_short_array(arr, offset, length)
+          jarr = Array.new(arr.size).to_java(:short)
+          begin
+            self.stream_.read_short_array(jarr, offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+          arr.fill(offset, length) {|i| jarr[i] }
+        end
+        def read_ushort()
+          begin
+            [self.stream_.read_ushort()].pack('s').unpack('S').first
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def read_ushort_array(arr, offset, length)
+          jarr = Array.new(arr.size).to_java(:short)
+          begin
+            self.stream_.read_octet_array(jarr, offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+          jarr = jarr.pack('s*').unpack('S*')
+          arr.fill(offset, length) {|i| jarr[i] }
+        end
+        def read_long()
+          begin
+            self.stream_.read_long()
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def read_long_array(arr, offset, length)
+          jarr = Array.new(arr.size).to_java(:int)
+          begin
+            self.stream_.read_long_array(jarr, offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+          arr.fill(offset, length) {|i| jarr[i] }
+        end
+        def read_ulong()
+          begin
+            [self.stream_.read_ulong()].pack('l').unpack('L').first
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def read_ulong_array(arr, offset, length)
+          jarr = Array.new(arr.size).to_java(:int)
+          begin
+            self.stream_.read_ulong_array(jarr, offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+          jarr = jarr.pack('l*').unpack('L*')
+          arr.fill(offset, length) {|i| jarr[i] }
+        end
+        def read_longlong()
+          begin
+            self.stream_.read_longlong()
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def read_longlong_array(arr, offset, length)
+          jarr = Array.new(arr.size).to_java(:long)
+          begin
+            self.stream_.read_longlong_array(jarr, offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+          arr.fill(offset, length) {|i| jarr[i] }
+        end
+        def read_ulonglong()
+          begin
+            [self.stream_.read_ulonglong()].pack('q').unpack('Q').first
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def read_ulonglong_array(arr, offset, length)
+          jarr = Array.new(arr.size).to_java(:long)
+          begin
+            self.stream_.read_ulonglong_array(jarr, offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+          jarr = jarr.pack('q*').unpack('Q*')
+          arr.fill(offset, length) {|i| jarr[i] }
+        end
+        def read_float()
+          begin
+            self.stream_.read_float()
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def read_float_array(arr, offset, length)
+          jarr = Array.new(arr.size).to_java(:float)
+          begin
+            self.stream_.read_float_array(jarr, offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+          arr.fill(offset, length) {|i| jarr[i] }
+        end
+        def read_double()
+          begin
+            self.stream_.read_double()
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def read_double_array(arr, offset, length)
+          jarr = Array.new(arr.size).to_java(:double)
+          begin
+            self.stream_.read_double_array(jarr, offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+          arr.fill(offset, length) {|i| jarr[i] }
+        end
+        def read_string()
+          begin
+            self.stream_.read_string()
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def read_wstring()
+          begin
+            self.stream_.read_wstring()
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def read_Object()
+          begin
+            CORBA::Object._wrap_native(self.stream_().read_Object())
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def read_TypeCode()
+          begin
+            CORBA::TypeCode._wrap_native(self.stream_().read_TypeCode())
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def read_fixed()
+          begin
+            java.math.BigDecimal.new(self.stream_.read_fixed().toString())
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def read_construct(tc)
+          begin
+            jany = self.stream_.orb().create_any()
+            jany.read_value(self.stream_, tc.tc_)
+            CORBA::Any.from_java(jany, self.stream_.orb(), tc)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def read_Abstract()
+          begin
+            obj = self.stream_.read_abstract_interface()
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+          obj = CORBA::Object._wrap_native(obj) if obj.is_a?(CORBA::Native::Object)
+          obj
+        end
+        def read_value()
+          begin
+            self.stream_.read_value()
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        alias :read_Value :read_value
+        def read_valuebox(boxedvalue_helper)
+          begin
+            self.stream_.read_value(boxedvalue_helper)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+      end
+
+      module OutputStream
+        @@wrapper_klass = Class.new do
+          include CORBA::Portable::OutputStream
+          def initialize(jobj)
+            @stream_ = jobj
+          end
+          attr_reader :stream_
+        end
+
+        def self._wrap_native(jobj)
+          if jobj.nil? || !jobj.is_a?(Native::V2_3::Portable::OutputStream)
+            raise ArgumentError, 'Expected org.omg.CORBA.portable.OutputStream'
+          end
+          @@wrapper_klass.new(jobj)
+        end
+
+        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
+            write_value(value)
+          when TK_VALUE_BOX
+            write_valuebox(value, tc.get_type().boxedvalue_helper())
+            ## TODO: TK_NATIVE
+          end
+        end
+
+        def write_any(value)
+          begin
+            self.stream_.write_any(value)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_boolean(value)
+          begin
+            self.stream_.write_boolean(value)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_boolean_array(value, offset, length)
+          begin
+            self.stream_.write_boolean_array(value.to_java(:boolean), offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_char(value)
+          begin
+            self.stream_.write_char(value[0])
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_char_array(value, offset, length)
+          begin
+            self.stream_.write_char_array(value.collect{|c| c[0]}.to_java(:char), offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_wchar(value)
+          self.stream_.write_wchar(value)
+        end
+        def write_wchar_array(value, offset, length)
+          begin
+            self.stream_.write_wchar_array(value.to_java(:char), offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_octet(value)
+          begin
+            self.stream_.write_octet([value].pack('C').unpack('c').first)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_octet_array(value, offset, length)
+          begin
+            self.stream_.write_octet_array(value.pack('C*').unpack('c*').to_java(:byte), offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_short(value)
+          begin
+            self.stream_.write_short(value)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_short_array(value, offset, length)
+          begin
+            self.stream_.write_short_array(value.to_java(:short), offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_ushort(value)
+          begin
+            self.stream_.write_ushort([value].pack('S').unpack('s').first)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_ushort_array(value, offset, length)
+          begin
+            self.stream_.write_ushort_array(value.pack('S*').unpack('s*').to_java(:short), offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_long(value)
+          begin
+            self.stream_.write_long(value)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_long_array(value, offset, length)
+          begin
+            self.stream_.write_long_array(value.to_java(:int), offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_ulong(value)
+          begin
+            self.stream_.write_ulong([value].pack('L').unpack('l').first)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_ulong_array(value, offset, length)
+          begin
+            self.stream_.write_ulong_array(value.pack('L*').unpack('l*').to_java(:int), offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_longlong(value)
+          begin
+            self.stream_.write_longlong(value)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_longlong_array(value, offset, length)
+          begin
+            self.stream_.write_longlong_array(value.to_java(:long), offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_ulonglong(value)
+          begin
+            self.stream_.write_ulonglong([value].pack('Q').unpack('q').first)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_ulonglong_array(value, offset, length)
+          begin
+            self.stream_.write_ulonglong_array(value.pack('Q*').unpack('q*').to_java(:long), offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_float(value)
+          begin
+            self.stream_.write_float(value)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_float_array(value, offset, length)
+          begin
+            self.stream_.write_float_array(value.to_java(:float), offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_double(value)
+          begin
+            self.stream_.write_double(value)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_double_array(value, offset, length)
+          begin
+            self.stream_.write_double_array(value.to_java(:double), offset, length)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_string(value)
+          begin
+            self.stream_.write_string(value)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_wstring(value)
+          begin
+            self.stream_.write_wstring(value.inject('') {|s,b| s << b.chr})
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_fixed(value)
+          begin
+            self.stream_.write_fixed(java.math.BigDecimal.new(value.to_s))
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_Object(value)
+          begin
+            self.stream_.write_Object(value.objref_)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_TypeCode(value)
+          begin
+            self.stream_.write_TypeCode(value.tc_)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_construct(value, tc)
+          begin
+            CORBA::Any.to_any(value, tc).to_java(self.stream_().orb()).write_value(self.stream_)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_Abstract(value)
+          begin
+            self.stream_().write_abstract_interface(value.is_a?(CORBA::Object) ? value.objref_ : value)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        def write_value(value)
+          begin
+            self.stream_.write_value(value)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+        alias :write_Value :write_value
+        def write_valuebox(value, boxedvalue_helper)
+          begin
+            self.stream_.write_value(value, boxedvalue_helper)
+          rescue ::NativeException
+            CORBA::Exception.native2r($!)
+          end
+        end
+      end
+    end
+  end
+end