# File lib/wsdl/soap/definitions.rb, line 26
26:   def self.array_complextype
27:     type = XMLSchema::ComplexType.new(::SOAP::ValueArrayName)
28:     type.complexcontent = XMLSchema::ComplexContent.new
29:     type.complexcontent.base = ::SOAP::ValueArrayName
30:     attr = XMLSchema::Attribute.new
31:     attr.ref = ::SOAP::AttrArrayTypeName
32:     anytype = XSD::AnyTypeName.dup
33:     anytype.name += '[]'
34:     attr.arytype = anytype
35:     type.complexcontent.attributes << attr
36:     type
37:   end

    # File lib/wsdl/soap/definitions.rb, line 62
62:   def self.exception_complextype
63:     type = XMLSchema::ComplexType.new(XSD::QName.new(
64:         ::SOAP::Mapping::RubyCustomTypeNamespace, 'SOAPException'))
65:     excn_name = XMLSchema::Element.new(XSD::QName.new(nil, 'excn_type_name'), XSD::XSDString::Type)
66:     cause = XMLSchema::Element.new(XSD::QName.new(nil, 'cause'), XSD::AnyTypeName)
67:     backtrace = XMLSchema::Element.new(XSD::QName.new(nil, 'backtrace'), ::SOAP::ValueArrayName)
68:     message = XMLSchema::Element.new(XSD::QName.new(nil, 'message'), XSD::XSDString::Type)
69:     type.all_elements = [excn_name, cause, backtrace, message]
70:     type
71:   end

    # File lib/wsdl/soap/definitions.rb, line 49
49:   def self.fault_complextype
50:     type = XMLSchema::ComplexType.new(::SOAP::EleFaultName)
51:     faultcode = XMLSchema::Element.new(::SOAP::EleFaultCodeName, XSD::XSDQName::Type)
52:     faultstring = XMLSchema::Element.new(::SOAP::EleFaultStringName, XSD::XSDString::Type)
53:     faultactor = XMLSchema::Element.new(::SOAP::EleFaultActorName, XSD::XSDAnyURI::Type)
54:     faultactor.minoccurs = 0
55:     detail = XMLSchema::Element.new(::SOAP::EleFaultDetailName, XSD::AnyTypeName)
56:     detail.minoccurs = 0
57:     type.all_elements = [faultcode, faultstring, faultactor, detail]
58:     type.final = 'extension'
59:     type
60:   end

    # File lib/wsdl/definitions.rb, line 24
24:   def initialize
25:     super
26:     @name = nil
27:     @targetnamespace = nil
28:     @location = nil
29:     @importedschema = {}
30: 
31:     @types = nil
32:     @imports = []
33:     @messages = XSD::NamedElements.new
34:     @porttypes = XSD::NamedElements.new
35:     @bindings = XSD::NamedElements.new
36:     @services = XSD::NamedElements.new
37: 
38:     @anontypes = XSD::NamedElements.new
39:     @root = self
40:   end

     # File lib/wsdl/definitions.rb, line 237
237:   def self.parse_element(element)
238:     if element == DefinitionsName
239:       Definitions.new
240:     else
241:       nil
242:     end
243:   end

    # File lib/wsdl/soap/definitions.rb, line 18
18:   def self.soap_rpc_complextypes
19:     types = XSD::NamedElements.new
20:     types << array_complextype
21:     types << fault_complextype
22:     types << exception_complextype
23:     types
24:   end

     # File lib/wsdl/definitions.rb, line 106
106:   def add_type(complextype)
107:     @anontypes << complextype
108:   end

     # File lib/wsdl/definitions.rb, line 162
162:   def binding(name)
163:     binding = @bindings[name]
164:     return binding if binding
165:     @imports.each do |import|
166:       binding = import.content.binding(name) if self.class === import.content
167:       return binding if binding
168:     end
169:     nil
170:   end

     # File lib/wsdl/definitions.rb, line 126
