Parent

Files

Class Index [+]

Quicksearch

SOAP::RPC::Router::Operation

Attributes

name[R]
soapaction[R]
request_style[R]
response_style[R]
request_use[R]
response_use[R]
faults[R]

Public Class Methods

new(soapaction, name, param_def, opt) click to toggle source
     # File lib/soap/rpc/router.rb, line 407
407:     def initialize(soapaction, name, param_def, opt)
408:       @soapaction = soapaction
409:       @name = name
410:       @request_style = opt[:request_style]
411:       @response_style = opt[:response_style]
412:       @request_use = opt[:request_use]
413:       @response_use = opt[:response_use]
414:       @faults = opt[:faults]
415:       check_style(@request_style)
416:       check_style(@response_style)
417:       check_use(@request_use)
418:       check_use(@response_use)
419:       if @response_style == :rpc
420:         request_qname = opt[:request_qname] or raise
421:         @rpc_method_factory =
422:           RPC::SOAPMethodRequest.new(request_qname, param_def, @soapaction)
423:         @rpc_response_qname = opt[:response_qname]
424:       else
425:         @doc_request_qnames = []
426:         @doc_request_qualified = []
427:         @doc_response_qnames = []
428:         @doc_response_qualified = []
429:         param_def.each do |inout, paramname, typeinfo, eleinfo|
430:           klass, nsdef, namedef = typeinfo
431:           qualified = eleinfo
432:           case inout
433:           when SOAPMethod::IN
434:             @doc_request_qnames << XSD::QName.new(nsdef, namedef)
435:             @doc_request_qualified << qualified
436:           when SOAPMethod::OUT
437:             @doc_response_qnames << XSD::QName.new(nsdef, namedef)
438:             @doc_response_qualified << qualified
439:           else
440:             raise ArgumentError.new(
441:               "illegal inout definition for document style: #{inout}")
442:           end
443:         end
444:       end
445:     end

Public Instance Methods

call(body, mapping_registry, literal_mapping_registry, opt) click to toggle source
     # File lib/soap/rpc/router.rb, line 455
455:     def call(body, mapping_registry, literal_mapping_registry, opt)
456:       if @request_style == :rpc
457:         values = request_rpc(body, mapping_registry, literal_mapping_registry,
458:           opt)
459:       else
460:         values = request_document(body, mapping_registry,
461:           literal_mapping_registry, opt)
462:       end
463:       result = receiver.method(@name.intern).call(*values)
464:       return result if result.is_a?(SOAPFault)
465:       if @response_style == :rpc
466:         response_rpc(result, mapping_registry, literal_mapping_registry, opt)
467:       elsif @doc_response_qnames.empty?
468:         # nothing to do
469:       else
470:         response_doc(result, mapping_registry, literal_mapping_registry, opt)
471:       end
472:     end
request_default_encodingstyle() click to toggle source
     # File lib/soap/rpc/router.rb, line 447
447:     def request_default_encodingstyle
448:       (@request_use == :encoded) ? EncodingNamespace : LiteralNamespace
449:     end
response_default_encodingstyle() click to toggle source
     # File lib/soap/rpc/router.rb, line 451
451:     def response_default_encodingstyle
452:       (@response_use == :encoded) ? EncodingNamespace : LiteralNamespace
453:     end

Private Instance Methods

check_style(style) click to toggle source
     # File lib/soap/rpc/router.rb, line 623
623:     def check_style(style)
624:       unless [:rpc, :document].include?(style)
625:         raise ArgumentError.new("unknown style: #{style}")
626:       end
627:     end
check_use(use) click to toggle source

nil means oneway

     # File lib/soap/rpc/router.rb, line 630
630:     def check_use(use)
631:       unless [:encoded, :literal, nil].include?(use)
632:         raise ArgumentError.new("unknown use: #{use}")
633:       end
634:     end
receiver() click to toggle source
     # File lib/soap/rpc/router.rb, line 476
476:     def receiver
477:       raise NotImplementedError.new('must be defined in derived class')
478:     end
request_doc_enc(body, mapping_registry, opt) click to toggle source
     # File lib/soap/rpc/router.rb, line 519
519:     def request_doc_enc(body, mapping_registry, opt)
520:       body.collect { |key, value|
521:         Mapping.soap2obj(value, mapping_registry, nil, opt)
522:       }
523:     end
request_doc_lit(body, mapping_registry, opt) click to toggle source
     # File lib/soap/rpc/router.rb, line 525
525:     def request_doc_lit(body, mapping_registry, opt)
526:       body.collect { |key, value|
527:         Mapping.soap2obj(value, mapping_registry, nil, opt)
528:       }
529:     end
request_document(body, mapping_registry, literal_mapping_registry, opt) click to toggle source
     # File lib/soap/rpc/router.rb, line 497
497:     def request_document(body, mapping_registry, literal_mapping_registry, opt)
498:       # ToDo: compare names with @doc_request_qnames
499:       if @request_use == :encoded
500:         request_doc_enc(body, mapping_registry, opt)
501:       else
502:         request_doc_lit(body, literal_mapping_registry, opt)
503:       end
504:     end
request_rpc(body, mapping_registry, literal_mapping_registry, opt) click to toggle source
     # File lib/soap/rpc/router.rb, line 480
