tomdz-soap4r 1.5.8.20111103171510

data/lib/soap/encodingstyle/handler.rb

@@ -0,0 +1,121 @@
+# encoding: ASCII-8BIT
+# SOAP4R - EncodingStyle handler library
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'soap/soap'
+require 'soap/baseData'
+require 'soap/element'
+
+
+module SOAP
+module EncodingStyle
+
+
+class Handler
+  @@handlers = {}
+
+  class EncodingStyleError < Error; end
+
+  class << self
+    def uri
+      self::Namespace
+    end
+
+    def handler(uri)
+      @@handlers[uri]
+    end
+
+    def each
+      @@handlers.each do |key, value|
+	yield(value)
+      end
+    end
+
+  private
+
+    def add_handler
+      @@handlers[self.uri] = self
+    end
+  end
+
+  attr_reader :charset
+  attr_accessor :generate_explicit_type
+  def decode_typemap=(definedtypes)
+    @decode_typemap = definedtypes
+  end
+
+  def initialize(charset)
+    @charset = charset
+    @generate_explicit_type = true
+    @decode_typemap = nil
+  end
+
+  ###
+  ## encode interface.
+  #
+  # Returns a XML instance as a string.
+  def encode_data(generator, ns, data, parent)
+    raise NotImplementError
+  end
+
+  def encode_data_end(generator, ns, data, parent)
+    raise NotImplementError
+  end
+
+  def encode_prologue
+  end
+
+  def encode_epilogue
+  end
+
+  ###
+  ## decode interface.
+  #
+  # Returns SOAP/OM data.
+  def decode_tag(ns, name, attrs, parent)
+    raise NotImplementError
+  end
+
+  def decode_tag_end(ns, name)
+    raise NotImplementError
+  end
+
+  def decode_text(ns, text)
+    raise NotImplementError
+  end
+
+  def decode_prologue
+  end
+
+  def decode_epilogue
+  end
+
+  def encode_attr_key(attrs, ns, qname)
+    if qname.namespace.nil?
+      qname.name
+    else
+      unless ns.assigned_as_tagged?(qname.namespace)
+        Generator.assign_ns!(attrs, ns, qname.namespace)
+      end
+      ns.name_attr(qname)
+    end
+  end
+
+  def encode_qname(attrs, ns, qname)
+    if qname.namespace.nil?
+      qname.name
+    else
+      Generator.assign_ns(attrs, ns, qname.namespace)
+      ns.name(qname)
+    end
+  end
+end
+
+
+end
+end

data/lib/soap/encodingstyle/literalHandler.rb

