soap5r 2.0.0

data/lib/soap/mapping/typeMap.rb

@@ -0,0 +1,107 @@
+# encoding: ASCII-8BIT
+# SOAP4R - Base type mapping definition
+# Copyright (C) 2000-2007  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::XSDNormalizedString::Type => SOAPNormalizedString,
+  XSD::XSDToken::Type => SOAPToken,
+  XSD::XSDLanguage::Type => SOAPLanguage,
+  XSD::XSDNMTOKEN::Type => SOAPNMTOKEN,
+  XSD::XSDNMTOKENS::Type => SOAPNMTOKENS,
+  XSD::XSDName::Type => SOAPName,
+  XSD::XSDNCName::Type => SOAPNCName,
+  XSD::XSDID::Type => SOAPID,
+  XSD::XSDIDREF::Type => SOAPIDREF,
+  XSD::XSDIDREFS::Type => SOAPIDREFS,
+  XSD::XSDENTITY::Type => SOAPENTITY,
+  XSD::XSDENTITIES::Type => SOAPENTITIES,
+  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,
+
+  # soap4r does not use soapenc types actively but it should be accepted.
+  SOAP::SOAPString::SOAPENCType => SOAPString,
+  SOAP::SOAPNormalizedString::Type => SOAPNormalizedString,
+  SOAP::SOAPToken::Type => SOAPToken,
+  SOAP::SOAPLanguage::Type => SOAPLanguage,
+  SOAP::SOAPNMTOKEN::Type => SOAPNMTOKEN,
+  SOAP::SOAPNMTOKENS::Type => SOAPNMTOKENS,
+  SOAP::SOAPName::Type => SOAPName,
+  SOAP::SOAPNCName::Type => SOAPNCName,
+  SOAP::SOAPID::Type => SOAPID,
+  SOAP::SOAPIDREF::Type => SOAPIDREF,
+  SOAP::SOAPIDREFS::Type => SOAPIDREFS,
+  SOAP::SOAPENTITY::Type => SOAPENTITY,
+  SOAP::SOAPENTITIES::Type => SOAPENTITIES,
+  SOAP::SOAPBoolean::SOAPENCType => SOAPBoolean,
+  SOAP::SOAPDecimal::SOAPENCType => SOAPDecimal,
+  SOAP::SOAPFloat::SOAPENCType => SOAPFloat,
+  SOAP::SOAPDouble::SOAPENCType => SOAPDouble,
+  SOAP::SOAPDuration::SOAPENCType => SOAPDuration,
+  SOAP::SOAPDateTime::SOAPENCType => SOAPDateTime,
+  SOAP::SOAPTime::SOAPENCType => SOAPTime,
+  SOAP::SOAPDate::SOAPENCType => SOAPDate,
+  SOAP::SOAPGYearMonth::SOAPENCType => SOAPGYearMonth,
+  SOAP::SOAPGYear::SOAPENCType => SOAPGYear,
+  SOAP::SOAPGMonthDay::SOAPENCType => SOAPGMonthDay,
+  SOAP::SOAPGDay::SOAPENCType => SOAPGDay,
+  SOAP::SOAPGMonth::SOAPENCType => SOAPGMonth,
+  SOAP::SOAPHexBinary::SOAPENCType => SOAPHexBinary,
+  SOAP::SOAPBase64::SOAPENCType => SOAPBase64,
+  SOAP::SOAPAnyURI::SOAPENCType => SOAPAnyURI,
+  SOAP::SOAPQName::SOAPENCType => SOAPQName,
+  SOAP::SOAPInteger::SOAPENCType => SOAPInteger,
+  SOAP::SOAPNonPositiveInteger::SOAPENCType => SOAPNonPositiveInteger,
+  SOAP::SOAPNegativeInteger::SOAPENCType => SOAPNegativeInteger,
+  SOAP::SOAPLong::SOAPENCType => SOAPLong,
+  SOAP::SOAPInt::SOAPENCType => SOAPInt,
+  SOAP::SOAPShort::SOAPENCType => SOAPShort,
+  SOAP::SOAPByte::SOAPENCType => SOAPByte,
+  SOAP::SOAPNonNegativeInteger::SOAPENCType => SOAPNonNegativeInteger,
+  SOAP::SOAPUnsignedLong::SOAPENCType => SOAPUnsignedLong,
+  SOAP::SOAPUnsignedInt::SOAPENCType => SOAPUnsignedInt,
+  SOAP::SOAPUnsignedShort::SOAPENCType => SOAPUnsignedShort,
+  SOAP::SOAPUnsignedByte::SOAPENCType => SOAPUnsignedByte,
+  SOAP::SOAPPositiveInteger::SOAPENCType => SOAPPositiveInteger,
+}
+
+
+end

