Java ElementOverNodeInfo类代码示例

import net.sf.saxon.dom.ElementOverNodeInfo; //导入依赖的package包/类
public static NodeInfo evaluateXPathToNode(ElementOverNodeInfo currentElement, String xPath) {
	if(xPath != null) {
		try {
			final SaxonNodeWrapper result = (SaxonNodeWrapper)createSaxonNodeWrapper(currentElement).evaluateXPathToNode(xPath);
			if (result != null) {
				return result.getNodeInfo(); 
			} else {
				return null;
			}
		} catch (Exception e) {
			logger.error(e, e);
			return null;
		}
	} else {
		return null;
	}
}
 

import net.sf.saxon.dom.ElementOverNodeInfo; //导入依赖的package包/类
private static XPathCache getXPathCache(ElementOverNodeInfo currentElement) {
	final Configuration elementConfig	= currentElement.getUnderlyingNodeInfo().getConfiguration();
	if ((xPathCache == null) || (!xPathCache.isCompatible(elementConfig))) {
		try {
			final BookCache 	bookCache 	= BookCacheHandler.getInstance().getBookCache(new URL(currentElement.getBaseURI()));
			final Configuration xPathConfig = bookCache.createConfiguration();
			xPathConfig.setNamePool(elementConfig.getNamePool());
			xPathConfig.setDocumentNumberAllocator(elementConfig.getDocumentNumberAllocator());
			xPathCache = new XPathCache(xPathConfig);
		} catch (MalformedURLException e) {
			logger.error(e, e);
			xPathCache = null;
		}
	}
	return xPathCache;
}
 

import net.sf.saxon.dom.ElementOverNodeInfo; //导入依赖的package包/类
public static String evaluateXPathToStringList(ElementOverNodeInfo currentElement, String xPath) {
	if(xPath != null) {
		try {
			return String.join(KeyDef.PATH_DELIMITER, createSaxonNodeWrapper(currentElement).evaluateXPathToStringList(xPath));
		} catch (Exception e) {
			logger.error(e, e);
			return null;
		}
	} else {
		return null;
	}
}
 

import net.sf.saxon.dom.ElementOverNodeInfo; //导入依赖的package包/类
public static String evaluateXPathToString(ElementOverNodeInfo currentElement, String xPath) {
	if(xPath != null) {
		try {
			return createSaxonNodeWrapper(currentElement).evaluateXPathToString(xPath);
		} catch (Exception e) {
			logger.error(e, e);
			return null;
		}
	} else {
		return null;
	}
}
 

import net.sf.saxon.dom.ElementOverNodeInfo; //导入依赖的package包/类
public static String getXPathListErrorMessage(ElementOverNodeInfo element, String xPath) {
	if (xPath != null) {
		try {
			createSaxonNodeWrapper(element).evaluateXPathToStringList(xPath);
			return null;
		} catch (Exception e) {
			logger.error(e, e);
			return e.getMessage();
		}
	} else {
		return null;
	}
}
 

import net.sf.saxon.dom.ElementOverNodeInfo; //导入依赖的package包/类
public static KeyDef createKeyDef(ElementOverNodeInfo currentElement) {
	try {
		return KeyDef.fromNode(createSaxonNodeWrapper(currentElement));
	} catch (Exception e) {
		logger.error(e, e);
		return null;
	}
}
 

import net.sf.saxon.dom.ElementOverNodeInfo; //导入依赖的package包/类
public static String getXPathErrorMessage(ElementOverNodeInfo currentElement, String xPath) {
	if (xPath != null) {
		try {
			createSaxonNodeWrapper(currentElement).evaluateXPathToString(xPath);
			return null;
		} catch (Exception e) {
			logger.error(e, e);
			return e.getMessage();
		}
	} else {
		return null;
	}
}
 

import net.sf.saxon.dom.ElementOverNodeInfo; //导入依赖的package包/类
public static String getXPathListErrorMessage(ElementOverNodeInfo currentElement, String xPath) {
	if (xPath != null) {
		try {
			createSaxonNodeWrapper(currentElement).evaluateXPathToStringList(xPath);
			return null;
		} catch (Exception e) {
			logger.error(e, e);
			return e.getMessage();
		}
	} else {
		return null;
	}
}
 

import net.sf.saxon.dom.ElementOverNodeInfo; //导入依赖的package包/类
protected static SaxonNodeWrapper createSaxonNodeWrapper(ElementOverNodeInfo currentElement) {
	NodeInfo node = currentElement.getUnderlyingNodeInfo();
	return new SaxonNodeWrapper(node, getXPathCache(currentElement));
}
 

