How to use

getSchemaType

method

in

org.apache.ws.commons.schema.XmlSchemaElement

 @Override
public List<QName> getChildElementNames(QName parentElementName) {
  XmlSchemaElement element = xmlSchemaCollection.getElementByQName(parentElementName);
  XmlSchemaType type = element != null ? element.getSchemaType() : null;

  List<QName> result = new LinkedList<>();
  if (type instanceof XmlSchemaComplexType) {
    addElementNames(result, (XmlSchemaComplexType) type);
  }
  return result;
}

/**
 * Extracts the schema type from the given element.
 * @param cparams The common parameters used in the schema generator
 * @param element The element the type will be extract from
 * @return The element type
 */
private static XmlSchemaComplexType extractElementSchemaType(CommonParams cparams,
    XmlSchemaElement element) {
  XmlSchemaComplexType type = (XmlSchemaComplexType) element.getSchemaType();
  /* if null, this must be globally defined */
  if (type == null) {
    type = cparams.getTypeMap().get(element.getSchemaTypeName());
  }
  return type;
}

protected XmlSchemaComplexType getComplexTypeForElement(XmlSchema xmlSchema, QName name) {
  for (XmlSchemaObject object : xmlSchema.getItems()) {
    if (object instanceof XmlSchemaElement && ((XmlSchemaElement) object).getQName().equals(name)) {
      XmlSchemaComplexType xmlSchemaComplexType = (XmlSchemaComplexType) ((XmlSchemaElement) object).getSchemaType();
      if ((xmlSchemaComplexType == null) && (((XmlSchemaElement) object).getSchemaTypeName() != null)) {
        xmlSchemaComplexType =
            (XmlSchemaComplexType) xmlSchema.getTypeByName(((XmlSchemaElement) object).getSchemaTypeName());
      }
      return xmlSchemaComplexType;
    }
  }
  return null;
}

/**
 * Checks whether a given element is a binary element
 *
 * @param elt
 */
private boolean isBinary(XmlSchemaElement elt) {
  return elt.getSchemaType() != null &&
      SchemaConstants.XSD_BASE64.equals(elt.getSchemaType().getQName());
}

protected XmlSchemaComplexType getComplexTypeForElement(XmlSchema xmlSchema, QName name) {
  for (XmlSchemaObject object : xmlSchema.getItems()) {
    if (object instanceof XmlSchemaElement && ((XmlSchemaElement) object).getQName().equals(name)) {
      XmlSchemaComplexType xmlSchemaComplexType = (XmlSchemaComplexType) ((XmlSchemaElement) object).getSchemaType();
      if ((xmlSchemaComplexType == null) && (((XmlSchemaElement) object).getSchemaTypeName() != null)) {
        xmlSchemaComplexType =
            (XmlSchemaComplexType) xmlSchema.getTypeByName(((XmlSchemaElement) object).getSchemaTypeName());
      }
      return xmlSchemaComplexType;
    }
  }
  return null;
}

/**
 * Checks whether a given element is a binary element
 *
 * @param elt
 */
private boolean isBinary(XmlSchemaElement elt) {
  return elt.getSchemaType() != null &&
      SchemaConstants.XSD_BASE64.equals(elt.getSchemaType().getQName());
}

private static void factorySetupType(XmlSchemaElement element, SchemaCollection schemaCollection,
                   ParticleInfo elementInfo) {
  elementInfo.type = element.getSchemaType();
  if (elementInfo.type == null) {
    if (element.getSchemaTypeName() == null // no type at all -> anyType
      || element.getSchemaTypeName().equals(Constants.XSD_ANYTYPE)) {
      elementInfo.anyType = true;
    } else {
      elementInfo.type = schemaCollection.getTypeByQName(element.getSchemaTypeName());
      if (elementInfo.type == null
        && !element.getSchemaTypeName()
            .getNamespaceURI().equals(Constants.URI_2001_SCHEMA_XSD)) {
        JavascriptUtils.unsupportedConstruct("MISSING_TYPE", element.getSchemaTypeName()
            .toString(), element.getQName(), element);
      }
    }
  } else if (elementInfo.type.getQName() != null
    && Constants.XSD_ANYTYPE.equals(elementInfo.type.getQName())) {
    elementInfo.anyType = true;
  }
}

private XmlSchemaElement getWrappedSchema(Message message)
{
  Part part = (Part) message.getParts().values().iterator().next();
  
  XmlSchemaElement schemaEl = schemas.getElementByQName(part.getElementName());
  
  if (schemaEl.getSchemaType() instanceof XmlSchemaComplexType)
    return schemaEl;
  
  return null;
}
 

private void addGlobalElement(final XmlSchemaElement element) {
  // Nested anonymous type
  QName xmlType = element.getSchemaTypeName();
  if (xmlType == null) {
    // Rule 1.b: Anonymous type inside an element ">E"
    xmlType = new QName(element.getQName().getNamespaceURI(), ">" + element.getQName().getLocalPart());
    addType(xmlType, element.getSchemaType());
  }
  // create the XmlElementInfo
  final XmlElementInfo elementInfo = createXmlElementInfo(element.getQName(), xmlType, element);
  xmlElements.put(element.getQName(), elementInfo);
}

private static XmlSchemaComplexType getRowNameBasedSchemaComplexType(
    XmlSchemaComplexType wrapperSchemaComplexType) {
  return (((XmlSchemaComplexType) ((XmlSchemaElement) ((XmlSchemaSequence) wrapperSchemaComplexType
      .getParticle()).getItems().getItem(0)).getSchemaType()));
}
 

