reidiculous-actionwebservice-client 3.0.4

data/lib/action_web_service/soap/mapping/typeMap.rb

@@ -0,0 +1,50 @@
+# SOAP4R - Base type mapping definition
+# Copyright (C) 2000, 2001, 2002, 2003  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+module SOAP
+
+
+TypeMap = {
+  XSD::XSDAnySimpleType::Type => SOAPAnySimpleType,
+  XSD::XSDString::Type => SOAPString,
+  XSD::XSDBoolean::Type => SOAPBoolean,
+  XSD::XSDDecimal::Type => SOAPDecimal,
+  XSD::XSDFloat::Type => SOAPFloat,
+  XSD::XSDDouble::Type => SOAPDouble,
+  XSD::XSDDuration::Type => SOAPDuration,
+  XSD::XSDDateTime::Type => SOAPDateTime,
+  XSD::XSDTime::Type => SOAPTime,
+  XSD::XSDDate::Type => SOAPDate,
+  XSD::XSDGYearMonth::Type => SOAPGYearMonth,
+  XSD::XSDGYear::Type => SOAPGYear,
+  XSD::XSDGMonthDay::Type => SOAPGMonthDay,
+  XSD::XSDGDay::Type => SOAPGDay,
+  XSD::XSDGMonth::Type => SOAPGMonth,
+  XSD::XSDHexBinary::Type => SOAPHexBinary,
+  XSD::XSDBase64Binary::Type => SOAPBase64,
+  XSD::XSDAnyURI::Type => SOAPAnyURI,
+  XSD::XSDQName::Type => SOAPQName,
+  XSD::XSDInteger::Type => SOAPInteger,
+  XSD::XSDNonPositiveInteger::Type => SOAPNonPositiveInteger,
+  XSD::XSDNegativeInteger::Type => SOAPNegativeInteger,
+  XSD::XSDLong::Type => SOAPLong,
+  XSD::XSDInt::Type => SOAPInt,
+  XSD::XSDShort::Type => SOAPShort,
+  XSD::XSDByte::Type => SOAPByte,
+  XSD::XSDNonNegativeInteger::Type => SOAPNonNegativeInteger,
+  XSD::XSDUnsignedLong::Type => SOAPUnsignedLong,
+  XSD::XSDUnsignedInt::Type => SOAPUnsignedInt,
+  XSD::XSDUnsignedShort::Type => SOAPUnsignedShort,
+  XSD::XSDUnsignedByte::Type => SOAPUnsignedByte,
+  XSD::XSDPositiveInteger::Type => SOAPPositiveInteger,
+
+  SOAP::SOAPBase64::Type => SOAPBase64,
+}
+
+
+end

data/lib/action_web_service/soap/mapping/wsdlencodedregistry.rb

