import net.sf.saxon.om.DocumentInfo; //导入依赖的package包/类
public Document convertToDocument(String xml) throws XQException {
  	
  	String baseURI = sqc.getBaseURI(); 
      StringReader sr = new StringReader(xml);
      InputSource is = new InputSource(sr);
      is.setSystemId(baseURI);
      Source source = new SAXSource(is);
      source.setSystemId(baseURI);
      
      try {
      	DocumentInfo doc = config.buildDocument(source);
      	return (Document) DocumentOverNodeInfo.wrap(doc);
} catch (XPathException ex) {
	throw new XQException(ex.getMessage());
}
  }
 

import net.sf.saxon.om.DocumentInfo; //导入依赖的package包/类
/**
 * Reads in the first part of an XML file, stopping at the first
 * close-element marker. Generally this captures enough information to
 * identify which kind of XML data is inside the file.
 * @throws IOException if the file can't be read
 * @throws XPathException if the document cannot be parsed
 */
public static DocumentInfo readXMLStub(XPathContext context, String filePath)
  throws IOException, XPathException
{
  // First, locate the file
  File file = resolveFile(context, filePath);
  if (!file.canRead())
    throw new IOException("Cannot read file '" + file.toString() + "'");
  
  // Now read it in, up to the first close-element marker.
  XMLStubReader xmlReader = new XMLStubReader();
  BufferedInputStream bufStream = new BufferedInputStream(new FileInputStream(file));
  InputSource inputSrc = new InputSource(bufStream);
  inputSrc.setSystemId(file.toURI().toString());
  Source saxSrc = new SAXSource(xmlReader, inputSrc);
  DocumentInfo doc = context.getConfiguration().buildDocument(saxSrc);
  return doc;
}
 

import net.sf.saxon.om.DocumentInfo; //导入依赖的package包/类
/**
 * Reads in an HTML page (specified by URL), and uses JTidy to make it into
 * XML that can be subsequently processed by a stylesheet.
 * 
 * @throws IOException if the file can't be read
 * @throws XPathException if the document cannot be parsed
 */
public static DocumentInfo readHTMLPage(XPathContext context, String urlStr)
  throws IOException, XPathException
{
  // Read the HTML page, and convert it to an XML string
  URL url;
  URLConnection connection;
  InputStream inStream = null;
  String pageStr;
  try {
    url = new URL(urlStr);
    connection = url.openConnection();
    inStream = connection.getInputStream();
    pageStr = HTMLToString.convert(inStream);
  }
  finally {
    if (inStream != null)
      inStream.close();
  }
  
  // And convert that string to an in-memory XML document.
  DocumentInfo doc = context.getConfiguration().buildDocument(
      new StreamSource(new StringReader(pageStr), urlStr));
  return doc;
}
 

import net.sf.saxon.om.DocumentInfo; //导入依赖的package包/类
/**
 * Optimized to use node test directly when possible, for speed.
 */
protected void constructIndex(DocumentInfo doc, Map index,
                            KeyDefinition keydef,
                            BuiltInAtomicType soughtItemType,
                            Set foundItemTypes, XPathContext context,
                            boolean isFirst)
  throws XPathException 
{
  PatternFinder match = keydef.getMatch();
  if (match instanceof NodeTestPattern) {
    match = new FastNodeTestPattern(((NodeTestPattern)match).getNodeTest());
    KeyDefinition oldDef = keydef;
    keydef = new KeyDefinition(match, 
                               oldDef.getUse(),
                               oldDef.getCollationName(), 
                               oldDef.getCollation());
  }
  super.constructIndex(doc, index, keydef, soughtItemType,
                       foundItemTypes, context, isFirst);
}
 

import net.sf.saxon.om.DocumentInfo; //导入依赖的package包/类
@Converter
public static Document toDOMDocument(NodeInfo node) throws XPathException {
    switch (node.getNodeKind()) {
    case Type.DOCUMENT:
        // DOCUMENT type nodes can be wrapped directly
        return (Document) NodeOverNodeInfo.wrap(node);
    case Type.ELEMENT:
        // ELEMENT nodes need to build a new DocumentInfo before wrapping
        Configuration config = node.getConfiguration();
        DocumentInfo documentInfo = config.buildDocument(node);
        return (Document) NodeOverNodeInfo.wrap(documentInfo);
    default:
        return null;
    }
}
 

import net.sf.saxon.om.DocumentInfo; //导入依赖的package包/类
/**
    * Get the root node, if it is a document node.
    *
    * @return the DocumentInfo representing the containing document.
    */

public DocumentInfo getDocumentRoot() {
	if (docWrapper.node instanceof Document) {
           return docWrapper;
       } else {
           return null;
       }
}
 

import net.sf.saxon.om.DocumentInfo; //导入依赖的package包/类
@Override
public XdmDocument build(Source src) throws SaxonApiException {
    return new XdmDocument(((DocumentInfo) super.build(src).getUnderlyingNode()), src.getSystemId());
}
 