@@ -0,0 +1,196 @@
+# encoding: ASCII-8BIT
+# SOAP4R - XML Literal EncodingStyle handler library
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'soap/encodingstyle/handler'
+
+
+module SOAP
+module EncodingStyle
+
+
+class LiteralHandler < Handler
+  Namespace = SOAP::LiteralNamespace
+  add_handler
+
+  def initialize(charset = nil)
+    super(charset)
+    @textbuf = []
+  end
+
+
+  ###
+  ## encode interface.
+  #
+  def encode_data(generator, ns, data, parent)
+    attrs = {}
+    name = generator.encode_name(ns, data, attrs)
+    if data.type and data.type.name and
+        (@generate_explicit_type or data.force_typed)
+      data.extraattr[XSD::AttrTypeName] = data.type
+    end
+    data.extraattr.each do |key, value|
+      keytag = key
+      if key.is_a?(XSD::QName)
+        keytag = encode_attr_key(attrs, ns, key)
+      end
+      if value.is_a?(XSD::QName)
+        value = encode_qname(attrs, ns, value)
+      end
+      attrs[keytag] = value
+    end
+    case data
+    when SOAPExternalReference
+      # do not encode SOAPExternalReference in
+      # literalHandler (which is used for literal service)
+      data.referred
+    when SOAPRawString
+      generator.encode_tag(name, attrs)
+      generator.encode_rawstring(data.to_s)
+    when XSD::XSDString
+      generator.encode_tag(name, attrs)
+      str = decode_str(data.to_s)
+      generator.encode_string(str)
+    when XSD::XSDAnySimpleType
+      generator.encode_tag(name, attrs)
+      generator.encode_string(data.to_s)
+    when SOAPStruct
+      generator.encode_tag(name, attrs)
+      data.each do |key, value|
+        generator.encode_child(ns, value, data)
+      end
+    when SOAPArray
+      generator.encode_tag(name, attrs)
+      data.traverse do |child, *rank|
+	data.position = nil
+        generator.encode_child(ns, child, data)
+      end
+    when SOAPElement
+      unless generator.use_default_namespace
+        # passes 2 times for simplifying namespace definition
+        data.each do |key, value|
+          if value.elename.namespace
+            Generator.assign_ns(attrs, ns, value.elename.namespace)
+          end
+        end
+      end
+      if data.text and data.text.is_a?(XSD::QName)
+        Generator.assign_ns(attrs, ns, data.text.namespace)
+      end
+      generator.encode_tag(name, attrs)
+      if data.text
+        if data.text.is_a?(XSD::QName)
+          text = ns.name(data.text)
+        else
+          text = data.text
+        end
+        generator.encode_string(text)
+      end
+      data.each do |key, value|
+        generator.encode_child(ns, value, data)
+      end
+    else
+      raise EncodingStyleError.new(
+        "unknown object:#{data} in this encodingStyle")
+    end
+  end
+
+  def encode_data_end(generator, ns, data, parent)
+    # do not encode SOAPExternalReference in
+    # literalHandler (which is used for literal service)
+    return nil if data.is_a?(SOAPExternalReference)
+    name = generator.encode_name_end(ns, data)
+    cr = (data.is_a?(SOAPCompoundtype) and data.have_member)
+    generator.encode_tag_end(name, cr)
+  end
+
+
+  ###
+  ## decode interface.
+  #
+  def decode_tag(ns, elename, attrs, parent)
+    @textbuf.clear
+    if attrs[XSD::AttrNilName] == 'true'
+      o = SOAPNil.decode(elename)
+    else
+      o = SOAPElement.decode(elename)
+    end
+    if definedtype = attrs[XSD::AttrTypeName]
+      o.type = ns.parse(definedtype)
+    end
+    o.parent = parent
+    o.extraattr.update(attrs)
+    decode_parent(parent, o)
+    o
+  end
+
+  def decode_tag_end(ns, node)
+    textbufstr = @textbuf.join
+    @textbuf.clear
+    o = node.node
+    decode_textbuf(o, textbufstr)
+  end
+
+  def decode_text(ns, text)
+    # @textbuf is set at decode_tag_end.
+    @textbuf << text
+  end
+
+  def decode_prologue
+  end
+
+  def decode_epilogue
+  end
+
+  def decode_parent(parent, node)
+    return unless parent.node
+    case parent.node
+    when SOAPElement
+      parent.node.add(node)
+      node.parent = parent.node
+    when SOAPStruct
+      parent.node.add(node.elename.name, node)
+      node.parent = parent.node
+    when SOAPArray
+      if node.position
+	parent.node[*(decode_arypos(node.position))] = node
+	parent.node.sparse = true
+      else
+	parent.node.add(node)
+      end
+      node.parent = parent.node
+    else
+      raise EncodingStyleError.new("illegal parent: #{parent.node}")
+    end
+  end
+
+private
+
+  def decode_textbuf(node, textbufstr)
+    case node
+    when XSD::XSDString, SOAPElement
+      if @charset
+	node.set(decode_str(textbufstr))
+      else
+	node.set(textbufstr)
+      end
+    else
+      # Nothing to do...
+    end
+  end
+
+  def decode_str(str)
+    @charset ? XSD::Charset.encoding_from_xml(str, @charset) : str
+  end
+end
+
+LiteralHandler.new
+
+
+end
+end

data/lib/soap/encodingstyle/soapHandler.rb

