Included Modules

Files

Class Index [+]

Quicksearch

SOAP::Mapping::LiteralRegistry

Constants

MAPPING_OPT

Attributes

excn_handler_obj2soap[RW]
excn_handler_soap2obj[RW]

Public Class Methods

new() click to toggle source
    # File lib/soap/mapping/literalregistry.rb, line 26
26:   def initialize
27:     super()
28:     @excn_handler_obj2soap = nil
29:     @excn_handler_soap2obj = nil
30:   end

Public Instance Methods

obj2soap(obj, qname, obj_class = nil) click to toggle source
    # File lib/soap/mapping/literalregistry.rb, line 32
32:   def obj2soap(obj, qname, obj_class = nil)
33:     soap_obj = nil
34:     if obj.is_a?(SOAPElement)
35:       soap_obj = obj
36:     else
37:       soap_obj = any2soap(obj, qname, obj_class)
38:     end
39:     return soap_obj if soap_obj
40:     if @excn_handler_obj2soap
41:       soap_obj = @excn_handler_obj2soap.call(obj) { |yield_obj|
42:         Mapping.obj2soap(yield_obj, nil, nil, MAPPING_OPT)
43:       }
44:       return soap_obj if soap_obj
45:     end
46:     raise MappingError.new("cannot map #{obj.class.name} as #{qname}")
47:   end
soap2obj(node, obj_class = nil) click to toggle source

node should be a SOAPElement

    # File lib/soap/mapping/literalregistry.rb, line 50
50:   def soap2obj(node, obj_class = nil)
51:     cause = nil
52:     begin
53:       return any2obj(node, obj_class)
54:     rescue MappingError
55:       cause = $!
56:     end
57:     if @excn_handler_soap2obj
58:       begin
59:         return @excn_handler_soap2obj.call(node) { |yield_node|
60:             Mapping.soap2obj(yield_node, nil, nil, MAPPING_OPT)
61:           }
62:       rescue Exception
63:       end
64:     end
65:     raise MappingError.new("cannot map #{node.elename.name}/#{node.type.name} to Ruby object", cause)
66:   end

Private Instance Methods

add_attributes2obj(node, obj) click to toggle source
     # File lib/soap/mapping/literalregistry.rb, line 343
343:   def add_attributes2obj(node, obj)
344:     return if obj.nil? or node.extraattr.empty?
345:     define_xmlattr(obj)
346:     node.extraattr.each do |qname, value|
347:       obj.__xmlattr[qname] = value
348:       define_xmlattr_accessor(obj, qname)
349:     end
350:   end
add_attributes2stubobj(node, obj, definition) click to toggle source
     # File lib/soap/mapping/literalregistry.rb, line 318
318:   def add_attributes2stubobj(node, obj, definition)
319:     return if obj.nil? or node.extraattr.empty?
320:     if attributes = definition.attributes
321:       define_xmlattr(obj)
322:       attributes.each do |qname, class_name|
323:         child = node.extraattr[qname]
324:         next if child.nil?
325:         if class_name
326:           klass = Mapping.class_from_name(class_name)
327:           if klass.include?(::SOAP::SOAPBasetype)
328:             child = klass.to_data(child)
329:           end
330:         end
331:         obj.__xmlattr[qname] = child
332:         define_xmlattr_accessor(obj, qname)
333:       end
334:     end
335:   end
add_elesoap2plainobj(node, obj) click to toggle source
     # File lib/soap/mapping/literalregistry.rb, line 337
337:   def add_elesoap2plainobj(node, obj)
338:     node.each do |name, value|
339:       obj.__add_xmlele_value(value.elename, any2obj(value))
340:     end
341:   end
add_elesoap2stubobj(node, obj, definition) click to toggle source
     # File lib/soap/mapping/literalregistry.rb, line 275
275:   def add_elesoap2stubobj(node, obj, definition)
276:     vars = {}
277:     node.each do |name, value|
278:       item = definition.elements.find_element(value.elename)
279:       if item
280:         child = elesoapchild2obj(value, item)
281:       else
282:         # unknown element is treated as anyType.
283:         child = any2obj(value)
284:       end
285:       if item and item.as_array?
286:         (vars[name] ||= []) << child
287:       elsif vars.key?(name)
288:         vars[name] = [vars[name], child].flatten
289:       else
290:         vars[name] = child
291:       end
292:     end
293:     if obj.is_a?(::Array) and is_stubobj_elements_for_array(vars)
294:       Array.instance_method(:replace).bind(obj).call(vars.values[0])
295:     else
296:       Mapping.set_attributes(obj, vars)
297:     end
298:   end
any2obj(node, obj_class = nil) click to toggle source
     # File lib/soap/mapping/literalregistry.rb, line 215
