* added files:

          * lib/soap/mapping/wsdl*.rb
          * lib/wsdl/soap/element.rb
          * lib/wsdl/xmlSchema/simpleContent.rb

        * modified files:
          * lib/soap/*
          * lib/wsdl/*
          * lib/xsd/*
          * test/soap/*
          * test/wsdl/*
          * test/xsd/*
          * sample/soap/*
          * sample/sdl/*

        * summary
          * imported from the soap4r repository.  Version: 1.5.3-ruby1.8.2

          * added several XSD basetype support: nonPositiveInteger,
            negativeInteger, nonNegativeInteger, unsignedLong, unsignedInt,
            unsignedShort, unsignedByte, positiveInteger

          * HTTP client connection/send/receive timeout support.

          * HTTP client/server gzipped content encoding support.

          * improved WSDL schema definition support; still is far from
            complete, but is making step by step improovement.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_1_8@7617 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

20 files changed, 1052 insertions, 680 deletions

diff --git a/lib/soap/baseData.rb b/lib/soap/baseData.rb
index 49c1d2d1f4..2d3d059ebf 100644
--- a/lib/soap/baseData.rb
+++ b/lib/soap/baseData.rb
@@ -319,6 +319,16 @@ class SOAPInteger < XSD::XSDInteger
   extend SOAPModuleUtils
 end
 
+class SOAPNonPositiveInteger < XSD::XSDNonPositiveInteger
+  include SOAPBasetype
+  extend SOAPModuleUtils
+end
+
+class SOAPNegativeInteger < XSD::XSDNegativeInteger
+  include SOAPBasetype
+  extend SOAPModuleUtils
+end
+
 class SOAPLong < XSD::XSDLong
   include SOAPBasetype
   extend SOAPModuleUtils
@@ -334,6 +344,41 @@ class SOAPShort < XSD::XSDShort
   extend SOAPModuleUtils
 end
 
+class SOAPByte < XSD::XSDByte
+  include SOAPBasetype
+  extend SOAPModuleUtils
+end
+
+class SOAPNonNegativeInteger < XSD::XSDNonNegativeInteger
+  include SOAPBasetype
+  extend SOAPModuleUtils
+end
+
+class SOAPUnsignedLong < XSD::XSDUnsignedLong
+  include SOAPBasetype
+  extend SOAPModuleUtils
+end
+
+class SOAPUnsignedInt < XSD::XSDUnsignedInt
+  include SOAPBasetype
+  extend SOAPModuleUtils
+end
+
+class SOAPUnsignedShort < XSD::XSDUnsignedShort
+  include SOAPBasetype
+  extend SOAPModuleUtils
+end
+
+class SOAPUnsignedByte < XSD::XSDUnsignedByte
+  include SOAPBasetype
+  extend SOAPModuleUtils
+end
+
+class SOAPPositiveInteger < XSD::XSDPositiveInteger
+  include SOAPBasetype
+  extend SOAPModuleUtils
+end
+
 
 ###
 ## Compound datatypes.
@@ -466,6 +511,7 @@ class SOAPElement
 
   # Text interface.
   attr_accessor :text
+  alias data text
 
   # Element interfaces.
   def add(value)
diff --git a/lib/soap/encodingstyle/literalHandler.rb b/lib/soap/encodingstyle/literalHandler.rb
index 72a10b2daa..5b702785e6 100644
--- a/lib/soap/encodingstyle/literalHandler.rb
+++ b/lib/soap/encodingstyle/literalHandler.rb
@@ -159,7 +159,7 @@ class LiteralHandler < Handler
   def decode_attrs(ns, attrs)
     extraattr = {}
     attrs.each do |key, value|
-      qname = ns.parse(key)
+      qname = ns.parse_local(key)
       extraattr[qname] = value
     end
     extraattr
diff --git a/lib/soap/encodingstyle/soapHandler.rb b/lib/soap/encodingstyle/soapHandler.rb
index 114060bd02..134a2ae8b8 100644
--- a/lib/soap/encodingstyle/soapHandler.rb
+++ b/lib/soap/encodingstyle/soapHandler.rb
@@ -404,7 +404,7 @@ private
 
   def decode_defined_complextype(elename, typename, typedef, arytypestr)
     case typedef.compoundtype
-    when :TYPE_STRUCT
+    when :TYPE_STRUCT, :TYPE_MAP
       o = SOAPStruct.decode(elename, typename)
       o.definedtype = typedef
       return o
@@ -421,6 +421,9 @@ private
       end
       o.definedtype = typedef
       return o
+    else
+      raise RuntimeError.new(
+        "Unknown kind of complexType: #{typedef.compoundtype}")
     end
     nil
   end
@@ -537,6 +540,7 @@ private
         id = value
         next
       end
+      qname = ns.parse_local(key)
       extraattr[qname] = decode_attr_value(ns, qname, value)
     end
 
diff --git a/lib/soap/mapping/factory.rb b/lib/soap/mapping/factory.rb
index 6b9ac1eeaa..8e82ae5efd 100644
--- a/lib/soap/mapping/factory.rb
+++ b/lib/soap/mapping/factory.rb
@@ -27,39 +27,6 @@ class Factory
     # return convert_succeeded_or_not, obj
   end
 
-  if Object.respond_to?(:allocate)
-    # ruby/1.7 or later.
-    def create_empty_object(klass)
-      klass.allocate
-    end
-  else
-    MARSHAL_TAG = {
-      String => ['"', 1],
-      Regexp => ['/', 2],
-      Array => ['[', 1],
-      Hash => ['{', 1]
-    }
-    def create_empty_object(klass)
-      if klass <= Struct
-	name = klass.name
-	return ::Marshal.load(sprintf("\004\006S:%c%s\000", name.length + 5, name))
-      end
-      if MARSHAL_TAG.has_key?(klass)
-	tag, terminate = MARSHAL_TAG[klass]
-	return ::Marshal.load(sprintf("\004\006%s%s", tag, "\000" * terminate))
-      end
-      MARSHAL_TAG.each do |k, v|
-	if klass < k
-	  name = klass.name
-	  tag, terminate = v
-	  return ::Marshal.load(sprintf("\004\006C:%c%s%s%s", name.length + 5, name, tag, "\000" * terminate))
-	end
-      end
-      name = klass.name
-      ::Marshal.load(sprintf("\004\006o:%c%s\000", name.length + 5, name))
-    end
-  end
-
   def setiv2obj(obj, node, map)
     return if node.nil?
     if obj.is_a?(Array)
@@ -129,7 +96,7 @@ class StringFactory_ < Factory
   end
 
   def soap2obj(obj_class, node, info, map)
-    obj = create_empty_object(obj_class)
+    obj = Mapping.create_empty_object(obj_class)
     decoded = XSD::Charset.encoding_conv(node.data, XSD::Charset.encoding, $KCODE)
     obj.replace(decoded)
     mark_unmarshalled_obj(node, obj)
@@ -253,16 +220,16 @@ class ArrayFactory_ < Factory
     else
       arytype = XSD::AnyTypeName
     end
-    param = SOAPArray.new(ValueArrayName, 1, arytype)
-    mark_marshalled_obj(obj, param)
-    obj.each do |var|
-      param.add(Mapping._obj2soap(var, map))
+    soap_obj = SOAPArray.new(ValueArrayName, 1, arytype)
+    mark_marshalled_obj(obj, soap_obj)
+    obj.each do |item|
+      soap_obj.add(Mapping._obj2soap(item, map))
     end
-    param
+    soap_obj
   end
 
   def soap2obj(obj_class, node, info, map)
-    obj = create_empty_object(obj_class)
+    obj = Mapping.create_empty_object(obj_class)
     mark_unmarshalled_obj(node, obj)
     node.soap2array(obj) do |elem|
       elem ? Mapping._soap2obj(elem, map) : nil
@@ -282,12 +249,12 @@ class TypedArrayFactory_ < Factory
       return nil
     end
     arytype = info[:type] || info[0]
-    param = SOAPArray.new(ValueArrayName, 1, arytype)
-    mark_marshalled_obj(obj, param)
+    soap_obj = SOAPArray.new(ValueArrayName, 1, arytype)
+    mark_marshalled_obj(obj, soap_obj)
     obj.each do |var|
-      param.add(Mapping._obj2soap(var, map))
+      soap_obj.add(Mapping._obj2soap(var, map))
     end
-    param
+    soap_obj
   end
 
   def soap2obj(obj_class, node, info, map)
@@ -298,7 +265,7 @@ class TypedArrayFactory_ < Factory
     unless node.arytype == arytype
       return false
     end
-    obj = create_empty_object(obj_class)
+    obj = Mapping.create_empty_object(obj_class)
     mark_unmarshalled_obj(node, obj)
     node.soap2array(obj) do |elem|
       elem ? Mapping._soap2obj(elem, map) : nil
@@ -310,14 +277,14 @@ end
 class TypedStructFactory_ < Factory
   def obj2soap(soap_class, obj, info, map)
     type = info[:type] || info[0]
-    param = soap_class.new(type)
-    mark_marshalled_obj(obj, param)
+    soap_obj = soap_class.new(type)
+    mark_marshalled_obj(obj, soap_obj)
     if obj.class <= SOAP::Marshallable
-      setiv2soap(param, obj, map)
+      setiv2soap(soap_obj, obj, map)
     else
-      setiv2soap(param, obj, map)
+      setiv2soap(soap_obj, obj, map)
     end
-    param
+    soap_obj
   end
 
   def soap2obj(obj_class, node, info, map)
@@ -325,7 +292,7 @@ class TypedStructFactory_ < Factory
     unless node.type == type
       return false
     end
-    obj = create_empty_object(obj_class)
+    obj = Mapping.create_empty_object(obj_class)
     mark_unmarshalled_obj(node, obj)
     setiv2obj(obj, node, map)
     return true, obj
@@ -347,16 +314,16 @@ class HashFactory_ < Factory
 	(obj.respond_to?(:default_proc) and obj.default_proc)
       return nil
     end
-    param = SOAPStruct.new(MapQName)
-    mark_marshalled_obj(obj, param)
+    soap_obj = SOAPStruct.new(MapQName)
+    mark_marshalled_obj(obj, soap_obj)
     obj.each do |key, value|
       elem = SOAPStruct.new
       elem.add("key", Mapping._obj2soap(key, map))
       elem.add("value", Mapping._obj2soap(value, map))
       # ApacheAxis allows only 'item' here.
-      param.add("item", elem)
+      soap_obj.add("item", elem)
     end
-    param
+    soap_obj
   end
 
   def soap2obj(obj_class, node, info, map)
@@ -366,7 +333,7 @@ class HashFactory_ < Factory
     if node.class == SOAPStruct and node.key?('default')
       return false
     end
-    obj = create_empty_object(obj_class)
+    obj = Mapping.create_empty_object(obj_class)
     mark_unmarshalled_obj(node, obj)
     if node.class == SOAPStruct
       node.each do |key, value|
diff --git a/lib/soap/mapping/mapping.rb b/lib/soap/mapping/mapping.rb
index db7ea607fd..17a0d3bcf4 100644
--- a/lib/soap/mapping/mapping.rb
+++ b/lib/soap/mapping/mapping.rb
@@ -1,11 +1,14 @@
 # SOAP4R - Ruby type mapping utility.
-# Copyright (C) 2000, 2001, 2003 NAKAMURA Hiroshi <nahi@ruby-lang.org>.
+# Copyright (C) 2000, 2001, 2003, 2004  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/codegen/gensupport'
+
+
 module SOAP
 
 
@@ -101,8 +104,10 @@ module Mapping
   def self._obj2soap(obj, registry, type = nil)
     if referent = Thread.current[:SOAPMarshalDataKey][obj.__id__]
       SOAPReference.new(referent)
+    elsif registry
+      registry.obj2soap(obj, type)
     else
-      registry.obj2soap(obj.class, obj, type)
+      raise MappingError.new("No mapping registry given.")
     end
   end
 
@@ -116,9 +121,41 @@ module Mapping
         return _soap2obj(target, registry)
       end
     end
-    return registry.soap2obj(node.class, node)
+    return registry.soap2obj(node)
   end
 
+  if Object.respond_to?(:allocate)
+    # ruby/1.7 or later.
+    def self.create_empty_object(klass)
+      klass.allocate
+    end
+  else
+    MARSHAL_TAG = {
+      String => ['"', 1],
+      Regexp => ['/', 2],
+      Array => ['[', 1],
+      Hash => ['{', 1]
+    }
+    def self.create_empty_object(klass)
+      if klass <= Struct
+	name = klass.name
+	return ::Marshal.load(sprintf("\004\006S:%c%s\000", name.length + 5, name))
+      end
+      if MARSHAL_TAG.has_key?(klass)
+	tag, terminate = MARSHAL_TAG[klass]
+	return ::Marshal.load(sprintf("\004\006%s%s", tag, "\000" * terminate))
+      end
+      MARSHAL_TAG.each do |k, v|
+	if klass < k
+	  name = klass.name
+	  tag, terminate = v
+	  return ::Marshal.load(sprintf("\004\006C:%c%s%s%s", name.length + 5, name, tag, "\000" * terminate))
+	end
+      end
+      name = klass.name
+      ::Marshal.load(sprintf("\004\006o:%c%s\000", name.length + 5, name))
+    end
+  end
   def self.set_instance_vars(obj, values)
     values.each do |name, value|
       setter = name + "="
@@ -200,6 +237,19 @@ module Mapping
     end
   end
 
+  def self.find_attribute(obj, attr_name)
+    if obj.is_a?(::Hash)
+      obj[attr_name] || obj[attr_name.intern]
+    else
+      name = ::XSD::CodeGen::GenSupport.safevarname(attr_name)
+      if obj.respond_to?(name)
+        obj.__send__(name)
+      else
+        obj.instance_eval("@#{name}")
+      end
+    end
+  end
+
   class << Mapping
   private
     def add_md_ary(md_ary, ary, indices, registry)
diff --git a/lib/soap/mapping/registry.rb b/lib/soap/mapping/registry.rb
index 1317d40cd6..24cd57fa71 100644
--- a/lib/soap/mapping/registry.rb
+++ b/lib/soap/mapping/registry.rb
@@ -64,12 +64,12 @@ end
 # For anyType object: SOAP::Mapping::Object not ::Object
 class Object; include Marshallable
   def initialize
-    @__members = []
-    @__value_type = {}
+    @__soap_members = []
+    @__soap_value_type = {}
   end
 
   def [](name)
-    if @__members.include?(name)
+    if @__soap_members.include?(name)
       self.__send__(name)
     else
       self.__send__(Object.safe_name(name))
@@ -77,39 +77,35 @@ class Object; include Marshallable
   end
 
   def []=(name, value)
-    if @__members.include?(name)
+    if @__soap_members.include?(name)
       self.__send__(name + '=', value)
     else
       self.__send__(Object.safe_name(name) + '=', value)
     end
   end
 
-  def __set_property(name, value)
+  def __soap_set_property(name, value)
     var_name = name
-    unless @__members.include?(name)
+    unless @__soap_members.include?(name)
       var_name = __define_attr_accessor(var_name)
     end
-    __set_property_value(var_name, value)
+    __soap_set_property_value(var_name, value)
     var_name
   end
 
-  def __members
-    @__members
-  end
-
 private
 
-  def __set_property_value(name, value)
+  def __soap_set_property_value(name, value)
     org = self.__send__(name)
-    case @__value_type[name]
+    case @__soap_value_type[name]
     when :single
       self.__send__(name + '=', [org, value])
-      @__value_type[name] = :multi
+      @__soap_value_type[name] = :multi
     when :multi
       org << value
     else
       self.__send__(name + '=', value)
-      @__value_type[name] = :single
+      @__soap_value_type[name] = :single
     end
     value
   end
@@ -130,7 +126,7 @@ private
       var_name = Object.safe_name(var_name)
       retry
     end
-    @__members << var_name
+    @__soap_members << var_name
     var_name
   end
 
@@ -147,30 +143,42 @@ class MappingError < Error; end
 class Registry
   class Map
     def initialize(registry)
-      @map = []
+      @obj2soap = {}
+      @soap2obj = {}
       @registry = registry
     end
 
-    def obj2soap(klass, obj, type_qname = nil)
-      @map.each do |obj_class, soap_class, factory, info|
-        if klass == obj_class or
-            (info[:derived_class] and klass <= obj_class)
+    def obj2soap(obj, type_qname = nil)
+      klass = obj.class
+      if map = @obj2soap[klass]
+        map.each do |soap_class, factory, info|
           ret = factory.obj2soap(soap_class, obj, info, @registry)
           return ret if ret
         end
       end
+      ancestors = klass.ancestors[1..-3] # except itself, Object and Kernel
+      ancestors.each do |klass|
+        if map = @obj2soap[klass]
+          map.each do |soap_class, factory, info|
+            if info[:derived_class]
+              ret = factory.obj2soap(soap_class, obj, info, @registry)
+              return ret if ret
+            end
+          end
+        end
+      end
       nil
     end
 
-    def soap2obj(klass, node)
-      @map.each do |obj_class, soap_class, factory, info|
-        if klass == soap_class or
-            (info[:derived_class] and klass <= soap_class)
+    def soap2obj(node)
+      klass = node.class
+      if map = @soap2obj[klass]
+        map.each do |obj_class, factory, info|
           conv, obj = factory.soap2obj(obj_class, node, info, @registry)
           return true, obj if conv
         end
       end
-      return false
+      return false, nil
     end
 
     # Give priority to former entry.
@@ -184,29 +192,21 @@ class Registry
     # Give priority to latter entry.
     def add(obj_class, soap_class, factory, info)
       info ||= {}
-      @map.unshift([obj_class, soap_class, factory, info])
+      (@obj2soap[obj_class] ||= []).unshift([soap_class, factory, info])
+      (@soap2obj[soap_class] ||= []).unshift([obj_class, factory, info])
     end
 
     def clear
-      @map.clear
+      @obj2soap.clear
+      @soap2obj.clear
     end
 
     def find_mapped_soap_class(target_obj_class)
-      @map.each do |obj_class, soap_class, factory, info|
-        if obj_class == target_obj_class
-          return soap_class
-        end
-      end
-      nil
+      @obj2soap[target_obj_class][0]
     end
 
     def find_mapped_obj_class(target_soap_class)
-      @map.each do |obj_class, soap_class, factory, info|
-        if soap_class == target_soap_class
-          return obj_class
-        end
-      end
-      nil
+      @soap2obj[target_soap_class][0]
     end
   end
 
@@ -243,6 +243,24 @@ class Registry
       {:derived_class => true}],
     [::Integer,      ::SOAP::SOAPShort,      BasetypeFactory,
       {:derived_class => true}],
+    [::Integer,      ::SOAP::SOAPByte,       BasetypeFactory,
+      {:derived_class => true}],
+    [::Integer,      ::SOAP::SOAPNonPositiveInteger, BasetypeFactory,
+      {:derived_class => true}],
+    [::Integer,      ::SOAP::SOAPNegativeInteger, BasetypeFactory,
+      {:derived_class => true}],
+    [::Integer,      ::SOAP::SOAPNonNegativeInteger, BasetypeFactory,
+      {:derived_class => true}],
+    [::Integer,      ::SOAP::SOAPPositiveInteger, BasetypeFactory,
+      {:derived_class => true}],
+    [::Integer,      ::SOAP::SOAPUnsignedLong, BasetypeFactory,
+      {:derived_class => true}],
+    [::Integer,      ::SOAP::SOAPUnsignedInt, BasetypeFactory,
+      {:derived_class => true}],
+    [::Integer,      ::SOAP::SOAPUnsignedShort, BasetypeFactory,
+      {:derived_class => true}],
+    [::Integer,      ::SOAP::SOAPUnsignedByte, BasetypeFactory,
+      {:derived_class => true}],
     [::URI::Generic, ::SOAP::SOAPAnyURI,     URIFactory,
       {:derived_class => true}],
     [::String,       ::SOAP::SOAPBase64,     Base64Factory],
@@ -289,6 +307,24 @@ class Registry
       {:derived_class => true}],
     [::Integer,      ::SOAP::SOAPShort,      BasetypeFactory,
       {:derived_class => true}],
+    [::Integer,      ::SOAP::SOAPByte,       BasetypeFactory,
+      {:derived_class => true}],
+    [::Integer,      ::SOAP::SOAPNonPositiveInteger, BasetypeFactory,
+      {:derived_class => true}],
+    [::Integer,      ::SOAP::SOAPNegativeInteger, BasetypeFactory,
+      {:derived_class => true}],
+    [::Integer,      ::SOAP::SOAPNonNegativeInteger, BasetypeFactory,
+      {:derived_class => true}],
+    [::Integer,      ::SOAP::SOAPPositiveInteger, BasetypeFactory,
+      {:derived_class => true}],
+    [::Integer,      ::SOAP::SOAPUnsignedLong, BasetypeFactory,
+      {:derived_class => true}],
+    [::Integer,      ::SOAP::SOAPUnsignedInt, BasetypeFactory,
+      {:derived_class => true}],
+    [::Integer,      ::SOAP::SOAPUnsignedShort, BasetypeFactory,
+      {:derived_class => true}],
+    [::Integer,      ::SOAP::SOAPUnsignedByte, BasetypeFactory,
+      {:derived_class => true}],
     [::URI::Generic, ::SOAP::SOAPAnyURI,     URIFactory,
       {:derived_class => true}],
     [::String,       ::SOAP::SOAPBase64,     Base64Factory],
@@ -313,6 +349,10 @@ class Registry
       {:type => XSD::QName.new(RubyCustomTypeNamespace, "SOAPException")}],
   ]
 
+  attr_accessor :default_factory
+  attr_accessor :excn_handler_obj2soap
+  attr_accessor :excn_handler_soap2obj
+
   def initialize(config = {})
     @config = config
     @map = Map.new(self)
@@ -323,7 +363,6 @@ class Registry
       @allow_original_mapping = false
       @map.init(SOAPBaseMap)
     end
-
     @allow_untyped_struct = @config.key?(:allow_untyped_struct) ?
       @config[:allow_untyped_struct] : true
     @rubytype_factory = RubytypeFactory.new(
@@ -341,16 +380,16 @@ class Registry
   alias set add
 
   # This mapping registry ignores type hint.
-  def obj2soap(klass, obj, type_qname = nil)
-    soap = _obj2soap(klass, obj, type_qname)
+  def obj2soap(obj, type_qname = nil)
+    soap = _obj2soap(obj, type_qname)
     if @allow_original_mapping
       addextend2soap(soap, obj)
     end
     soap
   end
 
-  def soap2obj(klass, node)
-    obj = _soap2obj(klass, node)
+  def soap2obj(node)
+    obj = _soap2obj(node)
     if @allow_original_mapping
       addextend2obj(obj, node.extraattr[RubyExtendName])
       addiv2obj(obj, node.extraattr[RubyIVarName])
@@ -358,18 +397,6 @@ class Registry
     obj
   end
 
-  def default_factory=(factory)
-    @default_factory = factory
-  end
-
-  def excn_handler_obj2soap=(handler)
-    @excn_handler_obj2soap = handler
-  end
-
-  def excn_handler_soap2obj=(handler)
-    @excn_handler_soap2obj = handler
-  end
-
   def find_mapped_soap_class(obj_class)
     @map.find_mapped_soap_class(obj_class)
   end
@@ -380,7 +407,7 @@ class Registry
 
 private
 
-  def _obj2soap(klass, obj, type_qname)
+  def _obj2soap(obj, type_qname)
     ret = nil
     if obj.is_a?(SOAPStruct) or obj.is_a?(SOAPArray)
       obj.replace do |ele|
@@ -391,32 +418,31 @@ private
       return obj
     end
     begin 
-      ret = @map.obj2soap(klass, obj, type_qname) ||
-        @default_factory.obj2soap(klass, obj, nil, self)
+      ret = @map.obj2soap(obj, type_qname) ||
+        @default_factory.obj2soap(nil, obj, nil, self)
+      return ret if ret
     rescue MappingError
     end
-    return ret if ret
     if @excn_handler_obj2soap
       ret = @excn_handler_obj2soap.call(obj) { |yield_obj|
         Mapping._obj2soap(yield_obj, self)
       }
+      return ret if ret
     end
-    return ret if ret
-    raise MappingError.new("Cannot map #{ klass.name } to SOAP/OM.")
+    raise MappingError.new("Cannot map #{ obj.class.name } to SOAP/OM.")
   end
 
   # Might return nil as a mapping result.
-  def _soap2obj(klass, node)
+  def _soap2obj(node)
     if node.extraattr.key?(RubyTypeName)
-      conv, obj = @rubytype_factory.soap2obj(klass, node, nil, self)
+      conv, obj = @rubytype_factory.soap2obj(nil, node, nil, self)
       return obj if conv
     else
-      conv, obj = @map.soap2obj(klass, node)
+      conv, obj = @map.soap2obj(node)
       return obj if conv
-      conv, obj = @default_factory.soap2obj(klass, node, nil, self)
+      conv, obj = @default_factory.soap2obj(nil, node, nil, self)
       return obj if conv
     end
-
     if @excn_handler_soap2obj
       begin
         return @excn_handler_soap2obj.call(node) { |yield_node|
diff --git a/lib/soap/mapping/rubytypeFactory.rb b/lib/soap/mapping/rubytypeFactory.rb
index a46d93275f..6266148b55 100644
--- a/lib/soap/mapping/rubytypeFactory.rb
+++ b/lib/soap/mapping/rubytypeFactory.rb
@@ -318,7 +318,7 @@ private
     case node.type
     when TYPE_HASH
       klass = rubytype ? Mapping.class_from_name(rubytype) : Hash
-      obj = create_empty_object(klass)
+      obj = Mapping.create_empty_object(klass)
       mark_unmarshalled_obj(node, obj)
       node.each do |key, value|
         next unless key == 'item'
@@ -330,14 +330,14 @@ private
       end
     when TYPE_REGEXP
       klass = rubytype ? Mapping.class_from_name(rubytype) : Regexp
-      obj = create_empty_object(klass)
+      obj = Mapping.create_empty_object(klass)
       mark_unmarshalled_obj(node, obj)
       source = node['source'].string
       options = node['options'].data || 0
       Regexp.instance_method(:initialize).bind(obj).call(source, options)
     when TYPE_RANGE
       klass = rubytype ? Mapping.class_from_name(rubytype) : Range
-      obj = create_empty_object(klass)
+      obj = Mapping.create_empty_object(klass)
       mark_unmarshalled_obj(node, obj)
       first = Mapping._soap2obj(node['begin'], map)
       last = Mapping._soap2obj(node['end'], map)
@@ -358,7 +358,7 @@ private
       unless klass <= ::Struct
         return false
       end
-      obj = create_empty_object(klass)
+      obj = Mapping.create_empty_object(klass)
       mark_unmarshalled_obj(node, obj)
       node['member'].each do |name, value|
         obj[Mapping.elename2name(name)] = Mapping._soap2obj(value, map)
@@ -378,7 +378,7 @@ private
       obj = klass.new
       mark_unmarshalled_obj(node, obj)
       node.each do |name, value|
-        obj.__set_property(name, Mapping._soap2obj(value, map))
+        obj.__soap_set_property(name, Mapping._soap2obj(value, map))
       end
       return true, obj
     else
@@ -414,7 +414,7 @@ private
     end
     klass_type = Mapping.class2qname(klass)
     return nil unless node.type.match(klass_type)
-    obj = create_empty_object(klass)
+    obj = Mapping.create_empty_object(klass)
     mark_unmarshalled_obj(node, obj)
     setiv2obj(obj, node, map)
     obj
@@ -423,7 +423,7 @@ private
   def exception2obj(klass, node, map)
     message = Mapping._soap2obj(node['message'], map)
     backtrace = Mapping._soap2obj(node['backtrace'], map)
-    obj = create_empty_object(klass)
+    obj = Mapping.create_empty_object(klass)
     obj = obj.exception(message)
     mark_unmarshalled_obj(node, obj)
     obj.set_backtrace(backtrace)
@@ -433,7 +433,7 @@ private
   # Only creates empty array.  Do String#replace it with real string.
   def array2obj(node, map, rubytype)
     klass = rubytype ? Mapping.class_from_name(rubytype) : Array
-    obj = create_empty_object(klass)
+    obj = Mapping.create_empty_object(klass)
     mark_unmarshalled_obj(node, obj)
     obj
   end
@@ -441,7 +441,7 @@ private
   # Only creates empty string.  Do String#replace it with real string.
   def string2obj(node, map, rubytype)
     klass = rubytype ? Mapping.class_from_name(rubytype) : String
-    obj = create_empty_object(klass)
+    obj = Mapping.create_empty_object(klass)
     mark_unmarshalled_obj(node, obj)
     obj
   end
diff --git a/lib/soap/mapping/typeMap.rb b/lib/soap/mapping/typeMap.rb
index 93f24b4bd8..34db19a5b6 100644
--- a/lib/soap/mapping/typeMap.rb
+++ b/lib/soap/mapping/typeMap.rb
@@ -30,9 +30,18 @@ TypeMap = {
   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,
 }
diff --git a/lib/soap/netHttpClient.rb b/lib/soap/netHttpClient.rb
index 1e9d71c5a3..5b16a5b443 100644
--- a/lib/soap/netHttpClient.rb
+++ b/lib/soap/netHttpClient.rb
@@ -26,13 +26,17 @@ class NetHttpClient
   attr_accessor :debug_dev
   attr_accessor :ssl_config		# ignored for now.
   attr_accessor :protocol_version	# ignored for now.
+  attr_accessor :connect_timeout
+  attr_accessor :send_timeout           # ignored for now.
+  attr_accessor :receive_timeout
 
   def initialize(proxy = nil, agent = nil)
     @proxy = proxy ? URI.parse(proxy) : nil
     @agent = agent
     @debug_dev = nil
     @session_manager = SessionManager.new
-    @no_proxy = nil
+    @no_proxy = @ssl_config = @protocol_version = nil
+    @connect_timeout = @send_timeout = @receive_timeout = nil
   end
 
   def test_loopback_response
@@ -55,6 +59,7 @@ class NetHttpClient
   def set_basic_auth(uri, user_id, passwd)
     # net/http does not handle url.
     @basic_auth = [user_id, passwd]
+    raise NotImplementedError.new("basic_auth is not supported under soap4r + net/http.")
   end
 
   def set_cookie_store(filename)
@@ -99,7 +104,7 @@ private
     http = create_connection(url)
     response = nil
     http.start { |worker|
-      response, = yield(worker)
+      response = yield(worker)
       worker.finish
     }
     @debug_dev << response.body if @debug_dev
@@ -116,6 +121,8 @@ private
     if http.respond_to?(:set_debug_output)
       http.set_debug_output(@debug_dev)
     end
+    http.open_timeout = @connect_timeout if @connect_timeout
+    http.read_timeout = @receive_timeout if @receive_timeout
     case url
     when URI::HTTPS
       if SSLEnabled
diff --git a/lib/soap/property.rb b/lib/soap/property.rb
index 113cc64f3c..882dcc6e28 100644
--- a/lib/soap/property.rb
+++ b/lib/soap/property.rb
@@ -32,6 +32,8 @@ module SOAP
 #     aaa.hhh = iii
 #
 class Property
+  FrozenError = (RUBY_VERSION >= "1.9.0") ? RuntimeError : TypeError
+
   include Enumerable
 
   module Util
@@ -78,8 +80,7 @@ class Property
       when LINE_REGEXP
 	key, value = $1.strip, $2.strip
 	key = "#{key_prefix}.#{key}" unless key_prefix.empty?
-	key = eval("\"#{key}\"")
-	value = eval("\"#{value}\"")
+	key, value = loadstr(key), loadstr(value)
 	self[key] = value
       else
 	raise TypeError.new(
@@ -190,7 +191,7 @@ protected
   def local_referent(key)
     check_lock(key)
     if propkey?(@store[key]) and @store[key].locked?
-      raise TypeError.new("cannot split any key from locked property")
+      raise FrozenError.new("cannot split any key from locked property")
     end
     @store[key]
   end
@@ -199,9 +200,9 @@ protected
     check_lock(key)
     if @locked
       if propkey?(value)
-	raise TypeError.new("cannot add any key to locked property")
+	raise FrozenError.new("cannot add any key to locked property")
       elsif propkey?(@store[key])
-	raise TypeError.new("cannot override any key in locked property")
+	raise FrozenError.new("cannot override any key in locked property")
       end
     end
     @store[key] = value
@@ -265,7 +266,7 @@ private
 
   def check_lock(key)
     if @locked and (key.nil? or !@store.key?(key))
-      raise TypeError.new("cannot add any key to locked property")
+      raise FrozenError.new("cannot add any key to locked property")
     end
   end
 
@@ -308,6 +309,10 @@ private
       load(f)
     end
   end
+
+  def loadstr(str)
+    str.gsub(/\\./) { |c| eval("\"#{c}\"") }
+  end
 end
 
 
diff --git a/lib/soap/rpc/cgistub.rb b/lib/soap/rpc/cgistub.rb
index 55437bac59..e545d53c42 100644
--- a/lib/soap/rpc/cgistub.rb
+++ b/lib/soap/rpc/cgistub.rb
@@ -163,16 +163,16 @@ private
     @response = WEBrick::HTTPResponse.new({:HTTPVersion => httpversion})
     conn_data = nil
     begin
-      log(INFO) { "Received a request from '#{ @remote_user }@#{ @remote_host }'." }
+      @log.info { "Received a request from '#{ @remote_user }@#{ @remote_host }'." }
       # SOAP request parsing.
       @request = SOAPRequest.new.init
       @response['Status'] = 200
       conn_data = ::SOAP::StreamHandler::ConnectionData.new
       conn_data.receive_string = @request.dump
       conn_data.receive_contenttype = @request.contenttype
-      log(DEBUG) { "XML Request: #{conn_data.receive_string}" }
+      @log.debug { "XML Request: #{conn_data.receive_string}" }
       conn_data = route(conn_data)
-      log(DEBUG) { "XML Response: #{conn_data.send_string}" }
+      @log.debug { "XML Response: #{conn_data.send_string}" }
       if conn_data.is_fault
 	@response['Status'] = 500
       end
@@ -189,7 +189,7 @@ private
       buf = ''
       @response.send_response(buf)
       buf.sub!(/^[^\r]+\r\n/, '')       # Trim status line.
-      log(DEBUG) { "SOAP CGI Response:\n#{ buf }" }
+      @log.debug { "SOAP CGI Response:\n#{ buf }" }
       print buf
       epilogue
     end
diff --git a/lib/soap/rpc/driver.rb b/lib/soap/rpc/driver.rb
index 0e59dde9be..028addc3eb 100644
--- a/lib/soap/rpc/driver.rb
+++ b/lib/soap/rpc/driver.rb
@@ -8,6 +8,7 @@
 
 require 'soap/soap'
 require 'soap/mapping'
+require 'soap/mapping/wsdlliteralregistry'
 require 'soap/rpc/rpc'
 require 'soap/rpc/proxy'
 require 'soap/rpc/element'
@@ -43,42 +44,45 @@ class Driver
 
   __attr_proxy :options
   __attr_proxy :headerhandler
+  __attr_proxy :streamhandler
   __attr_proxy :test_loopback_response
   __attr_proxy :endpoint_url, true
   __attr_proxy :mapping_registry, true
   __attr_proxy :soapaction, true
   __attr_proxy :default_encodingstyle, true
+  __attr_proxy :generate_explicit_type, true
+  __attr_proxy :allow_unqualified_element, true
 
   def httpproxy
-    @servant.options["protocol.http.proxy"]
+    options["protocol.http.proxy"]
   end
 
   def httpproxy=(httpproxy)
-    @servant.options["protocol.http.proxy"] = httpproxy
+    options["protocol.http.proxy"] = httpproxy
   end
 
   def wiredump_dev
-    @servant.options["protocol.http.wiredump_dev"]
+    options["protocol.http.wiredump_dev"]
   end
 
   def wiredump_dev=(wiredump_dev)
-    @servant.options["protocol.http.wiredump_dev"] = wiredump_dev
+    options["protocol.http.wiredump_dev"] = wiredump_dev
   end
 
   def mandatorycharset
-    @servant.options["protocol.mandatorycharset"]
+    options["protocol.mandatorycharset"]
   end
 
   def mandatorycharset=(mandatorycharset)
-    @servant.options["protocol.mandatorycharset"] = mandatorycharset
+    options["protocol.mandatorycharset"] = mandatorycharset
   end
 
   def wiredump_file_base
-    @servant.options["protocol.wiredump_file_base"]
+    options["protocol.wiredump_file_base"]
   end
 
   def wiredump_file_base=(wiredump_file_base)
-    @servant.options["protocol.wiredump_file_base"] = wiredump_file_base
+    options["protocol.wiredump_file_base"] = wiredump_file_base
   end
 
   def initialize(endpoint_url, namespace, soapaction = nil)
@@ -94,32 +98,59 @@ class Driver
   end
 
   def inspect
-    "#<#{self.class}:#{@servant.streamhandler.inspect}>"
+    "#<#{self.class}:#{@servant.inspect}>"
   end
 
-  def add_method(name, *params)
-    add_method_with_soapaction_as(name, name, @servant.soapaction, *params)
+  def add_rpc_method(name, *params)
+    param_def = create_rpc_param_def(params)
+    @servant.add_rpc_method(name, @servant.soapaction, name, param_def)
   end
 
-  def add_method_as(name, name_as, *params)
-    add_method_with_soapaction_as(name, name_as, @servant.soapaction, *params)
+  def add_rpc_method_as(name, name_as, *params)
+    param_def = create_rpc_param_def(params)
+    @servant.add_rpc_method(name_as, @servant.soapaction, name, param_def)
   end
 
-  def add_method_with_soapaction(name, soapaction, *params)
-    add_method_with_soapaction_as(name, name, soapaction, *params)
+  def add_rpc_method_with_soapaction(name, soapaction, *params)
+    param_def = create_rpc_param_def(params)
+    @servant.add_rpc_method(name, soapaction, name, param_def)
   end
 
-  def add_method_with_soapaction_as(name, name_as, soapaction, *params)
-    param_def = if params.size == 1 and params[0].is_a?(Array)
-        params[0]
-      else
-        SOAPMethod.create_param_def(params)
-      end
-    @servant.add_method(name_as, soapaction, name, param_def)
+  def add_rpc_method_with_soapaction_as(name, name_as, soapaction, *params)
+    param_def = create_rpc_param_def(params)
+    @servant.add_rpc_method(name_as, soapaction, name, param_def)
+  end
+
+  # add_method is for shortcut of typical rpc/encoded method definition.
+  alias add_method add_rpc_method
+  alias add_method_as add_rpc_method_as
+  alias add_method_with_soapaction add_rpc_method_with_soapaction
+  alias add_method_with_soapaction_as add_rpc_method_with_soapaction_as
+
+  def add_document_method(name, req_qname, res_qname)
+    param_def = create_document_param_def(name, req_qname, res_qname)
+    @servant.add_document_method(name, @servant.soapaction, name, param_def)
+  end
+
+  def add_document_method_as(name, name_as, req_qname, res_qname)
+    param_def = create_document_param_def(name, req_qname, res_qname)
+    @servant.add_document_method(name_as, @servant.soapaction, name, param_def)
+  end
+
+  def add_document_method_with_soapaction(name, soapaction, req_qname,
+      res_qname)
+    param_def = create_document_param_def(name, req_qname, res_qname)
+    @servant.add_document_method(name, soapaction, name, param_def)
+  end
+
+  def add_document_method_with_soapaction_as(name, name_as, soapaction,
+      req_qname, res_qname)
+    param_def = create_document_param_def(name, req_qname, res_qname)
+    @servant.add_document_method(name_as, soapaction, name, param_def)
   end
 
   def reset_stream
-    @servant.streamhandler.reset
+    @servant.reset_stream
   end
 
   def invoke(headers, body)
@@ -132,53 +163,62 @@ class Driver
 
 private
 
+  def create_rpc_param_def(params)
+    if params.size == 1 and params[0].is_a?(Array)
+      params[0]
+    else
+      SOAPMethod.create_param_def(params)
+    end
+  end
+
+  def create_document_param_def(name, req_qname, res_qname)
+    [
+      ['input', name, [nil, req_qname.namespace, req_qname.name]],
+      ['output', name, [nil, res_qname.namespace, res_qname.name]]
+    ]
+  end
+
   def add_rpc_method_interface(name, param_def)
     @servant.add_rpc_method_interface(name, param_def)
   end
 
+  def add_document_method_interface(name, paramname)
+    @servant.add_document_method_interface(name, paramname)
+  end
+
   class Servant__
-    attr_reader :options
-    attr_reader :streamhandler
-    attr_reader :headerhandler
     attr_reader :proxy
+    attr_reader :options
+    attr_accessor :soapaction
 
     def initialize(host, endpoint_url, namespace)
       @host = host
       @namespace = namespace
-      @mapping_registry = nil
       @soapaction = nil
-      @wiredump_file_base = nil
       @options = setup_options
-      @streamhandler = HTTPPostStreamHandler.new(endpoint_url,
-	@options["protocol.http"] ||= ::SOAP::Property.new)
-      @headerhandler = Header::HandlerSet.new
-      @proxy = Proxy.new(@streamhandler, @soapaction)
-      @proxy.allow_unqualified_element = true
+      @wiredump_file_base = nil
+      @endpoint_url = endpoint_url
+      @proxy = Proxy.new(endpoint_url, @soapaction, @options)
+    end
+
+    def inspect
+      "#<#{self.class}:#{@proxy.inspect}>"
     end
 
     def endpoint_url
-      @streamhandler.endpoint_url
+      @proxy.endpoint_url
     end
 
     def endpoint_url=(endpoint_url)
-      @streamhandler.endpoint_url = endpoint_url
-      @streamhandler.reset
+      @proxy.endpoint_url = endpoint_url
     end
 
     def mapping_registry
-      @mapping_registry
+      @proxy.mapping_registry
     end
 
     def mapping_registry=(mapping_registry)
-      @mapping_registry = mapping_registry
-    end
-
-    def soapaction
-      @soapaction
-    end
-
-    def soapaction=(soapaction)
-      @soapaction = soapaction
+      @proxy.mapping_registry = mapping_registry
     end
 
     def default_encodingstyle
@@ -189,11 +229,42 @@ private
       @proxy.default_encodingstyle = encodingstyle
     end
 
+    def generate_explicit_type
+      @proxy.generate_explicit_type
+    end
+
+    def generate_explicit_type=(generate_explicit_type)
+      @proxy.generate_explicit_type = generate_explicit_type
+    end
+
+    def allow_unqualified_element
+      @proxy.allow_unqualified_element
+    end
+
+    def allow_unqualified_element=(allow_unqualified_element)
+      @proxy.allow_unqualified_element = allow_unqualified_element
+    end
+
+    def headerhandler
+      @proxy.headerhandler
+    end
+
+    def streamhandler
+      @proxy.streamhandler
+    end
+
     def test_loopback_response
-      @streamhandler.test_loopback_response
+      @proxy.test_loopback_response
+    end
+
+    def reset_stream
+      @proxy.reset_stream
     end
 
     def invoke(headers, body)
+      if headers and !headers.is_a?(SOAPHeader)
+        headers = create_header(headers)
+      end
       set_wiredump_file_base(body.elename.name)
       env = @proxy.invoke(headers, body)
       if env.nil?
@@ -205,39 +276,25 @@ private
 
     def call(name, *params)
       set_wiredump_file_base(name)
-      # Convert parameters: params array => SOAPArray => members array
-      params = Mapping.obj2soap(params, @mapping_registry).to_a
-      env = @proxy.call(call_headers, name, *params)
-      raise EmptyResponseError.new("Empty response.") unless env
-      receive_headers(env.header)
-      begin
-	@proxy.check_fault(env.body)
-      rescue SOAP::FaultError => e
-	Mapping.fault2exception(e)
-      end
-
-      ret = env.body.response ?
-	Mapping.soap2obj(env.body.response, @mapping_registry) : nil
-      if env.body.outparams
-	outparams = env.body.outparams.collect { |outparam|
-	  Mapping.soap2obj(outparam)
-	}
-	return [ret].concat(outparams)
-      else
-	return ret
-      end
+      @proxy.call(name, *params)
     end
 
-    def add_method(name_as, soapaction, name, param_def)
+    def add_rpc_method(name_as, soapaction, name, param_def)
       qname = XSD::QName.new(@namespace, name_as)
-      @proxy.add_method(qname, soapaction, name, param_def)
+      @proxy.add_rpc_method(qname, soapaction, name, param_def)
       add_rpc_method_interface(name, param_def)
     end
 
+    def add_document_method(name_as, soapaction, name, param_def)
+      qname = XSD::QName.new(@namespace, name_as)
+      @proxy.add_document_method(qname, soapaction, name, param_def)
+      add_document_method_interface(name, param_def)
+    end
+
     def add_rpc_method_interface(name, param_def)
       param_names = []
       i = 0
-      @proxy.method[name].each_param_name(RPC::SOAPMethod::IN,
+      @proxy.operation[name].each_param_name(RPC::SOAPMethod::IN,
   	  RPC::SOAPMethod::INOUT) do |param_name|
    	i += 1
     	param_names << "arg#{ i }"
@@ -251,41 +308,41 @@ private
       @host.method(name)
     end
 
-  private
-
-    def call_headers
-      headers = @headerhandler.on_outbound
-      if headers.empty?
-	nil
-      else
-	h = ::SOAP::SOAPHeader.new
-	headers.each do |header|
-	  h.add(header.elename.name, header)
-	end
-	h
-      end
+    def add_document_method_interface(name, paramname)
+      @host.instance_eval <<-EOS
+     	def #{ name }(param)
+      	  @servant.call(#{ name.dump }, param)
+       	end
+      EOS
+      @host.method(name)
     end
 
-    def receive_headers(headers)
-      @headerhandler.on_inbound(headers) if headers
-    end
+  private
 
     def set_wiredump_file_base(name)
       if @wiredump_file_base
-      	@streamhandler.wiredump_file_base = @wiredump_file_base + "_#{ name }"
+      	@proxy.set_wiredump_file_base(@wiredump_file_base + "_#{ name }")
+      end
+    end
+
+    def create_header(headers)
+      header = SOAPHeader.new()
+      headers.each do |content, mustunderstand, encodingstyle|
+        header.add(SOAPHeaderItem.new(content, mustunderstand, encodingstyle))
       end
+      header
     end
 
     def setup_options
       if opt = Property.loadproperty(::SOAP::PropertyName)
-	opt = opt["client"]
+        opt = opt["client"]
       end
       opt ||= Property.new
       opt.add_hook("protocol.mandatorycharset") do |key, value|
-	@proxy.mandatorycharset = value
+        @proxy.mandatorycharset = value
       end
       opt.add_hook("protocol.wiredump_file_base") do |key, value|
-	@wiredump_file_base = value
+        @wiredump_file_base = value
       end
       opt["protocol.http.charset"] ||= XSD::Charset.encoding_label
       opt["protocol.http.proxy"] ||= Env::HTTP_PROXY
diff --git a/lib/soap/rpc/httpserver.rb b/lib/soap/rpc/httpserver.rb
index 7b1f961d9e..dccf950480 100644
--- a/lib/soap/rpc/httpserver.rb
+++ b/lib/soap/rpc/httpserver.rb
@@ -55,6 +55,8 @@ class HTTPServer < Logger::Application
     @soaplet.app_scope_router.mapping_registry = mapping_registry
   end
 
+  # servant entry interface
+
   def add_rpc_request_servant(factory, namespace = @default_namespace,
       mapping_registry = nil)
     @soaplet.add_rpc_request_servant(factory, namespace, mapping_registry)
@@ -72,23 +74,52 @@ class HTTPServer < Logger::Application
     @soaplet.add_rpc_headerhandler(obj)
   end
 
-  def add_method(obj, name, *param)
-    add_method_as(obj, name, name, *param)
+  # method entry interface
+
+  def add_rpc_method(obj, name, *param)
+    add_rpc_method_as(obj, name, name, *param)
+  end
+  alias add_method add_rpc_method
+
+  def add_document_method(obj, name, req_qname, res_qname)
+    opt = {}
+    opt[:request_style] = opt[:response_style] = :document
+    opt[:request_use] = opt[:response_use] = :literal
+    param_def = [
+      ['input', req_qname.name, [nil, req_qname.namespace, req_qname.name]],
+      ['output', req_qname.name, [nil, res_qname.namespace, res_qname.name]]
+    ]
+    @soaplet.app_scope_router.add_operation(req_qname, nil, obj, name,
+      param_def, opt)
   end
 
-  def add_method_as(obj, name, name_as, *param)
+  def add_rpc_method_as(obj, name, name_as, *param)
     qname = XSD::QName.new(@default_namespace, name_as)
     soapaction = nil
-    method = obj.method(name)
-    param_def = if param.size == 1 and param[0].is_a?(Array)
-        param[0]
-      elsif param.empty?
-	::SOAP::RPC::SOAPMethod.create_param_def(
-	  (1..method.arity.abs).collect { |i| "p#{ i }" })
-      else
-        SOAP::RPC::SOAPMethod.create_param_def(param)
-      end
-    @soaplet.app_scope_router.add_method(obj, qname, soapaction, name, param_def)
+    param_def = create_param_def(obj, name, param)
+    add_operation(qname, soapaction, obj, name, param_def)
+  end
+  alias add_method_as add_rpc_method_as
+
+  def add_operation(qname, soapaction, obj, name, param_def, opt = {})
+    opt[:request_style] ||= :rpc
+    opt[:response_style] ||= :rpc
+    opt[:request_use] ||= :encoded
+    opt[:response_use] ||= :encoded
+    @soaplet.app_scope_router.add_operation(qname, soapaction, obj, name,
+      param_def, opt)
+  end
+
+  def create_param_def(obj, name, param = nil)
+    if param.nil? or param.empty?
+      method = obj.method(name)
+      ::SOAP::RPC::SOAPMethod.create_param_def(
+        (1..method.arity.abs).collect { |i| "p#{i}" })
+    elsif param.size == 1 and param[0].is_a?(Array)
+      param[0]
+    else
+      ::SOAP::RPC::SOAPMethod.create_param_def(param)
+    end
   end
 
 private
diff --git a/lib/soap/rpc/proxy.rb b/lib/soap/rpc/proxy.rb
index 355bf2e81a..ca110664f9 100644
--- a/lib/soap/rpc/proxy.rb
+++ b/lib/soap/rpc/proxy.rb
@@ -28,73 +28,79 @@ public
   attr_accessor :mandatorycharset
   attr_accessor :allow_unqualified_element
   attr_accessor :default_encodingstyle
-  attr_reader :method
+  attr_accessor :generate_explicit_type
+  attr_reader :headerhandler
+  attr_reader :streamhandler
 
-  def initialize(streamhandler, soapaction = nil)
-    @streamhandler = streamhandler
+  attr_accessor :mapping_registry
+  attr_accessor :literal_mapping_registry
+
+  attr_reader :operation
+
+  def initialize(endpoint_url, soapaction, options)
+    @endpoint_url = endpoint_url
     @soapaction = soapaction
-    @method = {}
+    @options = options
+    @streamhandler = HTTPStreamHandler.new(
+      @options["protocol.http"] ||= ::SOAP::Property.new)
+    @operation = {}
     @mandatorycharset = nil
-    @allow_unqualified_element = false
+    @allow_unqualified_element = true
     @default_encodingstyle = nil
+    @generate_explicit_type = true
+    @headerhandler = Header::HandlerSet.new
+    @mapping_registry = nil
+    @literal_mapping_registry = ::SOAP::Mapping::WSDLLiteralRegistry.new
   end
 
-  class Request
-    include RPC
+  def inspect
+    "#<#{self.class}:#{@endpoint_url}>"
+  end
 
-  public
+  def endpoint_url
+    @endpoint_url
+  end
 
-    attr_reader :method
-    attr_reader :namespace
-    attr_reader :name
+  def endpoint_url=(endpoint_url)
+    @endpoint_url = endpoint_url
+    reset_stream
+  end
 
-    def initialize(model, values)
-      @method = model.dup
-      @namespace = @method.elename.namespace
-      @name = @method.elename.name
+  def reset_stream
+    @streamhandler.reset(@endpoint_url)
+  end
 
-      params = {}
-    
-      if ((values.size == 1) and (values[0].is_a?(Hash)))
-        params = values[0]
-      else
-        i = 0
-        @method.each_param_name(SOAPMethod::IN, SOAPMethod::INOUT) do |name|
-          params[name] = values[i] || SOAPNil.new
-          i += 1
-        end
-      end
-      @method.set_param(params)
-    end
+  def set_wiredump_file_base(wiredump_file_base)
+    @streamhandler.wiredump_file_base = wiredump_file_base
   end
 
-  def add_method(qname, soapaction, name, param_def)
-    @method[name] = SOAPMethodRequest.new(qname, param_def, soapaction)
+  def test_loopback_response
+    @streamhandler.test_loopback_response
   end
 
-  def create_request(name, *values)
-    if (@method.key?(name))
-      method = @method[name]
-      method.encodingstyle = @default_encodingstyle if @default_encodingstyle
-    else
-      raise SOAP::RPC::MethodDefinitionError.new(
-	"Method: #{ name } not defined.")
-    end
-    Request.new(method, values)
+  def add_rpc_method(qname, soapaction, name, param_def, opt = {})
+    opt[:request_style] ||= :rpc
+    opt[:response_style] ||= :rpc
+    opt[:request_use] ||= :encoded
+    opt[:response_use] ||= :encoded
+    @operation[name] = Operation.new(qname, soapaction, name, param_def, opt)
   end
 
-  def invoke(req_header, req_body, soapaction = nil)
-    if req_header and !req_header.is_a?(SOAPHeader)
-      req_header = create_header(req_header)
-    end
-    if !req_body.is_a?(SOAPBody)
-      req_body = SOAPBody.new(req_body)
-    end
-    opt = create_options
-    opt[:external_content] = nil
+  def add_document_method(qname, soapaction, name, param_def, opt = {})
+    opt[:request_style] ||= :document
+    opt[:response_style] ||= :document
+    opt[:request_use] ||= :literal
+    opt[:response_use] ||= :literal
+    @operation[name] = Operation.new(qname, soapaction, name, param_def, opt)
+  end
+
+  # add_method is for shortcut of typical rpc/encoded method definition.
+  alias add_method add_rpc_method
+
+  def invoke(req_header, req_body, opt = create_options)
     req_env = SOAPEnvelope.new(req_header, req_body)
-    send_string = Processor.marshal(req_env, opt)
-    conn_data = StreamHandler::ConnectionData.new(send_string)
+    opt[:external_content] = nil
+    conn_data = marshal(req_env, opt)
     if ext = opt[:external_content]
       mime = MIMEMessage.new
       ext.each do |k, v|
@@ -105,16 +111,33 @@ public
       conn_data.send_string = mime.content_str
       conn_data.send_contenttype = mime.headers['content-type'].str
     end
-    conn_data = @streamhandler.send(conn_data, soapaction)
+    conn_data = @streamhandler.send(@endpoint_url, conn_data, opt[:soapaction])
     if conn_data.receive_string.empty?
-      return nil, nil
+      return nil
     end
     unmarshal(conn_data, opt)
   end
 
-  def call(req_header, name, *values)
-    req = create_request(name, *values)
-    invoke(req_header, req.method, req.method.soapaction || @soapaction)
+  def call(name, *params)
+    unless op_info = @operation[name]
+      raise MethodDefinitionError, "Method: #{name} not defined."
+    end
+    req_header = create_request_header
+    req_body = op_info.create_request_body(params, @mapping_registry,
+      @literal_mapping_registry)
+    opt = create_options({
+      :soapaction => op_info.soapaction || @soapaction,
+      :default_encodingstyle => op_info.response_default_encodingstyle})
+    env = invoke(req_header, req_body, opt)
+    receive_headers(env.header)
+    raise EmptyResponseError.new("Empty response.") unless env
+    begin
+      check_fault(env.body)
+    rescue ::SOAP::FaultError => e
+      Mapping.fault2exception(e)
+    end
+    op_info.create_response_obj(env, @mapping_registry,
+      @literal_mapping_registry)
   end
 
   def check_fault(body)
@@ -125,6 +148,28 @@ public
 
 private
 
+  def create_request_header
+    headers = @headerhandler.on_outbound
+    if headers.empty?
+      nil
+    else
+      h = ::SOAP::SOAPHeader.new
+      headers.each do |header|
+        h.add(header.elename.name, header)
+      end
+      h
+    end
+  end
+
+  def receive_headers(headers)
+    @headerhandler.on_inbound(headers) if headers
+  end
+
+  def marshal(env, opt)
+    send_string = Processor.marshal(env, opt)
+    StreamHandler::ConnectionData.new(send_string)
+  end
+
   def unmarshal(conn_data, opt)
     contenttype = conn_data.receive_contenttype
     if /#{MIMEMessage::MultipartContentType}/i =~ contenttype
@@ -156,14 +201,115 @@ private
     header
   end
 
-  def create_options
+  def create_options(hash = nil)
     opt = {}
     opt[:default_encodingstyle] = @default_encodingstyle
-    if @allow_unqualified_element
-      opt[:allow_unqualified_element] = true
-    end
+    opt[:allow_unqualified_element] = @allow_unqualified_element
+    opt[:generate_explicit_type] = @generate_explicit_type
+    opt.update(hash) if hash
     opt
   end
+
+  class Operation
+    attr_reader :soapaction
+    attr_reader :request_style
+    attr_reader :response_style
+    attr_reader :request_use
+    attr_reader :response_use
+
+    def initialize(qname, soapaction, name, param_def, opt)
+      @soapaction = soapaction
+      @request_style = opt[:request_style]
+      @response_style = opt[:response_style]
+      @request_use = opt[:request_use]
+      @response_use = opt[:response_use]
+      @rpc_method_factory = @document_method_name = nil
+      check_style(@request_style)
+      check_style(@response_style)
+      if @request_style == :rpc
+        @rpc_method_factory = SOAPMethodRequest.new(qname, param_def,
+          @soapaction)
+      else
+        @document_method_name = {}
+        param_def.each do |inout, paramname, typeinfo|
+          klass, namespace, name = typeinfo
+          case inout.to_s
+          when "input"
+            @document_method_name[:input] = ::XSD::QName.new(namespace, name)
+          when "output"
+            @document_method_name[:output] = ::XSD::QName.new(namespace, name)
+          else
+            raise MethodDefinitionError, "unknown type: " + inout
+          end
+        end
+      end
+    end
+
+    def request_default_encodingstyle
+      (@request_style == :rpc) ? EncodingNamespace : LiteralNamespace
+    end
+
+    def response_default_encodingstyle
+      (@response_style == :rpc) ? EncodingNamespace : LiteralNamespace
+    end
+
+    # for rpc
+    def each_param_name(*target)
+      if @request_style == :rpc
+        @rpc_method_factory.each_param_name(*target) do |name|
+          yield(name)
+        end
+      else
+        yield(@document_method_name[:input].name)
+      end
+    end
+
+    def create_request_body(values, mapping_registry, literal_mapping_registry)
+      if @request_style == :rpc
+        values = Mapping.obj2soap(values, mapping_registry).to_a
+        method = @rpc_method_factory.dup
+        params = {}
+        idx = 0
+        method.each_param_name(::SOAP::RPC::SOAPMethod::IN,
+            ::SOAP::RPC::SOAPMethod::INOUT) do |name|
+          params[name] = values[idx] || SOAPNil.new
+          idx += 1
+        end
+        method.set_param(params)
+        SOAPBody.new(method)
+      else
+        name = @document_method_name[:input]
+        document = literal_mapping_registry.obj2soap(values[0], name)
+        SOAPBody.new(document)
+      end
+    end
+
+    def create_response_obj(env, mapping_registry, literal_mapping_registry)
+      if @response_style == :rpc
+        ret = env.body.response ?
+          Mapping.soap2obj(env.body.response, mapping_registry) : nil
+        if env.body.outparams
+          outparams = env.body.outparams.collect { |outparam|
+            Mapping.soap2obj(outparam)
+          }
+          [ret].concat(outparams)
+        else
+          ret
+        end
+      else
+        Mapping.soap2obj(env.body.root_node, literal_mapping_registry)
+      end
+    end
+
+  private
+
+    ALLOWED_STYLE = [:rpc, :document]
+    def check_style(style)
+      unless ALLOWED_STYLE.include?(style)
+        raise MethodDefinitionError, "unknown style: " + style
+      end
+    end
+  end
 end
 
 
diff --git a/lib/soap/rpc/router.rb b/lib/soap/rpc/router.rb
index 9d8d1c8da6..e9147af13a 100644
--- a/lib/soap/rpc/router.rb
+++ b/lib/soap/rpc/router.rb
@@ -9,6 +9,7 @@
 require 'soap/soap'
 require 'soap/processor'
 require 'soap/mapping'
+require 'soap/mapping/wsdlliteralregistry'
 require 'soap/rpc/rpc'
 require 'soap/rpc/element'
 require 'soap/streamHandler'
@@ -27,26 +28,48 @@ class Router
   attr_accessor :allow_unqualified_element
   attr_accessor :default_encodingstyle
   attr_accessor :mapping_registry
+  attr_accessor :literal_mapping_registry
   attr_reader :headerhandler
 
   def initialize(actor)
     @actor = actor
-    @receiver = {}
-    @method_name = {}
-    @method = {}
     @allow_unqualified_element = false
     @default_encodingstyle = nil
     @mapping_registry = nil
     @headerhandler = Header::HandlerSet.new
+    @literal_mapping_registry = ::SOAP::Mapping::WSDLLiteralRegistry.new
+    @operation = {}
   end
 
-  def add_method(receiver, qname, soapaction, name, param_def)
-    fqname = fqname(qname)
-    @receiver[fqname] = receiver
-    @method_name[fqname] = name
-    @method[fqname] = RPC::SOAPMethodRequest.new(qname, param_def, soapaction)
+  def add_rpc_method(receiver, qname, soapaction, name, param_def, opt = {})
+    opt[:request_style] ||= :rpc
+    opt[:response_style] ||= :rpc
+    opt[:request_use] ||= :encoded
+    opt[:response_use] ||= :encoded
+    add_operation(qname, soapaction, receiver, name, param_def, opt)
   end
 
+  def add_document_method(receiver, qname, soapaction, name, param_def, opt = {})
+    opt[:request_style] ||= :document
+    opt[:response_style] ||= :document
+    opt[:request_use] ||= :encoded
+    opt[:response_use] ||= :encoded
+    if opt[:request_style] == :document
+      inputdef = param_def.find { |inout, paramname, typeinfo| inout == "input" }
+      klass, nsdef, namedef = inputdef[2]
+      qname = ::XSD::QName.new(nsdef, namedef)
+    end
+    add_operation(qname, soapaction, receiver, name, param_def, opt)
+  end
+
+  def add_operation(qname, soapaction, receiver, name, param_def, opt)
+    @operation[fqname(qname)] = Operation.new(qname, soapaction, receiver,
+      name, param_def, opt)
+  end
+
+  # add_method is for shortcut of typical use="encoded" method definition.
+  alias add_method add_rpc_method
+
   def route(conn_data)
     soap_response = nil
     begin
@@ -55,33 +78,17 @@ class Router
 	raise ArgumentError.new("Illegal SOAP marshal format.")
       end
       receive_headers(env.header)
-      soap_request = env.body.request
-      unless soap_request.is_a?(SOAPStruct)
-	raise RPCRoutingError.new("Not an RPC style.")
+      request = env.body.request
+      op = @operation[fqname(request.elename)]
+      unless op
+        raise RPCRoutingError.new("Method: #{request.elename} not supported.")
       end
-      soap_response = dispatch(soap_request)
+      soap_response = op.call(request, @mapping_registry, @literal_mapping_registry)
     rescue Exception
       soap_response = fault($!)
       conn_data.is_fault = true
     end
-
-    opt = options
-    opt[:external_content] = nil
-    header = call_headers
-    body = SOAPBody.new(soap_response)
-    env = SOAPEnvelope.new(header, body)
-    response_string = Processor.marshal(env, opt)
-    conn_data.send_string = response_string
-    if ext = opt[:external_content]
-      mime = MIMEMessage.new
-      ext.each do |k, v|
-      	mime.add_attachment(v.data)
-      end
-      mime.add_part(conn_data.send_string + "\r\n")
-      mime.close
-      conn_data.send_string = mime.content_str
-      conn_data.send_contenttype = mime.headers['content-type'].str
-    end
+    marshal(conn_data, op, soap_response)
     conn_data
   end
 
@@ -118,9 +125,9 @@ private
     else
       h = ::SOAP::SOAPHeader.new
       headers.each do |header|
-      h.add(header.elename.name, header)
-    end
-    h
+        h.add(header.elename.name, header)
+      end
+      h
     end
   end
 
@@ -153,32 +160,28 @@ private
     env
   end
 
-  # Create new response.
-  def create_response(qname, result)
-    name = fqname(qname)
-    if (@method.key?(name))
-      method = @method[name]
-    else
-      raise RPCRoutingError.new("Method: #{ name } not defined.")
+  def marshal(conn_data, op, soap_response)
+    response_opt = options
+    response_opt[:external_content] = nil
+    if op and !conn_data.is_fault and op.response_use == :document
+      response_opt[:default_encodingstyle] =
+        ::SOAP::EncodingStyle::ASPDotNetHandler::Namespace
     end
-
-    soap_response = method.create_method_response
-    if soap_response.have_outparam?
-      unless result.is_a?(Array)
-	raise RPCRoutingError.new("Out parameter was not returned.")
-      end
-      outparams = {}
-      i = 1
-      soap_response.each_param_name('out', 'inout') do |outparam|
-	outparams[outparam] = Mapping.obj2soap(result[i], @mapping_registry)
-	i += 1
+    header = call_headers
+    body = SOAPBody.new(soap_response)
+    env = SOAPEnvelope.new(header, body)
+    response_string = Processor.marshal(env, response_opt)
+    conn_data.send_string = response_string
+    if ext = response_opt[:external_content]
+      mime = MIMEMessage.new
+      ext.each do |k, v|
+      	mime.add_attachment(v.data)
       end
-      soap_response.set_outparam(outparams)
-      soap_response.retval = Mapping.obj2soap(result[0], @mapping_registry)
-    else
-      soap_response.retval = Mapping.obj2soap(result, @mapping_registry)
+      mime.add_part(conn_data.send_string + "\r\n")
+      mime.close
+      conn_data.send_string = mime.content_str
+      conn_data.send_contenttype = mime.headers['content-type'].str
     end
-    soap_response
   end
 
   # Create fault response.
@@ -191,31 +194,6 @@ private
       Mapping.obj2soap(detail, @mapping_registry))
   end
 
-  # Dispatch to defined method.
-  def dispatch(soap_method)
-    request_struct = Mapping.soap2obj(soap_method, @mapping_registry)
-    values = soap_method.collect { |key, value| request_struct[key] }
-    method = lookup(soap_method.elename, values)
-    unless method
-      raise RPCRoutingError.new(
-	"Method: #{ soap_method.elename } not supported.")
-    end
-
-    result = method.call(*values)
-    create_response(soap_method.elename, result)
-  end
-
-  # Method lookup
-  def lookup(qname, values)
-    name = fqname(qname)
-    # It may be necessary to check all part of method signature...
-    if @method.member?(name)
-      @receiver[name].method(@method_name[name].intern)
-    else
-      nil
-    end
-  end
-
   def fqname(qname)
     "#{ qname.namespace }:#{ qname.name }"
   end
@@ -228,6 +206,87 @@ private
     end
     opt
   end
+
+  class Operation
+    attr_reader :receiver
+    attr_reader :name
+    attr_reader :soapaction
+    attr_reader :request_style
+    attr_reader :response_style
+    attr_reader :request_use
+    attr_reader :response_use
+    
+    def initialize(qname, soapaction, receiver, name, param_def, opt)
+      @soapaction = soapaction
+      @receiver = receiver
+      @name = name
+      @request_style = opt[:request_style]
+      @response_style = opt[:response_style]
+      @request_use = opt[:request_use]
+      @response_use = opt[:response_use]
+      if @response_style == :rpc
+        @rpc_response_factory =
+          RPC::SOAPMethodRequest.new(qname, param_def, @soapaction)
+      else
+        outputdef = param_def.find { |inout, paramname, typeinfo| inout == "output" }
+        klass, nsdef, namedef = outputdef[2]
+        @document_response_qname = ::XSD::QName.new(nsdef, namedef)
+      end
+    end
+
+    def call(request, mapping_registry, literal_mapping_registry)
+      if @request_style == :rpc
+        param = Mapping.soap2obj(request, mapping_registry)
+        result = rpc_call(request, param)
+      else
+        param = Mapping.soap2obj(request, literal_mapping_registry)
+        result = document_call(request, param)
+      end
+      if @response_style == :rpc
+        rpc_response(result, mapping_registry)
+      else
+        document_response(result, literal_mapping_registry)
+      end
+    end
+
+  private
+
+    def rpc_call(request, param)
+      unless request.is_a?(SOAPStruct)
+        raise RPCRoutingError.new("Not an RPC style.")
+      end
+      values = request.collect { |key, value| param[key] }
+      @receiver.method(@name.intern).call(*values)
+    end
+
+    def document_call(request, param)
+      @receiver.method(@name.intern).call(param)
+    end
+
+    def rpc_response(result, mapping_registry)
+      soap_response = @rpc_response_factory.create_method_response
+      if soap_response.have_outparam?
+        unless result.is_a?(Array)
+          raise RPCRoutingError.new("Out parameter was not returned.")
+        end
+        outparams = {}
+        i = 1
+        soap_response.each_param_name('out', 'inout') do |outparam|
+          outparams[outparam] = Mapping.obj2soap(result[i], mapping_registry)
+          i += 1
+        end
+        soap_response.set_outparam(outparams)
+        soap_response.retval = Mapping.obj2soap(result[0], mapping_registry)
+      else
+        soap_response.retval = Mapping.obj2soap(result, mapping_registry)
+      end
+      soap_response
+    end
+
+    def document_response(result, literal_mapping_registry)
+      literal_mapping_registry.obj2soap(result, @document_response_qname)
+    end
+  end
 end
 
 
diff --git a/lib/soap/rpc/rpc.rb b/lib/soap/rpc/rpc.rb
index 5f77b4d2e9..a48b525dbb 100644
--- a/lib/soap/rpc/rpc.rb
+++ b/lib/soap/rpc/rpc.rb
@@ -16,7 +16,7 @@ module RPC
     if obj.is_a?(Module)
       obj.methods - Module.methods
     else
-      obj.methods - Kernel.instance_methods(true)
+      obj.methods - Object.instance_methods(true)
     end
   end
 end
diff --git a/lib/soap/rpc/soaplet.rb b/lib/soap/rpc/soaplet.rb
index 0c1427acf5..8f18c53d3a 100644
--- a/lib/soap/rpc/soaplet.rb
+++ b/lib/soap/rpc/soaplet.rb
@@ -10,6 +10,13 @@ require 'webrick/httpservlet/abstract'
 require 'webrick/httpstatus'
 require 'soap/rpc/router'
 require 'soap/streamHandler'
+begin
+  require 'stringio'
+  require 'zlib'
+rescue LoadError
+  STDERR.puts "Loading stringio or zlib failed.  No gzipped response support." if $DEBUG
+end
+
 
 module SOAP
 module RPC
@@ -18,12 +25,18 @@ module RPC
 class SOAPlet < WEBrick::HTTPServlet::AbstractServlet
 public
   attr_reader :app_scope_router
+  attr_reader :options
 
   def initialize
-    @router_map = {}
+    @rpc_router_map = {}
     @app_scope_router = ::SOAP::RPC::Router.new(self.class.name)
     @headerhandlerfactory = []
     @app_scope_headerhandler = nil
+    @options = {}
+  end
+
+  def allow_content_encoding_gzip=(allow)
+    @options[:allow_content_encoding_gzip] = allow
   end
 
   # Add servant factory whose object has request scope.  A servant object is
@@ -41,7 +54,7 @@ public
     unless factory.respond_to?(:create)
       raise TypeError.new("factory must respond to 'create'")
     end
-    router = setup_request_router(namespace)
+    router = setup_rpc_request_router(namespace)
     router.factory = factory
     router.mapping_registry = mapping_registry
   end
@@ -49,8 +62,8 @@ public
   # Add servant object which has application scope.
   def add_rpc_servant(obj, namespace)
     router = @app_scope_router
-    SOAPlet.add_servant_to_router(router, obj, namespace)
-    add_router(namespace, router)
+    SOAPlet.add_rpc_servant_to_router(router, obj, namespace)
+    add_rpc_router(namespace, router)
   end
   alias add_servant add_rpc_servant
 
@@ -84,19 +97,26 @@ public
   end
 
   def do_POST(req, res)
-    namespace = parse_soapaction(req.meta_vars['HTTP_SOAPACTION'])
-    router = lookup_router(namespace)
+    @config[:Logger].debug { "SOAP request: " + req.body }
+    soapaction = parse_soapaction(req.meta_vars['HTTP_SOAPACTION'])
+    router = lookup_router(soapaction)
     with_headerhandler(router) do |router|
       begin
 	conn_data = ::SOAP::StreamHandler::ConnectionData.new
 	conn_data.receive_string = req.body
 	conn_data.receive_contenttype = req['content-type']
 	conn_data = router.route(conn_data)
+	res['content-type'] = conn_data.send_contenttype
 	if conn_data.is_fault
 	  res.status = WEBrick::HTTPStatus::RC_INTERNAL_SERVER_ERROR
 	end
-	res.body = conn_data.send_string
-	res['content-type'] = conn_data.send_contenttype
+        if outstring = encode_gzip(req, conn_data.send_string)
+          res['content-encoding'] = 'gzip'
+          res['content-length'] = outstring.size
+          res.body = outstring
+        else
+          res.body = conn_data.send_string
+        end
       rescue Exception => e
 	conn_data = router.create_fault_response(e)
 	res.status = WEBrick::HTTPStatus::RC_INTERNAL_SERVER_ERROR
@@ -107,6 +127,9 @@ public
 
     if res.body.is_a?(IO)
       res.chunked = true
+      @config[:Logger].debug { "SOAP response: (chunked response not logged)" }
+    else
+      @config[:Logger].debug { "SOAP response: " + res.body }
     end
   end
 
@@ -115,8 +138,9 @@ private
   class RequestRouter < ::SOAP::RPC::Router
     attr_accessor :factory
 
-    def initialize(namespace = nil)
+    def initialize(style = :rpc, namespace = nil)
       super(namespace)
+      @style = style
       @namespace = namespace
       @factory = nil
     end
@@ -125,19 +149,23 @@ private
       obj = @factory.create
       namespace = self.actor
       router = ::SOAP::RPC::Router.new(@namespace)
-      SOAPlet.add_servant_to_router(router, obj, namespace)
+      if @style == :rpc
+        SOAPlet.add_rpc_servant_to_router(router, obj, namespace)
+      else
+        raise RuntimeError.new("'document' style not supported.")
+      end
       router.route(soap_string)
     end
   end
 
-  def setup_request_router(namespace)
-    router = @router_map[namespace] || RequestRouter.new(namespace)
-    add_router(namespace, router)
+  def setup_rpc_request_router(namespace)
+    router = @rpc_router_map[namespace] || RequestRouter.new(:rpc, namespace)
+    add_rpc_router(namespace, router)
     router
   end
 
-  def add_router(namespace, router)
-    @router_map[namespace] = router
+  def add_rpc_router(namespace, router)
+    @rpc_router_map[namespace] = router
   end
 
   def parse_soapaction(soapaction)
@@ -152,7 +180,7 @@ private
 
   def lookup_router(namespace)
     if namespace
-      @router_map[namespace] || @app_scope_router
+      @rpc_router_map[namespace] || @app_scope_router
     else
       @app_scope_router
     end
@@ -172,25 +200,49 @@ private
     end
   end
 
+  def encode_gzip(req, outstring)
+    unless encode_gzip?(req)
+      return nil
+    end
+    begin
+      ostream = StringIO.new
+      gz = Zlib::GzipWriter.new(ostream)
+      gz.write(outstring)
+      ostream.string
+    ensure
+      gz.close
+    end
+  end
+
+  def encode_gzip?(req)
+    @options[:allow_content_encoding_gzip] and defined?(::Zlib) and
+      req['accept-encoding'] and
+      req['accept-encoding'].split(/,\s*/).include?('gzip')
+  end
+
   class << self
   public
