In Files

  • soap/mapping/rubytypeFactory.rb

Class/Module Index [+]

Quicksearch

SOAP::Mapping::RubytypeFactory

Public Class Methods

new(config = {}) click to toggle source
 
               # File soap/mapping/rubytypeFactory.rb, line 25
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
            

Public Instance Methods

obj2soap(soap_class, obj, info, map) click to toggle source
 
               # File soap/mapping/rubytypeFactory.rb, line 38
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))
    if obj.respond_to?('options')
      # Regexp#options is from Ruby/1.7
      options = obj.options
    else
      options = 0
      obj.inspect.sub(/^.*\//, '').each_byte do |c|
        options += case c
          when ?i
            1
          when ?x
            2
          when ?m
            4
          when ?n
            16
          when ?e
            32
          when ?s
            48
          when ?u
            64
          end
      end
    end
    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, ::Thread, ::ThreadGroup
      # from 1.8: Process::Status, 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
            
soap2obj(obj_class, node, info, map) click to toggle source
 
               # File soap/mapping/rubytypeFactory.rb, line 244
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
            

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.

blog comments powered by Disqus