215:   def any2obj(node, obj_class = nil)
216:     is_compound = node.is_a?(::SOAP::SOAPCompoundtype)
217:     # trust xsi:type first
218:     if is_compound and node.type
219:       definition = schema_definition_from_type(node.type)
220:     end
221:     # element name next
222:     definition ||= schema_definition_from_elename(node.elename)
223:     # class defined in parent type last
224:     if obj_class
225:       definition ||= schema_definition_from_class(obj_class)
226:     end
227:     if definition
228:       obj_class = definition.class_for
229:     end
230:     if is_compound
231:       if definition
232:         return elesoap2stubobj(node, obj_class, definition)
233:       elsif node.is_a?(::SOAP::SOAPNameAccessible)
234:         return elesoap2plainobj(node)
235:       end
236:     end
237:     obj = Mapping.soap2obj(node, nil, obj_class, MAPPING_OPT)
238:     add_attributes2obj(node, obj)
239:     obj
240:   end
any2soap(obj, qname, obj_class) click to toggle source
     # File lib/soap/mapping/literalregistry.rb, line 76
 76:   def any2soap(obj, qname, obj_class)
 77:     ele = nil
 78:     if obj.is_a?(SOAP::Mapping::Object)
 79:       return mappingobj2soap(obj, qname)
 80:     end
 81:     class_definition = schema_definition_from_class(obj.class)
 82:     if class_definition.nil? and obj_class
 83:       class_definition = schema_definition_from_class(obj_class)
 84:     end
 85:     elename_definition = schema_definition_from_elename(qname)
 86:     if !class_definition and !elename_definition
 87:       # no definition found
 88:       return anyobj2soap(obj, qname)
 89:     end
 90:     if !class_definition or !elename_definition
 91:       # use found one
 92:       return stubobj2soap(obj, qname, class_definition || elename_definition)
 93:     end
 94:     # found both:
 95:     if class_definition.class_for == elename_definition.class_for
 96:       # if two definitions are for the same class, give qname a priority.
 97:       return stubobj2soap(obj, qname, elename_definition)
 98:     end
 99:     # it should be a derived class
100:     return stubobj2soap(obj, qname, class_definition)
101:   end
anyobj2soap(obj, qname) click to toggle source
     # File lib/soap/mapping/literalregistry.rb, line 103
103:   def anyobj2soap(obj, qname)
104:     ele = nil
105:     case obj
106:     when Hash
107:       ele = SOAPElement.from_obj(obj, nil)
108:       ele.elename = qname
109:     when Array
110:       # treat as a list of simpletype
111:       ele = SOAPElement.new(qname, obj.join(" "))
112:     when XSD::QName
113:       ele = SOAPElement.new(qname)
114:       ele.text = obj
115:     else
116:       # expected to be a basetype or an anyType.
117:       # SOAPStruct, etc. is used instead of SOAPElement.
118:       begin
119:         ele = Mapping.obj2soap(obj, nil, nil, MAPPING_OPT)
120:         ele.elename = qname
121:       rescue MappingError
122:         ele = SOAPElement.new(qname, obj.to_s)
123:       end
124:     end
125:     add_attributes2soap(obj, ele)
126:     ele
127:   end
anytype2obj(node) click to toggle source
     # File lib/soap/mapping/literalregistry.rb, line 268
268:   def anytype2obj(node)
269:     if node.is_a?(::SOAP::SOAPBasetype)
270:       return node.data
271:     end
272:     ::SOAP::Mapping::Object.new
273:   end
define_xmlattr(obj) click to toggle source

Mapping.define_attr_accessor calls define_method with proc and it exhausts much memory for each singleton Object. just instance_eval instead of it.

     # File lib/soap/mapping/literalregistry.rb, line 374
374:   def define_xmlattr(obj)
375:     obj.instance_variable_set('@__xmlattr', {})
376:     unless obj.respond_to?(:__xmlattr)
377:       obj.instance_eval         def __xmlattr          @__xmlattr        end
378:     end
379:   end
define_xmlattr_accessor(obj, qname) click to toggle source

Mapping.define_attr_accessor calls define_method with proc and it exhausts much memory for each singleton Object. just instance_eval instead of it.

     # File lib/soap/mapping/literalregistry.rb, line 354
354:   def define_xmlattr_accessor(obj, qname)
355:     # untaint depends GenSupport.safemethodname
356:     name = Mapping.safemethodname('xmlattr_' + qname.name).untaint
357:     unless obj.respond_to?(name)
358:       # untaint depends QName#dump
359:       qnamedump = qname.dump.untaint
360:       obj.instance_eval         def #{name}          @__xmlattr[#{qnamedump}]        end        def #{name}=(value)          @__xmlattr[#{qnamedump}] = value        end
361:     end
362:   end
definedobj2soap(obj, definition) click to toggle source
    # File lib/soap/mapping/literalregistry.rb, line 72
72:   def definedobj2soap(obj, definition)
73:     obj2soap(obj, definition.elename, definition.mapped_class)
74:   end
elesoap2plainobj(node) click to toggle source
     # File lib/soap/mapping/literalregistry.rb, line 256