import net.sf.saxon.om.DocumentInfo; //导入依赖的package包/类
public SequenceIterator selectNodes(DocumentInfo doc, final XPathContext context) 
  throws XPathException 
{
  if (getNodeKind() == Type.ELEMENT)
    return doc.iterateAxis(Axis.DESCENDANT, getNodeTest());
  return super.selectNodes(doc, context);
}
 

import net.sf.saxon.om.DocumentInfo; //导入依赖的package包/类
/**
 * Creates a dynamic context for the given exchange
 */
protected DynamicQueryContext createDynamicContext(Exchange exchange) throws Exception {
    Configuration config = getConfiguration();
    DynamicQueryContext dynamicQueryContext = new DynamicQueryContext(config);

    Message in = exchange.getIn();
    Item item = null;
    if (ObjectHelper.isNotEmpty(getHeaderName())) {
        item = in.getHeader(getHeaderName(), Item.class);
    } else {
        item = in.getBody(Item.class);
    }
    if (item != null) {
        dynamicQueryContext.setContextItem(item);
    } else {
        Object body = null;
        if (ObjectHelper.isNotEmpty(getHeaderName())) {
            body = in.getHeader(getHeaderName());
        } else {
            body = in.getBody();
        }

        // the underlying input stream, which we need to close to avoid locking files or other resources
        InputStream is = null;
        try {
            Source source;
            // only convert to input stream if really needed
            if (isInputStreamNeeded(exchange)) {
                if (ObjectHelper.isNotEmpty(getHeaderName())) {
                    is = exchange.getIn().getHeader(getHeaderName(), InputStream.class);
                } else {
                    is = exchange.getIn().getBody(InputStream.class);
                }
                source = getSource(exchange, is);
            } else {
                source = getSource(exchange, body);
            }

            // special for bean invocation
            if (source == null) {
                if (body instanceof BeanInvocation) {
                    // if its a null bean invocation then handle that
                    BeanInvocation bi = exchange.getContext().getTypeConverter().convertTo(BeanInvocation.class, body);
                    if (bi.getArgs() != null && bi.getArgs().length == 1 && bi.getArgs()[0] == null) {
                        // its a null argument from the bean invocation so use null as answer
                        source = null;
                    }
                }
            }

            if (source == null) {
                // indicate it was not possible to convert to a Source type
                throw new NoTypeConversionAvailableException(body, Source.class);
            }

            DocumentInfo doc = config.buildDocument(source);
            dynamicQueryContext.setContextItem(doc);
        } finally {
            // can deal if is is null
            IOHelper.close(is);
        }
    }
    
    configureQuery(dynamicQueryContext, exchange);
    // call the reset if the in message body is StreamCache
    MessageHelper.resetStreamCache(exchange.getIn());
    return dynamicQueryContext;
}
 

import net.sf.saxon.om.DocumentInfo; //导入依赖的package包/类
public XdmDocument(DocumentInfo docInfo) {
    this(docInfo, null);
}
 

import net.sf.saxon.om.DocumentInfo; //导入依赖的package包/类
@Override
public DocumentInfo getUnderlyingNode() {
    return ((DocumentInfo) super.getUnderlyingNode());
}
 

import net.sf.saxon.om.DocumentInfo; //导入依赖的package包/类
@Override
public XdmDocument getXdmNode() {
    return new XdmDocument(((DocumentInfo) super.getXdmNode().getUnderlyingNode()));
}
 

import net.sf.saxon.om.DocumentInfo; //导入依赖的package包/类
/** Loads the real node and defers to it */
public @Override DocumentInfo getDocumentRoot() {
  return real().getDocumentRoot();
}
 

import net.sf.saxon.om.DocumentInfo; //导入依赖的package包/类
/**
 * Get the root (document) node
 * @return the DocumentInfo representing the containing document
 */
public @Override DocumentInfo getDocumentRoot() {
  return element.document.getDocumentRoot();
}
 

import net.sf.saxon.om.DocumentInfo; //导入依赖的package包/类
/**
 * Get the root (document) node
 * @return the DocumentInfo representing the document node, or null if the
 * root of the tree is not a document node
 */
public DocumentInfo getDocumentRoot() {
  return ((rootNodeNum == nodeNum) ? this : null);
}
 

import net.sf.saxon.om.DocumentInfo; //导入依赖的package包/类
/**
 * Get the root (document) node
 *
 * @return the DocumentInfo representing the containing document
 */
public DocumentInfo getDocumentRoot() {
  return getParent().getDocumentRoot();
}
 

import net.sf.saxon.om.DocumentInfo; //导入依赖的package包/类
/**
 * Get the root (document) node
 * @return the DocumentInfo representing the containing document
 */
public DocumentInfo getDocumentRoot() {
  return element.document.getDocumentRoot();
}
 

import net.sf.saxon.om.DocumentInfo; //导入依赖的package包/类
/**
 * Constructs a DocumentInfo Node from the given classpath resource
 * @param fileName
 * @return
 * @throws XPathException
 */
public static DocumentInfo nodeFromFile(String fileName) throws XPathException {
    //TODO If we ever want custom configuration, we'll need to pass the processor from the XQueryContext into here...
    return new Processor(false).getUnderlyingConfiguration().buildDocument(new StreamSource(SaxonHelpers.class.getResourceAsStream(fileName)));
}