Changeset 166

Timestamp:

07/04/01 12:46:59 (8 years ago)

Author:

nakahiro

Message:

Completely re-written.
Added mappingRegistry interface.
Changed soap2obj and obj2soap's interface.

Files:

• trunk/lib/soap/rpcUtils.rb (modified) (3 diffs)

trunk/lib/soap/rpcUtils.rb

@@ -84 +84 @@
-
-  ApacheSOAPTypeNamespace = 'http://xml.apache.org/xml-soap'
+
+
+  ###
+  ## Ruby's obj <-> SOAP/OM mapping registry.
+  #
+  class Factory
+    class FactoryError < Error; end
+
+    def obj2soap( soapKlass, obj, info, map )
+      raise NotImplementError.new
+    end
+
+    def soap2obj( objKlass, node, info, map )
+      raise NotImplementError.new
+    end
+
+  protected
+
+    def getTypeName( obj )
+      ret = nil
+      begin
+        ret = obj.instance_eval( "@typeName" ) || obj.instance_eval( "@@typeName" )
+      rescue NameError
+      end
+      ret
+    end
+
+    def getNamespace( obj )
+      ret = nil
+      begin
+        ret = obj.instance_eval( "@typeNamespace" ) || obj.instance_eval( "@@typeNamespace" )
+      rescue NameError
+      end
+      ret
+    end
+
+    def createEmptyObject( klass )
+      klass.module_eval <<-EOS
+        begin
+          alias __initialize initialize
+        rescue NameError
+        end
+        def initialize; end
+      EOS
+
+      obj = klass.new
+
+      klass.module_eval <<-EOS
+        undef initialize
+        begin
+          alias initialize __initialize
+        rescue NameError
+        end
+      EOS
+
+      obj
+    end
+
+    def addWriter( klass, values )
+      values.each do |name, value|
+        klass.module_eval <<-EOS
+          begin
+            alias __#{ name }= #{ name }=
+          rescue NameError
+          end
+          def #{ name }=( var )
+            @#{ name } = var
+          end
+        EOS
+      end
+    end
+
+    def restoreWriter( klass, values )
+      values.each do |name, value|
+        klass.module_eval <<-EOS
+          undef #{ name }=
+          begin
+            alias #{ name }= __#{ name }=
+          rescue NameError
+          end
+        EOS
+      end
+    end
+
+    def setInstanceVar( obj, var )
+      obj.instance_eval( "alias __initialize initialize; def initialize; end" )
+      obj.instance_eval( "undef initialize; alias initialize __initialize" )
+      obj
+    end
+
+    def toType( name )
+      capitalize( name )
+    end
+
+    # Create NCName
+    def toTypeName( name )
+      name.gsub( ':', '_' )
+    end
+
+    def capitalize( target )
+      target.gsub('^([a-z])') { $1.tr!('[a-z]', '[A-Z]') }
+    end
+  end
+
+  class BasetypeFactory_ < Factory
+    def obj2soap( soapKlass, obj, info, map )
+      soapKlass.new( obj )
+    end
+
+    def soap2obj( objKlass, node, info, map )
+      node.data
+    end
+  end
+
+  class Base64Factory_ < Factory
+    def obj2soap( soapKlass, obj, info, map )
+      raise FactoryError.new
+    end
+
+    def soap2obj( objKlass, node, info, map )
+      node.toString
+    end
+  end
+
+  class CompoundtypeFactory_ < Factory
+    def obj2soap( soapKlass, obj, info, map )
+      if soapKlass == SOAP::SOAPArray
+        # [ [1], [2] ] is converted to Array of Array, not 2-D Array.
+        # To create M-D Array, you must call RPCUtils.ary2md.
+        typeName = getTypeName( obj.type )
+        typeNamespace = getNamespace( obj.type ) || RubyTypeNamespace
+        unless typeName
+          typeName = XSD::AnyTypeLiteral
+          typeNamespace = XSD::Namespace
+        end
+        param = SOAPArray.new( typeName )
+        param.typeNamespace = typeNamespace
+        obj.each do | var |
+          param.add( RPCUtils.obj2soap( var, map ))
+        end
+        param
+      elsif soapKlass == SOAP::SOAPStruct
+        param = SOAPStruct.new( toTypeName( obj.type.to_s ))
+        param.typeNamespace = getNamespace( obj.type ) || RubyTypeNamespace
+        obj.members.each do |member|
+          param.add( member, RPCUtils.obj2soap( obj[ member ], map ))
+        end
+        param
+      else
+        nil
+      end
+    end
+
+    def soap2obj( objKlass, node, info, map )
+      if node.is_a?( SOAPArray )
+        obj = node.soap2array { | elem |
+          RPCUtils.soap2obj( elem, map )
+        }
+        obj.instance_eval( "@typeName = '#{ node.typeName }'; @typeNamespace = '#{ node.typeNamespace }'" )
+        obj
+      elsif node.is_a?( SOAPStruct )
+        if node.typeEqual( XSD::Namespace, XSD::AnyTypeLiteral )
+          unknownObj( node, map )
+        else
+          struct2obj( node, map )
+        end
+      else
+        raise FactoryError.new( "Unknown compound type: #{ node }" )
+      end
+    end
+
+  private
+
+    def unknownObj( node, map )
+      klass = Object    # SOAP::RPCUtils::Object
+      Thread.critical = true
+      addWriter( klass, node )
+      obj = klass.new
+      node.each do |name, value|
+        obj.send( name + "=", RPCUtils.soap2obj( value, map ))
+      end
+      restoreWriter( klass, node )
+      Thread.critical = false
+      obj.typeNamespace = node.typeNamespace
+      obj.typeName = node.typeName
+      obj
+    end
+
+    def struct2obj( node, map )
+      obj = nil
+      typeName = node.typeName || node.instance_eval( "@name" )
+      begin
+        klass = self.instance_eval( toType( typeName ))
+        if getNamespace( klass ) != node.typeNamespace
+          raise NameError.new()
+        elsif getTypeName( klass ) and ( getTypeName( klass ) != typeName )
+          raise NameError.new()
+        end
+
+        Thread.critical = true
+        addWriter( klass, node )
+        obj = createEmptyObject( klass )
+        node.each do |name, value|
+          obj.send( name + "=", RPCUtils.soap2obj( value, map ))
+        end
+        restoreWriter( klass, node )
+        Thread.critical = false
+
+      rescue NameError
+        klass = nil
+        structName = toType( typeName )
+        if ( Struct.constants - Struct.superclass.constants ).member?( structName )
+          klass = Struct.const_get( structName )
+          if klass.members.length != node.members.length
+            klass = Struct.new( structName, *node.members )
+          end
+        else
+          klass = Struct.new( structName, *node.members )
+        end
+        obj = klass.new
+        node.each do | name, value |
+          obj.send( name + "=", RPCUtils.soap2obj( value, map ))
+        end
+      end
+
+      obj
+    end
+  end
+
+  class HashFactory_ < Factory
+    def obj2soap( soapKlass, obj, info, map )
+      if obj.is_a?( Hash )
+        param = SOAPStruct.new( "Map" )
+        param.typeNamespace = ApacheSOAPTypeNamespace
+        i = 1
+        obj.each do | key, value |
+          elem = SOAPStruct.new( "mapItem" )
+          elem.add( "key", RPCUtils.obj2soap( key, map ))
+          elem.add( "value", RPCUtils.obj2soap( value, map ))
+          param.add( "item#{ i }", elem )
+          i += 1
+        end
+        param
+      else
+        nil
+      end
+    end
+
+    def soap2obj( objKlass, node, info, map )
+      if node.typeEqual( RubyTypeNamespace, 'Hash' )
+        obj = Hash.new
+        keyArray = RPCUtils.soap2obj( node.key, map )
+        valueArray = RPCUtils.soap2obj( node.value, map )
+        while !keyArray.empty?
+          obj[ keyArray.shift ] = valueArray.shift
+        end
+        obj
+      elsif node.typeEqual( ApacheSOAPTypeNamespace, 'Map' )
+        obj = Hash.new
+        node.each do | key, value |
+          obj[ RPCUtils.soap2obj( value.key, map ) ] =
+            RPCUtils.soap2obj( value.value, map )
+        end
+        obj
+      else
+        raise FactoryError.new( "#{ node } is not a Hash." )
+      end
+    end
+  end
+
+  class UnknownKlassFactory_ < Factory
+    def obj2soap( soapKlass, obj, info, map )
+      typeName = getTypeName( obj.type ) || obj.type.to_s
+      param = SOAPStruct.new( typeName  )
+      param.typeNamespace = getNamespace( obj.type ) || RubyCustomTypeNamespace
+      if obj.type.ancestors.member?( Marshallable )
+        obj.instance_variables do |var, data|
+          name = var.dup.sub!( /^@/, '' )
+          param.add( name, RPCUtils.obj2soap( data, map ))
+        end
+      else
+        obj.instance_variables.each do |var|
+          name = var.dup.sub!( /^@/, '' )
+          param.add( name, RPCUtils.obj2soap( obj.instance_eval( var ), map ))
+        end
+      end
+      param
+    end
+
+    def soap2obj( objKlass, node, info, map )
+      node
+    end
+  end
+
+=begin
+    when SOAP::RPCUtils::Object
+      typeName = obj.typeName
+      param = SOAPStruct.new( typeName  )
+      param.typeNamespace = obj.typeNamespace
+      obj.instance_variables do |var, data|
+        name = var.dup.sub!( /^@/, '' )
+        param.add( name, RPCUtils.obj2soap( data ))
+      end
+      param
+=end
+
+  class TypedStructFactory_ < Factory
+    def obj2soap( soapKlass, obj, info, map )
+      typeName = info[1]
+      param = SOAPStruct.new( typeName  )
+      param.typeNamespace = info[0]
+      if obj.type.ancestors.member?( Marshallable )
+        obj.instance_variables do |var, data|
+          name = var.dup.sub!( /^@/, '' )
+          param.add( name, RPCUtils.obj2soap( data, map ))
+        end
+      else
+        obj.instance_variables.each do |var|
+          name = var.dup.sub!( /^@/, '' )
+          param.add( name, RPCUtils.obj2soap( obj.instance_eval( var ), map ))
+        end
+      end
+      param
+    end
+
+    def soap2obj( objKlass, node, info, map )
+      if ( node.typeNamespace != info[0] ) || ( node.typeName != info[1] )
+        raise FactoryError.new( "Type mismatch" )
+      end
+
+      typeName = info[1]
+      Thread.critical = true
+      addWriter( objKlass, node )
+      obj = createEmptyObject( objKlass )
+      node.each do |name, value|
+        obj.send( name + "=", RPCUtils.soap2obj( value, map ))
+      end
+      restoreWriter( objKlass, node )
+      Thread.critical = false
+
+      obj
+    end
+  end
+
+  class MappingRegistry
+    class MappingError < Error; end
+
+    class Mapping
+      def initialize( mappingRegistry )
+        @map = []
+        @registry = mappingRegistry
+      end
+
+      def obj2soap( klass, obj )
+        @map.each do | objKlass, soapKlass, factory, info |
+          if klass.ancestors.include?( objKlass )
+            ret = factory.obj2soap( soapKlass, obj, info, @registry )
+            return ret if ret
+          end
+        end
+        nil
+      end
+
+      def soap2obj( klass, node )
+        @map.each do | objKlass, soapKlass, factory, info |
+          if klass == soapKlass
+            begin
+              return factory.soap2obj( objKlass, node, info, @registry )
+            rescue Factory::FactoryError
+            end
+          end
+        end
+        raise MappingError.new( "Unknown klass: #{ klass }" )
+      end
+
+      def init( initMapping = [] )
+        clear
+        initMapping.each do | objKlass, soapKlass, factory, info |
+          set( objKlass, soapKlass, factory, info )
+        end
+      end
+
+      def set( objKlass, soapKlass, factory, info )
+        @map << [ objKlass, soapKlass, factory, info ]
+      end
+
+      def clear
+        @map.clear
+      end
+    end
+
+    BasetypeFactory = BasetypeFactory_.new
+    CompoundtypeFactory = CompoundtypeFactory_.new
+    Base64Factory = Base64Factory_.new
+    HashFactory = HashFactory_.new
+    UnknownKlassFactory = UnknownKlassFactory_.new
+    TypedStructFactory = TypedStructFactory_.new
+
+    SOAPBaseMapping = [
+      [ ::NilClass,     ::SOAP::SOAPNil,        BasetypeFactory ],
+      [ ::TrueClass,    ::SOAP::SOAPBoolean,    BasetypeFactory ],
+      [ ::FalseClass,   ::SOAP::SOAPBoolean,    BasetypeFactory ],
+      [ ::String,       ::SOAP::SOAPString,     BasetypeFactory ],
+      [ ::Time,         ::SOAP::SOAPDateTime,   BasetypeFactory ],
+      [ ::Date,         ::SOAP::SOAPDateTime,   BasetypeFactory ],
+      [ ::Float,        ::SOAP::SOAPFloat,      BasetypeFactory ],
+      [ ::Float,        ::SOAP::SOAPDouble,     BasetypeFactory ],
+      [ ::Integer,      ::SOAP::SOAPInt,        BasetypeFactory ],
+      [ ::Integer,      ::SOAP::SOAPInteger,    BasetypeFactory ],
+      [ ::String,       ::SOAP::SOAPBase64,     Base64Factory ],
+      [ ::Array,        ::SOAP::SOAPArray,      CompoundtypeFactory ],
+      [ ::Struct,       ::SOAP::SOAPStruct,     CompoundtypeFactory ],
+    ]
+
+    UserMapping = [
+      [ ::Hash,         ::SOAP::SOAPStruct,     HashFactory ],
+    ]
+
+    def initialize()
+      @userMap = Mapping.new( self )
+      @baseMap = Mapping.new( self )
+      @baseMap.init( SOAPBaseMapping )
+      @defaultFactory = UnknownKlassFactory
+    end
+
+    def set( objKlass, soapKlass, factory, info )
+      @userMap.set( objKlass, soapKlass, factory, info )
+    end
+
+    def obj2soap( klass, obj )
+      @userMap.obj2soap( klass, obj ) ||
+        @baseMap.obj2soap( klass, obj ) ||
+        @defaultFactory.obj2soap( klass, obj, nil, self )
+    end
+
+    def soap2obj( klass, node )
+      begin
+        return @userMap.soap2obj( klass, node )
+      rescue MappingError
+        begin
+          return @baseMap.soap2obj( klass, node )
+        rescue MappingError
+        end
+      end
+
+      @defaultFactory.soap2obj( klass, node, nil, self )
+    end
+
+    def defaultFactory=( newFactory )
+      @defaultFactory = newFactory
+    end
+  end
-
-
@@ -227 +679 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-      # ToDo: multi-reference decoding...
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
-    mdAry = SOAPArray.new( XSD::AnyTypeLiteral, rank )
-    mdAry.typeNamespace = XSD::Namespace
@@ -363 +707 @@
-  end
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-  end
-end