WSDL::XMLSchema::ComplexType

 
               # File 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
            

 
               # File wsdl/xmlSchema/complexType.rb, line 95
def all_elements=(elements)
  @content = All.new
  elements.each do |element|
    @content << element
  end
end
            

 
               # File 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
            

 
               # File 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
            

 
               # File 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
            

 
               # File wsdl/soap/complexType.rb, line 18
def compoundtype
  @compoundtype ||= check_type
end
            

 
               # File 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
            

 
               # File wsdl/xmlSchema/complexType.rb, line 45
def elementformdefault
  parent.elementformdefault
end
            

 
               # File 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
            

 
               # File 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
            

 
               # File 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
            

 
               # File 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
            

 
               # File 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
            

 
               # File 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
            

 
               # File wsdl/xmlSchema/complexType.rb, line 88
def sequence_elements=(elements)
  @content = Sequence.new
  elements.each do |element|
    @content << element
  end
end
            

 
               # File 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