-    def add_servant_to_router(router, obj, namespace)
+    def add_rpc_servant_to_router(router, obj, namespace)
       ::SOAP::RPC.defined_methods(obj).each do |name|
         begin
-          add_servant_method_to_router(router, obj, namespace, name)
+          add_rpc_servant_method_to_router(router, obj, namespace, name)
         rescue SOAP::RPC::MethodDefinitionError => e
           p e if $DEBUG
         end
       end
     end
 
-    def add_servant_method_to_router(router, obj, namespace, name)
+    def add_rpc_servant_method_to_router(router, obj, namespace, name,
+        style = :rpc, use = :encoded)
       qname = XSD::QName.new(namespace, name)
       soapaction = nil
       method = obj.method(name)
       param_def = ::SOAP::RPC::SOAPMethod.create_param_def(
 	(1..method.arity.abs).collect { |i| "p#{ i }" })
-      router.add_method(obj, qname, soapaction, name, param_def)
+      opt = {}
+      opt[:request_style] = opt[:response_style] = style
+      opt[:request_use] = opt[:response_use] = use
+      router.add_operation(qname, soapaction, obj, name, param_def, opt)
     end
   end
 end
diff --git a/lib/soap/soap.rb b/lib/soap/soap.rb
index 02b26e4246..66ef1454a3 100644
--- a/lib/soap/soap.rb
+++ b/lib/soap/soap.rb
@@ -13,7 +13,7 @@ require 'xsd/charset'
 module SOAP
 
 
