r2corba 1.6.1-x64-mingw-ucrt

data/lib/corba/common/ORB.rb

@@ -0,0 +1,367 @@
+#--------------------------------------------------------------------
+# ORB.rb - Common 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
+#--------------------------------------------------------------------
+
+module R2CORBA
+  module CORBA
+
+    def CORBA.ORB_init(*args)
+      # actual CORBA wrapper implementation implements
+      # the ORB.init method
+      self::ORB.init(*args)
+    end
+
+    module ORB
+      @@wrapper_klass = Class.new do
+        include ::R2CORBA::CORBA::ORB
+        def initialize(norb)
+          @orb_ = norb
+        end
+        attr_reader :orb_
+      end
+
+      def self._wrap_native(norb)
+        raise ArgumentError, 'Expected org.omg.CORBA.ORB' unless norb.nil? || norb.is_a?(Native::ORB)
+        norb.nil?() ? norb : @@wrapper_klass.new(norb)
+      end
+
+      ## init() or init(orb_id, prop = {}) or init(argv, orb_id, prop={}) or init(argv, prop={})
+      def self.init(*args)
+        raise ::CORBA::NO_IMPLEMENT
+      end
+
+      @@cached_orb = nil
+
+      def self._orb
+        @@cached_orb || _singleton_orb_init
+      end
+
+      def ==(other)
+        self.class == other.class && self.orb_.eql?(other.orb_)
+      end
+
+      def hash
+        self.orb_.hash
+      end
+
+      def dup
+        self
+      end
+
+      def clone
+        self
+      end
+
+      # obj ::CORBA::Object
+      # ret ::String
+      def object_to_string(obj)
+        raise CORBA::BAD_PARAM.new('CORBA::Object required', 0, CORBA::COMPLETED_NO) unless obj.is_a?(CORBA::Object)
+        begin
+          self.orb_.object_to_string(obj.objref_)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      # str ::String
+      # ret ::CORBA::Object
+      def string_to_object(str)
+        begin
+          Object._wrap_native(self.orb_.string_to_object(str))
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      # str ::Integer
+      # ret ::CORBA::NVList
+      def create_list(count)
+        raise CORBA::NO_IMPLEMENT
+      end
+
+      # str OperationDef
+      # ret ::CORBA::NVList
+      def create_operation_list(oper)
+        raise CORBA::NO_IMPLEMENT
+      end
+
+      # ret Context
+      def get_default_context()
+        raise CORBA::NO_IMPLEMENT
+      end
+
+      # req RequestSeq
+      # ret void
+      def send_multiple_request_oneway(req)
+        raise CORBA::NO_IMPLEMENT
+      end
+
+      # req RequestSeq
+      # ret void
+      def send_multiple_request_deferred(req)
+        raise CORBA::NO_IMPLEMENT
+      end
+
+      # ret boolean
+      def poll_next_response()
+        raise CORBA::NO_IMPLEMENT
+      end
+
+      # ret Request
+      def get_next_response()
+        raise CORBA::NO_IMPLEMENT
+      end
+
+      #  Service information operations
+
+      # ServiceType service_type
+      # ret [boolean, ServiceInformation]
+      def get_service_information(service_type)
+        raise CORBA::NO_IMPLEMENT
+      end
+
+      # ret [::String, ...]
+      def list_initial_services()
+        self.orb_.list_initial_services()
+      end
+
+=begin
+// Initial reference operations
+=end
+      # ::String identifier
+      # ret Object
+      # raises InvalidName
+      def resolve_initial_references(identifier)
+        begin
+          Object._wrap_native(self.orb_.resolve_initial_references(identifier))
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      # ::String identifier
+      # CORBA::Object obj
+      # ret void
+      # raises InvalidName
+      def register_initial_reference(identifier, obj)
+        raise ::CORBA::NO_IMPLEMENT
+      end
+
+=begin
+// Type code creation operations
+=end
+      # String id
+      # String name
+      # [] members
+      # ret TypeCode
+      def create_struct_tc(id, name, *members)
+        return CORBA::TypeCode::Struct.new(id.to_s.freeze, name.to_s, nil, members)
+      end
+
+      # String id
+      # String name
+      # [] members
+      # ret TypeCode
+      def create_exception_tc(id, name, *members)
+        return CORBA::TypeCode::Except.new(id.to_s.freeze, name.to_s, nil, members)
+      end
+
+      # String id
+      # String name
+      # TypeCode discriminator_type
+      # [] members
+      # ret TypeCode
+      def create_union_tc(id, name, discriminator_type, *members)
+        return CORBA::TypeCode::Union.new(id.to_s.freeze, name.to_s, nil, discriminator_type, members)
+      end
+
+      # String id
+      # String name
+      # [] members
+      # ret TypeCode
+      def create_enum_tc(id, name, *members)
+        return CORBA::TypeCode::Enum.new(id.to_s.freeze, name.to_s, members)
+      end
+
+      # String id
+      # String name
+      # TypeCode original_type
+      # ret TypeCode
+      def create_alias_tc(id, name, original_type)
+        return CORBA::TypeCode::Alias.new(id.to_s.freeze, name.to_s, nil, original_type)
+      end
+
+      # String id
+      # String name
+      # ret TypeCode
+      def create_interface_tc(id, name)
+        return CORBA::TypeCode::ObjectRef.new(id.to_s.freeze, name.to_s, nil)
+      end
+
+      # Integer bound
+      # ret TypeCode
+      def create_string_tc(bound = nil)
+        return CORBA::TypeCode::String.new(bound)
+      end
+
+      # Integer bound
+      # ret TypeCode
+      def create_wstring_tc(bound = nil)
+        return CORBA::TypeCode::WString.new(bound)
+      end
+
+      # Integer(ushort) digits
+      # Integer(short) scale
+      # ret TypeCode
+      def create_fixed_tc(digits, scale)
+        return CORBA::TypeCode::Fixed.new(digits, scale)
+      end
+
+      # Integer bound
+      # TypeCode element_type
+      # ret TypeCode
+      def create_sequence_tc(bound, element_type)
+        return CORBA::TypeCode::Sequence.new(element_type, bound)
+      end
+
+      # Integer length
+      # TypeCode element_type
+      # ret TypeCode
+      def create_array_tc(length, element_type)
+        return CORBA::TypeCode::Array.new(element_type, length)
+      end
+
+      # String id
+      # ret TypeCode
+      def create_recursive_tc(id)
+        return CORBA::TypeCode::Recursive.new(id.to_s.freeze)
+      end
+
+      # RepositoryId id
+      # Identifier name
+      # ValueModifier type_modifier
+      # TypeCode concrete_base
+      # ValueMemberSeq members
+      # ret TypeCode
+      def create_value_tc(id, name, type_modifier, concrete_base, members)
+        return CORBA::TypeCode::Valuetype.new(id, name, type_modifier, concrete_base, members)
+      end
+
+      # RepositoryId id
+      # Identifier name
+      # TypeCode boxed_type
+      # ret TypeCode
+      def create_value_box_tc(id, name, boxed_type)
+        return CORBA::TypeCode::Valuebox.new(id, name, boxed_type)
+      end
+
+      # RepositoryId id
+      # Identifier name
+      # ret TypeCode
+      def create_native_tc(id, name)
+        # TODO ORB::create_native_tc
+        raise ::CORBA::NO_IMPLEMENT
+      end
+
+      # RepositoryId id
+      # Identifier name
+      # ret TypeCode
+      def create_abstract_interface_tc(id, name)
+        return CORBA::TypeCode::AbstractInterface.new(id.to_s.freeze, name.to_s, nil)
+      end
+
+=begin
+// Thread related operations
+=end
+
+      # ret boolean
+      def work_pending()
+        begin
+          self.orb_.work_pending()
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      # ret void
+      def perform_work()
+        begin
+          self.orb_.perform_work()
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      # ret void
+      def run()
+        begin
+          self.orb_.run()
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      # boolean wait_for_completion
+      # ret void
+      def shutdown(wait_for_completion = false)
+        begin
+          self.orb_.shutdown(wait_for_completion)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      # ret void
+      def destroy()
+        begin
+          self.orb_.destroy()
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+=begin
+// Policy related operations
+=end
+
+      # PolicyType type
+      # any val
+      # ret Policy
+      # raises PolicyError
+      def create_policy(type, val)
+        raise ::CORBA::NO_IMPLEMENT
+      end
+
+=begin
+// Value factory operations
+=end
+      # RepositoryId id
+      # ValueFactory factory
+      # ret ValueFactory
+      def register_value_factory(id, factory)
+        self.orb_().register_value_factory(id, factory)
+      end
+
+      # RepositoryId id
+      # ret void
+      def unregister_value_factory(id)
+        self.orb_().unregister_value_factory(id)
+      end
+
+      # RepositoryId id
+      # ret ValueFactory
+      def lookup_value_factory(id)
+        self.orb_().lookup_value_factory(id)
+      end
+    end # ORB
+
+  end # CORBA
+end # R2CORBA

