# File lib/soap/rpc/router.rb, line 342
342:     def initialize(soapaction, name, param_def, opt)
343:       @soapaction = soapaction
344:       @name = name
345:       @request_style = opt[:request_style]
346:       @response_style = opt[:response_style]
347:       @request_use = opt[:request_use]
348:       @response_use = opt[:response_use]
349:       check_style(@request_style)
350:       check_style(@response_style)
351:       check_use(@request_use)
352:       check_use(@response_use)
353:       if @response_style == :rpc
354:         request_qname = opt[:request_qname] or raise
355:         @rpc_method_factory =
356:           RPC::SOAPMethodRequest.new(request_qname, param_def, @soapaction)
357:         @rpc_response_qname = opt[:response_qname]
358:       else
359:         @doc_request_qnames = []
360:         @doc_request_qualified = []
361:         @doc_response_qnames = []
362:         @doc_response_qualified = []
363:         param_def.each do |inout, paramname, typeinfo, eleinfo|
364:           klass, nsdef, namedef = typeinfo
365:           qualified = eleinfo
366:           case inout
367:           when SOAPMethod::IN
368:             @doc_request_qnames << XSD::QName.new(nsdef, namedef)
369:             @doc_request_qualified << qualified
370:           when SOAPMethod::OUT
371:             @doc_response_qnames << XSD::QName.new(nsdef, namedef)
372:             @doc_response_qualified << qualified
373:           else
374:             raise ArgumentError.new(
375:               "illegal inout definition for document style: #{inout}")
376:           end
377:         end
378:       end
379:     end

     # File lib/soap/rpc/router.rb, line 389
389:     def call(body, mapping_registry, literal_mapping_registry, opt)
390:       if @request_style == :rpc
391:         values = request_rpc(body, mapping_registry, literal_mapping_registry,
392:           opt)
393:       else
394:         values = request_document(body, mapping_registry,
395:           literal_mapping_registry, opt)
396:       end
397:       result = receiver.method(@name.intern).call(*values)
398:       return result if result.is_a?(SOAPFault)
399:       if @response_style == :rpc
400:         response_rpc(result, mapping_registry, literal_mapping_registry, opt)
401:       else
402:         response_doc(result, mapping_registry, literal_mapping_registry, opt)
403:       end
404:     end

     # File lib/soap/rpc/router.rb, line 381
381:     def request_default_encodingstyle
382:       (@request_use == :encoded) ? EncodingNamespace : LiteralNamespace
383:     end

     # File lib/soap/rpc/router.rb, line 385
385:     def response_default_encodingstyle
386:       (@response_use == :encoded) ? EncodingNamespace : LiteralNamespace
387:     end

     # File lib/soap/rpc/router.rb, line 549
549:     def check_style(style)
550:       unless [:rpc, :document].include?(style)
551:         raise ArgumentError.new("unknown style: #{style}")
552:       end
553:     end

     # File lib/soap/rpc/router.rb, line 555
555:     def check_use(use)
556:       unless [:encoded, :literal].include?(use)
557:         raise ArgumentError.new("unknown use: #{use}")
558:       end
559:     end

     # File lib/soap/rpc/router.rb, line 408
408:     def receiver
409:       raise NotImplementedError.new('must be defined in derived class')
410:     end

     # File lib/soap/rpc/router.rb, line 446
446:     def request_doc_enc(body, mapping_registry, opt)
447:       body.collect { |key, value|
448:         Mapping.soap2obj(value, mapping_registry, nil, opt)
449:       }
450:     end

     # File lib/soap/rpc/router.rb, line 452
452:     def request_doc_lit(body, mapping_registry, opt)
453:       body.collect { |key, value|
454:         Mapping.soap2obj(value, mapping_registry, nil, opt)
455:       }
456:     end

     # File lib/soap/rpc/router.rb, line 424
424:     def request_document(body, mapping_registry, literal_mapping_registry, opt)
425:       # ToDo: compare names with @doc_request_qnames
426:       if @request_use == :encoded
427:         request_doc_enc(body, mapping_registry, opt)
428:       else
429:         request_doc_lit(body, literal_mapping_registry, opt)
430:       end
431:     end

     # File lib/soap/rpc/router.rb, line 412
412:     def request_rpc(body, mapping_registry, literal_mapping_registry, opt)
413:       request = body.request
414:       unless request.is_a?(SOAPStruct)
415:         raise RPCRoutingError.new("not an RPC style")
416:       end
417:       if @request_use == :encoded
418:         request_rpc_enc(request, mapping_registry, opt)
419:       else
420:         request_rpc_lit(request, literal_mapping_registry, opt)
421:       end
422:     end

     # File lib/soap/rpc/router.rb, line 433
