etapper 0.0.0

data/vendor/gems/soap4r-1.5.8.2/lib/soap/mapping/registry.rb

@@ -0,0 +1,295 @@
+# SOAP4R - Mapping registry.
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'soap/baseData'
+require 'soap/mapping/mapping'
+
+
+module SOAP
+
+
+module Marshallable
+  # @@type_ns = Mapping::RubyCustomTypeNamespace
+end
+
+
+module Mapping
+
+  
+module MappedException; end
+
+
+RubyTypeName = XSD::QName.new(RubyTypeInstanceNamespace, 'rubyType')
+RubyExtendName = XSD::QName.new(RubyTypeInstanceNamespace, 'extends')
+RubyIVarName = XSD::QName.new(RubyTypeInstanceNamespace, 'ivars')
+
+
+# For anyType object: SOAP::Mapping::Object not ::Object
+class Object
+  def initialize
+    @__xmlele_type = {}
+    @__xmlele = []
+    @__xmlattr = {}
+  end
+
+  def inspect
+    sprintf("#<%s:0x%x%s>", self.class.name, __id__,
+      @__xmlele.collect { |name, value| " #{name}=#{value.inspect}" }.join)
+  end
+
+  def __xmlattr
+    @__xmlattr
+  end
+
+  def __xmlele
+    @__xmlele
+  end
+
+  def [](qname)
+    qname = Mapping.to_qname(qname)
+    @__xmlele.each do |k, v|
+      return v if k == qname
+    end
+    # fallback
+    @__xmlele.each do |k, v|
+      return v if k.name == qname.name
+    end
+    nil
+  end
+
+  def []=(qname, value)
+    qname = Mapping.to_qname(qname)
+    found = false
+    @__xmlele.each do |pair|
+      if pair[0] == qname
+        found = true
+        pair[1] = value
+      end
+    end
+    unless found
+      __define_attr_accessor(qname)
+      @__xmlele << [qname, value]
+    end
+    @__xmlele_type[qname] = :single
+  end
+
+  def __add_xmlele_value(qname, value)
+    found = false
+    @__xmlele.map! do |k, v|
+      if k == qname
+        found = true
+        [k, __set_xmlele_value(k, v, value)]
+      else
+        [k, v]
+      end
+    end
+    unless found
+      __define_attr_accessor(qname)
+      @__xmlele << [qname, value]
+      @__xmlele_type[qname] = :single
+    end
+    value
+  end
+
+  def marshal_load(dumpobj)
+    __import(dumpobj)
+  end
+
+private
+
+  # Mapping.define_attr_accessor calls define_method with proc and it exhausts
+  # much memory for each singleton Object.  just instance_eval instead of it.
+  def __define_attr_accessor(qname)
+    # untaint depends GenSupport.safemethodname
+    name = Mapping.safemethodname(qname.name).untaint
+    # untaint depends on QName#dump
+    qnamedump = qname.dump.untaint
+    singleton = false
+    unless self.respond_to?(name)
+      singleton = true
+      instance_eval <<-EOS
+        def #{name}
+          self[#{qnamedump}]
+        end
+      EOS
+    end
+    unless self.respond_to?(name + "=")
+      singleton = true
+      instance_eval <<-EOS
+        def #{name}=(value)
+          self[#{qnamedump}] = value
+        end
+      EOS
+    end
+    if singleton && !self.respond_to?(:marshal_dump)
+      instance_eval <<-EOS
+        def marshal_dump
+          __export
+        end
+      EOS
+    end
+  end
+
+  def __set_xmlele_value(key, org, value)
+    case @__xmlele_type[key]
+    when :multi
+      org << value
+      org
+    when :single
+      @__xmlele_type[key] = :multi
+      [org, value]
+    else
+      raise RuntimeError.new("unknown type")
+    end
+  end
+
+  def __export
+    dumpobj = ::SOAP::Mapping::Object.new
+    dumpobj.__xmlele.replace(@__xmlele)
+    dumpobj.__xmlattr.replace(@__xmlattr)
+    dumpobj
+  end
+
+  def __import(dumpobj)
+    @__xmlele_type = {}
+    @__xmlele = []
+    @__xmlattr = {}
+    dumpobj.__xmlele.each do |qname, value|
+      __add_xmlele_value(qname, value)
+    end
+    @__xmlattr.replace(dumpobj.__xmlattr)
+  end
+end
+
+
+class MappingError < Error; end
+
+
+module RegistrySupport
+  def initialize
+    super()
+    @class_schema_definition = {}
+    @class_elename_schema_definition = {}
+    @elename_schema_definition = {}
+    @type_schema_definition = {}
+  end
+
+  def register(definition)
+    obj_class = definition[:class]
+    definition = Mapping.create_schema_definition(obj_class, definition)
+    # give complexType definition a priority explicitly
+    if !@class_schema_definition[obj_class] or definition.type
+      @class_schema_definition[obj_class] = definition
+    end
+    if definition.elename and !definition.is_anonymous?
+      @class_elename_schema_definition[obj_class] = definition
+      @elename_schema_definition[definition.elename] = definition
+    end
+    if definition.type
+      @type_schema_definition[definition.type] = definition
+    end
+  end
+
+  def schema_definition_from_class(klass)
+    @class_schema_definition[klass] || Mapping.schema_definition_classdef(klass)
+  end
+
+  def elename_schema_definition_from_class(klass)
+    @class_elename_schema_definition[klass]
+  end
+
+  def schema_definition_from_elename(qname)
+    @elename_schema_definition[qname]
+  end
+
+  def schema_definition_from_type(type)
+    @type_schema_definition[type]
+  end
+
+  def find_node_definition(node)
+    schema_definition_from_type(node.type) ||
+      schema_definition_from_elename(node.elename) ||
+      find_schema_definition(node.elename.name) ||
+      find_schema_definition(node.type.name)
+  end
+
+  def find_schema_definition(name)
+    return nil unless name
+    typestr = Mapping.safeconstname(name)
+    obj_class = Mapping.class_from_name(typestr)
+    if obj_class
+      schema_definition_from_class(obj_class)
+    end
+  end
+  
+  def add_attributes2soap(obj, ele)
+    if definition = Mapping.schema_definition_classdef(obj.class)
+      add_definedattributes2soap(obj, ele, definition)
+    elsif obj.respond_to?(:__xmlattr)
+      obj.__xmlattr.each do |key, value|
+        ele.extraattr[key] = value
+      end
+    end
+  end
+
+  def add_definedattributes2soap(obj, ele, typedef)
+    if typedef.attributes
+      typedef.attributes.each do |qname, param|
+        value = get_xmlattr_value(obj, qname)
+        ele.extraattr[qname] = value unless value.nil?
+      end
+    end
+  end
+
+  def get_xmlattr_value(obj, qname)
+    attrname = 'xmlattr_' + qname.name
+    value = Mapping.get_attribute(obj, attrname)
+    if value.nil?
+      attrname = Mapping.safemethodname('xmlattr_' + qname.name)
+      value = Mapping.get_attribute(obj, attrname)
+    end
+    value
+  end
+
+  def base2soap(obj, type, qualified = nil)
+    return SOAPNil.new if obj.nil?
+    soap_obj = nil
+    if type <= XSD::XSDString
+      str = XSD::Charset.encoding_conv(obj.to_s, Mapping.external_ces,
+        XSD::Charset.encoding)
+      soap_obj = type.new(str)
+    else
+      soap_obj = type.new(obj)
+    end
+    soap_obj.qualified = qualified
+    soap_obj
+  end
+
+  def base2obj(value, klass)
+    v = if value.respond_to?(:data)
+          value.data
+        elsif value.respond_to?(:text)
+          value.text
+        else
+          nil
+        end
+    if value.is_a?(klass)
+      v
+    else
+      klass.to_data(v)
+    end
+  end
+
+  def is_stubobj_elements_for_array(vars)
+    vars.keys.size == 1 and vars.values[0].is_a?(::Array)
+  end
+end
+
+
+end
+end

data/vendor/gems/soap4r-1.5.8.2/lib/soap/mapping/rubytypeFactory.rb

@@ -0,0 +1,446 @@
+# SOAP4R - Ruby type mapping factory.
+# 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 'continuation'
+
+module SOAP
+module Mapping
+
+
+class RubytypeFactory < Factory
+  TYPE_STRING = XSD::QName.new(RubyTypeNamespace, 'String')
+  TYPE_TIME = XSD::QName.new(RubyTypeNamespace, 'Time')
+  TYPE_ARRAY = XSD::QName.new(RubyTypeNamespace, 'Array')
+  TYPE_REGEXP = XSD::QName.new(RubyTypeNamespace, 'Regexp')
+  TYPE_RANGE = XSD::QName.new(RubyTypeNamespace, 'Range')
+  TYPE_CLASS = XSD::QName.new(RubyTypeNamespace, 'Class')
+  TYPE_MODULE = XSD::QName.new(RubyTypeNamespace, 'Module')
+  TYPE_SYMBOL = XSD::QName.new(RubyTypeNamespace, 'Symbol')
+  TYPE_STRUCT = XSD::QName.new(RubyTypeNamespace, 'Struct')
+  TYPE_HASH = XSD::QName.new(RubyTypeNamespace, 'Map')
+
+  def initialize(config = {})
+    @config = config
+    @allow_untyped_struct = @config.key?(:allow_untyped_struct) ?
+      @config[:allow_untyped_struct] : true
+    @allow_original_mapping = @config.key?(:allow_original_mapping) ?
+      @config[:allow_original_mapping] : false
+    @string_factory = StringFactory_.new(true)
+    @basetype_factory = BasetypeFactory_.new(true)
+    @datetime_factory = DateTimeFactory_.new(true)
+    @array_factory = ArrayFactory_.new(true)
+    @hash_factory = HashFactory_.new(true)
+  end
+
+  def obj2soap(soap_class, obj, info, map)
+    param = nil
+    case obj
+    when ::String
+      unless @allow_original_mapping
+        return nil
+      end
+      param = @string_factory.obj2soap(SOAPString, obj, info, map)
+      if obj.class != String
+        param.extraattr[RubyTypeName] = obj.class.name
+      end
+      addiv2soapattr(param, obj, map)
+    when ::Time
+      unless @allow_original_mapping
+        return nil
+      end
+      param = @datetime_factory.obj2soap(SOAPDateTime, obj, info, map)
+      if obj.class != Time
+        param.extraattr[RubyTypeName] = obj.class.name
+      end
+      addiv2soapattr(param, obj, map)
+    when ::Array
+      unless @allow_original_mapping
+        return nil
+      end
+      param = @array_factory.obj2soap(nil, obj, info, map)
+      if obj.class != Array
+        param.extraattr[RubyTypeName] = obj.class.name
+      end
+      addiv2soapattr(param, obj, map)
+    when ::NilClass
+      unless @allow_original_mapping
+        return nil
+      end
+      param = @basetype_factory.obj2soap(SOAPNil, obj, info, map)
+      addiv2soapattr(param, obj, map)
+    when ::FalseClass, ::TrueClass
+      unless @allow_original_mapping
+        return nil
+      end
+      param = @basetype_factory.obj2soap(SOAPBoolean, obj, info, map)
+      addiv2soapattr(param, obj, map)
+    when ::Integer
+      unless @allow_original_mapping
+        return nil
+      end
+      param = @basetype_factory.obj2soap(SOAPInt, obj, info, map)
+      param ||= @basetype_factory.obj2soap(SOAPInteger, obj, info, map)
+      param ||= @basetype_factory.obj2soap(SOAPDecimal, obj, info, map)
+      addiv2soapattr(param, obj, map)
+    when ::Float
+      unless @allow_original_mapping
+        return nil
+      end
+      param = @basetype_factory.obj2soap(SOAPDouble, obj, info, map)
+      if obj.class != Float
+        param.extraattr[RubyTypeName] = obj.class.name
+      end
+      addiv2soapattr(param, obj, map)
+    when ::Hash
+      unless @allow_original_mapping
+        return nil
+      end
+      if obj.respond_to?(:default_proc) && obj.default_proc
+        raise TypeError.new("cannot dump hash with default proc")
+      end
+      param = SOAPStruct.new(TYPE_HASH)
+      mark_marshalled_obj(obj, param)
+      if obj.class != Hash
+        param.extraattr[RubyTypeName] = obj.class.name
+      end
+      obj.each do |key, value|
+        elem = SOAPStruct.new # Undefined type.
+        elem.add("key", Mapping._obj2soap(key, map))
+        elem.add("value", Mapping._obj2soap(value, map))
+        param.add("item", elem)
+      end
+      param.add('default', Mapping._obj2soap(obj.default, map))
+      addiv2soapattr(param, obj, map)
+    when ::Regexp
+      unless @allow_original_mapping
+        return nil
+      end
+      param = SOAPStruct.new(TYPE_REGEXP)
+      mark_marshalled_obj(obj, param)
+      if obj.class != Regexp
+        param.extraattr[RubyTypeName] = obj.class.name
+      end
+      param.add('source', SOAPBase64.new(obj.source))
+      options = obj.options
+      param.add('options', SOAPInt.new(options))
+      addiv2soapattr(param, obj, map)
+    when ::Range
+      unless @allow_original_mapping
+        return nil
+      end
+      param = SOAPStruct.new(TYPE_RANGE)
+      mark_marshalled_obj(obj, param)
+      if obj.class != Range
+        param.extraattr[RubyTypeName] = obj.class.name
+      end
+      param.add('begin', Mapping._obj2soap(obj.begin, map))
+      param.add('end', Mapping._obj2soap(obj.end, map))
+      param.add('exclude_end', SOAP::SOAPBoolean.new(obj.exclude_end?))
+      addiv2soapattr(param, obj, map)
+    when ::Class
+      unless @allow_original_mapping
+        return nil
+      end
+      if obj.to_s[0] == ?#
+        raise TypeError.new("can't dump anonymous class #{obj}")
+      end
+      param = SOAPStruct.new(TYPE_CLASS)
+      mark_marshalled_obj(obj, param)
+      param.add('name', SOAPString.new(obj.name))
+      addiv2soapattr(param, obj, map)
+    when ::Module
+      unless @allow_original_mapping
+        return nil
+      end
+      if obj.to_s[0] == ?#
+        raise TypeError.new("can't dump anonymous module #{obj}")
+      end
+      param = SOAPStruct.new(TYPE_MODULE)
+      mark_marshalled_obj(obj, param)
+      param.add('name', SOAPString.new(obj.name))
+      addiv2soapattr(param, obj, map)
+    when ::Symbol
+      unless @allow_original_mapping
+        return nil
+      end
+      param = SOAPStruct.new(TYPE_SYMBOL)
+      mark_marshalled_obj(obj, param)
+      param.add('id', SOAPString.new(obj.id2name))
+      addiv2soapattr(param, obj, map)
+    when ::Struct
+      unless @allow_original_mapping
+        # treat it as an user defined class. [ruby-talk:104980]
+        #param = unknownobj2soap(soap_class, obj, info, map)
+        param = SOAPStruct.new(XSD::AnyTypeName)
+        mark_marshalled_obj(obj, param)
+        obj.members.each do |member|
+          param.add(Mapping.name2elename(member),
+            Mapping._obj2soap(obj[member], map))
+        end
+      else
+        param = SOAPStruct.new(TYPE_STRUCT)
+        mark_marshalled_obj(obj, param)
+        param.add('type', ele_type = SOAPString.new(obj.class.to_s))
+        ele_member = SOAPStruct.new
+        obj.members.each do |member|
+          ele_member.add(Mapping.name2elename(member),
+            Mapping._obj2soap(obj[member], map))
+        end
+        param.add('member', ele_member)
+        addiv2soapattr(param, obj, map)
+      end
+    when ::IO, ::Binding, ::Continuation, ::Data, ::Dir, ::File::Stat,
+        ::MatchData, Method, ::Proc, ::Process::Status, ::Thread,
+        ::ThreadGroup, ::UnboundMethod
+      return nil
+    when ::SOAP::Mapping::Object
+      param = SOAPStruct.new(XSD::AnyTypeName)
+      mark_marshalled_obj(obj, param)
+      obj.__xmlele.each do |key, value|
+        param.add(key.name, Mapping._obj2soap(value, map))
+      end
+      obj.__xmlattr.each do |key, value|
+        param.extraattr[key] = value
+      end
+    when ::Exception
+      typestr = Mapping.name2elename(obj.class.to_s)
+      param = SOAPStruct.new(XSD::QName.new(RubyTypeNamespace, typestr))
+      mark_marshalled_obj(obj, param)
+      param.add('message', Mapping._obj2soap(obj.message, map))
+      param.add('backtrace', Mapping._obj2soap(obj.backtrace, map))
+      addiv2soapattr(param, obj, map)
+    else
+      param = unknownobj2soap(soap_class, obj, info, map)
+    end
+    param
+  end
+
+  def soap2obj(obj_class, node, info, map)
+    rubytype = node.extraattr[RubyTypeName]
+    if rubytype or node.type.namespace == RubyTypeNamespace
+      rubytype2obj(node, info, map, rubytype)
+    elsif node.type == XSD::AnyTypeName or node.type == XSD::AnySimpleTypeName
+      anytype2obj(node, info, map)
+    else
+      unknowntype2obj(node, info, map)
+    end
+  end
+
+private
+
+  def addiv2soapattr(node, obj, map)
+    return if obj.instance_variables.empty?
+    ivars = SOAPStruct.new    # Undefined type.
+    setiv2soap(ivars, obj, map)
+    node.extraattr[RubyIVarName] = ivars
+  end
+
+  def unknownobj2soap(soap_class, obj, info, map)
+    if anonymous_class?(obj)
+      raise TypeError.new("can't dump anonymous class #{obj}")
+    end
+    singleton_class = class << obj; self; end
+    if !obj.singleton_methods(true).empty? or
+	!singleton_class.instance_variables.empty?
+      raise TypeError.new("singleton can't be dumped #{obj}")
+    end
+    if !(singleton_class.ancestors - obj.class.ancestors).empty?
+      typestr = Mapping.name2elename(obj.class.to_s)
+      type = XSD::QName.new(RubyTypeNamespace, typestr)
+    else
+      type = Mapping.class2element(obj.class)
+    end
+    param = SOAPStruct.new(type)
+    mark_marshalled_obj(obj, param)
+    setiv2soap(param, obj, map)
+    param
+  end
+
+  def rubytype2obj(node, info, map, rubytype)
+    klass = rubytype ? Mapping.class_from_name(rubytype) : nil
+    obj = nil
+    case node
+    when SOAPString
+      return @string_factory.soap2obj(klass || String, node, info, map)
+    when SOAPDateTime
+      #return @datetime_factory.soap2obj(klass || Time, node, info, map)
+      klass ||= Time
+      t = node.to_time
+      arg = [t.year, t.month, t.mday, t.hour, t.min, t.sec, t.usec]
+      obj = t.gmt? ? klass.gm(*arg) : klass.local(*arg)
+      mark_unmarshalled_obj(node, obj)
+      return true, obj
+    when SOAPArray
+      return @array_factory.soap2obj(klass || Array, node, info, map)
+    when SOAPNil, SOAPBoolean, SOAPInt, SOAPInteger, SOAPDecimal, SOAPDouble
+      return @basetype_factory.soap2obj(nil, node, info, map)
+    when SOAPStruct
+      return rubytypestruct2obj(node, info, map, rubytype)
+    else
+      raise
+    end
+  end
+
+  def rubytypestruct2obj(node, info, map, rubytype)
+    klass = rubytype ? Mapping.class_from_name(rubytype) : nil
+    obj = nil
+    case node.type
+    when TYPE_HASH
+      klass = rubytype ? Mapping.class_from_name(rubytype) : Hash
+      obj = Mapping.create_empty_object(klass)
+      mark_unmarshalled_obj(node, obj)
+      node.each do |key, value|
+        next unless key == 'item'
+        obj[Mapping._soap2obj(value['key'], map)] =
+          Mapping._soap2obj(value['value'], map)
+      end
+      if node.key?('default')
+        obj.default = Mapping._soap2obj(node['default'], map)
+      end
+    when TYPE_REGEXP
+      klass = rubytype ? Mapping.class_from_name(rubytype) : Regexp
+      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 = Mapping.create_empty_object(klass)
+      mark_unmarshalled_obj(node, obj)
+      first = Mapping._soap2obj(node['begin'], map)
+      last = Mapping._soap2obj(node['end'], map)
+      exclude_end = node['exclude_end'].data
+      Range.instance_method(:initialize).bind(obj).call(first, last, exclude_end)
+    when TYPE_CLASS
+      obj = Mapping.class_from_name(node['name'].data)
+    when TYPE_MODULE
+      obj = Mapping.class_from_name(node['name'].data)
+    when TYPE_SYMBOL
+      obj = node['id'].data.intern
+    when TYPE_STRUCT
+      typestr = Mapping.elename2name(node['type'].data)
+      klass = Mapping.class_from_name(typestr)
+      if klass.nil?
+        return false
+      end
+      unless klass <= ::Struct
+        return false
+      end
+      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)
+      end
+    else
+      return unknowntype2obj(node, info, map)
+    end
+    return true, obj
+  end
+
+  def anytype2obj(node, info, map)
+    case node
+    when SOAPBasetype
+      return true, node.data
+    when SOAPStruct
+      klass = ::SOAP::Mapping::Object
+      obj = klass.new
+      mark_unmarshalled_obj(node, obj)
+      node.each do |name, value|
+        obj.__add_xmlele_value(XSD::QName.new(nil, name),
+          Mapping._soap2obj(value, map))
+      end
+      unless node.extraattr.empty?
+        obj.instance_variable_set('@__xmlattr', node.extraattr)
+      end
+      return true, obj
+    else
+      return false
+    end
+  end
+
+  def unknowntype2obj(node, info, map)
+    case node
+    when SOAPBasetype
+      return true, node.data
+    when SOAPArray
+      return @array_factory.soap2obj(Array, node, info, map)
+    when SOAPStruct
+      obj = unknownstruct2obj(node, info, map)
+      return true, obj if obj
+      if !@allow_untyped_struct
+        return false
+      end
+      return anytype2obj(node, info, map)
+    else
+      # Basetype which is not defined...
+      return false
+    end
+  end
+
+  def unknownstruct2obj(node, info, map)
+    unless node.type.name
+      return nil
+    end
+    typestr = Mapping.elename2name(node.type.name)
+    klass = Mapping.class_from_name(typestr)
+    if klass.respond_to?(:soap_marshallable) and !klass.soap_marshallable
+      return nil
+    end
+    if klass.nil? and @allow_untyped_struct
+      klass = Mapping.class_from_name(typestr, true)    # lenient
+    end
+    if klass.nil?
+      return nil
+    end
+    if klass <= ::Exception
+      return exception2obj(klass, node, map)
+    end
+    klass_type = Mapping.class2qname(klass)
+    return nil unless node.type.match(klass_type)
+    obj = nil
+    begin
+      obj = Mapping.create_empty_object(klass)
+    rescue
+      # type name "data" tries Data.new which raises TypeError
+      nil
+    end
+    mark_unmarshalled_obj(node, obj)
+    setiv2obj(obj, node, map)
+    obj
+  end
+
+  def exception2obj(klass, node, map)
+    message = Mapping._soap2obj(node['message'], map)
+    backtrace = Mapping._soap2obj(node['backtrace'], map)
+    obj = Mapping.create_empty_object(klass)
+    obj = obj.exception(message)
+    mark_unmarshalled_obj(node, obj)
+    obj.set_backtrace(backtrace)
+    obj
+  end
+
+  # 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 = Mapping.create_empty_object(klass)
+    mark_unmarshalled_obj(node, obj)
+    obj
+  end
+
+  # 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 = Mapping.create_empty_object(klass)
+    mark_unmarshalled_obj(node, obj)
+    obj
+  end
+end
+
+
+end
+end