import org.apache.xerces.impl.xs.XMLSchemaLoader; //导入依赖的package包/类
/**
 * Constructs a parser configuration using the specified symbol table,
 * grammar pool, and parent settings.
 * <p>
 * <strong>REVISIT:</strong> 
 * Grammar pool will be updated when the new validation engine is
 * implemented.
 *
 * @param symbolTable    The symbol table to use.
 * @param grammarPool    The grammar pool to use.
 * @param parentSettings The parent settings.
 */
public XMLGrammarCachingConfiguration(SymbolTable symbolTable,
                                   XMLGrammarPool grammarPool,
                                   XMLComponentManager parentSettings) {
    super(symbolTable, grammarPool, parentSettings);

    // REVISIT:  may need to add some features/properties
    // specific to this configuration at some point...

    // add default recognized features
    // set state for default features
    // add default recognized properties
    // create and register missing components
    fSchemaLoader = new XMLSchemaLoader(fSymbolTable);
    fSchemaLoader.setProperty(XMLGRAMMAR_POOL, fGrammarPool);

    // and set up the DTD loader too:
    fDTDLoader = new XMLDTDLoader(fSymbolTable, fGrammarPool);
}
 

import org.apache.xerces.impl.xs.XMLSchemaLoader; //导入依赖的package包/类
private XMLInputSource resolveSchemaSource(XSDDescription desc, boolean mustResolve,
        Element referElement, boolean usePairs) {

    XMLInputSource schemaSource = null;
    try {
        Hashtable pairs = usePairs ? fLocationPairs : EMPTY_TABLE;
        schemaSource = XMLSchemaLoader.resolveDocument(desc, pairs, fEntityResolver);
    }
    catch (IOException ex) {
        if (mustResolve) {
            reportSchemaError("schema_reference.4",
                    new Object[]{desc.getLocationHints()[0]},
                    referElement);
        }
        else {
            reportSchemaWarning("schema_reference.4",
                    new Object[]{desc.getLocationHints()[0]},
                    referElement);
        }
    }
    
    return schemaSource;
}
 

import org.apache.xerces.impl.xs.XMLSchemaLoader; //导入依赖的package包/类
private XbrlTaxonomy loadMissingTaxonomyFromKnownSchemas(String namespace, String name) throws XbrlException, IOException{

		XSNamedMap elementDeclarations = null;
		if(missingSchemaElementDeclarations.containsKey(namespace))
			elementDeclarations = missingSchemaElementDeclarations.get(namespace);
		else if(knownSchemaMapping.containsKey(namespace)){
			XMLSchemaLoader schemaLoader = new XMLSchemaLoader();
			schemaLoader.setEntityResolver(loader);
			schemaLoader.setFeature("http://apache.org/xml/features/generate-synthetic-annotations", true);
			//URI targetLink = loader.getBaseURIResolver().getBaseURI().resolve(knownSchemaMapping.get(namespace));
			String cachedFilePath = this.loader.getFileCache().getCachedFilePath(knownSchemaMapping.get(namespace));
			String uri = new File(cachedFilePath).toURI().toString();
			XSModel xbrlSchemaModel = schemaLoader.loadURI(uri);
			schemaToNamespaceMap.put(knownSchemaMapping.get(namespace), namespace);
			
			elementDeclarations = xbrlSchemaModel.getComponents(XSConstants.ELEMENT_DECLARATION);
			if(elementDeclarations != null)
				missingSchemaElementDeclarations.put(namespace, elementDeclarations);
		}
		
		if(elementDeclarations != null){
			XSElementDeclaration elementDec = (XSElementDeclaration)elementDeclarations.itemByName(namespace, name);
			if(elementDec != null){
				XbrlTaxonomy xbrlTaxonomy = parseXbrlTaxonomy(elementDec);
				
				if(xbrlTaxonomy != null){
					xbrlConceptCache.put(xbrlTaxonomy.getIdentifier(), xbrlTaxonomy);
					return xbrlTaxonomy;
				}
			}
		}
		return null;
	}
 

import org.apache.xerces.impl.xs.XMLSchemaLoader; //导入依赖的package包/类
/**
 * resolveSchema method is responsible for resolving location of the schema (using XMLEntityResolver),
 * and if it was succefully resolved getting the schema Document.
 * @param desc
 * @param mustResolve
 * @param referElement
 * @return A schema Element or null.
 */