126:   def bindings
127:     result = @bindings.dup
128:     @imports.each do |import|
129:       result.concat(import.content.bindings) if self.class === import.content
130:     end
131:     result
132:   end

    # File lib/wsdl/definitions.rb, line 53
53:   def collect_attributes
54:     result = XSD::NamedElements.new
55:     if @types
56:       @types.schemas.each do |schema|
57:         result.concat(schema.collect_attributes)
58:       end
59:     end
60:     @imports.each do |import|
61:       result.concat(import.content.collect_attributes)
62:     end
63:     result
64:   end

    # File lib/wsdl/definitions.rb, line 79
79:   def collect_complextypes
80:     result = @anontypes.dup
81:     if @types
82:       @types.schemas.each do |schema|
83:         result.concat(schema.collect_complextypes)
84:       end
85:     end
86:     @imports.each do |import|
87:       result.concat(import.content.collect_complextypes)
88:     end
89:     result
90:   end

    # File lib/wsdl/definitions.rb, line 66
66:   def collect_elements
67:     result = XSD::NamedElements.new
68:     if @types
69:       @types.schemas.each do |schema|
70:         result.concat(schema.collect_elements)
71:       end
72:     end
73:     @imports.each do |import|
74:       result.concat(import.content.collect_elements)
75:     end
76:     result
77:   end

    # File lib/wsdl/soap/definitions.rb, line 78
78:   def collect_faulttypes
79:     result = []
80:     collect_fault_messages.each do |name|
81:       faultparts = message(name).parts
82:       if faultparts.size != 1
83:         raise RuntimeError.new("expecting fault message to have only 1 part")
84:       end
85:       if result.index(faultparts[0].type).nil?
86:         result << faultparts[0].type
87:       end
88:     end
89:     result
90:   end

     # File lib/wsdl/definitions.rb, line 92
 92:   def collect_simpletypes
 93:     result = XSD::NamedElements.new
 94:     if @types
 95:       @types.schemas.each do |schema|
 96:         result.concat(schema.collect_simpletypes)
 97:       end
 98:     end
 99:     @imports.each do |import|
100:       result.concat(import.content.collect_simpletypes)
101:     end
102:     result
103:   end

    # File lib/wsdl/definitions.rb, line 42
42:   def inspect
43:     sprintf("#<%s:0x%x %s>", self.class.name, __id__, @name || '(unnamed)')
44:   end

     # File lib/wsdl/definitions.rb, line 142
142:   def message(name)
143:     message = @messages[name]
144:     return message if message
145:     @imports.each do |import|
146:       message = import.content.message(name) if self.class === import.content
147:       return message if message
148:     end
149:     nil
150:   end

     # File lib/wsdl/definitions.rb, line 110
110:   def messages
111:     result = @messages.dup
112:     @imports.each do |import|
113:       result.concat(import.content.messages) if self.class === import.content
114:     end
115:     result
116:   end

     # File lib/wsdl/definitions.rb, line 226
226:   def parse_attr(attr, value)
227:     case attr
228:     when NameAttrName
229:       @name = XSD::QName.new(targetnamespace, value.source)
230:     when TargetNamespaceAttrName
231:       self.targetnamespace = value.source
232:     else
233:       nil
234:     end
235:   end

     # File lib/wsdl/definitions.rb, line 192
192:   def parse_element(element)
193:     case element
194:     when ImportName
195:       o = Import.new
196:       @imports << o
197:       o
198:     when TypesName
199:       o = Types.new
200:       @types = o
201:       o
202:     when MessageName
203:       o = Message.new
204:       @messages << o
205:       o
206:     when PortTypeName
207:       o = PortType.new
208:       @porttypes << o
209:       o
210:     when BindingName
211:       o = Binding.new
212:       @bindings << o
213:       o
214:     when ServiceName
215:       o = Service.new
216:       @services << o
217:       o
218:     when DocumentationName
219:       o = Documentation.new
220:       o
221:     else
222:       nil
223:     end
224:   end

     # File lib/wsdl/definitions.rb, line 152