data/lib/soap/mapping/wsdlencodedregistry.rb

@@ -0,0 +1,212 @@
+# encoding: ASCII-8BIT
+# SOAP4R - WSDL encoded mapping registry.
+# Copyright (C) 2000-2007  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 'xsd/qname'
+require 'xsd/namedelements'
+require 'soap/baseData'
+require 'soap/mapping/mapping'
+require 'soap/mapping/typeMap'
+
+
+module SOAP
+module Mapping
+
+
+class WSDLEncodedRegistry < EncodedRegistry
+  attr_reader :definedelements
+  attr_reader :definedtypes
+
+  def initialize(definedtypes = XSD::NamedElements::Empty)
+    super()
+    @definedtypes = definedtypes
+    # @definedelements = definedelements  needed?
+    # For mapping AnyType element.
+    @rubytype_factory = RubytypeFactory.new(
+      :allow_untyped_struct => true,
+      :allow_original_mapping => true
+    )
+  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)
+    cause = nil
+    begin
+      unless obj_class
+        typestr = Mapping.safeconstname(node.elename.name)
+        obj_class = Mapping.class_from_name(typestr)
+      end
+      return Mapping._soap2obj(node, Mapping::DefaultRegistry, obj_class)
+    rescue MappingError
+      cause = $!
+    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", cause)
+  end
+
+private
+
+  def any2soap(obj, qname)
+    ele = nil
+    if obj.nil?
+      ele = SOAPNil.new
+    elsif qname.nil? or qname == XSD::AnyTypeName
+      ele = @rubytype_factory.obj2soap(nil, obj, nil, self)
+    elsif obj.is_a?(XSD::NSDBase)
+      ele = soap2soap(obj, qname)
+    elsif type = TypeMap[qname]
+      ele = base2soap(obj, type)
+    end
+    add_attributes2soap(obj, ele) unless ele.nil?
+    ele
+  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.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.
+    if type.base
+      ele = base2soap(obj, TypeMap[type.base])
+      ele.type = type.name
+    elsif type.list
+      value = obj.is_a?(Array) ? obj.join(" ") : obj.to_s
+      ele = base2soap(value, SOAP::SOAPString)
+    else
+      raise MappingError.new("unsupported simpleType: #{type}")
+    end
+    ele
+  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 struct2soap(obj, type_qname, type)
+    return SOAPNil.new if obj.nil?      # ToDo: check nillable.
+    soap_obj = SOAPStruct.new(type_qname)
+    mark_marshalled_obj(obj, soap_obj)
+    elements2soap(obj, soap_obj, type.elements)
+    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
+end
+
+
+end
+end

data/lib/soap/mapping/wsdlliteralregistry.rb