private Element resolveSchema(XSDDescription desc, boolean mustResolve,
                              Element referElement, boolean usePairs) {
    XMLInputSource schemaSource = null;
    try {
        Hashtable pairs = usePairs ? fLocationPairs : EMPTY_TABLE;
        schemaSource = XMLSchemaLoader.resolveDocument(desc, pairs, fEntityResolver);
    }
    catch (IOException ex) {
        if (mustResolve) {
            reportSchemaError("schema_reference.4",
                    new Object[]{desc.getLocationHints()[0]},
                    referElement);
        }
        else {
            reportSchemaWarning("schema_reference.4",
                    new Object[]{desc.getLocationHints()[0]},
                    referElement);
        }
    }
    if (schemaSource instanceof DOMInputSource) {
        return getSchemaDocument(desc.getTargetNamespace(), (DOMInputSource) schemaSource, mustResolve, desc.getContextType(), referElement);    
    } // DOMInputSource
    else if (schemaSource instanceof SAXInputSource) {
        return getSchemaDocument(desc.getTargetNamespace(), (SAXInputSource) schemaSource, mustResolve, desc.getContextType(), referElement);         
    } // SAXInputSource
    else if (schemaSource instanceof StAXInputSource) {
        return getSchemaDocument(desc.getTargetNamespace(), (StAXInputSource) schemaSource, mustResolve, desc.getContextType(), referElement); 
    } // StAXInputSource
    else if (schemaSource instanceof XSInputSource) {
        return getSchemaDocument((XSInputSource) schemaSource, desc);
    } // XSInputSource
    return getSchemaDocument(desc.getTargetNamespace(), schemaSource, mustResolve, desc.getContextType(), referElement);
}
 

import org.apache.xerces.impl.xs.XMLSchemaLoader; //导入依赖的package包/类
public Schema createSchema(LSInput input) {
    ErrorHandler errorHandler = new ErrorHandler();

    XMLSchemaLoader loader = new XMLSchemaLoader();
    if (resolver != null)
        loader.setEntityResolver(new EntityResolver(resolver));

    loader.setErrorHandler(errorHandler);
    loader.setParameter(Constants.DOM_ERROR_HANDLER, errorHandler);

    XSModel model = loader.load(input);

    errorHandler.throwExceptionIfHasError();
    return createSchema(model);
}
 

import org.apache.xerces.impl.xs.XMLSchemaLoader; //导入依赖的package包/类
protected List<XSModel> getXSModels(List<nl.nn.adapterframework.validation.Schema> schemas) throws IOException, XMLStreamException, ConfigurationException {
	List<XSModel> result = new ArrayList<XSModel>();
	XMLSchemaLoader xsLoader = new XMLSchemaLoader();
	for (nl.nn.adapterframework.validation.Schema schema : schemas) {
		XSModel xsModel = xsLoader.loadURI(schema.getSystemId());
		result.add(xsModel);
	}
	return result;
}
 

import org.apache.xerces.impl.xs.XMLSchemaLoader; //导入依赖的package包/类
/**
 * @param args
 */
public static void main(String[] args)
{
   if (!args[0].equals("--dump"))
   {
      // Activates the resolver for Drb
      try
      {
         DrbFactoryResolver.setMetadataResolver (
               new DrbCortexMetadataResolver (
            DrbCortexModel.getDefaultModel ()));
      }
      catch (IOException e)
      {
         System.err.println ("Resolver cannot be handled.");
      }
      process(args[0]);
   }
   else
   {
   System.out.println("declare function local:deduplicate($list) {");
   System.out.println("  if (fn:empty($list)) then ()");
   System.out.println("  else");
   System.out.println("    let $head := $list[1],");
   System.out.println("      $tail := $list[position() > 1]");
   System.out.println("    return");
   System.out
         .println("      if (fn:exists($tail[ . = $head ])) then " +
               "local:deduplicate($tail)");
   System.out.println("      else ($head, local:deduplicate($tail))");
   System.out.println("};");
   System.out.println();
   System.out.println("declare function local:values($list) {");
   System.out
         .println("  fn:string-join(local:deduplicate(" +
               "fn:data($list)), ' ')");
   System.out.println("};");
   System.out.println();

   System.out.println("let $doc := !!!! GIVE PATH HERE !!!!");
   System.out.println("return\n(\n");

   /**
    * Open XML Schema
    */
   final XSLoader loader = new XMLSchemaLoader();

   final XSModel model = loader.loadURI(args[1]);

   XSNamedMap map = model.getComponents(XSConstants.ELEMENT_DECLARATION);

   if (map != null)
   {
      for (int j = 0; j < map.getLength(); j++)
      {
         dumpElement("", (XSElementDeclaration) map.item(j));
      }
   }

   System.out.println("\n) ^--- REMOVE LAST COMMA !!!");
   }
}