import org.apache.xerces.xni.parser.XMLInputSource; //导入依赖的package包/类
private XSDResolver() {
	EXISchemaFactory exiSchemaFactory = new EXISchemaFactory();
	EXISchemaFactoryExceptionHandler esfe = new EXISchemaFactoryExceptionHandler();
	exiSchemaFactory.setCompilerErrorHandler(esfe);
	
	InputStream isV2GCIMsgDef = getClass().getResourceAsStream(GlobalValues.SCHEMA_PATH_MSG_DEF.toString());
	XMLInputSource xmlISV2GCIMsgDef = new XMLInputSource(null, null, null, isV2GCIMsgDef, null);
	
	InputStream isV2GCIMsgHeader = getClass().getResourceAsStream(GlobalValues.SCHEMA_PATH_MSG_HEADER.toString());
	XMLInputSource xmlISV2GCIMsgHeader = new XMLInputSource(null, null, null, isV2GCIMsgHeader, null);
	
	InputStream isV2GCIMsgBody = getClass().getResourceAsStream(GlobalValues.SCHEMA_PATH_MSG_BODY.toString());
	XMLInputSource xmlISV2GCIMsgBody = new XMLInputSource(null, null, null, isV2GCIMsgBody, null);
	
	InputStream isV2GCIMsgDataTypes = getClass().getResourceAsStream(GlobalValues.SCHEMA_PATH_MSG_DATA_TYPES.toString());
	XMLInputSource xmlISV2GCIMsgDataTypes = new XMLInputSource(null, null, null, isV2GCIMsgDataTypes, null);
	
	InputStream isXMLDSig = getClass().getResourceAsStream(GlobalValues.SCHEMA_PATH_XMLDSIG.toString());
	XMLInputSource xmlISXMLDSig = new XMLInputSource(null, null, null, isXMLDSig, null);
	
	setEntity("V2G_CI_MsgDef.xsd", xmlISV2GCIMsgDef);
	setEntity("V2G_CI_MsgBody.xsd", xmlISV2GCIMsgBody);
	setEntity("V2G_CI_MsgHeader.xsd", xmlISV2GCIMsgHeader);
	setEntity("V2G_CI_MsgDataTypes.xsd", xmlISV2GCIMsgDataTypes);
	setEntity("xmldsig-core-schema.xsd", xmlISXMLDSig);
}
 

import org.apache.xerces.xni.parser.XMLInputSource; //导入依赖的package包/类
@Override
public XMLInputSource resolveEntity(XMLResourceIdentifier resourceIdentifier) throws XNIException, IOException {
	//logger.info("Resolving entity for: " + resourceIdentifier.getExpandedSystemId() + " namespace " + resourceIdentifier.getNamespace());
	
	try{
		URI originalURI = new URI(resourceIdentifier.getExpandedSystemId());
		if(xbrlSchemaRemap.containsKey(originalURI)){
			URI newURI = xbrlSchemaRemap.get(originalURI);
			
			return new XMLInputSource(null, newURI.toString(), newURI.toString(), fileCache.getFileInputStream(newURI.toString()), null);
		}
	}
	catch(URISyntaxException e){
		
	}
	
	return new XMLInputSource(resourceIdentifier.getPublicId(), 
			resourceIdentifier.getExpandedSystemId(), 
			resourceIdentifier.getExpandedSystemId(), 
			fileCache.getFileInputStream(resourceIdentifier.getExpandedSystemId()), 
			null);

}
 

import org.apache.xerces.xni.parser.XMLInputSource; //导入依赖的package包/类
/**
 * Parse a grammar from a location identified by an
 * XMLInputSource.
 * This method also adds this grammar to the XMLGrammarPool
 *
 * @param type The type of the grammar to be constructed
 * @param is The XMLInputSource containing this grammar's
 * information
 * <strong>If a URI is included in the systemId field, the parser will not expand this URI or make it
 * available to the EntityResolver</strong>
 * @return The newly created <code>Grammar</code>.
 * @exception XNIException thrown on an error in grammar
 * construction
 * @exception IOException thrown if an error is encountered
 * in reading the file
 */
