Class: SOAP::EncodingStyle::LiteralHandler

Inherits:
Handler show all
Defined in:
lib/soap/encodingstyle/literalHandler.rb

Constant Summary collapse

Namespace = 
SOAP::LiteralNamespace

Instance Attribute Summary

Attributes inherited from Handler

#charset, #generate_explicit_type

Instance Method Summary collapse

Methods inherited from Handler

#decode_typemap=, each, #encode_epilogue, #encode_prologue, #encode_qname, handler, uri

Constructor Details

#initialize(charset = nil) ⇒ LiteralHandler

Returns a new instance of LiteralHandler.



20
21
22
23
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 20

def initialize(charset = nil)
  super(charset)
  @textbuf = []
end

Instance Method Details

#decode_attrs(ns, attrs) ⇒ Object 



141
142
143
144
145
146
147
148
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 141

def decode_attrs(ns, attrs)
  extraattr = {}
  attrs.each do |key, value|
    qname = ns.parse_local(key)
    extraattr[qname] = value
  end
  extraattr
end

#decode_epilogue ⇒ Object 



153
154
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 153

def decode_epilogue
end

#decode_parent(parent, node) ⇒ Object 



156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 156

def decode_parent(parent, node)
  return unless parent.node
  case parent.node
  when SOAPElement
    parent.node.add(node)
    node.parent = parent.node
  when SOAPStruct
    parent.node.add(node.elename.name, node)
    node.parent = parent.node
  when SOAPArray
    if node.position
	parent.node[*(decode_arypos(node.position))] = node
	parent.node.sparse = true
    else
	parent.node.add(node)
    end
    node.parent = parent.node
  else
    raise EncodingStyleError.new("illegal parent: #{parent.node}")
  end
end

#decode_prologue ⇒ Object 



150
151
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 150

def decode_prologue
end

#decode_tag(ns, elename, attrs, parent) ⇒ Object

decode interface.



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 112

def decode_tag(ns, elename, attrs, parent)
  @textbuf.clear
  extraattrs = decode_attrs(ns, attrs)
  if extraattrs[XSD::AttrNilName] == 'true'
    o = SOAPNil.decode(elename)
  else
    o = SOAPElement.decode(elename)
  end
  if definedtype = extraattrs[XSD::AttrTypeName]
    o.type = ns.parse(definedtype)
  end
  o.parent = parent
  o.extraattr.update(extraattrs)
  decode_parent(parent, o)
  o
end

#decode_tag_end(ns, node) ⇒ Object 



129
130
131
132
133
134
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 129

def decode_tag_end(ns, node)
  textbufstr = @textbuf.join
  @textbuf.clear
  o = node.node
  decode_textbuf(o, textbufstr)
end

#decode_text(ns, text) ⇒ Object 



136
137
138
139
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 136

def decode_text(ns, text)
  # @textbuf is set at decode_tag_end.
  @textbuf << text
end

#encode_data(generator, ns, data, parent) ⇒ Object

encode interface.



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 29

def encode_data(generator, ns, data, parent)
  attrs = {}
  name = generator.encode_name(ns, data, attrs)
  data.extraattr.each do |key, value|
    next if !@generate_explicit_type and key == XSD::AttrTypeName
    # ToDo: check generator.attributeformdefault here
    keytag = key
    if key.is_a?(XSD::QName)
      keytag = encode_qname(attrs, ns, key)
    end
    if value.is_a?(XSD::QName)
      value = encode_qname(attrs, ns, value)
    end
    attrs[keytag] = value
  end
  case data
  when SOAPExternalReference
    # do not encode SOAPExternalReference in
    # literalHandler (which is used for literal service)
    data.referred
  when SOAPRawString
    generator.encode_tag(name, attrs)
    generator.encode_rawstring(data.to_s)
  when XSD::XSDString
    generator.encode_tag(name, attrs)
    str = data.to_s
    str = XSD::Charset.encoding_to_xml(str, @charset) if @charset
    generator.encode_string(str)
  when XSD::XSDAnySimpleType
    generator.encode_tag(name, attrs)
    generator.encode_string(data.to_s)
  when SOAPStruct
    generator.encode_tag(name, attrs)
    data.each do |key, value|
      generator.encode_child(ns, value, data)
    end
  when SOAPArray
    generator.encode_tag(name, attrs)
    data.traverse do |child, *rank|
	data.position = nil
      generator.encode_child(ns, child, data)
    end
  when SOAPElement
    # passes 2 times for simplifying namespace definition
    data.each do |key, value|
      if value.elename.namespace
        SOAPGenerator.assign_ns(attrs, ns, value.elename.namespace)
      end
    end
    if data.text and data.text.is_a?(XSD::QName)
      SOAPGenerator.assign_ns(attrs, ns, data.text.namespace)
    end
    generator.encode_tag(name, attrs)
    if data.text
      if data.text.is_a?(XSD::QName)
        text = ns.name(data.text)
      else
        text = data.text
      end
      generator.encode_rawstring(text)
    end
    data.each do |key, value|
      generator.encode_child(ns, value, data)
    end
  else
    raise EncodingStyleError.new(
      "unknown object:#{data} in this encodingStyle")
  end
end

#encode_data_end(generator, ns, data, parent) ⇒ Object 



99
100
101
102
103
104
105
106
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 99

def encode_data_end(generator, ns, data, parent)
  # do not encode SOAPExternalReference in
  # literalHandler (which is used for literal service)
  return nil if data.is_a?(SOAPExternalReference)
  name = generator.encode_name_end(ns, data)
  cr = (data.is_a?(SOAPCompoundtype) and data.have_member)
  generator.encode_tag_end(name, cr)
end