Class: WSDL::XMLSchema::ComplexType

Inherits:
Info
  • Object
show all
Defined in:
lib/wsdl/soap/complexType.rb,
lib/wsdl/xmlSchema/complexType.rb

Constant Summary collapse

AnyAsElement = 
Element.new(XSD::QName.new(nil, 'any'), XSD::AnyTypeName)

Instance Attribute Summary collapse

Attributes inherited from Info

#id, #parent, #root

Instance Method Summary collapse

Methods inherited from Info

#inspect, #parse_epilogue

Constructor Details

#initialize(name = nil) ⇒ ComplexType

Returns a new instance of ComplexType.



28
29
30
31
32
33
34
35
36
37
 
# File 'lib/wsdl/xmlSchema/complexType.rb', line 28

def initialize(name = nil)
  super()
  @name = name
  @complexcontent = nil
  @simplecontent = nil
  @content = nil
  @final = nil
  @mixed = false
  @attributes = XSD::NamedElements.new
end

Instance Attribute Details

#attributes ⇒ Object (readonly)

Returns the value of attribute attributes



26
27
28
 
# File 'lib/wsdl/xmlSchema/complexType.rb', line 26

def attributes
  @attributes
end

#complexcontent ⇒ Object

Returns the value of attribute complexcontent



21
22
23
 
# File 'lib/wsdl/xmlSchema/complexType.rb', line 21

def complexcontent
  @complexcontent
end

#content ⇒ Object (readonly)

Returns the value of attribute content



23
24
25
 
# File 'lib/wsdl/xmlSchema/complexType.rb', line 23

def content
  @content
end

#final ⇒ Object

Returns the value of attribute final



24
25
26
 
# File 'lib/wsdl/xmlSchema/complexType.rb', line 24

def final
  @final
end

#mixed ⇒ Object

Returns the value of attribute mixed



25
26
27
 
# File 'lib/wsdl/xmlSchema/complexType.rb', line 25

def mixed
  @mixed
end

#name ⇒ Object

Returns the value of attribute name



20
21
22
 
# File 'lib/wsdl/xmlSchema/complexType.rb', line 20

def name
  @name
end

#simplecontent ⇒ Object

Returns the value of attribute simplecontent



22
23
24
 
# File 'lib/wsdl/xmlSchema/complexType.rb', line 22

def simplecontent
  @simplecontent
end

Instance Method Details

#all_elements=(elements) ⇒ Object 



95
96
97
98
99
100
 
# File 'lib/wsdl/xmlSchema/complexType.rb', line 95

def all_elements=(elements)
  @content = All.new
  elements.each do |element|
    @content << element
  end
end

#check_type ⇒ Object 



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/wsdl/soap/complexType.rb', line 22

def check_type
  if content
    if attributes.empty? and
        content.elements.size == 1 and content.elements[0].maxoccurs != '1'
      if name == ::SOAP::Mapping::MapQName
        :TYPE_MAP
      else
        :TYPE_ARRAY
      end
    else
	:TYPE_STRUCT
    end
  elsif complexcontent
    if complexcontent.base == ::SOAP::ValueArrayName
      :TYPE_ARRAY
    else
      complexcontent.basetype.check_type
    end
  elsif simplecontent
    :TYPE_SIMPLE
  elsif !attributes.empty?
    :TYPE_STRUCT
  else # empty complexType definition (seen in partner.wsdl of salesforce)
    :TYPE_EMPTY
  end
end

#child_defined_complextype(name) ⇒ Object 



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/wsdl/soap/complexType.rb', line 74

def child_defined_complextype(name)
  ele = nil
  case compoundtype
  when :TYPE_STRUCT, :TYPE_MAP
    unless ele = find_element(name)
     	if name.namespace.nil?
	  ele = find_element_by_name(name.name)
 	end
    end
  when :TYPE_ARRAY
    if content.elements.size == 1
	ele = content.elements[0]
    else
	raise RuntimeError.new("Assert: must not reach.")
    end
  else
    raise RuntimeError.new("Assert: Not implemented.")
  end
  unless ele
    raise RuntimeError.new("Cannot find #{name} as a children of #{@name}.")
  end
  ele.local_complextype
end

#child_type(name = nil) ⇒ Object 



49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/wsdl/soap/complexType.rb', line 49