public Grammar preparseGrammar(String type, XMLInputSource
            is) throws XNIException, IOException {
    if (fLoaders.containsKey(type)) {
        XMLGrammarLoaderContainer xglc = (XMLGrammarLoaderContainer) fLoaders.get(type);
        XMLGrammarLoader gl = xglc.loader;
        if (xglc.modCount != fModCount) {
            // make sure gl's been set up with all the "basic" properties:
            gl.setProperty(SYMBOL_TABLE, fSymbolTable);
            gl.setProperty(ENTITY_RESOLVER, fEntityResolver);
            gl.setProperty(ERROR_REPORTER, fErrorReporter);
            // potentially, not all will support this one...
            if (fGrammarPool != null) {
                try {
                    gl.setProperty(GRAMMAR_POOL, fGrammarPool);
                } catch(Exception e) {
                    // too bad...
                }
            }
            xglc.modCount = fModCount;
        }
        return gl.loadGrammar(is);
    }
    return null;
}
 

import org.apache.xerces.xni.parser.XMLInputSource; //导入依赖的package包/类
DTDGrammar parseDTD(XMLInputSource is) 
            throws IOException {
    XMLEntityResolver resolver = getEntityResolver();
    if(resolver != null) {
        fDTDLoader.setEntityResolver(resolver);
    }
    fDTDLoader.setProperty(ERROR_REPORTER, fErrorReporter);

    // Should check whether the grammar with this namespace is already in
    // the grammar resolver. But since we don't know the target namespace
    // of the document here, we leave such check to the application...
    DTDGrammar grammar = (DTDGrammar)fDTDLoader.loadGrammar(is);
    // by default, hand it off to the grammar pool
    if (grammar != null) {
        fGrammarPool.cacheGrammars(XMLGrammarDescription.XML_DTD,
                                  new Grammar[]{grammar});
    }
    
    return grammar;

}
 

import org.apache.xerces.xni.parser.XMLInputSource; //导入依赖的package包/类
/**
 * Creates an XMLInputSource from a SAX InputSource.
 */
private XMLInputSource createXMLInputSource(InputSource source, String baseURI) {
 
    String publicId = source.getPublicId();
    String systemId = source.getSystemId();
    String baseSystemId = baseURI;
    InputStream byteStream = source.getByteStream();
    Reader charStream = source.getCharacterStream();
    String encoding = source.getEncoding();
    XMLInputSource xmlInputSource =
        new XMLInputSource(publicId, systemId, baseSystemId);
    xmlInputSource.setByteStream(byteStream);
    xmlInputSource.setCharacterStream(charStream);
    xmlInputSource.setEncoding(encoding);
    return xmlInputSource;
    
}
 

import org.apache.xerces.xni.parser.XMLInputSource; //导入依赖的package包/类
private static XMLInputSource saxToXMLInputSource(InputSource sis) {
    String publicId = sis.getPublicId();
    String systemId = sis.getSystemId();
    
    Reader charStream = sis.getCharacterStream();
    if (charStream != null) {
        return new XMLInputSource(publicId, systemId, null, charStream,
                null);
    }
    
    InputStream byteStream = sis.getByteStream();
    if (byteStream != null) {
        return new XMLInputSource(publicId, systemId, null, byteStream,
                sis.getEncoding());
    }
    
    return new XMLInputSource(publicId, systemId, null);
}
 

import org.apache.xerces.xni.parser.XMLInputSource; //导入依赖的package包/类
private void validateAnnotations(ArrayList annotationInfo) {
    if (fAnnotationValidator == null) {
        createAnnotationValidator();
    }
    final int size = annotationInfo.size();
    final XMLInputSource src = new XMLInputSource(null, null, null);
    fGrammarBucketAdapter.refreshGrammars(fGrammarBucket);
    for (int i = 0; i < size; i += 2) {
        src.setSystemId((String) annotationInfo.get(i));
        XSAnnotationInfo annotation = (XSAnnotationInfo) annotationInfo.get(i+1);
        while (annotation != null) {
            src.setCharacterStream(new StringReader(annotation.fAnnotation));
            try {
                fAnnotationValidator.parse(src);
            }
            catch (IOException exc) {}
            annotation = annotation.next;
        }
    }
}
 