@@ -0,0 +1,280 @@
+# SOAP4R - WSDL encoded mapping registry.
+# Copyright (C) 2000-2003, 2005  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'action_web_service/xsd/qname'
+require 'action_web_service/xsd/namedelements'
+require 'action_web_service/soap/baseData'
+require 'action_web_service/soap/mapping/mapping'
+require 'action_web_service/soap/mapping/typeMap'
+
+
+module SOAP
+module Mapping
+
+
+class WSDLEncodedRegistry < Registry
+  include TraverseSupport
+
+  attr_reader :definedelements
+  attr_reader :definedtypes
+  attr_accessor :excn_handler_obj2soap
+  attr_accessor :excn_handler_soap2obj
+
+  def initialize(definedtypes = XSD::NamedElements::Empty)
+    @definedtypes = definedtypes
+    # @definedelements = definedelements  needed?
+    @excn_handler_obj2soap = nil
+    @excn_handler_soap2obj = nil
+    # For mapping AnyType element.
+    @rubytype_factory = RubytypeFactory.new(
+      :allow_untyped_struct => true,
+      :allow_original_mapping => true
+    )
+    @schema_element_cache = {}
+  end
+
+  def obj2soap(obj, qname = nil)
+    soap_obj = nil
+    if type = @definedtypes[qname]
+      soap_obj = obj2typesoap(obj, type)
+    else
+      soap_obj = any2soap(obj, qname)
+    end
+    return soap_obj if soap_obj
+    if @excn_handler_obj2soap
+      soap_obj = @excn_handler_obj2soap.call(obj) { |yield_obj|
+        Mapping._obj2soap(yield_obj, self)
+      }
+      return soap_obj if soap_obj
+    end
+    if qname
+      raise MappingError.new("cannot map #{obj.class.name} as #{qname}")
+    else
+      raise MappingError.new("cannot map #{obj.class.name} to SOAP/OM")
+    end
+  end
+
+  # map anything for now: must refer WSDL while mapping.  [ToDo]
+  def soap2obj(node, obj_class = nil)
+    begin
+      return any2obj(node, obj_class)
+    rescue MappingError
+    end
+    if @excn_handler_soap2obj
+      begin
+        return @excn_handler_soap2obj.call(node) { |yield_node|
+	    Mapping._soap2obj(yield_node, self)
+	  }
+      rescue Exception
+      end
+    end
+    raise MappingError.new("cannot map #{node.type.name} to Ruby object")
+  end
+
+private
+
+  def any2soap(obj, qname)
+    if obj.nil?
+      SOAPNil.new
+    elsif qname.nil? or qname == XSD::AnyTypeName
+      @rubytype_factory.obj2soap(nil, obj, nil, self)
+    elsif obj.is_a?(XSD::NSDBase)
+      soap2soap(obj, qname)
+    elsif (type = TypeMap[qname])
+      base2soap(obj, type)
+    else
+      nil
+    end
+  end
+
+  def soap2soap(obj, type_qname)
+    if obj.is_a?(SOAPBasetype)
+      obj
+    elsif obj.is_a?(SOAPStruct) && (type = @definedtypes[type_qname])
+      soap_obj = obj
+      mark_marshalled_obj(obj, soap_obj)
+      elements2soap(obj, soap_obj, type.content.elements)
+      soap_obj
+    elsif obj.is_a?(SOAPArray) && (type = @definedtypes[type_qname])
+      soap_obj = obj
+      contenttype = type.child_type
+      mark_marshalled_obj(obj, soap_obj)
+      obj.replace do |ele|
+	Mapping._obj2soap(ele, self, contenttype)
+      end
+      soap_obj
+    else
+      nil
+    end
+  end
+
+  def obj2typesoap(obj, type)
+    if type.is_a?(::WSDL::XMLSchema::SimpleType)
+      simpleobj2soap(obj, type)
+    else
+      complexobj2soap(obj, type)
+    end
+  end
+
+  def simpleobj2soap(obj, type)
+    type.check_lexical_format(obj)
+    return SOAPNil.new if obj.nil?      # ToDo: check nillable.
+    o = base2soap(obj, TypeMap[type.base])
+    o
+  end
+
+  def complexobj2soap(obj, type)
+    case type.compoundtype
+    when :TYPE_STRUCT
+      struct2soap(obj, type.name, type)
+    when :TYPE_ARRAY
+      array2soap(obj, type.name, type)
+    when :TYPE_MAP
+      map2soap(obj, type.name, type)
+    when :TYPE_SIMPLE
+      simpleobj2soap(obj, type.simplecontent)
+    when :TYPE_EMPTY
+      raise MappingError.new("should be empty") unless obj.nil?
+      SOAPNil.new
+    else
+      raise MappingError.new("unknown compound type: #{type.compoundtype}")
+    end
+  end
+
+  def base2soap(obj, type)
+    soap_obj = nil
+    if type <= XSD::XSDString
+      str = XSD::Charset.encoding_conv(obj.to_s,
+        Thread.current[:SOAPExternalCES], XSD::Charset.encoding)
+      soap_obj = type.new(str)
+      mark_marshalled_obj(obj, soap_obj)
+    else
+      soap_obj = type.new(obj)
+    end
+    soap_obj
+  end
+
+  def struct2soap(obj, type_qname, type)
+    return SOAPNil.new if obj.nil?      # ToDo: check nillable.
+    soap_obj = SOAPStruct.new(type_qname)
+    unless obj.nil?
+      mark_marshalled_obj(obj, soap_obj)
+      elements2soap(obj, soap_obj, type.content.elements)
+    end
+    soap_obj
+  end
+
+  def array2soap(obj, type_qname, type)
+    return SOAPNil.new if obj.nil?      # ToDo: check nillable.
+    arytype = type.child_type
+    soap_obj = SOAPArray.new(ValueArrayName, 1, arytype)
+    unless obj.nil?
+      mark_marshalled_obj(obj, soap_obj)
+      obj.each do |item|
+        soap_obj.add(Mapping._obj2soap(item, self, arytype))
+      end
+    end
+    soap_obj
+  end
+
+  MapKeyName = XSD::QName.new(nil, "key")
+  MapValueName = XSD::QName.new(nil, "value")
+  def map2soap(obj, type_qname, type)
+    return SOAPNil.new if obj.nil?      # ToDo: check nillable.
+    keytype = type.child_type(MapKeyName) || XSD::AnyTypeName
+    valuetype = type.child_type(MapValueName) || XSD::AnyTypeName
+    soap_obj = SOAPStruct.new(MapQName)
+    unless obj.nil?
+      mark_marshalled_obj(obj, soap_obj)
+      obj.each do |key, value|
+        elem = SOAPStruct.new
+        elem.add("key", Mapping._obj2soap(key, self, keytype))
+        elem.add("value", Mapping._obj2soap(value, self, valuetype))
+        # ApacheAxis allows only 'item' here.
+        soap_obj.add("item", elem)
+      end
+    end
+    soap_obj
+  end
+
+  def elements2soap(obj, soap_obj, elements)
+    elements.each do |element|
+      name = element.name.name
+      child_obj = Mapping.get_attribute(obj, name)
+      soap_obj.add(name,
+        Mapping._obj2soap(child_obj, self, element.type || element.name))
+    end
+  end
+
+  def any2obj(node, obj_class)
+    unless obj_class
+      typestr = XSD::CodeGen::GenSupport.safeconstname(node.elename.name)
+      obj_class = Mapping.class_from_name(typestr)
+    end
+    if obj_class and obj_class.class_variables.include?('@@schema_element')
+      soap2stubobj(node, obj_class)
+    else
+      Mapping._soap2obj(node, Mapping::DefaultRegistry, obj_class)
+    end
+  end
+
+  def soap2stubobj(node, obj_class)
+    obj = Mapping.create_empty_object(obj_class)
+    unless node.is_a?(SOAPNil)
+      add_elements2stubobj(node, obj)
+    end
+    obj
+  end
+
+  def add_elements2stubobj(node, obj)
+    elements, as_array = schema_element_definition(obj.class)
+    vars = {}
+    node.each do |name, value|
+      item = elements.find { |k, v| k.name == name }
+      if item
+        elename, class_name = item
+        if klass = Mapping.class_from_name(class_name)
+          # klass must be a SOAPBasetype or a class
+          if klass.ancestors.include?(::SOAP::SOAPBasetype)
+            if value.respond_to?(:data)
+              child = klass.new(value.data).data
+            else
+              child = klass.new(nil).data
+            end
+          else
+            child = Mapping._soap2obj(value, self, klass)
+          end
+        elsif klass = Mapping.module_from_name(class_name)
+          # simpletype
+          if value.respond_to?(:data)
+            child = value.data
+          else
+            raise MappingError.new(
+              "cannot map to a module value: #{class_name}")
+          end
+        else
+          raise MappingError.new("unknown class: #{class_name}")
+        end
+      else      # untyped element is treated as anyType.
+        child = Mapping._soap2obj(value, self)
+      end
+      vars[name] = child
+    end
+    Mapping.set_attributes(obj, vars)
+  end
+
+  # it caches @@schema_element.  this means that @@schema_element must not be
+  # changed while a lifetime of a WSDLLiteralRegistry.
+  def schema_element_definition(klass)
+    @schema_element_cache[klass] ||= Mapping.schema_element_definition(klass)
+  end
+end
+
+
+end
+end