-Version = '1.5.2'
+Version = '1.5.3-ruby1.8.2'
 PropertyName = 'soap/property'
 
 EnvelopeNamespace = 'http://schemas.xmlsoap.org/soap/envelope/'
diff --git a/lib/soap/streamHandler.rb b/lib/soap/streamHandler.rb
index efadf21e07..ac2f54d5c9 100644
--- a/lib/soap/streamHandler.rb
+++ b/lib/soap/streamHandler.rb
@@ -8,6 +8,12 @@
 
 require 'soap/soap'
 require 'soap/property'
+begin
+  require 'stringio'
+  require 'zlib'
+rescue LoadError
+  STDERR.puts "Loading stringio or zlib failed.  No gzipped response support." if $DEBUG
+end
 
 
 module SOAP
@@ -44,12 +50,6 @@ class StreamHandler
     end
   end
 
-  attr_accessor :endpoint_url
-
-  def initialize(endpoint_url)
-    @endpoint_url = endpoint_url
-  end
-
   def self.parse_media_type(str)
     if /^#{ MediaType }(?:\s*;\s*charset=([^"]+|"[^"]+"))?$/i !~ str
       return nil
@@ -65,7 +65,7 @@ class StreamHandler
 end
 
 
-class HTTPPostStreamHandler < StreamHandler
+class HTTPStreamHandler < StreamHandler
   include SOAP
 
 public