256:   def elesoap2plainobj(node)
257:     obj = nil
258:     if !node.have_member
259:       obj = base2obj(node, ::SOAP::SOAPString)
260:     else
261:       obj = anytype2obj(node)
262:       add_elesoap2plainobj(node, obj)
263:     end
264:     add_attributes2obj(node, obj)
265:     obj
266:   end
elesoap2stubobj(node, obj_class, definition) click to toggle source
     # File lib/soap/mapping/literalregistry.rb, line 242
242:   def elesoap2stubobj(node, obj_class, definition)
243:     obj = nil
244:     if obj_class == ::String
245:       obj = node.text
246:     elsif obj_class < ::String
247:       obj = obj_class.new(node.text)
248:     else
249:       obj = Mapping.create_empty_object(obj_class)
250:       add_elesoap2stubobj(node, obj, definition)
251:     end
252:     add_attributes2stubobj(node, obj, definition)
253:     obj
254:   end
elesoapchild2obj(value, eledef) click to toggle source
     # File lib/soap/mapping/literalregistry.rb, line 300
300:   def elesoapchild2obj(value, eledef)
301:     if eledef.mapped_class
302:       if eledef.mapped_class.include?(::SOAP::SOAPBasetype)
303:         base2obj(value, eledef.mapped_class)
304:       else
305:         any2obj(value, eledef.mapped_class)
306:       end
307:     else
308:       child_definition = schema_definition_from_elename(eledef.elename)
309:       if child_definition
310:         any2obj(value, child_definition.class_for)
311:       else
312:         # untyped element is treated as anyType.
313:         any2obj(value)
314:       end
315:     end
316:   end
mappingobj2soap(obj, qname) click to toggle source
     # File lib/soap/mapping/literalregistry.rb, line 198
198:   def mappingobj2soap(obj, qname)
199:     ele = SOAPElement.new(qname)
200:     obj.__xmlele.each do |key, value|
201:       if value.is_a?(::Array)
202:         value.each do |item|
203:           ele.add(obj2soap(item, key))
204:         end
205:       else
206:         ele.add(obj2soap(value, key))
207:       end
208:     end
209:     obj.__xmlattr.each do |key, value|
210:       ele.extraattr[key] = value
211:     end
212:     ele
213:   end
stubobj2soap(obj, qname, definition) click to toggle source
     # File lib/soap/mapping/literalregistry.rb, line 129
129:   def stubobj2soap(obj, qname, definition)
130:     if obj.nil?
131:       ele = SOAPNil.new
132:       ele.elename = qname
133:     elsif obj.is_a?(::String)
134:       ele = SOAPElement.new(qname, obj)
135:     else
136:       ele = SOAPElement.new(qname)
137:     end
138:     ele.qualified = definition.qualified
139:     if definition.type and (definition.basetype or Mapping.root_type_hint)
140:       Mapping.reset_root_type_hint
141:       ele.extraattr[XSD::AttrTypeName] = definition.type
142:     end
143:     if qname.nil? and definition.elename
144:       ele.elename = definition.elename
145:     end
146:     return ele if obj.nil?
147:     stubobj2soap_elements(obj, ele, definition.elements)
148:     add_definedattributes2soap(obj, ele, definition)
149:     ele
150:   end
stubobj2soap_elements(obj, ele, definition, is_choice = false) click to toggle source
     # File lib/soap/mapping/literalregistry.rb, line 152
152:   def stubobj2soap_elements(obj, ele, definition, is_choice = false)
153:     added = false
154:     case definition
155:     when SchemaSequenceDefinition, SchemaEmptyDefinition
156:       definition.each do |eledef|
157:         ele_added = stubobj2soap_elements(obj, ele, eledef, is_choice)
158:         added = true if ele_added
159:       end
160:     when SchemaChoiceDefinition
161:       definition.each do |eledef|
162:         added = stubobj2soap_elements(obj, ele, eledef, true)
163:         break if added
164:       end
165:     else
166:       added = true
167:       if definition.as_any?
168:         any = Mapping.get_attributes_for_any(obj)
169:         SOAPElement.from_objs(any).each do |child|
170:           ele.add(child)
171:         end
172:       elsif obj.respond_to?(:each) and definition.as_array?
173:         obj.each do |item|
174:           ele.add(definedobj2soap(item, definition))
175:         end
176:       else
177:         child = Mapping.get_attribute(obj, definition.varname)
178:         if child.nil? and (is_choice or definition.minoccurs == 0)
179:           added = false
180:         else
181:           if child.respond_to?(:each) and definition.as_array?
182:             if child.empty?
183:               added = false
184:             else
185:               child.each do |item|
186:                 ele.add(definedobj2soap(item, definition))
187:               end
188:             end
189:           else
190:             ele.add(definedobj2soap(child, definition))
191:           end
192:         end
193:       end
194:     end
195:     added
196:   end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.