@@ -0,0 +1,249 @@
+# encoding: ASCII-8BIT
+# SOAP4R - WSDL literal mapping registry.
+# Copyright (C) 2000-2007  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 'soap/baseData'
+require 'soap/mapping/mapping'
+require 'soap/mapping/literalregistry'
+require 'soap/mapping/typeMap'
+require 'xsd/codegen/gensupport'
+require 'xsd/namedelements'
+
+
+module SOAP
+module Mapping
+
+
+class WSDLLiteralRegistry < LiteralRegistry
+  attr_reader :definedelements
+  attr_reader :definedtypes
+
+  def initialize(definedtypes = XSD::NamedElements::Empty,
+      definedelements = XSD::NamedElements::Empty)
+    super()
+    @definedtypes = definedtypes
+    @definedelements = definedelements
+  end
+
+  def obj2soap(obj, qname, obj_class = nil)
+    soap_obj = nil
+    if obj.is_a?(SOAPElement)
+      soap_obj = obj
+    elsif eledef = @definedelements[qname]
+      soap_obj = obj2elesoap(obj, eledef)
+    elsif type = @definedtypes[qname]
+      soap_obj = obj2typesoap(obj, type)
+    else
+      soap_obj = any2soap(obj, qname, obj_class)
+    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)
+    cause = nil
+    begin
+      return any2obj(node, obj_class)
+    rescue MappingError
+      cause = $!
+    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", cause)
+    else
+      raise MappingError.new("cannot map #{node.elename.name} to Ruby object", cause)
+    end
+  end
+
+private
+
+  def obj2elesoap(obj, eledef)
+    ele = nil
+    qualified = (eledef.elementform == 'qualified')
+    if obj.is_a?(SOAPNil)
+      ele = obj
+    elsif eledef.type
+      if type = @definedtypes[eledef.type]
+        ele = obj2typesoap(obj, type)
+      elsif type = TypeMap[eledef.type]
+        ele = base2soap(obj, type)
+      else
+        raise MappingError.new("cannot find type #{eledef.type}")
+      end
+    elsif eledef.local_complextype
+      ele = obj2typesoap(obj, eledef.local_complextype)
+    elsif eledef.local_simpletype
+      ele = obj2typesoap(obj, eledef.local_simpletype)
+    else
+      raise MappingError.new('illegal schema?')
+    end
+    ele.elename = eledef.name
+    ele.qualified = qualified
+    ele
+  end
+
+  def obj2typesoap(obj, type)
+    ele = nil
+    if type.is_a?(::WSDL::XMLSchema::SimpleType)
+      ele = simpleobj2soap(obj, type)
+    else # complexType
+      if type.simplecontent
+        ele = simpleobj2soap(obj, type.simplecontent)
+      else
+        ele = complexobj2soap(obj, type)
+      end
+      ele.type = type.name
+      if type.base or Mapping.root_type_hint
+        Mapping.reset_root_type_hint
+        ele.force_typed = true
+      end
+      add_definedattributes2soap(obj, ele, type)
+    end
+    ele
+  end
+
+  def simpleobj2soap(obj, type)
+    type.check_lexical_format(obj)
+    return SOAPNil.new if obj.nil?
+    if type.base
+      ele = base2soap(obj, TypeMap[type.base])
+    elsif type.list
+      value = obj.is_a?(Array) ? obj.join(" ") : obj.to_s
+      ele = base2soap(value, SOAP::SOAPString)
+    else
+      raise MappingError.new("unsupported simpleType: #{type}")
+    end
+    ele
+  end
+
+  def complexobj2soap(obj, type)
+    ele = SOAPElement.new(type.name)
+    complexobj2sequencesoap(obj, ele, type, type.choice?, type.choice?)
+    ele
+  end
+
+  def complexobj2sequencesoap(obj, soap, type, nillable, is_choice)
+    added = false
+    type.elements.each do |child_ele|
+      case child_ele
+      when WSDL::XMLSchema::Any
+        any = Mapping.get_attributes_for_any(obj)
+        SOAPElement.from_objs(any).each do |child|
+          soap.add(child)
+        end
+        ele_added = true
+      when WSDL::XMLSchema::Element
+        ele_added = complexobj2soapchildren(obj, soap, child_ele, nillable)
+      when WSDL::XMLSchema::Sequence
+        ele_added = complexobj2sequencesoap(obj, soap, child_ele, nillable, false)
+      when WSDL::XMLSchema::Choice
+        ele_added = complexobj2sequencesoap(obj, soap, child_ele, true, true)
+      else
+        raise MappingError.new("unknown type: #{child_ele}")
+      end
+      added = true if ele_added
+      break if is_choice and ele_added
+    end
+    added
+  end
+
+  def complexobj2soapchildren(obj, soap, child_ele, nillable = false)
+    if child_ele.map_as_array?
+      complexobj2soapchildren_array(obj, soap, child_ele, nillable)
+    else
+      complexobj2soapchildren_single(obj, soap, child_ele, nillable)
+    end
+  end
+
+  def complexobj2soapchildren_array(obj, soap, child_ele, nillable)
+    child = Mapping.get_attribute(obj, child_ele.name.name)
+    if child.nil? and obj.is_a?(::Array)
+      child = obj
+    end
+    if child.nil?
+      return false if nillable
+      if child_soap = nil2soap(child_ele)
+        soap.add(child_soap)
+        return true
+      else
+        return false
+      end
+    end
+    unless child.respond_to?(:each)
+      return false
+    end
+    child.each do |item|
+      if item.is_a?(SOAPElement)
+        soap.add(item)
+      else
+        child_soap = obj2elesoap(item, child_ele)
+        soap.add(child_soap)
+      end
+    end
+    true
+  end
+
+  def complexobj2soapchildren_single(obj, soap, child_ele, nillable)
+    child = Mapping.get_attribute(obj, child_ele.name.name)
+    case child
+    when NilClass
+      return false if nillable
+      if child_soap = nil2soap(child_ele)
+        soap.add(child_soap)
+        true
+      else
+        false
+      end
+    when SOAPElement
+      soap.add(child)
+      true
+    else
+      child_soap = obj2elesoap(child, child_ele)
+      soap.add(child_soap)
+      true
+    end
+  end
+
+  def nil2soap(ele)
+    if ele.nillable
+      obj2elesoap(nil, ele)     # add an empty element
+    elsif ele.minoccurs == 0
+      nil       # intends no element
+    else
+      warn("nil not allowed: #{ele.name.name}")
+      nil
+    end
+  end
+
+  def add_definedattributes2soap(obj, ele, typedef)
+    if typedef.attributes
+      typedef.attributes.each do |at|
+        value = get_xmlattr_value(obj, at.name)
+        ele.extraattr[at.name] = value unless value.nil?
+      end
+    end
+  end
+end
+
+
+end
+end