@@ -75,31 +75,40 @@ public
   
   NofRetry = 10       	# [times]
 
-  def initialize(endpoint_url, options)
-    super(endpoint_url)
+  def initialize(options)
+    super()
     @client = Client.new(nil, "SOAP4R/#{ Version }")
     @wiredump_file_base = nil
-    @charset = @wiredump_dev = nil
+    @charset = @wiredump_dev = @nil
     @options = options
     set_options
     @client.debug_dev = @wiredump_dev
     @cookie_store = nil
+    @accept_encoding_gzip = false
   end
 
   def test_loopback_response
     @client.test_loopback_response
   end
 
+  def accept_encoding_gzip=(allow)
+    @accept_encoding_gzip = allow
+  end
+
   def inspect
-    "#<#{self.class}:#{endpoint_url}>"
+    "#<#{self.class}>"
   end
 
-  def send(conn_data, soapaction = nil, charset = @charset)
-    send_post(conn_data, soapaction, charset)
+  def send(endpoint_url, conn_data, soapaction = nil, charset = @charset)
+    send_post(endpoint_url, conn_data, soapaction, charset)
   end
 
-  def reset
-    @client.reset(@endpoint_url)
+  def reset(endpoint_url = nil)
+    if endpoint_url.nil?
+      @client.reset_all
+    else
+      @client.reset(endpoint_url)
+    end
     @client.save_cookie_store if @cookie_store
   end
 