def child_type(name = nil)
  case compoundtype
  when :TYPE_STRUCT
    if ele = find_element(name)
      ele.type
    elsif ele = find_element_by_name(name.name)
	ele.type
    end
  when :TYPE_ARRAY
    @contenttype ||= content_arytype
  when :TYPE_MAP
    item_ele = find_element_by_name("item") or
      raise RuntimeError.new("'item' element not found in Map definition.")
    content = item_ele.local_complextype or
      raise RuntimeError.new("No complexType definition for 'item'.")
    if ele = content.find_element(name)
      ele.type
    elsif ele = content.find_element_by_name(name.name)
      ele.type
    end
  else
    raise NotImplementedError.new("Unknown kind of complexType.")
  end
end

#compoundtype ⇒ Object 



18
19
20
 
# File 'lib/wsdl/soap/complexType.rb', line 18

def compoundtype
  @compoundtype ||= check_type
end

#each_element ⇒ Object 



50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/wsdl/xmlSchema/complexType.rb', line 50

def each_element
  if content
    content.elements.each do |element|
      if element.is_a?(Any)
        yield(AnyAsElement)
      else
        yield(element)
      end
    end
  end
end

#elementformdefault ⇒ Object 



45
46
47
 
# File 'lib/wsdl/xmlSchema/complexType.rb', line 45

def elementformdefault
  parent.elementformdefault
end

#find_aryelement ⇒ Object 



117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/wsdl/soap/complexType.rb', line 117

def find_aryelement
  unless compoundtype == :TYPE_ARRAY
    raise RuntimeError.new("Assert: not for array")
  end
  if complexcontent
    if check_array_content(complexcontent.content)
      return complexcontent.content.elements[0]
    end
  elsif check_array_content(content)
    return content.elements[0]
  end
  nil # use default item name
end

#find_arytype ⇒ Object

Raises:

  • (RuntimeError) 


98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/wsdl/soap/complexType.rb', line 98

def find_arytype
  unless compoundtype == :TYPE_ARRAY
    raise RuntimeError.new("Assert: not for array")
  end
  if complexcontent
    complexcontent.attributes.each do |attribute|
	if attribute.ref == ::SOAP::AttrArrayTypeName
 return attribute.arytype
	end
    end
    if check_array_content(complexcontent.content)
      return element_simpletype(complexcontent.content.elements[0])
    end
  elsif check_array_content(content)
    return element_simpletype(content.elements[0])
  end
  raise RuntimeError.new("Assert: Unknown array definition.")
end

#find_element(name) ⇒ Object 



62
63
64
65
66
67
68
69
70
71
72
73
 
# File 'lib/wsdl/xmlSchema/complexType.rb', line 62

def find_element(name)
  if content
    content.elements.each do |element|
      if element.is_a?(Any)
        return AnyAsElement if name == AnyAsElement.name
      else
        return element if name == element.name
      end
    end
  end
  nil
end

#find_element_by_name(name) ⇒ Object 



75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/wsdl/xmlSchema/complexType.rb', line 75

def find_element_by_name(name)
  if content
    content.elements.each do |element|
      if element.is_a?(Any)
        return AnyAsElement if name == AnyAsElement.name.name
      else
        return element if name == element.name.name
      end
    end
  end
  nil
end

#parse_attr(attr, value) ⇒ Object 



123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/wsdl/xmlSchema/complexType.rb', line 123

def parse_attr(attr, value)
  case attr
  when FinalAttrName
    @final = value.source
  when MixedAttrName
    @mixed = (value.source == 'true')
  when NameAttrName
    @name = XSD::QName.new(targetnamespace, value.source)
  else
    nil
  end
end

#parse_element(element) ⇒ Object 



102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/wsdl/xmlSchema/complexType.rb', line 102

def parse_element(element)
  case element
  when AllName
    @content = All.new
  when SequenceName
    @content = Sequence.new
  when ChoiceName
    @content = Choice.new
  when ComplexContentName
    @complexcontent = ComplexContent.new
  when SimpleContentName
    @simplecontent = SimpleContent.new
  when AttributeName
    o = Attribute.new
    @attributes << o
    o
  else
    nil
  end
end

#sequence_elements=(elements) ⇒ Object 



88
89
90
91
92
93
 
# File 'lib/wsdl/xmlSchema/complexType.rb', line 88

def sequence_elements=(elements)
  @content = Sequence.new
  elements.each do |element|
    @content << element
  end
end

#targetnamespace ⇒ Object 



39
40
41
42
43
 
# File 'lib/wsdl/xmlSchema/complexType.rb', line 39

def targetnamespace
  # inner elements can be qualified
  # parent.is_a?(WSDL::XMLSchema::Element) ? nil : parent.targetnamespace
  parent.targetnamespace
end