private void addElementCrossImportsElement(XmlSchema schema, XmlSchemaElement item) {
  XmlSchemaElement element = item;
  XmlSchemaUtils.addImportIfNeeded(schema, element.getRef().getTargetQName());
  XmlSchemaUtils.addImportIfNeeded(schema, element.getSchemaTypeName());
  // if there's an anonymous type, it might have element refs in it.
  XmlSchemaType schemaType = element.getSchemaType();
  if (!crossImportsAdded(schema, schemaType)) {
    addCrossImportsType(schema, schemaType);
  }
}

public static XmlSchemaType getXmlSchemaType(ServiceInfo serviceInfo, QName name) {
  XmlSchemaType result = null;
  if ((name != null) && (serviceInfo != null)) {
    SchemaCollection col = serviceInfo.getXmlSchemaCollection();
    result = col.getTypeByQName(name);
    if (result == null) {
      //check the name, if it is an element
      XmlSchemaElement el = col.getElementByQName(name);
      if (el != null) {
        result = el.getSchemaType();
      }
    }
  }
  return result;
}

private void addElementCrossImportsElement(XmlSchema schema, XmlSchemaElement item) {
  XmlSchemaElement element = item;
  XmlSchemaUtils.addImportIfNeeded(schema, element.getRef().getTargetQName());
  XmlSchemaUtils.addImportIfNeeded(schema, element.getSchemaTypeName());
  // if there's an anonymous type, it might have element refs in it.
  XmlSchemaType schemaType = element.getSchemaType();
  if (!crossImportsAdded(schema, schemaType)) {
    addCrossImportsType(schema, schemaType);
  }
}

protected XmlSchemaType lookUpType(Part part) {
  XmlSchemaType schemaType = null;
  for (XmlSchema xmlSchema : xmlSchemaList.getXmlSchemas()) {
    if (part.getElementName() != null) {
      XmlSchemaElement schemaElement = xmlSchema.getElementByName(part.getElementName());
      if (schemaElement != null) {
        schemaType = schemaElement.getSchemaType();
      }
    } else {
      if (part.getTypeName() != null) {
        schemaType = xmlSchema.getTypeByName(part.getTypeName());
      }
    }
    if (schemaType != null) {
      return schemaType;
    }
  }
  return schemaType;
}

private void addElementCrossImportsElement(XmlSchema schema, XmlSchemaElement item) {
  XmlSchemaElement element = item;
  XmlSchemaUtils.addImportIfNeeded(schema, element.getRef().getTargetQName());
  XmlSchemaUtils.addImportIfNeeded(schema, element.getSchemaTypeName());
  // if there's an anonymous type, it might have element refs in it.
  XmlSchemaType schemaType = element.getSchemaType();
  if (!crossImportsAdded(schema, schemaType)) {
    addCrossImportsType(schema, schemaType);
  }
}

private static ElementInfo getElementInfo(XmlSchemaElement element) {
  if (element == null) {
    return null;
  }
  ElementInfo elementInfo = new ElementInfo(element.getQName(), getTypeInfo(element.getSchemaType()));
  elementInfo.setMany(element.getMaxOccurs() > 1);
  elementInfo.setNillable(element.isNillable());
  elementInfo.setOmissible(element.getMinOccurs()==0);
  return elementInfo;
}

private void addElementCrossImportsElement(XmlSchema schema, XmlSchemaElement item) {
  XmlSchemaElement element = (XmlSchemaElement)item;
  XmlSchemaUtils.addImportIfNeeded(schema, element.getRef().getTargetQName());
  XmlSchemaUtils.addImportIfNeeded(schema, element.getSchemaTypeName());
  // if there's an anonymous type, it might have element refs in it.
  XmlSchemaType schemaType = element.getSchemaType();
  if (!crossImportsAdded(schema, schemaType)) {
    addCrossImportsType(schema, schemaType);
  }
}

private static ElementInfo getElementInfo(XmlSchemaElement element) {
  if (element == null) {
    return null;
  }
  ElementInfo elementInfo = new ElementInfo(element.getQName(), getTypeInfo(element.getSchemaType()));
  elementInfo.setMany(element.getMaxOccurs() > 1);
  elementInfo.setNillable(element.isNillable());
  elementInfo.setOmissible(element.getMinOccurs()==0);
  return elementInfo;
}

private void addElementCrossImportsElement(XmlSchema schema, XmlSchemaElement item) {
  XmlSchemaElement element = item;
  XmlSchemaUtils.addImportIfNeeded(schema, element.getRef().getTargetQName());
  XmlSchemaUtils.addImportIfNeeded(schema, element.getSchemaTypeName());
  // if there's an anonymous type, it might have element refs in it.
  XmlSchemaType schemaType = element.getSchemaType();
  if (!crossImportsAdded(schema, schemaType)) {
    addCrossImportsType(schema, schemaType);
  }
}

private XSDType getElementDataType(QName elementName, XmlSchemaCollection collection, PortType portType, IntrospectionContext context) {
  XmlSchemaElement element = collection.getElementByQName(elementName);
  if (element == null) {
    SchemaTypeNotFound error = new SchemaTypeNotFound("Schema type " + elementName + " not found referenced in: " + portType.getQName());
    context.addError(error);
    return null;
  }
  XmlSchemaType type = element.getSchemaType();
  if (type == null) {
    SchemaTypeNotFound error = new SchemaTypeNotFound("Invalid schema type " + elementName + " referenced in: " + portType.getQName());
    context.addError(error);
    return null;
  }
  return createDataType(type, elementName);
}