@@ -143,6 +152,15 @@ private
     basic_auth.add_hook do |key, value|
       set_basic_auth(basic_auth)
     end
+    @options.add_hook("connect_timeout") do |key, value|
+      @client.connect_timeout = value
+    end
+    @options.add_hook("send_timeout") do |key, value|
+      @client.send_timeout = value
+    end
+    @options.add_hook("receive_timeout") do |key, value|
+      @client.receive_timeout = value
+    end
     @options.lock(true)
     ssl_config.unlock
     basic_auth.unlock
@@ -213,7 +231,7 @@ private
     OpenSSL::PKey::RSA.new(File.open(filename) { |f| f.read })
   end
 
-  def send_post(conn_data, soapaction, charset)
+  def send_post(endpoint_url, conn_data, soapaction, charset)
     conn_data.send_contenttype ||= StreamHandler.create_media_type(charset)
 
     if @wiredump_file_base
@@ -226,26 +244,23 @@ private
     extra = {}
     extra['Content-Type'] = conn_data.send_contenttype
     extra['SOAPAction'] = "\"#{ soapaction }\""
+    extra['Accept-Encoding'] = 'gzip' if send_accept_encoding_gzip?
     send_string = conn_data.send_string
-
     @wiredump_dev << "Wire dump:\n\n" if @wiredump_dev
     begin