480:     def request_rpc(body, mapping_registry, literal_mapping_registry, opt)
481:       request = body.request
482:       unless request.is_a?(SOAPNameAccessible)
483:         if request.is_a?(SOAPNil)
484:           # SOAP::Lite/0.69 seems to send xsi:nil="true" element as a request.
485:           request = SOAPStruct.new(request.elename)
486:         else
487:           raise RPCRoutingError.new("not an RPC style")
488:         end
489:       end
490:       if @request_use == :encoded
491:         request_rpc_enc(request, mapping_registry, opt)
492:       else
493:         request_rpc_lit(request, literal_mapping_registry, opt)
494:       end
495:     end
request_rpc_enc(request, mapping_registry, opt) click to toggle source
     # File lib/soap/rpc/router.rb, line 506
506:     def request_rpc_enc(request, mapping_registry, opt)
507:       param = Mapping.soap2obj(request, mapping_registry, nil, opt)
508:       request.collect { |key, value|
509:         param[key]
510:       }
511:     end
request_rpc_lit(request, mapping_registry, opt) click to toggle source
     # File lib/soap/rpc/router.rb, line 513
513:     def request_rpc_lit(request, mapping_registry, opt)
514:       request.collect { |key, value|
515:         Mapping.soap2obj(value, mapping_registry, nil, opt)
516:       }
517:     end
response_doc(result, mapping_registry, literal_mapping_registry, opt) click to toggle source
     # File lib/soap/rpc/router.rb, line 539
539:     def response_doc(result, mapping_registry, literal_mapping_registry, opt)
540:       if @doc_response_qnames.size == 0
541:         result = []
542:       elsif @doc_response_qnames.size == 1
543:         result = [result]
544:       end
545:       if result.size != @doc_response_qnames.size
546:         raise "required #{@doc_response_qnames.size} responses " +
547:           "but #{result.size} given"
548:       end
549:       if @response_use == :encoded
550:         response_doc_enc(result, mapping_registry, opt)
551:       else
552:         response_doc_lit(result, literal_mapping_registry, opt)
553:       end
554:     end
response_doc_enc(result, mapping_registry, opt) click to toggle source
     # File lib/soap/rpc/router.rb, line 604
604:     def response_doc_enc(result, mapping_registry, opt)
605:       (0...result.size).collect { |idx|
606:         ele = Mapping.obj2soap(result[idx], mapping_registry, nil, opt)
607:         ele.elename = @doc_response_qnames[idx]
608:         ele.qualified = @doc_response_qualified[idx]
609:         ele
610:       }
611:     end
response_doc_lit(result, mapping_registry, opt) click to toggle source
     # File lib/soap/rpc/router.rb, line 613
613:     def response_doc_lit(result, mapping_registry, opt)
614:       (0...result.size).collect { |idx|
615:         ele = Mapping.obj2soap(result[idx], mapping_registry,
616:           @doc_response_qnames[idx])
617:         ele.encodingstyle = LiteralNamespace
618:         ele.qualified = @doc_response_qualified[idx]
619:         ele
620:       }
621:     end
response_rpc(result, mapping_registry, literal_mapping_registry, opt) click to toggle source
     # File lib/soap/rpc/router.rb, line 531
531:     def response_rpc(result, mapping_registry, literal_mapping_registry, opt)
532:       if @response_use == :encoded
533:         response_rpc_enc(result, mapping_registry, opt)
534:       else
535:         response_rpc_lit(result, literal_mapping_registry, opt)
536:       end
537:     end
response_rpc_enc(result, mapping_registry, opt) click to toggle source
     # File lib/soap/rpc/router.rb, line 556
556:     def response_rpc_enc(result, mapping_registry, opt)
557:       soap_response =
558:         @rpc_method_factory.create_method_response(@rpc_response_qname)
559:       if soap_response.have_outparam?
560:         unless result.is_a?(Array)
561:           raise RPCRoutingError.new("out parameter was not returned")
562:         end
563:         outparams = {}
564:         i = 1
565:         soap_response.output_params.each do |outparam|
566:           outparams[outparam] = Mapping.obj2soap(result[i], mapping_registry,
567:             nil, opt)
568:           i += 1
569:         end
570:         soap_response.set_outparam(outparams)
571:         soap_response.retval = Mapping.obj2soap(result[0], mapping_registry,
572:           nil, opt)
573:       else
574:         soap_response.retval = Mapping.obj2soap(result, mapping_registry, nil,
575:           opt)
576:       end
577:       soap_response
578:     end
response_rpc_lit(result, mapping_registry, opt) click to toggle source
     # File lib/soap/rpc/router.rb, line 580
580:     def response_rpc_lit(result, mapping_registry, opt)
581:       soap_response =
582:         @rpc_method_factory.create_method_response(@rpc_response_qname)
583:       if soap_response.have_outparam?
584:         unless result.is_a?(Array)
585:           raise RPCRoutingError.new("out parameter was not returned")
586:         end
587:         outparams = {}
588:         i = 1
589:         soap_response.output_params.each do |outparam|
590:           outparams[outparam] = Mapping.obj2soap(result[i], mapping_registry,
591:             XSD::QName.new(nil, outparam), opt)
592:           i += 1
593:         end
594:         soap_response.set_outparam(outparams)
595:         soap_response.retval = Mapping.obj2soap(result[0], mapping_registry,
596:           soap_response.elename, opt)
597:       else
598:         soap_response.retval = Mapping.obj2soap(result, mapping_registry,
599:           soap_response.elename, opt)
600:       end
601:       soap_response
602:     end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.