data/lib/corba/common/Object.rb

@@ -0,0 +1,211 @@
+#--------------------------------------------------------------------
+# Object.rb - Common CORBA Object 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
+
+    def CORBA.is_nil(obj)
+      if obj.nil?
+        return true
+      elsif obj.is_a?(R2CORBA::CORBA::Object) || obj.respond_to?(:_is_nil?)
+        return obj._is_nil?()
+      end
+      false
+    end
+
+    module Object
+      @@wrapper_klass = Class.new do
+        include CORBA::Object
+        def initialize(nobj)
+          @objref_ = nobj
+        end
+
+        def _free_ref
+          self._release
+        end
+        attr_reader :objref_
+        def self.name
+          'CORBA::Object'
+        end
+      end
+
+      def self._wrap_native(nobj)
+        raise ArgumentError, 'Expected org.omg.CORBA.Object' unless nobj.nil? || nobj.is_a?(Native::Object)
+        (nobj.nil? || (nobj.respond_to?(:_is_nil) && nobj._is_nil)) ? nil : @@wrapper_klass.new(nobj)
+      end
+
+      def self._narrow(obj)
+        raise CORBA::BAD_PARAM.new('not an object reference', 0, CORBA::COMPLETED_NO) unless obj.nil? || obj.is_a?(CORBA::Object) || obj.is_a?(Native::Object)
+        obj = self._wrap_native(obj) if obj.is_a?(Native::Object)
+        obj
+      end
+
+      def self._tc
+        CORBA._tc_Object
+      end
+
+      #-------------------  4.3 "Object Reference Operations"
+
+      def ==(other)
+        self.class == other.class && self.objref_.eql?(other.objref_)
+      end
+
+      def hash
+        self.objref_.hash
+      end
+
+      def dup
+        self
+      end
+
+      def clone
+        self
+      end
+
+      # ret InterfaceDef
+      def _get_interface()
+        raise ::CORBA::NO_IMPLEMENT
+      end
+
+      # ret boolean
+      def _is_nil?()
+        self.objref_.nil? || (self.objref_.respond_to?(:_is_nil) && self.objref_._is_nil)
+      end
+
+      # ret ::CORBA::Object
+      def _duplicate()
+        return nil if self._is_nil?()
+        begin
+          self._wrap_native(self.objref_._duplicate)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      # ret void
+      def _release()
+        self.objref_._release unless self.objref_.nil?
+        @objref_ = nil
+      end
+
+      # ::String logical_type_id
+      # ret boolean
+      def _is_a?(logical_type_id)
+        return false if self._is_nil?()
+        begin
+          self.objref_._is_a(logical_type_id)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      # ret boolean
+      def _non_existent?()
+        raise CORBA::INV_OBJREF.new if self._is_nil?()
+        begin
+          self.objref_._non_existent
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      # ::CORBA::Object other_object
+      # ret boolean
+      def _is_equivalent?(other_object)
+        raise CORBA::INV_OBJREF.new if self._is_nil?()
+        begin
+          self.objref_._is_equivalent(other_object)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      # Integer(ulong) maximum
+      # ret unsigned long
+      def _hash(maximum)
+        raise CORBA::INV_OBJREF.new if self._is_nil?()
+        begin
+          self.objref_._hash(maximum)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      # ret ::String
+      def _repository_id()
+        raise CORBA::INV_OBJREF.new if self._is_nil?()
+        ## if this object ref has already been narrowed
+        return self._interface_repository_id if self.respond_to?(:_interface_repository_id)
+        ## ask the remote side
+        begin
+          self.objref_._repository_id()
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      # def PolicyType policy_type
+      # ret Policy
+      def _get_policy(policy_type)
+        raise ::CORBA::NO_IMPLEMENT
+      end
+
+      # PolicyList policies
+      # SetOverrideType set_add
+      # ret ::CORBA::Object
+      def _set_policy_overrides(policies, set_add)
+        raise ::CORBA::NO_IMPLEMENT
+      end
+
+      # int[] types
+      # ret PolicyList
+      def _get_policy_overrides(types)
+        raise ::CORBA::NO_IMPLEMENT
+      end
+
+      # PolicyList inconsistent_policies
+      # ret bool
+      def _validate_connection(inconsistent_policies)
+        raise ::CORBA::NO_IMPLEMENT
+      end
+
+      # ret ::CORBA::Object
+      def _get_component()
+        raise CORBA::INV_OBJREF.new if self._is_nil?()
+        begin
+          CORBA::Object._wrap_native(self.objref_._get_component())
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      # ret CORBA::ORB
+      def _get_orb()
+        raise CORBA::INV_OBJREF.new if self._is_nil?()
+        begin
+          CORBA::ORB._wrap_native(self.objref_._get_orb)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+      def _request(operation)
+        raise CORBA::INV_OBJREF.new if self._is_nil?()
+        begin
+          self.objref_._request(operation.to_s)
+        rescue ::NativeException
+          CORBA::Exception.native2r($!)
+        end
+      end
+
+    end # Object
+  end # CORBA
+end # R2CORBA