data/lib/action_web_service/soap/mapping/wsdlliteralregistry.rb

@@ -0,0 +1,418 @@
+# SOAP4R - WSDL literal mapping registry.
+# Copyright (C) 2004, 2005  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'action_web_service/soap/baseData'
+require 'action_web_service/soap/mapping/mapping'
+require 'action_web_service/soap/mapping/typeMap'
+require 'action_web_service/xsd/codegen/gensupport'
+require 'action_web_service/xsd/namedelements'
+
+
+module SOAP
+module Mapping
+
+
+class WSDLLiteralRegistry < Registry
+  attr_reader :definedelements
+  attr_reader :definedtypes
+  attr_accessor :excn_handler_obj2soap
+  attr_accessor :excn_handler_soap2obj
+
+  def initialize(definedtypes = XSD::NamedElements::Empty,
+      definedelements = XSD::NamedElements::Empty)
+    @definedtypes = definedtypes
+    @definedelements = definedelements
+    @excn_handler_obj2soap = nil
+    @excn_handler_soap2obj = nil
+    @schema_element_cache = {}
+    @schema_attribute_cache = {}
+  end
+
+  def obj2soap(obj, qname)
+    soap_obj = nil
+    if ele = @definedelements[qname]
+      soap_obj = obj2elesoap(obj, ele)
+    elsif type = @definedtypes[qname]
+      soap_obj = obj2typesoap(obj, type, true)
+    else
+      soap_obj = any2soap(obj, qname)
+    end
+    return soap_obj if soap_obj
+    if @excn_handler_obj2soap
+      soap_obj = @excn_handler_obj2soap.call(obj) { |yield_obj|
+        Mapping.obj2soap(yield_obj, nil, nil, MAPPING_OPT)
+      }
+      return soap_obj if soap_obj
+    end
+    raise MappingError.new("cannot map #{obj.class.name} as #{qname}")
+  end
+
+  # node should be a SOAPElement
+  def soap2obj(node, obj_class = nil)
+    # obj_class is given when rpc/literal service.  but ignored for now.
+    begin
+      return any2obj(node)
+    rescue MappingError
+    end
+    if @excn_handler_soap2obj
+      begin
+        return @excn_handler_soap2obj.call(node) { |yield_node|
+	    Mapping.soap2obj(yield_node, nil, nil, MAPPING_OPT)
+	  }
+      rescue Exception
+      end
+    end
+    if node.respond_to?(:type)
+      raise MappingError.new("cannot map #{node.type.name} to Ruby object")
+    else
+      raise MappingError.new("cannot map #{node.elename.name} to Ruby object")
+    end
+  end
+
+private
+
+  MAPPING_OPT = { :no_reference => true }
+
+  def obj2elesoap(obj, ele)
+    o = nil
+    qualified = (ele.elementform == 'qualified')
+    if ele.type
+      if type = @definedtypes[ele.type]
+        o = obj2typesoap(obj, type, qualified)
+      elsif type = TypeMap[ele.type]
+        o = base2soap(obj, type)
+      else
+        raise MappingError.new("cannot find type #{ele.type}")
+      end
+    elsif ele.local_complextype
+      o = obj2typesoap(obj, ele.local_complextype, qualified)
+      add_attributes2soap(obj, o)
+    elsif ele.local_simpletype
+      o = obj2typesoap(obj, ele.local_simpletype, qualified)
+    else
+      raise MappingError.new('illegal schema?')
+    end
+    o.elename = ele.name
+    o
+  end
+
+  def obj2typesoap(obj, type, qualified)
+    if type.is_a?(::WSDL::XMLSchema::SimpleType)
+      simpleobj2soap(obj, type)
+    else
+      complexobj2soap(obj, type, qualified)
+    end
+  end
+
+  def simpleobj2soap(obj, type)
+    type.check_lexical_format(obj)
+    return SOAPNil.new if obj.nil?      # ToDo: check nillable.
+    o = base2soap(obj, TypeMap[type.base])
+    o
+  end
+
+  def complexobj2soap(obj, type, qualified)
+    o = SOAPElement.new(type.name)
+    o.qualified = qualified
+    type.each_element do |child_ele|
+      child = Mapping.get_attribute(obj, child_ele.name.name)
+      if child.nil?
+        if child_ele.nillable
+          # ToDo: test
+          # add empty element
+          child_soap = obj2elesoap(nil, child_ele)
+          o.add(child_soap)
+        elsif Integer(child_ele.minoccurs) == 0
+          # nothing to do
+        else
+          raise MappingError.new("nil not allowed: #{child_ele.name.name}")
+        end
+      elsif child_ele.map_as_array?
+        child.each do |item|
+          child_soap = obj2elesoap(item, child_ele)
+          o.add(child_soap)
+        end
+      else
+        child_soap = obj2elesoap(child, child_ele)
+        o.add(child_soap)
+      end
+    end
+    o
+  end
+
+  def any2soap(obj, qname)
+    if obj.is_a?(SOAPElement)
+      obj
+    elsif obj.class.class_variables.include?('@@schema_element')
+      stubobj2soap(obj, qname)
+    elsif obj.is_a?(SOAP::Mapping::Object)
+      mappingobj2soap(obj, qname)
+    elsif obj.is_a?(Hash)
+      ele = SOAPElement.from_obj(obj)
+      ele.elename = qname
+      ele
+    else
+      # expected to be a basetype or an anyType.
+      # SOAPStruct, etc. is used instead of SOAPElement.
+      begin
+        ele = Mapping.obj2soap(obj, nil, nil, MAPPING_OPT)
+        ele.elename = qname
+        ele
+      rescue MappingError
+        ele = SOAPElement.new(qname, obj.to_s)
+      end
+      if obj.respond_to?(:__xmlattr)
+        obj.__xmlattr.each do |key, value|
+          ele.extraattr[key] = value
+        end
+      end
+      ele
+    end
+  end
+
+  def stubobj2soap(obj, qname)
+    ele = SOAPElement.new(qname)
+    ele.qualified =
+      (obj.class.class_variables.include?('@@schema_qualified') and
+      obj.class.class_eval('@@schema_qualified'))
+    add_elements2soap(obj, ele)
+    add_attributes2soap(obj, ele)
+    ele
+  end
+
+  def mappingobj2soap(obj, qname)
+    ele = SOAPElement.new(qname)
+    obj.__xmlele.each do |key, value|
+      if value.is_a?(::Array)
+        value.each do |item|
+          ele.add(obj2soap(item, key))
+        end
+      else
+        ele.add(obj2soap(value, key))
+      end
+    end
+    obj.__xmlattr.each do |key, value|
+      ele.extraattr[key] = value
+    end
+    ele
+  end
+
+  def add_elements2soap(obj, ele)
+    elements, as_array = schema_element_definition(obj.class)
+    if elements
+      elements.each do |elename, type|
+        if child = Mapping.get_attribute(obj, elename.name)
+          if as_array.include?(elename.name)
+            child.each do |item|
+              ele.add(obj2soap(item, elename))
+            end
+          else
+            ele.add(obj2soap(child, elename))
+          end
+        elsif obj.is_a?(::Array) and as_array.include?(elename.name)
+          obj.each do |item|
+            ele.add(obj2soap(item, elename))
+          end
+        end
+      end
+    end
+  end
+  
+  def add_attributes2soap(obj, ele)
+    attributes = schema_attribute_definition(obj.class)
+    if attributes
+      attributes.each do |qname, param|
+        attr = obj.__send__('xmlattr_' +
+          XSD::CodeGen::GenSupport.safevarname(qname.name))
+        ele.extraattr[qname] = attr
+      end
+    end
+  end
+
+  def base2soap(obj, type)
+    soap_obj = nil
+    if type <= XSD::XSDString
+      str = XSD::Charset.encoding_conv(obj.to_s,
+        Thread.current[:SOAPExternalCES], XSD::Charset.encoding)
+      soap_obj = type.new(str)
+    else
+      soap_obj = type.new(obj)
+    end
+    soap_obj
+  end
+
+  def anytype2obj(node)
+    if node.is_a?(::SOAP::SOAPBasetype)
+      return node.data
+    end
+    klass = ::SOAP::Mapping::Object
+    obj = klass.new
+    obj
+  end
+
+  def any2obj(node, obj_class = nil)
+    unless obj_class
+      typestr = XSD::CodeGen::GenSupport.safeconstname(node.elename.name)
+      obj_class = Mapping.class_from_name(typestr)
+    end
+    if obj_class and obj_class.class_variables.include?('@@schema_element')
+      soapele2stubobj(node, obj_class)
+    elsif node.is_a?(SOAPElement) or node.is_a?(SOAPStruct)
+        # SOAPArray for literal?
+      soapele2plainobj(node)
+    else
+      obj = Mapping.soap2obj(node, nil, obj_class, MAPPING_OPT)
+      add_attributes2plainobj(node, obj)
+      obj
+    end
+  end
+
+  def soapele2stubobj(node, obj_class)
+    obj = Mapping.create_empty_object(obj_class)
+    add_elements2stubobj(node, obj)
+    add_attributes2stubobj(node, obj)
+    obj
+  end
+
+  def soapele2plainobj(node)
+    obj = anytype2obj(node)
+    add_elements2plainobj(node, obj)
+    add_attributes2plainobj(node, obj)
+    obj
+  end
+
+  def add_elements2stubobj(node, obj)
+    elements, as_array = schema_element_definition(obj.class)
+    vars = {}
+    node.each do |name, value|
+      item = elements.find { |k, v| k.name == name }
+      if item
+        elename, class_name = item
+        if klass = Mapping.class_from_name(class_name)
+          # klass must be a SOAPBasetype or a class
+          if klass.ancestors.include?(::SOAP::SOAPBasetype)
+            if value.respond_to?(:data)
+              child = klass.new(value.data).data
+            else
+              child = klass.new(nil).data
+            end
+          else
+            child = any2obj(value, klass)
+          end
+        elsif klass = Mapping.module_from_name(class_name)
+          # simpletype
+          if value.respond_to?(:data)
+            child = value.data
+          else
+            raise MappingError.new(
+              "cannot map to a module value: #{class_name}")
+          end
+        else
+          raise MappingError.new("unknown class/module: #{class_name}")
+        end
+      else      # untyped element is treated as anyType.
+        child = any2obj(value)
+      end
+      if as_array.include?(elename.name)
+        (vars[name] ||= []) << child
+      else
+        vars[name] = child
+      end
+    end
+    Mapping.set_attributes(obj, vars)
+  end
+
+  def add_attributes2stubobj(node, obj)
+    if attributes = schema_attribute_definition(obj.class)
+      define_xmlattr(obj)
+      attributes.each do |qname, class_name|
+        attr = node.extraattr[qname]
+        next if attr.nil? or attr.empty?
+        klass = Mapping.class_from_name(class_name)
+        if klass.ancestors.include?(::SOAP::SOAPBasetype)
+          child = klass.new(attr).data
+        else
+          child = attr
+        end
+        obj.__xmlattr[qname] = child
+        define_xmlattr_accessor(obj, qname)
+      end
+    end
+  end
+
+  def add_elements2plainobj(node, obj)
+    node.each do |name, value|
+      obj.__add_xmlele_value(value.elename, any2obj(value))
+    end
+  end
+
+  def add_attributes2plainobj(node, obj)
+    return if node.extraattr.empty?
+    define_xmlattr(obj)
+    node.extraattr.each do |qname, value|
+      obj.__xmlattr[qname] = value
+      define_xmlattr_accessor(obj, qname)
+    end
+  end
+
+  if RUBY_VERSION > "1.7.0"
+    def define_xmlattr_accessor(obj, qname)
+      name = XSD::CodeGen::GenSupport.safemethodname(qname.name)
+      Mapping.define_attr_accessor(obj, 'xmlattr_' + name,
+        proc { @__xmlattr[qname] },
+        proc { |value| @__xmlattr[qname] = value })
+    end
+  else
+    def define_xmlattr_accessor(obj, qname)
+      name = XSD::CodeGen::GenSupport.safemethodname(qname.name)
+      obj.instance_eval <<-EOS
+        def #{name}
+          @__xmlattr[#{qname.dump}]
+        end
+
+        def #{name}=(value)
+          @__xmlattr[#{qname.dump}] = value
+        end
+      EOS
+    end
+  end
+
+  if RUBY_VERSION > "1.7.0"
+    def define_xmlattr(obj)
+      obj.instance_variable_set('@__xmlattr', {})
+      unless obj.respond_to?(:__xmlattr)
+        Mapping.define_attr_accessor(obj, :__xmlattr, proc { @__xmlattr })
+      end
+    end
+  else
+    def define_xmlattr(obj)
+      obj.instance_variable_set('@__xmlattr', {})
+      unless obj.respond_to?(:__xmlattr)
+        obj.instance_eval <<-EOS
+          def __xmlattr
+            @__xmlattr
+          end
+        EOS
+      end
+    end
+  end
+
+  # it caches @@schema_element.  this means that @@schema_element must not be
+  # changed while a lifetime of a WSDLLiteralRegistry.
+  def schema_element_definition(klass)
+    @schema_element_cache[klass] ||= Mapping.schema_element_definition(klass)
+  end
+
+  def schema_attribute_definition(klass)
+    @schema_attribute_cache[klass] ||= Mapping.schema_attribute_definition(klass)
+  end
+end
+
+
+end
+end