Files

Class Index [+]

Quicksearch

SOAP::Mapping

Constants

RubyTypeName
RubyExtendName
RubyIVarName
RubyTypeNamespace
RubyTypeInstanceNamespace
RubyCustomTypeNamespace
ApacheSOAPTypeNamespace
EMPTY_OPT
MARSHAL_TAG
MapQName

Public Class Methods

_obj2soap(obj, registry, type = nil) click to toggle source
     # File lib/soap/mapping/mapping.rb, line 122
122:   def self._obj2soap(obj, registry, type = nil)
123:     if obj.respond_to?(:to_xmlpart)
124:       SOAPRawData.new(obj)
125:     elsif defined?(::REXML) and obj.is_a?(::REXML::Element)
126:       SOAPRawData.new(SOAPREXMLElementWrap.new(obj))
127:     elsif referent = Thread.current[:SOAPMapping][:MarshalKey][obj.__id__] and
128:         !Thread.current[:SOAPMapping][:NoReference]
129:       SOAPReference.new(referent)
130:     elsif registry
131:       registry.obj2soap(obj, type)
132:     else
133:       raise MappingError.new("no mapping registry given")
134:     end
135:   end
_soap2obj(node, registry, klass = nil) click to toggle source
     # File lib/soap/mapping/mapping.rb, line 137
137:   def self._soap2obj(node, registry, klass = nil)
138:     if node.nil?
139:       return nil
140:     elsif node.is_a?(SOAPReference)
141:       target = node.__getobj__
142:       # target.id is not Object#id but SOAPReference#id
143:       if referent = Thread.current[:SOAPMapping][:MarshalKey][target.id] and
144:           !Thread.current[:SOAPMapping][:NoReference]
145:         return referent
146:       else
147:         return _soap2obj(target, registry, klass)
148:       end
149:     end
150:     return registry.soap2obj(node, klass)
151:   end
ary2md(ary, rank, type_ns = XSD::Namespace, typename = XSD::AnyTypeLiteral, registry = nil, opt = EMPTY_OPT) click to toggle source
    # File lib/soap/mapping/mapping.rb, line 82
82:   def self.ary2md(ary, rank, type_ns = XSD::Namespace, typename = XSD::AnyTypeLiteral, registry = nil, opt = EMPTY_OPT)
83:     registry ||= Mapping::DefaultRegistry
84:     type = XSD::QName.new(type_ns, typename)
85:     md_ary = SOAPArray.new(ValueArrayName, rank, type)
86:     protect_mapping(opt) do
87:       add_md_ary(md_ary, ary, [], registry)
88:     end
89:     md_ary
90:   end
ary2soap(ary, type_ns = XSD::Namespace, typename = XSD::AnyTypeLiteral, registry = nil, opt = EMPTY_OPT) click to toggle source
    # File lib/soap/mapping/mapping.rb, line 70
70:   def self.ary2soap(ary, type_ns = XSD::Namespace, typename = XSD::AnyTypeLiteral, registry = nil, opt = EMPTY_OPT)
71:     registry ||= Mapping::DefaultRegistry
72:     type = XSD::QName.new(type_ns, typename)
73:     soap_ary = SOAPArray.new(ValueArrayName, 1, type)
74:     protect_mapping(opt) do
75:       ary.each do |ele|
76:         soap_ary.add(_obj2soap(ele, registry, type))
77:       end
78:     end
79:     soap_ary
80:   end
class2element(klass) click to toggle source
     # File lib/soap/mapping/mapping.rb, line 269
269:   def self.class2element(klass)
270:     name = schema_type_definition(klass) ||
271:       Mapping.name2elename(klass.name)
272:     namespace = schema_ns_definition(klass) || RubyCustomTypeNamespace
273:     XSD::QName.new(namespace, name)
274:   end
class2qname(klass) click to toggle source
     # File lib/soap/mapping/mapping.rb, line 263
263:   def self.class2qname(klass)
264:     name = schema_type_definition(klass)
265:     namespace = schema_ns_definition(klass)
266:     XSD::QName.new(namespace, name)
267:   end
class_from_name(name, lenient = false) click to toggle source
     # File lib/soap/mapping/mapping.rb, line 228
228:   def self.class_from_name(name, lenient = false)
229:     unless lenient
230:       const = const_from_name_nonlenient(name)
231:     else
232:       const = const_from_name(name, true)
233:     end
234:     if const.is_a?(::Class)
235:       const
236:     else
237:       nil
238:     end
239:   end
const_from_name(name, lenient = false) click to toggle source
     # File lib/soap/mapping/mapping.rb, line 204
