All Downloads are FREE. Search and download functionalities are using the official Maven repository.
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.picketlink.common.util.StaxParserUtil Maven / Gradle / Ivy
/*
* JBoss, Home of Professional Open Source
*
* Copyright 2013 Red Hat, Inc. and/or its affiliates.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.picketlink.common.util;
import org.picketlink.common.PicketLinkLogger;
import org.picketlink.common.PicketLinkLoggerFactory;
import org.picketlink.common.constants.GeneralConstants;
import org.picketlink.common.constants.JBossSAMLConstants;
import org.picketlink.common.constants.JBossSAMLURIConstants;
import org.picketlink.common.exceptions.ConfigurationException;
import org.picketlink.common.exceptions.ParsingException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import javax.xml.namespace.QName;
import javax.xml.stream.Location;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.Attribute;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.stax.StAXSource;
import javax.xml.validation.Validator;
import java.io.InputStream;
import static org.picketlink.common.ErrorCodes.EXPECTED_XSI;
/**
* Utility for the stax based parser
*
* @author [email protected]
* @since Feb 8, 2010
*/
public class StaxParserUtil {
private static final PicketLinkLogger logger = PicketLinkLoggerFactory.getLogger();
protected static Validator validator = null;
/**
* Bypass an entire XML element block from startElement to endElement
*
* @param xmlEventReader
* @param tag Tag of the XML element that we need to bypass
*
* @throws ParsingException
*/
public static void bypassElementBlock(XMLEventReader xmlEventReader, String tag) throws ParsingException {
while (xmlEventReader.hasNext()) {
EndElement endElement = getNextEndElement(xmlEventReader);
if (endElement == null)
return;
if (StaxParserUtil.matches(endElement, tag))
return;
}
}
/**
* Given an {@code Attribute}, get its trimmed value
*
* @param attribute
*
* @return
*/
public static String getAttributeValue(Attribute attribute) {
String str = trim(attribute.getValue());
str = StringUtil.getSystemPropertyAsString(str);
return str;
}
/**
* Get the Attribute value
*
* @param startElement
* @param tag localpart of the qname of the attribute
*
* @return
*/
public static String getAttributeValue(StartElement startElement, String tag) {
String result = null;
Attribute attr = startElement.getAttributeByName(new QName(tag));
if (attr != null)
result = getAttributeValue(attr);
return result;
}
/**
* Given that the {@code XMLEventReader} is in {@code XMLStreamConstants.START_ELEMENT} mode, we parse into a DOM
* Element
*
* @param xmlEventReader
*
* @return
*
* @throws ParsingException
*/
public static Element getDOMElement(XMLEventReader xmlEventReader) throws ParsingException {
Transformer transformer = null;
final String JDK_TRANSFORMER_PROPERTY = "picketlink.jdk.transformer";
boolean useJDKTransformer = Boolean.parseBoolean(SecurityActions.getSystemProperty(JDK_TRANSFORMER_PROPERTY, "false"));
try {
if (useJDKTransformer) {
transformer = TransformerUtil.getTransformer();
} else {
transformer = TransformerUtil.getStaxSourceToDomResultTransformer();
}
Document resultDocument = DocumentUtil.createDocument();
DOMResult domResult = new DOMResult(resultDocument);
Source source = new StAXSource(xmlEventReader);
TransformerUtil.transform(transformer, source, domResult);
Document doc = (Document) domResult.getNode();
return doc.getDocumentElement();
} catch (ConfigurationException e) {
throw logger.parserException(e);
} catch (XMLStreamException e) {
throw logger.parserException(e);
}
}
/**
* Get the element text.
*
* @param xmlEventReader
*
* @return A trimmed string value
*
* @throws ParsingException
*/
public static String getElementText(XMLEventReader xmlEventReader) throws ParsingException {
String str = null;
try {
str = xmlEventReader.getElementText().trim();
str = StringUtil.getSystemPropertyAsString(str);
} catch (XMLStreamException e) {
throw logger.parserException(e);
}
return str;
}
/**
* Get the XML event reader
*
* @param is
*
* @return
*/
public static XMLEventReader getXMLEventReader(InputStream is) {
XMLInputFactory xmlInputFactory = null;
XMLEventReader xmlEventReader = null;
try {
xmlInputFactory = getXMLInputFactory();
xmlInputFactory.setProperty(XMLInputFactory.IS_REPLACING_ENTITY_REFERENCES, Boolean.TRUE);
xmlInputFactory.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, Boolean.FALSE);
xmlInputFactory.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, Boolean.TRUE);
xmlInputFactory.setProperty(XMLInputFactory.IS_COALESCING, Boolean.TRUE);
xmlEventReader = xmlInputFactory.createXMLEventReader(is);
} catch (Exception ex) {
throw new RuntimeException(ex);
}
return xmlEventReader;
}
/**
* Given a {@code Location}, return a formatted string [lineNum,colNum]
*
* @param location
*
* @return
*/
public static String getLineColumnNumber(Location location) {
StringBuilder builder = new StringBuilder("[");
builder.append(location.getLineNumber()).append(",").append(location.getColumnNumber()).append("]");
return builder.toString();
}
/**
* Get the next xml event
*
* @param xmlEventReader
*
* @return
*
* @throws ParsingException
*/
public static XMLEvent getNextEvent(XMLEventReader xmlEventReader) throws ParsingException {
try {
return xmlEventReader.nextEvent();
} catch (XMLStreamException e) {
throw logger.parserException(e);
}
}
/**
* Get the next {@code StartElement }
*
* @param xmlEventReader
*
* @return
*
* @throws ParsingException
*/
public static StartElement getNextStartElement(XMLEventReader xmlEventReader) throws ParsingException {
try {
while (xmlEventReader.hasNext()) {
XMLEvent xmlEvent = xmlEventReader.nextEvent();
if (xmlEvent == null || xmlEvent.isStartElement())
return (StartElement) xmlEvent;
}
} catch (XMLStreamException e) {
throw logger.parserException(e);
}
return null;
}
/**
* Get the next {@code EndElement}
*
* @param xmlEventReader
*
* @return
*
* @throws ParsingException
*/
public static EndElement getNextEndElement(XMLEventReader xmlEventReader) throws ParsingException {
try {
while (xmlEventReader.hasNext()) {
XMLEvent xmlEvent = xmlEventReader.nextEvent();
if (xmlEvent == null || xmlEvent.isEndElement())
return (EndElement) xmlEvent;
}
} catch (XMLStreamException e) {
throw logger.parserException(e);
}
return null;
}
/**
* Return the name of the start element
*
* @param startElement
*
* @return
*/
public static String getStartElementName(StartElement startElement) {
return trim(startElement.getName().getLocalPart());
}
/**
* Return the name of the end element
*
* @param endElement
*
* @return
*/
public static String getEndElementName(EndElement endElement) {
return trim(endElement.getName().getLocalPart());
}
/**
* Given a start element, obtain the xsi:type defined
*
* @param startElement
*
* @return
*
* @throws RuntimeException if xsi:type is missing
*/
public static String getXSITypeValue(StartElement startElement) {
Attribute xsiType = startElement.getAttributeByName(new QName(JBossSAMLURIConstants.XSI_NSURI.get(),
JBossSAMLConstants.TYPE.get()));
if (xsiType == null)
throw logger.parserExpectedXSI(EXPECTED_XSI);
return StaxParserUtil.getAttributeValue(xsiType);
}
/**
* Return whether the next event is going to be text
*
* @param xmlEventReader
*
* @return
*
* @throws ParsingException
*/
public static boolean hasTextAhead(XMLEventReader xmlEventReader) throws ParsingException {
XMLEvent event = peek(xmlEventReader);
return event.getEventType() == XMLEvent.CHARACTERS;
}
/**
* Match that the start element with the expected tag
*
* @param startElement
* @param tag
*
* @return boolean if the tags match
*/
public static boolean matches(StartElement startElement, String tag) {
String elementTag = getStartElementName(startElement);
return tag.equals(elementTag);
}
/**
* Match that the end element with the expected tag
*
* @param endElement
* @param tag
*
* @return boolean if the tags match
*/
public static boolean matches(EndElement endElement, String tag) {
String elementTag = getEndElementName(endElement);
return tag.equals(elementTag);
}
/**
* Peek at the next event
*
* @param xmlEventReader
*
* @return
*
* @throws ParsingException
*/
public static XMLEvent peek(XMLEventReader xmlEventReader) throws ParsingException {
try {
return xmlEventReader.peek();
} catch (XMLStreamException e) {
throw logger.parserException(e);
}
}
/**
* Peek the next {@code StartElement }
*
* @param xmlEventReader
*
* @return
*
* @throws ParsingException
*/
public static StartElement peekNextStartElement(XMLEventReader xmlEventReader) throws ParsingException {
try {
while (true) {
XMLEvent xmlEvent = xmlEventReader.peek();
if (xmlEvent == null || xmlEvent.isStartElement())
return (StartElement) xmlEvent;
else
xmlEvent = xmlEventReader.nextEvent();
}
} catch (XMLStreamException e) {
throw logger.parserException(e);
}
}
/**
* Peek the next {@code EndElement}
*
* @param xmlEventReader
*
* @return
*
* @throws ParsingException
*/
public static EndElement peekNextEndElement(XMLEventReader xmlEventReader) throws ParsingException {
try {
while (true) {
XMLEvent xmlEvent = xmlEventReader.peek();
if (xmlEvent == null || xmlEvent.isEndElement())
return (EndElement) xmlEvent;
else
xmlEvent = xmlEventReader.nextEvent();
}
} catch (XMLStreamException e) {
throw logger.parserException(e);
}
}
/**
* Given a string, trim it
*
* @param str
*
* @return
*
* @throws {@code IllegalArgumentException} if the passed str is null
*/
public static final String trim(String str) {
if (str == null)
throw logger.nullArgumentError("String to trim");
return str.trim();
}
/**
* Validate that the start element has the expected tag
*
* @param startElement
* @param tag
*
* @throws RuntimeException mismatch
*/
public static void validate(StartElement startElement, String tag) {
String foundElementTag = getStartElementName(startElement);
if (!tag.equals(foundElementTag))
throw logger.parserExpectedTag(tag, foundElementTag);
}
/**
* Validate that the end element has the expected tag
*
* @param endElement
* @param tag
*
* @throws RuntimeException mismatch
*/
public static void validate(EndElement endElement, String tag) {
String elementTag = getEndElementName(endElement);
if (!tag.equals(elementTag))
throw new RuntimeException(logger.parserExpectedEndTag(". Found "));
}
private static XMLInputFactory getXMLInputFactory() {
boolean tccl_jaxp = SystemPropertiesUtil.getSystemProperty(GeneralConstants.TCCL_JAXP, "false")
.equalsIgnoreCase("true");
ClassLoader prevTCCL = SecurityActions.getTCCL();
try {
if (tccl_jaxp) {
SecurityActions.setTCCL(StaxParserUtil.class.getClassLoader());
}
return XMLInputFactory.newInstance();
} finally {
if (tccl_jaxp) {
SecurityActions.setTCCL(prevTCCL);
}
}
}
}