-      res = @client.post(@endpoint_url, send_string, extra)
+      res = @client.post(endpoint_url, send_string, extra)
     rescue
-      @client.reset(@endpoint_url)
+      @client.reset(endpoint_url)
       raise
     end
     @wiredump_dev << "\n\n" if @wiredump_dev
-
     receive_string = res.content
-
     if @wiredump_file_base
       filename = @wiredump_file_base + '_response.xml'
       f = File.open(filename, "w")
       f << receive_string
       f.close
     end
-
     case res.status
     when 405
       raise PostUnavailableError.new("#{ res.status }: #{ res.reason }")
@@ -254,13 +269,30 @@ private
     else
       raise HTTPStreamError.new("#{ res.status }: #{ res.reason }")
     end
-
+    if res.respond_to?(:header) and !res.header['content-encoding'].empty? and
+        res.header['content-encoding'][0].downcase == 'gzip'
+      receive_string = decode_gzip(receive_string)
+    end
     conn_data.receive_string = receive_string
     conn_data.receive_contenttype = res.contenttype
     conn_data
   end
 
-  CRLF = "\r\n"
+  def send_accept_encoding_gzip?
+    @accept_encoding_gzip and defined?(::Zlib)
+  end
+
+  def decode_gzip(instring)
+    unless send_accept_encoding_gzip?
+      raise HTTPStreamError.new("Gzipped response content.")
+    end
+    begin
+      gz = Zlib::GzipReader.new(StringIO.new(instring))
+      gz.read
+    ensure
+      gz.close
+    end
+  end
 end
 
 