433:     def request_rpc_enc(request, mapping_registry, opt)
434:       param = Mapping.soap2obj(request, mapping_registry, nil, opt)
435:       request.collect { |key, value|
436:         param[key]
437:       }
438:     end

     # File lib/soap/rpc/router.rb, line 440
440:     def request_rpc_lit(request, mapping_registry, opt)
441:       request.collect { |key, value|
442:         Mapping.soap2obj(value, mapping_registry, nil, opt)
443:       }
444:     end

     # File lib/soap/rpc/router.rb, line 466
466:     def response_doc(result, mapping_registry, literal_mapping_registry, opt)
467:       if @doc_response_qnames.size == 1 and !result.is_a?(Array)
468:         result = [result]
469:       end
470:       if result.size != @doc_response_qnames.size
471:         raise "required #{@doc_response_qnames.size} responses " +
472:           "but #{result.size} given"
473:       end
474:       if @response_use == :encoded
475:         response_doc_enc(result, mapping_registry, opt)
476:       else
477:         response_doc_lit(result, literal_mapping_registry, opt)
478:       end
479:     end

     # File lib/soap/rpc/router.rb, line 529
529:     def response_doc_enc(result, mapping_registry, opt)
530:       (0...result.size).collect { |idx|
531:         ele = Mapping.obj2soap(result[idx], mapping_registry, nil, opt)
532:         ele.elename = @doc_response_qnames[idx]
533:         ele
534:       }
535:     end

     # File lib/soap/rpc/router.rb, line 537
537:     def response_doc_lit(result, mapping_registry, opt)
538:       (0...result.size).collect { |idx|
539:         ele = Mapping.obj2soap(result[idx], mapping_registry,
540:           @doc_response_qnames[idx])
541:         ele.encodingstyle = LiteralNamespace
542:         if ele.respond_to?(:qualified)
543:           ele.qualified = @doc_response_qualified[idx]
544:         end
545:         ele
546:       }
547:     end

     # File lib/soap/rpc/router.rb, line 458
458:     def response_rpc(result, mapping_registry, literal_mapping_registry, opt)
459:       if @response_use == :encoded
460:         response_rpc_enc(result, mapping_registry, opt)
461:       else
462:         response_rpc_lit(result, literal_mapping_registry, opt)
463:       end
464:     end

     # File lib/soap/rpc/router.rb, line 481
481:     def response_rpc_enc(result, mapping_registry, opt)
482:       soap_response =
483:         @rpc_method_factory.create_method_response(@rpc_response_qname)
484:       if soap_response.have_outparam?
485:         unless result.is_a?(Array)
486:           raise RPCRoutingError.new("out parameter was not returned")
487:         end
488:         outparams = {}
489:         i = 1
490:         soap_response.output_params.each do |outparam|
491:           outparams[outparam] = Mapping.obj2soap(result[i], mapping_registry,
492:             nil, opt)
493:           i += 1
494:         end
495:         soap_response.set_outparam(outparams)
496:         soap_response.retval = Mapping.obj2soap(result[0], mapping_registry,
497:           nil, opt)
498:       else
499:         soap_response.retval = Mapping.obj2soap(result, mapping_registry, nil,
500:           opt)
501:       end
502:       soap_response
503:     end

     # File lib/soap/rpc/router.rb, line 505
505:     def response_rpc_lit(result, mapping_registry, opt)
506:       soap_response =
507:         @rpc_method_factory.create_method_response(@rpc_response_qname)
508:       if soap_response.have_outparam?
509:         unless result.is_a?(Array)
510:           raise RPCRoutingError.new("out parameter was not returned")
511:         end
512:         outparams = {}
513:         i = 1
514:         soap_response.output_params.each do |outparam|
515:           outparams[outparam] = Mapping.obj2soap(result[i], mapping_registry,
516:             XSD::QName.new(nil, outparam), opt)
517:           i += 1
518:         end
519:         soap_response.set_outparam(outparams)
520:         soap_response.retval = Mapping.obj2soap(result[0], mapping_registry,
521:           XSD::QName.new(nil, soap_response.elename), opt)
522:       else
523:         soap_response.retval = Mapping.obj2soap(result, mapping_registry,
524:           XSD::QName.new(nil, soap_response.elename), opt)
525:       end
526:       soap_response
527:     end