import net.sf.saxon.dom.ElementOverNodeInfo; //导入依赖的package包/类
public static KeyRef createKeyRef(ElementOverNodeInfo element) {
	NodeInfo 			node 		= element.getUnderlyingNodeInfo();
	SaxonNodeWrapper 	nodeWrapper = new SaxonNodeWrapper(node, new XPathCache(node.getConfiguration()));
	return KeyRef.fromNode(nodeWrapper);
}
 

import net.sf.saxon.dom.ElementOverNodeInfo; //导入依赖的package包/类
public static String getKeyDefID(ElementOverNodeInfo element) {
	return KeyDef.fromNode(createSaxonNodeWrapper(element)).getDefId();
}
 

import net.sf.saxon.dom.ElementOverNodeInfo; //导入依赖的package包/类
@Override
public void afterPropertiesSet() throws Exception {
    this.testExprPattern = Pattern.compile(String.format(TEST_EXPR_PATTERN_FORMAT, this.doc.getUri().toString()));

    IndependentContext xpathContext = new IndependentContext(this.xpathCompiler.getUnderlyingStaticContext());

    Stream.of(((ElementOverNodeInfo) this.doc.getDocument().getDocumentElement()).getUnderlyingNodeInfo().getDeclaredNamespaces(null)).forEach(
        ns -> xpathContext.declareNamespace(ns.getPrefix(), ns.getURI()));

    xpathContext.declareNamespace(StringUtils.EMPTY, CrigttXmlNs.VALIDATE_VOCAB_STATIC_DOC_URI);

    this.valueSets = new LinkedHashMap<>();
    this.codes = MultiValueMap.multiValueMap(new LinkedHashMap<>());
    this.namedCodes = MultiValueMap.multiValueMap(new LinkedHashMap<>());
    this.codeSystemCodes = MultiValueMap.multiValueMap(new LinkedHashMap<>());
    this.namedCodeSystemCodes = MultiValueMap.multiValueMap(new LinkedHashMap<>());
    this.valueSetCodes = MultiValueMap.multiValueMap(new LinkedHashMap<>());
    this.namedValueSetCodes = MultiValueMap.multiValueMap(new LinkedHashMap<>());

    ElementOverNodeInfo systemElem;
    String valueSetId, codeSystemId, codeId, codeName;
    Code code;

    for (XdmNode systemNode : this.xpathCompiler.evaluateNodes(SYS_NODE_XPATH_EXPR, xpathContext, this.doc)) {
        this.valueSets.put(
            (valueSetId =
                (systemElem = ((ElementOverNodeInfo) NodeOverNodeInfo.wrap(systemNode.getUnderlyingNode())))
                    .getAttribute(VocabXmlNames.VALUE_SET_OID_ATTR_NAME)),
            new ValueSetImpl(valueSetId, systemElem.getAttribute(VocabXmlNames.VALUE_SET_NAME_ATTR_NAME), systemElem
                .getAttribute(VocabXmlNames.VALUE_SET_VERSION_ATTR_NAME)));

        for (ElementOverNodeInfo codeElem : Stream.of(this.xpathCompiler.evaluateNodes(VocabXmlNames.CODE_NODE_NAME, xpathContext, systemNode))
            .map(codeNode -> ((ElementOverNodeInfo) NodeOverNodeInfo.wrap(codeNode.getUnderlyingNode()))).toArray(ElementOverNodeInfo[]::new)) {
            codeSystemId = codeElem.getAttribute(VocabXmlNames.CODE_SYSTEM_ATTR_NAME);

            this.codes.put(new MultiKey<>(valueSetId, codeSystemId, (codeId = codeElem.getAttribute(VocabXmlNames.VALUE_ATTR_NAME))), (code =
                new CodeImpl(codeId, (codeName = codeElem.getAttribute(VocabXmlNames.DISPLAY_NAME_ATTR_NAME)))));
            this.namedCodes.put(new MultiKey<>(valueSetId, codeSystemId, codeName), code);

            this.codeSystemCodes.put(new MultiKey<>(codeSystemId, codeId), code);
            this.namedCodeSystemCodes.put(new MultiKey<>(codeSystemId, codeName), code);

            this.valueSetCodes.put(new MultiKey<>(valueSetId, codeId), code);
            this.namedValueSetCodes.put(new MultiKey<>(valueSetId, codeName), code);
        }
    }

    super.afterPropertiesSet();
}