diff --git a/lib/soap/wsdlDriver.rb b/lib/soap/wsdlDriver.rb
index af868ea886..aa822df4e4 100644
--- a/lib/soap/wsdlDriver.rb
+++ b/lib/soap/wsdlDriver.rb
@@ -14,12 +14,14 @@ require 'soap/baseData'
 require 'soap/streamHandler'
 require 'soap/mimemessage'
 require 'soap/mapping'
-require 'soap/mapping/wsdlRegistry'
+require 'soap/mapping/wsdlencodedregistry'
+require 'soap/mapping/wsdlliteralregistry'
 require 'soap/rpc/rpc'
 require 'soap/rpc/element'
+require 'soap/rpc/proxy'
 require 'soap/processor'
 require 'soap/header/handlerset'
-require 'logger'
+require 'xsd/codegen/gensupport'
 
 
 module SOAP
@@ -94,13 +96,14 @@ class WSDLDriver
 
   __attr_proxy :options
   __attr_proxy :headerhandler
+  __attr_proxy :streamhandler
   __attr_proxy :test_loopback_response
   __attr_proxy :endpoint_url, true
   __attr_proxy :mapping_registry, true		# for RPC unmarshal
   __attr_proxy :wsdl_mapping_registry, true	# for RPC marshal
   __attr_proxy :default_encodingstyle, true
-  __attr_proxy :allow_unqualified_element, true
   __attr_proxy :generate_explicit_type, true
+  __attr_proxy :allow_unqualified_element, true
 
   def httpproxy
     @servant.options["protocol.http.proxy"]
@@ -143,105 +146,105 @@ class WSDLDriver
   end
 
   def reset_stream
-    @servant.streamhandler.reset
+    @servant.reset_stream
   end
 
   # Backward compatibility.
   alias generateEncodeType= generate_explicit_type=
 
   class Servant__
-    include Logger::Severity
     include SOAP
 
     attr_reader :options
-    attr_reader :streamhandler
-    attr_reader :headerhandler
     attr_reader :port
 
-    attr_accessor :mapping_registry
-    attr_accessor :wsdl_mapping_registry
+    attr_accessor :soapaction
     attr_accessor :default_encodingstyle
     attr_accessor :allow_unqualified_element
     attr_accessor :generate_explicit_type
+    attr_accessor :mapping_registry
+    attr_accessor :wsdl_mapping_registry
 
     def initialize(host, wsdl, port, logdev)
       @host = host
       @wsdl = wsdl
       @port = port
       @logdev = logdev
-
+      @soapaction = nil
       @options = setup_options
+      @default_encodingstyle = nil
+      @allow_unqualified_element = nil
+      @generate_explicit_type = false
       @mapping_registry = nil		# for rpc unmarshal
       @wsdl_mapping_registry = nil	# for rpc marshal
-      @default_encodingstyle = EncodingNamespace
-      @allow_unqualified_element = true
-      @generate_explicit_type = false
       @wiredump_file_base = nil
       @mandatorycharset = nil
-
       @wsdl_elements = @wsdl.collect_elements
       @wsdl_types = @wsdl.collect_complextypes + @wsdl.collect_simpletypes
       @rpc_decode_typemap = @wsdl_types +
 	@wsdl.soap_rpc_complextypes(port.find_binding)
-      @wsdl_mapping_registry = Mapping::WSDLRegistry.new(@rpc_decode_typemap)
-      @doc_mapper = Mapper.new(@wsdl_elements, @wsdl_types)
+      @wsdl_mapping_registry = Mapping::WSDLEncodedRegistry.new(@rpc_decode_typemap)
+      @doc_mapper = Mapping::WSDLLiteralRegistry.new(@wsdl_elements, @wsdl_types)
       endpoint_url = @port.soap_address.location
-      @streamhandler = HTTPPostStreamHandler.new(endpoint_url,
-	@options["protocol.http"] ||= Property.new)
-      @headerhandler = Header::HandlerSet.new
       # Convert a map which key is QName, to a Hash which key is String.
-      @operations = {}
+      @operation = {}
       @port.inputoperation_map.each do |op_name, op_info|
-	@operations[op_name.name] = op_info
+	@operation[op_name.name] = op_info
 	add_method_interface(op_info)
       end
+      @proxy = ::SOAP::RPC::Proxy.new(endpoint_url, @soapaction, @options)
+    end
+
+    def inspect
+      "#<#{self.class}:#{@proxy.inspect}>"
     end
 
     def endpoint_url
-      @streamhandler.endpoint_url
+      @proxy.endpoint_url
     end
 
     def endpoint_url=(endpoint_url)
-      @streamhandler.endpoint_url = endpoint_url
-      @streamhandler.reset
+      @proxy.endpoint_url = endpoint_url
     end
 
-    def test_loopback_response
-      @streamhandler.test_loopback_response
+    def headerhandler
+      @proxy.headerhandler
     end
 
-    def rpc_send(method_name, *params)
-      log(INFO) { "call: calling method '#{ method_name }'." }
-      log(DEBUG) { "call: parameters '#{ params.inspect }'." }
+    def streamhandler
+      @proxy.streamhandler
+    end
 
-      op_info = @operations[method_name]
-      method = create_method_struct(op_info, params)
-      req_header = call_headers
-      req_body = SOAPBody.new(method)
-      req_env = SOAPEnvelope.new(req_header, req_body)
+    def test_loopback_response
+      @proxy.test_loopback_response
+    end
 
-      if @wiredump_file_base
-	@streamhandler.wiredump_file_base =
-	  @wiredump_file_base + '_' << method_name
-      end
+    def reset_stream
+      @proxy.reset_stream
+    end
 
+    def rpc_call(name, *values)
+      set_wiredump_file_base(name)
+      unless op_info = @operation[name]
+        raise MethodDefinitionError, "Method: #{name} not defined."
+      end
+      req_header = create_request_header
+      req_body = create_request_body(op_info, *values)
+      opt = create_options({
+        :soapaction => op_info.soapaction || @soapaction,
+        :decode_typemap => @rpc_decode_typemap})
+      env = @proxy.invoke(req_header, req_body, opt)
+      raise EmptyResponseError.new("Empty response.") unless env
+      receive_headers(env.header)
       begin
