class SOAP::RPC::Proxy::Operation

Attributes

attributeformdefault[R]
elementformdefault[R]
request_style[R]
request_use[R]
response_style[R]
response_use[R]
soapaction[R]

Public Class Methods

new(soapaction, param_def, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 282
def initialize(soapaction, param_def, opt)
  @soapaction = soapaction
  @request_style = opt[:request_style]
  @response_style = opt[:response_style]
  @request_use = opt[:request_use]
  @response_use = opt[:response_use]
  # set nil(unqualified) by default
  @elementformdefault = opt[:elementformdefault]
  @attributeformdefault = opt[:attributeformdefault]
  check_style(@request_style)
  check_style(@response_style)
  check_use(@request_use)
  check_use(@response_use)
  if @request_style == :rpc
    @rpc_request_qname = opt[:request_qname]
    if @rpc_request_qname.nil?
      raise MethodDefinitionError.new("rpc_request_qname must be given")
    end
    @rpc_method_factory =
      RPC::SOAPMethodRequest.new(@rpc_request_qname, param_def, @soapaction)
  else
    @doc_request_qnames = []
    @doc_request_qualified = []
    @doc_response_qnames = []
    @doc_response_qualified = []
    param_def.each do |inout, paramname, typeinfo, eleinfo|
      klass_not_used, nsdef, namedef = typeinfo
      qualified = eleinfo
      if namedef.nil?
        raise MethodDefinitionError.new("qname must be given")
      end
      case inout
      when SOAPMethod::IN
        @doc_request_qnames << XSD::QName.new(nsdef, namedef)
        @doc_request_qualified << qualified
      when SOAPMethod::OUT
        @doc_response_qnames << XSD::QName.new(nsdef, namedef)
        @doc_response_qualified << qualified
      else
        raise MethodDefinitionError.new(
          "illegal inout definition for document style: #{inout}")
      end
    end
  end
end

Public Instance Methods

raise_fault(e, mapping_registry, literal_mapping_registry) click to toggle source
# File lib/soap/rpc/proxy.rb, line 352
def raise_fault(e, mapping_registry, literal_mapping_registry)
  if @response_style == :rpc
    Mapping.fault2exception(e, mapping_registry)
  else
    Mapping.fault2exception(e, literal_mapping_registry)
  end
end
request_body(values, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 336
def request_body(values, mapping_registry, literal_mapping_registry, opt)
  if @request_style == :rpc
    request_rpc(values, mapping_registry, literal_mapping_registry, opt)
  else
    request_doc(values, mapping_registry, literal_mapping_registry, opt)
  end
end
request_default_encodingstyle() click to toggle source
# File lib/soap/rpc/proxy.rb, line 328
def request_default_encodingstyle
  (@request_use == :encoded) ? EncodingNamespace : LiteralNamespace
end
response_default_encodingstyle() click to toggle source
# File lib/soap/rpc/proxy.rb, line 332
def response_default_encodingstyle
  (@response_use == :encoded) ? EncodingNamespace : LiteralNamespace
end
response_obj(body, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 344
def response_obj(body, mapping_registry, literal_mapping_registry, opt)
  if @response_style == :rpc
    response_rpc(body, mapping_registry, literal_mapping_registry, opt)
  else
    response_doc(body, mapping_registry, literal_mapping_registry, opt)
  end
end

Private Instance Methods

check_style(style) click to toggle source
# File lib/soap/rpc/proxy.rb, line 362
def check_style(style)
  unless [:rpc, :document].include?(style)
    raise MethodDefinitionError.new("unknown style: #{style}")
  end
end
check_use(use) click to toggle source
# File lib/soap/rpc/proxy.rb, line 368
def check_use(use)
  unless [:encoded, :literal].include?(use)
    raise MethodDefinitionError.new("unknown use: #{use}")
  end
end
create_request_obj(names, params) click to toggle source
# File lib/soap/rpc/proxy.rb, line 483
def create_request_obj(names, params)
  o = Object.new
  idx = 0
  while idx < params.length
    o.instance_variable_set('@' + names[idx], params[idx])
    idx += 1
  end
  o
end
request_doc(values, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 382
def request_doc(values, mapping_registry, literal_mapping_registry, opt)
  if @request_use == :encoded
    request_doc_enc(values, mapping_registry, opt)
  else
    request_doc_lit(values, literal_mapping_registry, opt)
  end
end
request_doc_enc(values, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 412
def request_doc_enc(values, mapping_registry, opt)
  (0...values.size).collect { |idx|
    ele = Mapping.obj2soap(values[idx], mapping_registry, nil, opt)
    ele.elename = @doc_request_qnames[idx]
    ele
  }
end
request_doc_lit(values, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 420
def request_doc_lit(values, mapping_registry, opt)
  (0...values.size).collect { |idx|
    ele = Mapping.obj2soap(values[idx], mapping_registry,
      @doc_request_qnames[idx], opt)
    ele.encodingstyle = LiteralNamespace
    if ele.respond_to?(:qualified)
      ele.qualified = @doc_request_qualified[idx]
    end
    ele
  }
end
request_rpc(values, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 374
def request_rpc(values, mapping_registry, literal_mapping_registry, opt)
  if @request_use == :encoded
    request_rpc_enc(values, mapping_registry, opt)
  else
    request_rpc_lit(values, literal_mapping_registry, opt)
  end
end
request_rpc_enc(values, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 390
def request_rpc_enc(values, mapping_registry, opt)
  method = @rpc_method_factory.dup
  names = method.input_params
  obj = create_request_obj(names, values)
  soap = Mapping.obj2soap(obj, mapping_registry, @rpc_request_qname, opt)
  method.set_param(soap)
  method
end
request_rpc_lit(values, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 399
def request_rpc_lit(values, mapping_registry, opt)
  method = @rpc_method_factory.dup
  params = {}
  idx = 0
  method.input_params.each do |name|
    params[name] = Mapping.obj2soap(values[idx], mapping_registry, 
      XSD::QName.new(nil, name), opt)
    idx += 1
  end
  method.set_param(params)
  method
end
response_doc(body, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 440
def response_doc(body, mapping_registry, literal_mapping_registry, opt)
  if @response_use == :encoded
    return *response_doc_enc(body, mapping_registry, opt)
  else
    return *response_doc_lit(body, literal_mapping_registry, opt)
  end
end
response_doc_enc(body, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 471
def response_doc_enc(body, mapping_registry, opt)
  body.collect { |key, value|
    Mapping.soap2obj(value, mapping_registry, nil, opt)
  }
end
response_doc_lit(body, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 477
def response_doc_lit(body, mapping_registry, opt)
  body.collect { |key, value|
    Mapping.soap2obj(value, mapping_registry)
  }
end
response_rpc(body, mapping_registry, literal_mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 432
def response_rpc(body, mapping_registry, literal_mapping_registry, opt)
  if @response_use == :encoded
    response_rpc_enc(body, mapping_registry, opt)
  else
    response_rpc_lit(body, literal_mapping_registry, opt)
  end
end
response_rpc_enc(body, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 448
def response_rpc_enc(body, mapping_registry, opt)
  ret = nil
  if body.response
    ret = Mapping.soap2obj(body.response, mapping_registry,
      @rpc_method_factory.retval_class_name, opt)
  end
  if body.outparams
    outparams = body.outparams.collect { |outparam|
      Mapping.soap2obj(outparam, mapping_registry, nil, opt)
    }
    [ret].concat(outparams)
  else
    ret
  end
end
response_rpc_lit(body, mapping_registry, opt) click to toggle source
# File lib/soap/rpc/proxy.rb, line 464
def response_rpc_lit(body, mapping_registry, opt)
  body.root_node.collect { |key, value|
    Mapping.soap2obj(value, mapping_registry,
      @rpc_method_factory.retval_class_name, opt)
  }
end