public XSLoader createXSLoader(StringList versions) throws XSException { XSLoader loader = new XSLoaderImpl(); if (versions == null){ return loader; } for (int i=0; i<versions.getLength();i++){ if (!versions.item(i).equals("1.0")){ String msg = DOMMessageFormatter.formatMessage( DOMMessageFormatter.DOM_DOMAIN, "FEATURE_NOT_SUPPORTED", new Object[] { versions.item(i) }); throw new XSException(XSException.NOT_SUPPORTED_ERR, msg); } } return loader; }
private void addNewGrammarLocations(SchemaGrammar srcGrammar, SchemaGrammar dstGrammar) { final StringList locations = srcGrammar.getDocumentLocations(); final int locSize = locations.size(); final StringList locations2 = dstGrammar.getDocumentLocations(); for (int i=0; i<locSize; i++) { String loc = locations.item(i); if (!locations2.contains(loc)) { dstGrammar.addDocument(null, loc); } } }
XSObjectList facetList = xsSimpleType.getMultiValueFacets(); System.out.println("myDefinedType's facets: "); for(int i = 0; i < facetList.getLength(); i++) { XSMultiValueFacet facet = (XSMultiValueFacet ) facetList.item(i); System.out.println(" "+facetKindToString(facet.getFacetKind())); StringList strList = facet.getLexicalFacetValues(); System.out.println(" " + strList.item(0)); }
private void setLocationHints(XSDDescription desc, String[] locations, StringList docLocations) { int length = locations.length; String[] hints = new String[length]; int counter = 0; for (int i=0; i<length; i++) { if (!docLocations.contains(locations[i])) { hints[counter++] = locations[i]; } } if (counter > 0) { if (counter == length) { fXSDDescription.fLocationHints = hints; } else { fXSDDescription.fLocationHints = new String[counter]; System.arraycopy(hints, 0, fXSDDescription.fLocationHints, 0, counter); } } }
public static boolean checkEnumType(XSTypeDefinition td) { final XSSimpleTypeDefinition st; if (td.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) { XSComplexTypeDefinition ctd = (XSComplexTypeDefinition) td; if (ctd.getContentType() != XSComplexTypeDefinition.CONTENTTYPE_SIMPLE) { return false; } if (ctd.getAttributeUses() != null) { for (int i = 0; i < ctd.getAttributeUses().getLength(); i++) { XSSimpleTypeDefinition xsstd = ((XSAttributeUse) ctd.getAttributeUses() .item(i)).getAttrDeclaration() .getTypeDefinition(); if ("ID".equals(xsstd.getName())) { continue; } return false; } } st = ctd.getSimpleType(); } else if (td.getTypeCategory() == XSTypeDefinition.SIMPLE_TYPE) { st = (XSSimpleTypeDefinition) td; } else { return false; } return st.getLexicalEnumeration() != null && st.getLexicalEnumeration().getLength() != 0; }
private boolean isExistingGrammar(XSDDescription desc, boolean ignoreConflict) { SchemaGrammar sg = fGrammarBucket.getGrammar(desc.getTargetNamespace()); if (sg == null) { return findGrammar(desc, ignoreConflict) != null; } else if (sg.isImmutable()) { return true; } else { try { return sg.getDocumentLocations().contains(XMLEntityManager.expandSystemId(desc.getLiteralSystemId(), desc.getBaseSystemId(), false)); } catch (MalformedURIException e) { return false; } } }
/** * Get the TargetNamespace from the schema model */ public static String getTargetNamespace(XSModel xsmodel) { if (xsmodel == null) throw MESSAGES.illegalNullArgument("xsmodel"); String targetNS = null; StringList slist = xsmodel.getNamespaces(); int len = slist != null ? slist.getLength() : 0; for (int i = 0; i < len; i++) { String ns = slist.item(i); if (Constants.NS_SCHEMA_XSD.equals(ns)) continue; targetNS = ns; break; } return targetNS; }
if(namespaces.contains(targetNamespace))
private synchronized Map<String, List<String>> getNSMap() { if ( nsToLocations == null ) { nsToLocations = new LinkedHashMap<String, List<String>>(); XSNamespaceItemList nsItems = xsModel.getNamespaceItems(); for ( int i = 0; i < nsItems.getLength(); i++ ) { XSNamespaceItem nsItem = nsItems.item( i ); StringList locations = nsItem.getDocumentLocations(); List<String> loc = new ArrayList<String>( locations.getLength() ); for ( int j = 0; j < locations.getLength(); j++ ) { loc.add( locations.item( j ) ); } nsToLocations.put( nsItem.getSchemaNamespace(), loc ); } } return nsToLocations; }
public XSModel loadURIList(StringList uriList) { int length = uriList.getLength(); SchemaGrammar[] gs = new SchemaGrammar[length]; for (int i = 0; i < length; i++) { try { gs[i] = (SchemaGrammar) loadGrammar(new XMLInputSource(null, uriList.item(i), null)); } catch (Exception e) { reportDOMFatalError(e); return null; } } return new XSModelImpl(gs); }
if (fNamespaceGrowth) { try { if (isg.getDocumentLocations().contains(XMLEntityManager.expandSystemId(schemaHint, fSchemaGrammarDescription.getBaseSystemId(), false))) { continue; boolean alreadyTraversed = (fNamespaceGrowth) ? sg.getDocumentLocations().contains(schemaId) : false; if (!alreadyTraversed) { newSchemaRoot = resolveSchema(schemaSource, fSchemaGrammarDescription, mustResolve, child);
private void exportSimpleType( XMLStreamWriter writer, XSSimpleTypeDefinition simple ) throws XMLStreamException { writer.writeStartElement( "simpleType" ); if ( !simple.getAnonymous() ) { writer.writeAttribute( "name", simple.getName() ); } // TODO how can one find the derivation type? getFinal() is wrong! LOG.debug( "Exporting a simple type is done always by restriction. Other derivations may be possible?!" ); writer.writeStartElement( "restriction" ); QName qName = new QName( simple.getBaseType().getNamespace(), simple.getBaseType().getName() ); writer.writeAttribute( "base", getPrefixedName( qName ) ); StringList members = simple.getLexicalEnumeration(); if ( members != null && members.getLength() > 0 ) { for ( int i = 0; i < members.getLength(); i++ ) { writer.writeEmptyElement( "enumeration" ); writer.writeAttribute( "value", members.item( i ) ); } } writer.writeEndElement(); // derivation (restriction, extension, etc.) writer.writeEndElement(); // simpleType }
if (grammar.getDocumentLocations().contains(XMLEntityManager.expandSystemId(xis.getSystemId(), xis.getBaseSystemId(), false))) { toParseSchema = false;
private static List<String> getEnumeratedValues(XSSimpleTypeDefinition simpleType) { ArrayList<String> enums = new ArrayList<>(); XSObjectList facets = simpleType.getMultiValueFacets(); if (facets != null) { for (int i = 0; i < facets.getLength(); i++) { XSMultiValueFacet facet = (XSMultiValueFacet) facets.item(i); if (facet.getFacetKind() == XSSimpleTypeDefinition.FACET_ENUMERATION) { StringList values = facet.getLexicalFacetValues(); for (int j = 0; j < values.getLength(); j++) { enums.add(values.item(j)); } } } } return enums; }
case XSWildcard.NSCONSTRAINT_LIST: StringList list = wildcard.getNsConstraintList(); int rand = RandomUtil.random(0, list.getLength() - 1); uri = list.item(rand); if (uri == null) { uri = ""; // <xs:any namespace="##local"/> returns nsConstraintList with null list = wildcard.getNsConstraintList(); List<String> namespaces = new ArrayList<>(); for (int i = 0; i < list.getLength(); i++) { namespaces.add(list.item(i));
/** * Parses the content of XML Schema documents specified as the list of URI * references. If the URI contains a fragment identifier, the behavior * is not defined by this specification. * @param uriList The list of URI locations. * @return An XSModel representing the schema documents. */ public XSModel loadURIList(StringList uriList) { int length = uriList.getLength(); try { fGrammarPool.clear(); for (int i = 0; i < length; ++i) { fSchemaLoader.loadGrammar(new XMLInputSource(null, uriList.item(i), null)); } return fGrammarPool.toXSModel(); } catch (Exception e) { fSchemaLoader.reportDOMFatalError(e); return null; } }
else if(type.getLexicalPattern().item(0) != null && type.derivedFrom(Constants.NS_XML_SCHEMA, )) String item = type.getLexicalPattern().item(0); if(item.indexOf('0') != -1 && item.indexOf('1') != -1) if(lexicalEnumeration != null && lexicalEnumeration.getLength() > 0) List values = new ArrayList(lexicalEnumeration.getLength()); for(int i = 0; i < lexicalEnumeration.getLength(); ++i) values.add(lexicalEnumeration.item(i));