-	opt = create_options
-	opt[:decode_typemap] = @rpc_decode_typemap
-	res_env = invoke(req_env, op_info, opt)
-	receive_headers(res_env.header)
-	if res_env.body.fault
-	  raise ::SOAP::FaultError.new(res_env.body.fault)
-	end
+        @proxy.check_fault(env.body)
       rescue ::SOAP::FaultError => e
 	Mapping.fault2exception(e)
       end
-
-      ret = res_env.body.response ?
-	Mapping.soap2obj(res_env.body.response, @mapping_registry) : nil
-
-      if res_env.body.outparams
-	outparams = res_env.body.outparams.collect { |outparam|
+      ret = env.body.response ?
+	Mapping.soap2obj(env.body.response, @mapping_registry) : nil
+      if env.body.outparams
+	outparams = env.body.outparams.collect { |outparam|
   	  Mapping.soap2obj(outparam)
    	}
     	return [ret].concat(outparams)
@@ -250,32 +253,64 @@ class WSDLDriver
       end
     end
 
+    def document_call(name, param)
+      set_wiredump_file_base(name)
+      op_info = @operation[name]
+      req_header = header_from_obj(header_obj, op_info)
+      req_body = body_from_obj(body_obj, op_info)
+      env = @proxy.invoke(req_header, req_body, op_info.soapaction || @soapaction, @wsdl_types)
+      raise EmptyResponseError.new("Empty response.") unless env
+      if env.body.fault
+	raise ::SOAP::FaultError.new(env.body.fault)
+      end
+      res_body_obj = env.body.response ?
+	Mapping.soap2obj(env.body.response, @mapping_registry) : nil
+      return env.header, res_body_obj
+    end
+
     # req_header: [[element, mustunderstand, encodingstyle(QName/String)], ...]
     # req_body: SOAPBasetype/SOAPCompoundtype
     def document_send(name, header_obj, body_obj)
-      log(INFO) { "document_send: sending document '#{ name }'." }
-      op_info = @operations[name]
+      set_wiredump_file_base(name)
+      op_info = @operation[name]
       req_header = header_from_obj(header_obj, op_info)
       req_body = body_from_obj(body_obj, op_info)
-      req_env = SOAPEnvelope.new(req_header, req_body)
-      opt = create_options
-      res_env = invoke(req_env, op_info, opt)
-      if res_env.body.fault
-	raise ::SOAP::FaultError.new(res_env.body.fault)
-      end
-      res_body_obj = res_env.body.response ?
-	Mapping.soap2obj(res_env.body.response, @mapping_registry) : nil
-      return res_env.header, res_body_obj
+      opt = create_options({
+        :soapaction => op_info.soapaction || @soapaction,
+        :decode_typemap => @wsdl_types})
+      env = @proxy.invoke(req_header, req_body, opt)
+      raise EmptyResponseError.new("Empty response.") unless env
+      if env.body.fault
+	raise ::SOAP::FaultError.new(env.body.fault)
+      end
+      res_body_obj = env.body.response ?
+	Mapping.soap2obj(env.body.response, @mapping_registry) : nil
+      return env.header, res_body_obj
     end
 
   private
 
-    def call_headers
-      headers = @headerhandler.on_outbound
+    def create_options(hash = nil)
+      opt = {}
+      opt[:default_encodingstyle] = @default_encodingstyle
+      opt[:allow_unqualified_element] = @allow_unqualified_element
+      opt[:generate_explicit_type] = @generate_explicit_type
+      opt.update(hash) if hash
+      opt
+    end
+
+    def set_wiredump_file_base(name)
+      if @wiredump_file_base
+      	@proxy.set_wiredump_file_base(@wiredump_file_base + "_#{ name }")
+      end
+    end
+
+    def create_request_header
+      headers = @proxy.headerhandler.on_outbound
       if headers.empty?
 	nil
       else
-	h = ::SOAP::SOAPHeader.new
+	h = SOAPHeader.new
 	headers.each do |header|
 	  h.add(header.elename.name, header)
 	end
@@ -284,10 +319,15 @@ class WSDLDriver
     end
 
     def receive_headers(headers)
-      @headerhandler.on_inbound(headers) if headers
+      @proxy.headerhandler.on_inbound(headers) if headers
+    end
+
+    def create_request_body(op_info, *values)
+      method = create_method_struct(op_info, *values)
+      SOAPBody.new(method)
     end
 
-    def create_method_struct(op_info, params)
+    def create_method_struct(op_info, *params)
       parts_names = op_info.bodyparts.collect { |part| part.name }
       obj = create_method_obj(parts_names, params)
       method = Mapping.obj2soap(obj, @wsdl_mapping_registry, op_info.optype_name)
@@ -313,52 +353,6 @@ class WSDLDriver
       o
     end
 
-    def invoke(req_env, op_info, opt)
-      opt[:external_content] = nil
-      send_string = Processor.marshal(req_env, opt)
-      log(DEBUG) { "invoke: sending string #{ send_string }" }
-      conn_data = StreamHandler::ConnectionData.new(send_string)
-      if ext = opt[:external_content]
-       	mime = MIMEMessage.new
-	ext.each do |k, v|
-	  mime.add_attachment(v.data)
-	end
-	mime.add_part(conn_data.send_string + "\r\n")
-	mime.close
-	conn_data.send_string = mime.content_str
-	conn_data.send_contenttype = mime.headers['content-type'].str
-      end
-      conn_data = @streamhandler.send(conn_data, op_info.soapaction)
-      log(DEBUG) { "invoke: received string #{ conn_data.receive_string }" }
-      if conn_data.receive_string.empty?
-	return nil, nil
-      end
-      unmarshal(conn_data, opt)
-    end
-
-    def unmarshal(conn_data, opt)
-      contenttype = conn_data.receive_contenttype
-      if /#{MIMEMessage::MultipartContentType}/i =~ contenttype
-	opt[:external_content] = {}
-	mime = MIMEMessage.parse("Content-Type: " + contenttype,
-	  conn_data.receive_string)
-	mime.parts.each do |part|
-	  value = Attachment.new(part.content)
-	  value.contentid = part.contentid
-	  obj = SOAPAttachment.new(value)
-	  opt[:external_content][value.contentid] = obj if value.contentid
-	end
-	opt[:charset] = @mandatorycharset ||
-	  StreamHandler.parse_media_type(mime.root.headers['content-type'].str)
-	env = Processor.unmarshal(mime.root.content, opt)
-      else
-	opt[:charset] = @mandatorycharset ||
-	::SOAP::StreamHandler.parse_media_type(contenttype)
-	env = Processor.unmarshal(conn_data.receive_string, opt)
-      end
-      env
-    end
-
     def header_from_obj(obj, op_info)
       if obj.is_a?(SOAPHeader)
 	obj
@@ -376,7 +370,7 @@ class WSDLDriver
       else
 	header = SOAPHeader.new()
 	op_info.headerparts.each do |part|
-	  child = Mapper.find_attribute(obj, part.name)
+	  child = Mapping.find_attribute(obj, part.name)
 	  ele = headeritem_from_obj(child, part.element || part.eletype)
 	  header.add(part.name, ele)
 	end
@@ -390,7 +384,7 @@ class WSDLDriver
       elsif obj.is_a?(SOAPHeaderItem)
 	obj
       else
-	@doc_mapper.obj2ele(obj, name)
+	@doc_mapper.obj2soap(obj, name)
       end
     end
 
@@ -410,7 +404,7 @@ class WSDLDriver
       else
 	body = SOAPBody.new
 	op_info.bodyparts.each do |part|
-	  child = Mapper.find_attribute(obj, part.name)
+	  child = Mapping.find_attribute(obj, part.name)
 	  ele = bodyitem_from_obj(child, part.element || part.type)
 	  body.add(ele.elename.name, ele)
 	end
@@ -424,51 +418,40 @@ class WSDLDriver
       elsif obj.is_a?(SOAPElement)
 	obj
       else
-	@doc_mapper.obj2ele(obj, name)
+	@doc_mapper.obj2soap(obj, name)
       end
     end
 
     def add_method_interface(op_info)
+      name = ::XSD::CodeGen::GenSupport.safemethodname(op_info.op_name.name)
       case op_info.style
       when :document
-	add_document_method_interface(op_info.op_name.name)
+	add_document_method_interface(name)
       when :rpc
 	parts_names = op_info.bodyparts.collect { |part| part.name }
-	add_rpc_method_interface(op_info.op_name.name, parts_names)
+	add_rpc_method_interface(name, parts_names)
       else
 	raise RuntimeError.new("Unknown style: #{op_info.style}")
       end
     end
 
-    def add_document_method_interface(name)
-      @host.instance_eval <<-EOS
-	def #{ name }(headers, body)
-	  @servant.document_send(#{ name.dump }, headers, body)
-	end
-      EOS
-    end
-
     def add_rpc_method_interface(name, parts_names)
       i = 0
       param_names = parts_names.collect { |orgname| i += 1; "arg#{ i }" }
       callparam = (param_names.collect { |pname| ", " + pname }).join
       @host.instance_eval <<-EOS
 	def #{ name }(#{ param_names.join(", ") })
-	  @servant.rpc_send(#{ name.dump }#{ callparam })
+	  @servant.rpc_call(#{ name.dump }#{ callparam })
 	end
       EOS
     end
 
-    def create_options
-      opt = {}
-      opt[:default_encodingstyle] = @default_encodingstyle
-      opt[:allow_unqualified_element] = @allow_unqualified_element
-      opt[:generate_explicit_type] = @generate_explicit_type
-      opt
-    end
-
-    def log(sev)
-      @logdev.add(sev, nil, self.class) { yield } if @logdev
+    def add_document_method_interface(name)
+      @host.instance_eval <<-EOS
+	def #{ name }(h, b)
+	  @servant.document_send(#{ name.dump }, h, b)
+	end
+      EOS
     end
 
     def setup_options
@@ -487,108 +470,6 @@ class WSDLDriver
       opt["protocol.http.no_proxy"] ||= Env::NO_PROXY
       opt
     end
-
-    class MappingError < StandardError; end
-    class Mapper
-      def initialize(elements, types)
-	@elements = elements
-	@types = types
-      end
-
-      def obj2ele(obj, name)
-	if ele = @elements[name]
-	  _obj2ele(obj, ele)
-	elsif type = @types[name]
-	  obj2type(obj, type)
-	else
-	  raise MappingError.new("Cannot find name #{name} in schema.")
-	end
-      end
-
-      def ele2obj(ele, *arg)
-	raise NotImplementedError.new
-      end
-
-      def Mapper.find_attribute(obj, attr_name)
-	if obj.respond_to?(attr_name)
-	  obj.__send__(attr_name)
-	elsif obj.is_a?(Hash)
-	  obj[attr_name] || obj[attr_name.intern]
-	else
-	  obj.instance_eval("@#{ attr_name }")
-	end
-      end
-
-    private
-
-      def _obj2ele(obj, ele)
-	o = nil
-	if ele.type
-	  if type = @types[ele.type]
-	    o = obj2type(obj, type)
-	  elsif type = TypeMap[ele.type]
-	    o = base2soap(obj, type)
-	  else
-	    raise MappingError.new("Cannot find type #{ele.type}.")
-	  end
-	  o.elename = ele.name
-	elsif ele.local_complextype
-	  o = SOAPElement.new(ele.name)
-	  ele.local_complextype.each_element do |child_ele|
-            o.add(_obj2ele(Mapper.find_attribute(obj, child_ele.name.name),
-              child_ele))
-	  end
-	else
-	  raise MappingError.new("Illegal schema?")
-	end
-	o
-      end
-
-      def obj2type(obj, type)
-        if type.is_a?(::WSDL::XMLSchema::SimpleType)
-          simple2soap(obj, type)
-        else
-          complex2soap(obj, type)
-        end
-      end
-
-      def simple2soap(obj, type)
-        o = base2soap(obj, TypeMap[type.base])
-        if type.restriction.enumeration.empty?
-          STDERR.puts("#{type.name}: simpleType which is not enum type not supported.")
-          return o
-        end
-        if type.restriction.enumeration.include?(o)
-	  raise MappingError.new("#{o} is not allowed for #{type.name}")
-        end
-        o
-      end
-
-      def complex2soap(obj, type)
-        o = SOAPElement.new(type.name)
-        type.each_element do |child_ele|
-          o.add(_obj2ele(Mapper.find_attribute(obj, child_ele.name.name),
-            child_ele))
-        end
-	o
-      end
-
-      def _ele2obj(ele)
-	raise NotImplementedError.new
-      end
-
-      def base2soap(obj, type)
-	soap_obj = nil
-	if type <= XSD::XSDString
-	  soap_obj = type.new(XSD::Charset.is_ces(obj, $KCODE) ?
-	    XSD::Charset.encoding_conv(obj, $KCODE, XSD::Charset.encoding) :
-	    obj)
-	else
-	  soap_obj = type.new(obj)
-	end
-	soap_obj
-      end
-    end
   end
 end