data/lib/soap/mapping.rb

@@ -0,0 +1,13 @@
+# encoding: ASCII-8BIT
+# SOAP4R - Ruby type mapping utility.
+# Copyright (C) 2000-2007  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 'soap/mapping/mapping'
+require 'soap/mapping/registry'
+require 'soap/mapping/encodedregistry'
+require 'soap/mapping/literalregistry'

data/lib/soap/marshal.rb

@@ -0,0 +1,60 @@
+# encoding: ASCII-8BIT
+# SOAP4R - Marshalling/Unmarshalling Ruby's object using SOAP Encoding.
+# Copyright (C) 2000-2007  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 "soap/mapping"
+require "soap/processor"
+
+
+module SOAP
+
+
+module Marshal
+  # Trying xsd:dateTime data to be recovered as aTime.
+  MarshalMappingRegistry = Mapping::EncodedRegistry.new(
+    :allow_original_mapping => true)
+  MarshalMappingRegistry.add(
+    Time,
+    ::SOAP::SOAPDateTime,
+    ::SOAP::Mapping::EncodedRegistry::DateTimeFactory
+  )
+
+  class << self
+  public
+    def dump(obj, io = nil)
+      marshal(obj, MarshalMappingRegistry, io)
+    end
+
+    def load(stream)
+      unmarshal(stream, MarshalMappingRegistry)
+    end
+
+    def marshal(obj, mapping_registry = MarshalMappingRegistry, io = nil)
+      elename = Mapping.name2elename(obj.class.to_s)
+      soap_obj = Mapping.obj2soap(obj, mapping_registry)
+      body = SOAPBody.new
+      body.add(elename, soap_obj)
+      env = SOAPEnvelope.new(nil, body)
+      SOAP::Processor.marshal(env, {}, io)
+    end
+
+    def unmarshal(stream, mapping_registry = MarshalMappingRegistry)
+      env = SOAP::Processor.unmarshal(stream)
+      if env.nil?
+	raise ArgumentError.new("Illegal SOAP marshal format.")
+      end
+      Mapping.soap2obj(env.body.root_node, mapping_registry)
+    end
+  end
+end
+
+
+end
+
+
+SOAPMarshal = SOAP::Marshal