data/lib/corba/common/Request.rb

@@ -0,0 +1,19 @@
+#--------------------------------------------------------------------
+# Request.rb - Common 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
+    end
+
+  end # CORBA
+end # R2CORBA

data/lib/corba/common/Servant.rb

@@ -0,0 +1,107 @@
+#--------------------------------------------------------------------
+# 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
+
+    class Servant
+
+      module Intf
+        Id  = 'IDL:omg.org/CORBA/Object:1.0'.freeze
+        Ids = [ Id ].freeze
+        Operations = {}.freeze
+      end
+
+      def Servant.include(*modules)
+        modules.reverse_each { |mod|
+          if mod.respond_to?(:superclass) && mod.superclass == R2CORBA::PortableServer::Servant
+            include_srv(mod)
+          elsif mod < CORBA::ValueBase && mod.const_defined?(:Intf)
+            include_valuetype(mod)
+          else
+            super(mod)
+          end
+        }
+      end
+
+      def get_operation_signature(opsym)
+        self.class::Operations[opsym]
+      end
+
+    private
+      def Servant.include_interface(intf)
+        self::Intf.module_eval(%Q{ include ::#{intf.name} })
+        self::Intf::Operations.merge!(intf::Operations)
+        self::Intf::Ids.concat(intf::Ids)
+      end
+
+      def Servant.include_srv(srv)
+        if !self.const_defined?('Id')
+          if self.superclass == R2CORBA::PortableServer::Servant || !self.constants.include?('Id')
+            self.const_set('Id', srv::Id.dup.freeze)
+          else
+            self.const_set('Id', self::Id.dup.freeze)
+          end
+        end
+        if !self.const_defined?('Ids')
+          if self.superclass == R2CORBA::PortableServer::Servant || !self.constants.include?('Ids')
+            self.const_set('Ids', [])
+          else
+            self.const_set('Ids', self::Ids.dup)
+          end
+        end
+        if !self.const_defined?('Operations')
+          if self.superclass == R2CORBA::PortableServer::Servant || !self.constants.include?('Operations')
+            self.const_set('Operations', {})
+          else
+            self.const_set('Operations', self::Operations.dup)
+          end
+        end
+        self.module_eval(%Q{ include ::#{srv.name}::Intf })
+        self::Operations.merge!(srv::Operations)
+        self::Ids.concat(srv::Ids).uniq!
+      end
+    end
+
+    def Servant.include_valuetype(vt)
+      self.module_eval do
+        if vt < CORBA::Portable::CustomValueBase
+          include CORBA::Portable::CustomValueBase unless self.include?(CORBA::Portable::CustomValueBase)
+        else
+          include CORBA::ValueBase unless self.include?(CORBA::ValueBase)
+        end
+        self.const_set(:TRUNCATABLE_IDS, vt::TRUNCATABLE_IDS)
+        self.const_set(:VT_TC, vt._tc)
+        # @@tc_vt_ = vt._tc
+        def self._tc
+          # @@tc_vt_
+          self.const_get(:VT_TC)
+        end
+        include vt::Intf
+      end
+    end
+
+    class DynamicImplementation < Servant
+      def invoke(request)
+        if self.class.const_defined?('OPTABLE') && self.class::OPTABLE.has_key?(request.operation)
+          request.describe(self.class::OPTABLE[request.operation])
+          return self.__send__(request.operation, *request.arguments) { request }
+        else
+          return self.__send__(request.operation) { request }
+        end
+      end
+    end
+
+  end
+
+end

data/lib/corba/common/Struct.rb

@@ -0,0 +1,21 @@
+#--------------------------------------------------------------------
+# Struct.rb - Definition of CORBA Struct class as baseclass for all
+#             IDL defined structs
+#
+# 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
+      class Struct
+      end
+    end
+  end
+end