152:   def porttype(name)
153:     porttype = @porttypes[name]
154:     return porttype if porttype
155:     @imports.each do |import|
156:       porttype = import.content.porttype(name) if self.class === import.content
157:       return porttype if porttype
158:     end
159:     nil
160:   end

     # File lib/wsdl/definitions.rb, line 182
182:   def porttype_binding(name)
183:     binding = @bindings.find { |item| item.type == name }
184:     return binding if binding
185:     @imports.each do |import|
186:       binding = import.content.porttype_binding(name) if self.class === import.content
187:       return binding if binding
188:     end
189:     nil
190:   end

     # File lib/wsdl/definitions.rb, line 118
118:   def porttypes
119:     result = @porttypes.dup
120:     @imports.each do |import|
121:       result.concat(import.content.porttypes) if self.class === import.content
122:     end
123:     result
124:   end

     # File lib/wsdl/definitions.rb, line 172
172:   def service(name)
173:     service = @services[name]
174:     return service if service
175:     @imports.each do |import|
176:       service = import.content.service(name) if self.class === import.content
177:       return service if service
178:     end
179:     nil
180:   end

     # File lib/wsdl/definitions.rb, line 134
134:   def services
135:     result = @services.dup
136:     @imports.each do |import|
137:       result.concat(import.content.services) if self.class === import.content
138:     end
139:     result
140:   end

    # File lib/wsdl/soap/definitions.rb, line 73
73:   def soap_rpc_complextypes(binding)
74:     types = rpc_operation_complextypes(binding)
75:     types + self.class.soap_rpc_complextypes
76:   end

    # File lib/wsdl/definitions.rb, line 46
46:   def targetnamespace=(targetnamespace)
47:     @targetnamespace = targetnamespace
48:     if @name
49:       @name = XSD::QName.new(@targetnamespace, @name.name)
50:     end
51:   end

     # File lib/wsdl/soap/definitions.rb, line 94
 94:   def collect_fault_messages
 95:     result = []
 96:     porttypes.each do |porttype|
 97:       porttype.operations.each do |operation|
 98:         operation.fault.each do |fault|
 99:           if result.index(fault.message).nil?
100:             result << fault.message
101:           end
102:         end
103:       end
104:     end
105:     result
106:   end

     # File lib/wsdl/soap/definitions.rb, line 134
134:   def elements_from_message(message)
135:     message.parts.collect { |part|
136:       if part.element
137:         collect_elements[part.element]
138:       elsif part.name.nil? or part.type.nil?
139:         raise RuntimeError.new("part of a message must be an element or typed")
140:       else
141:         qname = XSD::QName.new(nil, part.name)
142:         XMLSchema::Element.new(qname, part.type)
143:       end
144:     }
145:   end

     # File lib/wsdl/soap/definitions.rb, line 130
130:   def op_bind_rpc?(op_bind)
131:     op_bind.soapoperation_style == :rpc
132:   end

     # File lib/wsdl/soap/definitions.rb, line 108
108:   def rpc_operation_complextypes(binding)
109:     types = XSD::NamedElements.new
110:     binding.operations.each do |op_bind|
111:       if op_bind_rpc?(op_bind)
112:         operation = op_bind.find_operation
113:         if op_bind.input
114:           type = XMLSchema::ComplexType.new(op_bind.soapoperation_name)
115:           message = messages[operation.input.message]
116:           type.sequence_elements = elements_from_message(message)
117:           types << type
118:         end
119:         if op_bind.output
120:           type = XMLSchema::ComplexType.new(operation.outputname)
121:           message = messages[operation.output.message]
122:           type.sequence_elements = elements_from_message(message)
123:           types << type
124:         end
125:       end
126:     end
127:     types
128:   end