204:   def self.const_from_name(name, lenient = false)
205:     const = ::Object
206:     name.sub(/\A::/, '').split('::').each do |const_str|
207:       if /\A[A-Z]/ =~ const_str
208:         begin
209:           if const.const_defined?(const_str)
210:             const = const.const_get(const_str)
211:             next
212:           end
213:         rescue NameError
214:         end
215:       end
216:       if lenient
217:         const_str = Mapping.safeconstname(const_str)
218:         if const.const_defined?(const_str)
219:           const = const.const_get(const_str)
220:           next
221:         end
222:       end
223:       return nil
224:     end
225:     const
226:   end
const_from_name_nonlenient(name) click to toggle source
     # File lib/soap/mapping/mapping.rb, line 254
254:   def self.const_from_name_nonlenient(name)
255:     if Thread.current[:SOAPMapping]
256:       Thread.current[:SOAPMapping][:ConstFromName][name] ||=
257:         const_from_name(name)
258:     else
259:       const_from_name(name)
260:     end
261:   end
create_empty_object(klass) click to toggle source

ruby/1.7 or later.

     # File lib/soap/mapping/mapping.rb, line 155
155:     def self.create_empty_object(klass)
156:       klass.allocate
157:     end
create_empty_object(klass) click to toggle source
     # File lib/soap/mapping/mapping.rb, line 165
165:     def self.create_empty_object(klass)
166:       if klass <= Struct
167:         name = klass.name
168:         return ::Marshal.load(sprintf("\0004\0006S:%c%s\0000", name.length + 5, name))
169:       end
170:       if MARSHAL_TAG.has_key?(klass)
171:         tag, terminate = MARSHAL_TAG[klass]
172:         return ::Marshal.load(sprintf("\0004\0006%s%s", tag, "\0000" * terminate))
173:       end
174:       MARSHAL_TAG.each do |k, v|
175:         if klass < k
176:           name = klass.name
177:           tag, terminate = v
178:           return ::Marshal.load(sprintf("\0004\0006C:%c%s%s%s", name.length + 5, name, tag, "\0000" * terminate))
179:         end
180:       end
181:       name = klass.name
182:       ::Marshal.load(sprintf("\0004\0006o:%c%s\0000", name.length + 5, name))
183:     end
define_singleton_method(obj, name, &block) click to toggle source
     # File lib/soap/mapping/mapping.rb, line 300