@@ -0,0 +1,560 @@
+# encoding: ASCII-8BIT
+# SOAP4R - SOAP EncodingStyle handler library
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'soap/encodingstyle/handler'
+require 'soap/mapping/registry'
+
+
+module SOAP
+module EncodingStyle
+
+
+class SOAPHandler < Handler
+  Namespace = SOAP::EncodingNamespace
+  add_handler
+
+  def initialize(charset = nil)
+    super(charset)
+    @refpool = []
+    @idpool = []
+    @textbuf = []
+    @is_first_top_ele = true
+  end
+
+
+  ###
+  ## encode interface.
+  #
+  def encode_data(generator, ns, data, parent)
+    attrs = encode_attrs(generator, ns, data, parent)
+    if parent && parent.is_a?(SOAPArray) && parent.position
+      attrs[ns.name(AttrPositionName)] = "[#{parent.position.join(',')}]"
+    end
+    name = generator.encode_name(ns, data, attrs)
+    case data
+    when SOAPReference
+      attrs['href'] = data.refidstr
+      generator.encode_tag(name, attrs)
+    when SOAPExternalReference
+      data.referred
+      attrs['href'] = data.refidstr
+      generator.encode_tag(name, attrs)
+    when SOAPRawString
+      generator.encode_tag(name, attrs)
+      generator.encode_rawstring(data.to_s)
+    when XSD::XSDString
+      generator.encode_tag(name, attrs)
+      generator.encode_string(@charset ?
+	XSD::Charset.encoding_to_xml(data.to_s, @charset) : data.to_s)
+    when XSD::XSDAnySimpleType
+      generator.encode_tag(name, attrs)
+      generator.encode_string(data.to_s)
+    when SOAPStruct
+      generator.encode_tag(name, attrs)
+      data.each do |key, value|
+        generator.encode_child(ns, value, data)
+      end
+    when SOAPArray
+      generator.encode_tag(name, attrs)
+      data.traverse do |child, *rank|
+	data.position = data.sparse ? rank : nil
+        generator.encode_child(ns, child, data)
+      end
+    else
+      raise EncodingStyleError.new(
+	"unknown object:#{data} in this encodingStyle")
+    end
+  end
+
+  def encode_data_end(generator, ns, data, parent)
+    name = generator.encode_name_end(ns, data)
+    cr = (data.is_a?(SOAPCompoundtype) and data.have_member)
+    generator.encode_tag_end(name, cr)
+  end
+
+
+  ###
+  ## decode interface.
+  #
+  class SOAPTemporalObject
+    attr_accessor :parent
+    attr_accessor :position
+    attr_accessor :id
+    attr_accessor :root
+
+    def initialize
+      @parent = nil
+      @position = nil
+      @id = nil
+      @root = nil
+    end
+  end
+
+  class SOAPUnknown < SOAPTemporalObject
+    attr_reader :type
+    attr_accessor :definedtype
+    attr_reader :extraattr
+
+    def initialize(handler, elename, type, extraattr)
+      super()
+      @handler = handler
+      @elename = elename
+      @type = type
+      @extraattr = extraattr
+      @definedtype = nil
+    end
+
+    def as_struct
+      if @extraattr[XSD::AttrNilName] == 'true'
+        return as_nil
+      end
+      o = SOAPStruct.decode(@elename, @type)
+      o.id = @id
+      o.root = @root
+      o.parent = @parent
+      o.position = @position
+      o.extraattr.update(@extraattr)
+      @handler.decode_parent(@parent, o)
+      o
+    end
+
+    def as_string
+      if @extraattr[XSD::AttrNilName] == 'true'
+        return as_nil
+      end
+      o = SOAPString.decode(@elename)
+      o.id = @id
+      o.root = @root
+      o.parent = @parent
+      o.position = @position
+      o.extraattr.update(@extraattr)
+      @handler.decode_parent(@parent, o)
+      o
+    end
+
+    def as_nil
+      o = SOAPNil.decode(@elename)
+      o.id = @id
+      o.root = @root
+      o.parent = @parent
+      o.position = @position
+      o.extraattr.update(@extraattr)
+      @handler.decode_parent(@parent, o)
+      o
+    end
+  end
+
+  def decode_tag(ns, elename, attrs, parent)
+    @textbuf.clear
+    is_nil, type, arytype, root, offset, position, href, id =
+      extract_attrs(ns, attrs)
+    o = nil
+    if is_nil
+      o = SOAPNil.decode(elename)
+    elsif href
+      o = SOAPReference.decode(elename, href)
+      @refpool << o
+    elsif @decode_typemap
+      o = decode_tag_by_wsdl(ns, elename, type, parent.node, arytype, attrs)
+    else
+      o = decode_tag_by_type(ns, elename, type, parent.node, arytype, attrs)
+    end
+
+    if o.is_a?(SOAPArray)
+      if offset
+	o.offset = decode_arypos(offset)
+	o.sparse = true
+      else
+	o.sparse = false
+      end
+    end
+
+    o.parent = parent
+    o.id = id
+    o.root = root
+    o.position = position
+
+    unless o.is_a?(SOAPTemporalObject)
+      @idpool << o if o.id
+      decode_parent(parent, o)
+    end
+    o
+  end
+
+  def decode_tag_end(ns, node)
+    textbufstr = @textbuf.join
+    @textbuf.clear
+    o = node.node
+    if o.is_a?(SOAPUnknown)
+      newnode = if /\A\s*\z/ =~ textbufstr
+	o.as_struct
+      else
+	o.as_string
+      end
+      if newnode.id
+	@idpool << newnode
+      end
+      node.replace_node(newnode)
+      o = node.node
+    end
+    decode_textbuf(o, textbufstr)
+    # unlink definedtype
+    o.definedtype = nil
+  end
+
+  def decode_text(ns, text)
+    @textbuf << text
+  end
+
+  def decode_prologue
+    @refpool.clear
+    @idpool.clear
+    @is_first_top_ele = true
+  end
+
+  def decode_epilogue
+    decode_resolve_id
+  end
+
+  def decode_parent(parent, node)
+    return unless parent.node
+    case parent.node
+    when SOAPUnknown
+      newparent = parent.node.as_struct
+      node.parent = newparent
+      if newparent.id
+	@idpool << newparent
+      end
+      parent.replace_node(newparent)
+      decode_parent(parent, node)
+    when SOAPStruct
+      parent.node.add(node.elename.name, node)
+      node.parent = parent.node
+    when SOAPArray
+      if node.position
+	parent.node[*(decode_arypos(node.position))] = node
+	parent.node.sparse = true
+      else
+	parent.node.add(node)
+      end
+      node.parent = parent.node
+    else
+      raise EncodingStyleError.new("illegal parent: #{parent.node}")
+    end
+  end
+
+private
+
+  def content_ranksize(typename)
+    typename.scan(/\[[\d,]*\]$/)[0]
+  end
+
+  def content_typename(typename)
+    typename.sub(/\[,*\]$/, '')
+  end
+
+  def create_arytype(ns, data)
+    XSD::QName.new(data.arytype.namespace,
+      content_typename(data.arytype.name) + "[#{data.size.join(',')}]")
+  end
+
+  def encode_attrs(generator, ns, data, parent)
+    attrs = {}
+    return attrs if data.is_a?(SOAPReference)
+
+    if !parent || parent.encodingstyle != EncodingNamespace
+      if @generate_explicit_type
+        Generator.assign_ns(attrs, ns, EnvelopeNamespace)
+        attrs[ns.name(AttrEncodingStyleName)] = EncodingNamespace
+      end
+      data.encodingstyle = EncodingNamespace
+    end
+
+    if data.is_a?(SOAPNil)
+      attrs[ns.name(XSD::AttrNilName)] = XSD::NilValue
+    elsif @generate_explicit_type
+      if data.type.namespace
+        Generator.assign_ns(attrs, ns, data.type.namespace)
+      end
+      if data.is_a?(SOAPArray)
+	if data.arytype.namespace
+          Generator.assign_ns(attrs, ns, data.arytype.namespace)
+   	end
+	Generator.assign_ns(attrs, ns, EncodingNamespace)
+	attrs[ns.name(AttrArrayTypeName)] = ns.name(create_arytype(ns, data))
+	if data.type.name
+	  attrs[ns.name(XSD::AttrTypeName)] = ns.name(data.type)
+	end
+      elsif parent && parent.is_a?(SOAPArray) && (parent.arytype == data.type)
+	# No need to add.
+      elsif !data.type.namespace
+	# No need to add.
+      else
+	attrs[ns.name(XSD::AttrTypeName)] = ns.name(data.type)
+      end
+    end
+    data.extraattr.each do |key, value|
+      keytag = key
+      if key.is_a?(XSD::QName)
+        keytag = encode_attr_key(attrs, ns, key)
+      end
+      if value.is_a?(XSD::QName)
+        value = encode_qname(attrs, ns, value)
+      else
+        value = encode_attr_value(generator, ns, key, value)
+      end
+      attrs[keytag] = value
+    end
+    if data.id
+      attrs['id'] = data.id
+    end
+    attrs
+  end
+
+  def encode_attr_value(generator, ns, qname, value)
+    case value
+    when SOAPType
+      ref = SOAPReference.new(value)
+      generator.add_reftarget(qname.name, value)
+      ref.refidstr
+    else
+      value.to_s
+    end
+  end
+
+  def decode_tag_by_wsdl(ns, elename, typestr, parent, arytypestr, attrs)
+    o = nil
+    if parent.class == SOAPBody
+      # root element: should branch by root attribute?
+      if @is_first_top_ele
+	# Unqualified name is allowed here.
+	@is_first_top_ele = false
+	type = @decode_typemap[elename] ||
+	  @decode_typemap.find_name(elename.name)
+	if type
+	  o = SOAPStruct.new(elename)
+          o.elename = elename
+	  o.definedtype = type
+	  return o
+	end
+      end
+      # multi-ref element.
+      if typestr
+	typename = ns.parse(typestr)
+	typedef = @decode_typemap[typename]
+	if typedef
+          return decode_definedtype(elename, typename, typedef, arytypestr)
+	end
+      end
+      return decode_tag_by_type(ns, elename, typestr, parent, arytypestr, attrs)
+    end
+
+    if parent.type == XSD::AnyTypeName
+      return decode_tag_by_type(ns, elename, typestr, parent, arytypestr, attrs)
+    end
+
+    # parent.definedtype == nil means the parent is SOAPUnknown.  SOAPUnknown
+    # is generated by decode_tag_by_type when its type is anyType.
+    parenttype = parent.definedtype || @decode_typemap[parent.type]
+    unless parenttype
+      return decode_tag_by_type(ns, elename, typestr, parent, arytypestr, attrs)
+    end
+
+    definedtype_name = parenttype.child_type(elename)
+    if definedtype_name and (klass = TypeMap[definedtype_name])
+      return decode_basetype(klass, elename)
+    elsif definedtype_name == XSD::AnyTypeName
+      return decode_tag_by_type(ns, elename, typestr, parent, arytypestr, attrs)
+    end
+
+    if definedtype_name
+      typedef = @decode_typemap[definedtype_name]
+    else
+      typedef = parenttype.child_defined_complextype(elename)
+    end
+    decode_definedtype(elename, definedtype_name, typedef, arytypestr)
+  end
+
+  def decode_definedtype(elename, typename, typedef, arytypestr)
+    unless typedef
+      raise EncodingStyleError.new("unknown type '#{typename}'")
+    end
+    if typedef.is_a?(::WSDL::XMLSchema::SimpleType)
+      decode_defined_simpletype(elename, typename, typedef, arytypestr)
+    else
+      decode_defined_complextype(elename, typename, typedef, arytypestr)
+    end
+  end
+
+  def decode_basetype(klass, elename)
+    klass.decode(elename)
+  end
+
+  def decode_defined_simpletype(elename, typename, typedef, arytypestr)
+    if typedef.base
+      o = decode_basetype(TypeMap[typedef.base], elename)
+      o.definedtype = typedef
+      o
+    else
+      raise RuntimeError.new("unsupported simpleType: #{typedef}")
+    end
+  end
+
+  def decode_defined_complextype(elename, typename, typedef, arytypestr)
+    case typedef.compoundtype
+    when :TYPE_STRUCT, :TYPE_MAP
+      o = SOAPStruct.decode(elename, typename)
+      o.definedtype = typedef
+      return o
+    when :TYPE_ARRAY
+      expected_arytype = typedef.find_arytype
+      if arytypestr
+	actual_arytype = XSD::QName.new(expected_arytype.namespace,
+	  content_typename(expected_arytype.name) <<
+	  content_ranksize(arytypestr))
+	o = SOAPArray.decode(elename, typename, actual_arytype)
+      else
+	o = SOAPArray.new(typename, 1, expected_arytype)
+	o.elename = elename
+      end
+      o.definedtype = typedef
+      return o
+    when :TYPE_EMPTY
+      o = SOAPNil.decode(elename)
+      o.definedtype = typedef
+      return o
+    else
+      raise RuntimeError.new(
+        "Unknown kind of complexType: #{typedef.compoundtype}")
+    end
+    nil
+  end
+
+  def decode_tag_by_type(ns, elename, typestr, parent, arytypestr, attrs)
+    if arytypestr
+      type = typestr ? ns.parse(typestr) : ValueArrayName
+      node = SOAPArray.decode(elename, type, ns.parse(arytypestr))
+      node.extraattr.update(attrs)
+      return node
+    end
+
+    type = nil
+    if typestr
+      type = ns.parse(typestr)
+    elsif parent.is_a?(SOAPArray)
+      type = parent.arytype
+    else
+      # Since it's in dynamic(without any type) encoding process,
+      # assumes entity as its type itself.
+      #   <SOAP-ENC:Array ...> => type Array in SOAP-ENC.
+      #   <Country xmlns="foo"> => type Country in foo.
+      type = elename
+    end
+
+    if klass = TypeMap[type]
+      node = decode_basetype(klass, elename)
+      node.extraattr.update(attrs)
+      return node
+    end
+
+    # Unknown type... Struct or String
+    SOAPUnknown.new(self, elename, type, attrs)
+  end
+
+  def decode_textbuf(node, textbufstr)
+    case node
+    when XSD::XSDHexBinary, XSD::XSDBase64Binary
+      node.set_encoded(textbufstr)
+    when XSD::XSDString
+      if @charset
+	textbufstr = XSD::Charset.encoding_from_xml(textbufstr, @charset)
+      end
+      if node.definedtype
+        node.definedtype.check_lexical_format(textbufstr)
+      end
+      node.set(textbufstr)
+    when SOAPNil
+      # Nothing to do.
+    when SOAPBasetype
+      node.set(textbufstr)
+    else
+      # Nothing to do...
+    end
+  end
+
+  NilLiteralMap = {
+    'true' => true,
+    '1' => true,
+    'false' => false,
+    '0' => false
+  }
+  RootLiteralMap = {
+    '1' => 1,
+    '0' => 0
+  }
+  def extract_attrs(ns, attrs)
+    is_nil = NilLiteralMap[attrs[XSD::AttrNilName]]
+    type = attrs[XSD::AttrTypeName]
+    arytype = attrs[AttrArrayTypeName]
+    root = attrs[AttrRootName]
+    offset = attrs[AttrOffsetName]
+    position = attrs[AttrPositionName]
+    href = attrs[AttrHrefName]
+    id = attrs[AttrIdName]
+    if attrs.key?(Mapping::RubyIVarName)
+      attrs[Mapping::RubyIVarName] =
+        decode_ref_value(ns, attrs[Mapping::RubyIVarName])
+    end
+    return is_nil, type, arytype, root, offset, position, href, id
+  end
+
+  def decode_ref_value(ns, value)
+    if /\A#/ =~ value
+      o = SOAPReference.decode(nil, value)
+      @refpool << o
+      o
+    else
+      value
+    end
+  end
+
+  def decode_arypos(position)
+    /^\[(.+)\]$/ =~ position
+    $1.split(',').collect { |s| s.to_i }
+  end
+
+  def decode_resolve_id
+    count = @refpool.length	# To avoid infinite loop
+    while !@refpool.empty? && count > 0
+      @refpool = @refpool.find_all { |ref|
+	o = @idpool.find { |item|
+	  item.id == ref.refid
+	}
+	if o.is_a?(SOAPReference)
+	  true	# link of link.
+	elsif o
+	  ref.__setobj__(o)
+	  false
+	elsif o = ref.rootnode.external_content[ref.refid]
+	  ref.__setobj__(o)
+      	  false
+	else
+	  raise EncodingStyleError.new("unresolved reference: #{ref.refid}")
+	end
+      }
+      count -= 1
+    end
+  end
+end
+
+SOAPHandler.new
+
+
+end
+end