import org.apache.xerces.xni.parser.XMLInputSource; //导入依赖的package包/类
private Element resolveSchema(XMLInputSource schemaSource, XSDDescription desc,
        boolean mustResolve, Element 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.xni.parser.XMLInputSource; //导入依赖的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.xni.parser.XMLInputSource; //导入依赖的package包/类
/**
 * Error handling code shared between the various getSchemaDocument() methods.
 */
private Element getSchemaDocument1(boolean mustResolve, boolean hasInput, 
        XMLInputSource schemaSource, Element referElement, IOException ioe) {
    // either an error occured (exception), or empty input source was
    // returned, we need to report an error or a warning
    if (mustResolve) {
        if (hasInput) {
            reportSchemaError("schema_reference.4",
                    new Object[]{schemaSource.getSystemId()},
                    referElement, ioe);
        }
        else {
            reportSchemaError("schema_reference.4",
                    new Object[]{schemaSource == null ? "" : schemaSource.getSystemId()},
                    referElement, ioe);
        }
    }
    else if (hasInput) {
        reportSchemaWarning("schema_reference.4",
                new Object[]{schemaSource.getSystemId()},
                referElement, ioe);
    }
    
    fLastSchemaWasDuplicate = false;
    return null;
}
 

import org.apache.xerces.xni.parser.XMLInputSource; //导入依赖的package包/类
/**
 * This method tries to open the necessary stream for the given
 * XMLInputSource. If the input source already has a character
 * stream (java.io.Reader) or a byte stream (java.io.InputStream)
 * set, this method returns immediately. However, if no character
 * or byte stream is already open, this method attempts to open
 * an input stream using the source's system identifier.
 *
 * @param source The input source to open.
 */
protected void openInputSourceStream(XMLInputSource source)
    throws IOException {
    if (source.getCharacterStream() != null) {
        return;
    }
    InputStream stream = source.getByteStream();
    if (stream == null) {
        String systemId = source.getSystemId();
        try {
            URL url = new URL(systemId);
            stream = url.openStream();
        }
        catch (MalformedURLException e) {
            stream = new FileInputStream(systemId);
        }
        source.setByteStream(stream);
    }
}
 

import org.apache.xerces.xni.parser.XMLInputSource; //导入依赖的package包/类
@Override
public XMLInputSource resolveEntity(XMLResourceIdentifier identifier)
		throws XNIException, IOException {

	String systemId = identifier.getExpandedSystemId();
	String redirectedSystemId = systemId != null ? redirect(systemId)
			: null;
	LOG.debug("'" + systemId + "' -> '" + redirectedSystemId + "'");
	if (redirectedSystemId != null
			&& redirectedSystemId.startsWith("https:")) {
		InputStream is = UrlUtils.open(new URL(redirectedSystemId));
		return new XMLInputSource(null, systemId, redirectedSystemId, is,
				null);
	}
	return new XMLInputSource(null, redirectedSystemId, null);
}
 

import org.apache.xerces.xni.parser.XMLInputSource; //导入依赖的package包/类
@Override
public void endElement(QName element, Augmentations augs) throws XNIException {
  if (currentOsmlTag != null && "script".equalsIgnoreCase(element.rawname)) {
    QName endingTag = currentOsmlTag;
    currentOsmlTag = null;

    XMLInputSource scriptSource = new XMLInputSource(null, null, null);
    scriptSource.setCharacterStream(new StringReader(scriptContent.toString()));
    scriptContent.setLength(0);

    // Evaluate the content of the script block immediately
    scanner.evaluateInputSource(scriptSource);

    super.endElement(endingTag, augs);
  } else {
    super.endElement(element, augs);
  }
}
 

import org.apache.xerces.xni.parser.XMLInputSource; //导入依赖的package包/类
public void setEntity(String literalSystemId, XMLInputSource xmlInput) {
	if (xmlInputSourceEntities == null) {
		xmlInputSourceEntities = new HashMap<String, XMLInputSource>();
	}
	
	xmlInputSourceEntities.put(literalSystemId, xmlInput);
}
 

import org.apache.xerces.xni.parser.XMLInputSource; //导入依赖的package包/类
@Override
public XMLInputSource resolveEntity(XMLResourceIdentifier resourceIdentifier) 
		throws XNIException, IOException {
	String literalSystemId = resourceIdentifier.getLiteralSystemId(); 
	
	if (xmlInputSourceEntities != null && xmlInputSourceEntities.containsKey(literalSystemId)) {
		return xmlInputSourceEntities.get(literalSystemId);
	}

	return null;
}
 

import org.apache.xerces.xni.parser.XMLInputSource; //导入依赖的package包/类
@Override
public XMLInputSource resolveEntity(XMLResourceIdentifier resourceIdentifier) throws XNIException, IOException {
    XMLInputSource entity = catalogResolver.resolveEntity(resourceIdentifier);
    if (entity == null) {
        LOGGER.info("Could not resolve entity: {}", resourceIdentifier.getBaseSystemId());
        LOGGER.info("Identifer: {}", catalogResolver.resolveIdentifier(resourceIdentifier));
        return null;
    }
    LOGGER.info("Resolve entity: {} --> {}", resourceIdentifier.getBaseSystemId(), entity.getBaseSystemId());
    return entity;
}
 

import org.apache.xerces.xni.parser.XMLInputSource; //导入依赖的package包/类
public Schema createSchema(SAXSource source, PropertyMap properties)
        throws IOException, SAXException, IncorrectSchemaException {
  SymbolTable symbolTable = new SymbolTable();
  XMLGrammarPreparser preparser = new XMLGrammarPreparser(symbolTable);
  XMLGrammarPool grammarPool = new XMLGrammarPoolImpl();
  preparser.registerPreparser(XMLGrammarDescription.XML_SCHEMA, null);
  preparser.setGrammarPool(grammarPool);
  ErrorHandler eh = properties.get(ValidateProperty.ERROR_HANDLER);
  SAXXMLErrorHandler xeh = new SAXXMLErrorHandler(eh);
  preparser.setErrorHandler(xeh);
  EntityResolver er = properties.get(ValidateProperty.ENTITY_RESOLVER);
  if (er != null)
    preparser.setEntityResolver(new EntityResolverWrapper(er));
  try {
    preparser.preparseGrammar(XMLGrammarDescription.XML_SCHEMA, toXMLInputSource(source.getInputSource()));
    Name attributeOwner = properties.get(WrapProperty.ATTRIBUTE_OWNER);
    if (attributeOwner != null) {
      Reader r = new StringReader(createWrapper(attributeOwner));
 	preparser.preparseGrammar(XMLGrammarDescription.XML_SCHEMA,
                                new XMLInputSource(null, null, null, r, null));
    }
  }
  catch (XNIException e) {
    throw ValidatorImpl.toSAXException(e);
  }
  if (xeh.getHadError())
    throw new IncorrectSchemaException();
  return new SchemaImpl(new SynchronizedSymbolTable(symbolTable),
                        new CachingParserPool.SynchronizedGrammarPool(grammarPool),
                        properties,
                        supportedPropertyIds);
}
 

import org.apache.xerces.xni.parser.XMLInputSource; //导入依赖的package包/类
private static XMLInputSource toXMLInputSource(InputSource in) {
  XMLInputSource xin = new XMLInputSource(in.getPublicId(), in.getSystemId(), null);
  xin.setByteStream(in.getByteStream());
  xin.setCharacterStream(in.getCharacterStream());
  xin.setEncoding(in.getEncoding());
  return xin;
}
 

import org.apache.xerces.xni.parser.XMLInputSource; //导入依赖的package包/类
/**
 * <p>Attempt to locate an external subset for a document that does not otherwise
 * have one. If an external subset is located, then it is scanned.</p>
 */
protected void resolveExternalSubsetAndRead()
    throws IOException, XNIException {
    
    fDTDDescription.setValues(null, null, fEntityManager.getCurrentResourceIdentifier().getExpandedSystemId(), null);
    fDTDDescription.setRootName(fElementQName.rawname);
    XMLInputSource src = fExternalSubsetResolver.getExternalSubset(fDTDDescription);
    
    if (src != null) {
        fDoctypeName = fElementQName.rawname;
        fDoctypePublicId = src.getPublicId();
        fDoctypeSystemId = src.getSystemId();
        // call document handler
        if (fDocumentHandler != null) {
            // This inserts a doctypeDecl event into the stream though no 
            // DOCTYPE existed in the instance document.
            fDocumentHandler.doctypeDecl(fDoctypeName, fDoctypePublicId, fDoctypeSystemId, null);
        }
        try {
            if (fValidationManager == null || !fValidationManager.isCachedDTD()) {
                fDTDScanner.setInputSource(src);
                while (fDTDScanner.scanDTDExternalSubset(true));
            }
            else {
                // This sends startDTD and endDTD calls down the pipeline.
                fDTDScanner.setInputSource(null);
            }
        }
        finally {
            fEntityManager.setEntityHandler(XMLDocumentScannerMMImpl.this);
        }
    }
}
 

import org.apache.xerces.xni.parser.XMLInputSource; //导入依赖的package包/类
public static WSDLValidationInfo validate(XMLInputSource xmlInputSource) throws Exception {
	XMLGrammarPreparser preparser = new XMLGrammarPreparser();
	preparser.registerPreparser(XMLGrammarDescription.XML_SCHEMA, null);
       preparser.setFeature(NAMESPACES_FEATURE_ID, true);
       preparser.setFeature(VALIDATION_FEATURE_ID, true);
       preparser.setFeature(SCHEMA_VALIDATION_FEATURE_ID, true);
       WSDLValidationInfo validationInfo = new WSDLValidationInfo();
       preparser.setErrorHandler(new ErrorHandler(validationInfo));
       preparser.preparseGrammar(XMLGrammarDescription.XML_SCHEMA, xmlInputSource);
       return validationInfo;
}