300:   def self.define_singleton_method(obj, name, &block)
301:     sclass = (class << obj; self; end
elename2name(name) click to toggle source
     # File lib/soap/mapping/mapping.rb, line 198
198:   def self.elename2name(name)
199:     name.gsub(/\.\./, '::').gsub(/((?:\.[0-9a-fA-F]{2})+)/) {
200:       [$1.delete('.')].pack('H*')
201:     }
202:   end
fault2exception(fault, registry = nil) click to toggle source
     # File lib/soap/mapping/mapping.rb, line 92
 92:   def self.fault2exception(fault, registry = nil)
 93:     registry ||= Mapping::DefaultRegistry
 94:     detail = if fault.detail
 95:         soap2obj(fault.detail, registry) || ""
 96:       else
 97:         ""
 98:       end
 99:     if detail.is_a?(Mapping::SOAPException)
100:       begin
101:         e = detail.to_e
102:         remote_backtrace = e.backtrace
103:         e.set_backtrace(nil)
104:         raise e # ruby sets current caller as local backtrace of e => e2.
105:       rescue Exception => e
106:         e.set_backtrace(remote_backtrace + e.backtrace[1..1])
107:         raise
108:       end
109:     else
110:       fault.detail = detail
111:       fault.set_backtrace(
112:         if detail.is_a?(Array)
113:           detail
114:         else
115:           [detail.to_s]
116:         end
117:       )
118:       raise
119:     end
120:   end
module_from_name(name, lenient = false) click to toggle source
     # File lib/soap/mapping/mapping.rb, line 241
241:   def self.module_from_name(name, lenient = false)
242:     unless lenient
243:       const = const_from_name_nonlenient(name)
244:     else
245:       const = const_from_name(name, true)
246:     end
247:     if const.is_a?(::Module)
248:       const
249:     else
250:       nil
251:     end
252:   end
name2elename(name) click to toggle source

Allow only (Letter | ‘_’) (Letter | Digit | ’-’ | ‘_’)* here. Caution: ’.’ is not allowed here. To follow XML spec., it should be NCName.

  (denied chars) => .[0-F][0-F]
  ex. a.b => a.2eb
     # File lib/soap/mapping/mapping.rb, line 192
192:   def self.name2elename(name)
193:     name.gsub(/([^a-zA-Z0-9:_\-]+)/) {
194:       '.' << $1.unpack('H2' * $1.size).join('.')
195:     }.gsub(/::/, '..')
196:   end
obj2element(obj) click to toggle source
     # File lib/soap/mapping/mapping.rb, line 276
276:   def self.obj2element(obj)
277:     name = namespace = nil
278:     ivars = obj.instance_variables
279:     if ivars.include?('@schema_type')
280:       name = obj.instance_variable_get('@schema_type')
281:     end
282:     if ivars.include?('@schema_ns')
283:       namespace = obj.instance_variable_get('@schema_ns')
284:     end
285:     if !name or !namespace
286:       class2qname(obj.class)
287:     else
288:       XSD::QName.new(namespace, name)
289:     end
290:   end
obj2soap(obj, registry = nil, type = nil, opt = EMPTY_OPT) click to toggle source
    # File lib/soap/mapping/mapping.rb, line 39
39:   def self.obj2soap(obj, registry = nil, type = nil, opt = EMPTY_OPT)
40:     registry ||= Mapping::DefaultRegistry
41:     soap_obj = nil
42:     protect_mapping(opt) do
43:       soap_obj = _obj2soap(obj, registry, type)
44:     end
45:     soap_obj
46:   end
objs2soap(objs, registry = nil, types = nil, opt = EMPTY_OPT) click to toggle source
    # File lib/soap/mapping/mapping.rb, line 48
48:   def self.objs2soap(objs, registry = nil, types = nil, opt = EMPTY_OPT)
49:     registry ||= Mapping::DefaultRegistry
50:     ary = []
51:     protect_mapping(opt) do
52:       0.upto(objs.length - 1) do |idx|
53:         type = types ? types[idx] : nil
54:         soap = _obj2soap(objs[idx], registry, type)
55:         ary << soap
56:       end
57:     end
58:     ary
59:   end
protect_threadvars(*symbols) click to toggle source
     # File lib/soap/mapping/mapping.rb, line 559
559:     def protect_threadvars(*symbols)
560:       backup = {}
561:       begin
562:         symbols.each do |sym|
563:           backup[sym] = Thread.current[sym]
564:         end
565:         yield
566:       ensure
567:         symbols.each do |sym|
568:           Thread.current[sym] = backup[sym]
569:         end
570:       end
571:     end
soap2obj(node, registry = nil, klass = nil, opt = EMPTY_OPT) click to toggle source
    # File lib/soap/mapping/mapping.rb, line 61
61:   def self.soap2obj(node, registry = nil, klass = nil, opt = EMPTY_OPT)
62:     registry ||= Mapping::DefaultRegistry
63:     obj = nil
64:     protect_mapping(opt) do
65:       obj = _soap2obj(node, registry, klass)
66:     end
67:     obj
68:   end
to_qname(obj, ns = nil) click to toggle source
     # File lib/soap/mapping/mapping.rb, line 292
292:   def self.to_qname(obj, ns = nil)
293:     if obj.is_a?(XSD::QName)
294:       obj
295:     else
296:       XSD::QName.new(ns, obj)
297:     end
298:   end

Private Class Methods

add_md_ary(md_ary, ary, indices, registry) click to toggle source
     # File lib/soap/mapping/mapping.rb, line 596
596:     def add_md_ary(md_ary, ary, indices, registry)
597:       for idx in 0..(ary.size - 1)
598:         if ary[idx].is_a?(Array)
599:           add_md_ary(md_ary, ary[idx], indices + [idx], registry)
600:         else
601:           md_ary[*(indices + [idx])] = _obj2soap(ary[idx], registry)
602:         end
603:       end
604:     end
class_schema_variable(sym, klass) click to toggle source
     # File lib/soap/mapping/mapping.rb, line 575
575:     def class_schema_variable(sym, klass)
576:       var = "@@#{sym}"
577:       klass.class_variables.include?(var) ? klass.class_eval(var) : nil
578:     end
protect_mapping(opt) click to toggle source
     # File lib/soap/mapping/mapping.rb, line 580
580:     def protect_mapping(opt)
581:       protect_threadvars(:SOAPMapping) do
582:         data = Thread.current[:SOAPMapping] = {}
583:         data[:MarshalKey] = {}
584:         data[:ExternalCES] = opt[:external_ces] || XSD::Charset.encoding
585:         data[:NoReference] = opt[:no_reference]
586:         data[:RootTypeHint] = opt[:root_type_hint]
587:         data[:SchemaDefinition] = {}
588:         data[:SafeConstName] = {}
589:         data[:SafeMethodName] = {}
590:         data[:SafeVarName] = {}
591:         data[:ConstFromName] = {}
592:         yield
593:       end
594:     end

Public Instance Methods

add_elesoap2stubobj(node, obj, definition) click to toggle source

XXX consider to merge with the method in LiteralRegistry

     # File lib/soap/mapping/encodedregistry.rb, line 503
503:   def add_elesoap2stubobj(node, obj, definition)
504:     vars = {}
505:     node.each do |name, value|
506:       item = definition.elements.find_element(value.elename)
507:       if item
508:         child = soap2typedobj(value, item.mapped_class)
509:       else
510:         # unknown element is treated as anyType.
511:         child = Mapping._soap2obj(value, self)
512:       end
513:       if item and item.as_array?
514:         (vars[name] ||= []) << child
515:       elsif vars.key?(name)
516:         vars[name] = [vars[name], child].flatten
517:       else
518:         vars[name] = child
519:       end
520:     end
521:     if obj.is_a?(::Array) and is_stubobj_elements_for_array(vars)
522:       Array.instance_method(:replace).bind(obj).call(vars.values[0])
523:     else
524:       Mapping.set_attributes(obj, vars)
525:     end
526:   end
anytype2obj(node, info, map) click to toggle source
     # File lib/soap/mapping/rubytypeFactory.rb, line 377
377:   def anytype2obj(node, info, map)
378:     case node
379:     when SOAPBasetype
380:       return true, node.data
381:     when SOAPStruct
382:       klass = ::SOAP::Mapping::Object
383:       obj = klass.new
384:       mark_unmarshalled_obj(node, obj)
385:       node.each do |name, value|
386:         obj.__add_xmlele_value(XSD::QName.new(nil, name),
387:           Mapping._soap2obj(value, map))
388:       end
389:       unless node.extraattr.empty?
390:         obj.instance_variable_set('@__xmlattr', node.extraattr)
391:       end
392:       return true, obj
393:     else
394:       return false
395:     end
396:   end
array2obj(node, map, rubytype) click to toggle source

Only creates empty array. Do String#replace it with real string.

     # File lib/soap/mapping/rubytypeFactory.rb, line 460
460:   def array2obj(node, map, rubytype)
461:     klass = rubytype ? Mapping.class_from_name(rubytype) : Array
462:     obj = Mapping.create_empty_object(klass)
463:     mark_unmarshalled_obj(node, obj)
464:     obj
465:   end
array2soap(obj, definition) click to toggle source
     # File lib/soap/mapping/encodedregistry.rb, line 446
446:   def array2soap(obj, definition)
447:     return SOAPNil.new if obj.nil?      # ToDo: check nillable.
448:     eledef = definition.elements[0]
449:     soap_obj = SOAPArray.new(ValueArrayName, 1, eledef.elename)
450:     mark_marshalled_obj(obj, soap_obj)
451:     obj.each do |item|
452:       soap_obj.add(typedobj2soap(item, eledef.mapped_class))
453:     end
454:     soap_obj
455:   end
elesoap2stubobj(node, obj_class, definition) click to toggle source
     # File lib/soap/mapping/encodedregistry.rb, line 496
496:   def elesoap2stubobj(node, obj_class, definition)
497:     obj = Mapping.create_empty_object(obj_class)
498:     add_elesoap2stubobj(node, obj, definition)
499:     obj
500:   end
exception2obj(klass, node, map) click to toggle source
     # File lib/soap/mapping/rubytypeFactory.rb, line 449
449:   def exception2obj(klass, node, map)
450:     message = Mapping._soap2obj(node['message'], map)
451:     backtrace = Mapping._soap2obj(node['backtrace'], map)
452:     obj = Mapping.create_empty_object(klass)
453:     obj = obj.exception(message)
454:     mark_unmarshalled_obj(node, obj)
455:     obj.set_backtrace(backtrace)
456:     obj
457:   end
rubytype2obj(node, info, map, rubytype) click to toggle source
     # File lib/soap/mapping/rubytypeFactory.rb, line 295
295:   def rubytype2obj(node, info, map, rubytype)
296:     klass = rubytype ? Mapping.class_from_name(rubytype) : nil
297:     obj = nil
298:     case node
299:     when SOAPString
300:       return @string_factory.soap2obj(klass || String, node, info, map)
301:     when SOAPDateTime
302:       #return @datetime_factory.soap2obj(klass || Time, node, info, map)
303:       klass ||= Time
304:       t = node.to_time
305:       arg = [t.year, t.month, t.mday, t.hour, t.min, t.sec, t.usec]
306:       obj = t.gmt? ? klass.gm(*arg) : klass.local(*arg)
307:       mark_unmarshalled_obj(node, obj)
308:       return true, obj
309:     when SOAPArray
310:       return @array_factory.soap2obj(klass || Array, node, info, map)
311:     when SOAPNil, SOAPBoolean, SOAPInt, SOAPInteger, SOAPDecimal, SOAPDouble
312:       return @basetype_factory.soap2obj(nil, node, info, map)
313:     when SOAPStruct
314:       return rubytypestruct2obj(node, info, map, rubytype)
315:     else
316:       raise
317:     end
318:   end
rubytypestruct2obj(node, info, map, rubytype) click to toggle source
     # File lib/soap/mapping/rubytypeFactory.rb, line 320
320:   def rubytypestruct2obj(node, info, map, rubytype)
321:     klass = rubytype ? Mapping.class_from_name(rubytype) : nil
322:     obj = nil
323:     case node.type
324:     when TYPE_HASH
325:       klass = rubytype ? Mapping.class_from_name(rubytype) : Hash
326:       obj = Mapping.create_empty_object(klass)
327:       mark_unmarshalled_obj(node, obj)
328:       node.each do |key, value|
329:         next unless key == 'item'
330:         obj[Mapping._soap2obj(value['key'], map)] =
331:           Mapping._soap2obj(value['value'], map)
332:       end
333:       if node.key?('default')
334:         obj.default = Mapping._soap2obj(node['default'], map)
335:       end
336:     when TYPE_REGEXP
337:       klass = rubytype ? Mapping.class_from_name(rubytype) : Regexp
338:       obj = Mapping.create_empty_object(klass)
339:       mark_unmarshalled_obj(node, obj)
340:       source = node['source'].string
341:       options = node['options'].data || 0
342:       Regexp.instance_method(:initialize).bind(obj).call(source, options)
343:     when TYPE_RANGE
344:       klass = rubytype ? Mapping.class_from_name(rubytype) : Range
345:       obj = Mapping.create_empty_object(klass)
346:       mark_unmarshalled_obj(node, obj)
347:       first = Mapping._soap2obj(node['begin'], map)
348:       last = Mapping._soap2obj(node['end'], map)
349:       exclude_end = node['exclude_end'].data
350:       Range.instance_method(:initialize).bind(obj).call(first, last, exclude_end)
351:     when TYPE_CLASS
352:       obj = Mapping.class_from_name(node['name'].data)
353:     when TYPE_MODULE
354:       obj = Mapping.class_from_name(node['name'].data)
355:     when TYPE_SYMBOL
356:       obj = node['id'].data.intern
357:     when TYPE_STRUCT
358:       typestr = Mapping.elename2name(node['type'].data)
359:       klass = Mapping.class_from_name(typestr)
360:       if klass.nil?
361:         return false
362:       end
363:       unless klass <= ::Struct
364:         return false
365:       end
366:       obj = Mapping.create_empty_object(klass)
367:       mark_unmarshalled_obj(node, obj)
368:       node['member'].each do |name, value|
369:         obj[Mapping.elename2name(name)] = Mapping._soap2obj(value, map)
370:       end
371:     else
372:       return unknowntype2obj(node, info, map)
373:     end
374:     return true, obj
375:   end
singleton_methods_true(obj) click to toggle source
     # File lib/soap/mapping/rubytypeFactory.rb, line 286
286:     def singleton_methods_true(obj)
287:       obj.singleton_methods(true)
288:     end
singleton_methods_true(obj) click to toggle source
     # File lib/soap/mapping/rubytypeFactory.rb, line 290
290:     def singleton_methods_true(obj)
291:       obj.singleton_methods
292:     end
soap2typedobj(value, klass) click to toggle source
     # File lib/soap/mapping/encodedregistry.rb, line 528
528:   def soap2typedobj(value, klass)
529:     unless klass
530:       raise MappingError.new("unknown class: #{klass}")
531:     end
532:     if klass.include?(::SOAP::SOAPBasetype)
533:       obj = base2obj(value, klass)
534:     else
535:       obj = Mapping._soap2obj(value, self, klass)
536:     end
537:     obj
538:   end
string2obj(node, map, rubytype) click to toggle source

Only creates empty string. Do String#replace it with real string.

     # File lib/soap/mapping/rubytypeFactory.rb, line 468
468:   def string2obj(node, map, rubytype)
469:     klass = rubytype ? Mapping.class_from_name(rubytype) : String
470:     obj = Mapping.create_empty_object(klass)
471:     mark_unmarshalled_obj(node, obj)
472:     obj
473:   end
stubobj2soap(obj, definition) click to toggle source
     # File lib/soap/mapping/encodedregistry.rb, line 437
437:   def stubobj2soap(obj, definition)
438:     case obj
439:     when ::Array
440:       array2soap(obj, definition)
441:     else
442:       unknownstubobj2soap(obj, definition)
443:     end
444:   end
typedobj2soap(value, klass) click to toggle source
     # File lib/soap/mapping/encodedregistry.rb, line 488
488:   def typedobj2soap(value, klass)
489:     if klass and klass.include?(::SOAP::SOAPBasetype)
490:       base2soap(value, klass)
491:     else
492:       Mapping._obj2soap(value, self)
493:     end
494:   end
unknownstruct2obj(node, info, map) click to toggle source
     # File lib/soap/mapping/rubytypeFactory.rb, line 417
417:   def unknownstruct2obj(node, info, map)
418:     unless node.type.name
419:       return nil
420:     end
421:     typestr = Mapping.elename2name(node.type.name)
422:     klass = Mapping.class_from_name(typestr)
423:     if klass.respond_to?(:soap_marshallable) and !klass.soap_marshallable
424:       return nil
425:     end
426:     if klass.nil? and @allow_untyped_struct
427:       klass = Mapping.class_from_name(typestr, true)    # lenient
428:     end
429:     if klass.nil?
430:       return nil
431:     end
432:     if klass <= ::Exception
433:       return exception2obj(klass, node, map)
434:     end
435:     klass_type = Mapping.class2qname(klass)
436:     return nil unless node.type.match(klass_type)
437:     obj = nil
438:     begin
439:       obj = Mapping.create_empty_object(klass)
440:     rescue
441:       # type name "data" tries Data.new which raises TypeError
442:       nil
443:     end
444:     mark_unmarshalled_obj(node, obj)
445:     setiv2obj(obj, node, map)
446:     obj
447:   end
unknownstubobj2soap(obj, definition) click to toggle source
     # File lib/soap/mapping/encodedregistry.rb, line 457
457:   def unknownstubobj2soap(obj, definition)
458:     return SOAPNil.new if obj.nil?
459:     if definition.elements.size == 0
460:       ele = Mapping.obj2soap(obj)
461:       ele.elename = definition.elename if definition.elename
462:       ele.extraattr[XSD::AttrTypeName] = definition.type if definition.type
463:       return ele
464:     else
465:       ele = SOAPStruct.new(definition.type)
466:       mark_marshalled_obj(obj, ele)
467:     end
468:     definition.elements.each do |eledef|
469:       name = eledef.elename.name
470:       if obj.respond_to?(:each) and eledef.as_array?
471:         obj.each do |item|
472:           ele.add(name, typedobj2soap(item, eledef.mapped_class))
473:         end
474:       else
475:         child = Mapping.get_attribute(obj, eledef.varname)
476:         if child.respond_to?(:each) and eledef.as_array?
477:           child.each do |item|
478:             ele.add(name, typedobj2soap(item, eledef.mapped_class))
479:           end
480:         else
481:           ele.add(name, typedobj2soap(child, eledef.mapped_class))
482:         end
483:       end
484:     end
485:     ele
486:   end
unknowntype2obj(node, info, map) click to toggle source
     # File lib/soap/mapping/rubytypeFactory.rb, line 398
398:   def unknowntype2obj(node, info, map)
399:     case node
400:     when SOAPBasetype
401:       return true, node.data
402:     when SOAPArray
403:       return @array_factory.soap2obj(Array, node, info, map)
404:     when SOAPStruct
405:       obj = unknownstruct2obj(node, info, map)
406:       return true, obj if obj
407:       if !@allow_untyped_struct
408:         return false
409:       end
410:       return anytype2obj(node, info, map)
411:     else
412:       # Basetype which is not defined...
413:       return false
414:     end
415:   end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.