package org.opendaylight.controller.sal.rest.impl;
import static com.google.common.base.Preconditions.checkArgument;
-
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import org.opendaylight.controller.sal.restconf.impl.SimpleNodeWrapper;
import org.opendaylight.yangtools.yang.data.api.Node;
+/**
+ * @deprecated class will be removed in Lithium release
+ */
+@Deprecated
public class XmlToCompositeNodeReader {
private final static XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
+ static {
+ xmlInputFactory.setProperty("javax.xml.stream.isSupportingExternalEntities", false);
+ }
private XMLEventReader eventReader;
- public CompositeNodeWrapper read(InputStream entityStream) throws XMLStreamException, UnsupportedFormatException,
- IOException {
- // Get an XML stream which can be marked, and reset, so we can check and
- // see if there is any content being provided.
+ public Node<?> read(InputStream entityStream) throws XMLStreamException,
+ UnsupportedFormatException,
+ IOException {
+ //Get an XML stream which can be marked, and reset, so we can check and see if there is
+ //any content being provided.
entityStream = getMarkableStream(entityStream);
if (isInputStreamEmpty(entityStream)) {
}
eventReader = xmlInputFactory.createXMLEventReader(entityStream);
-
if (eventReader.hasNext()) {
- XMLEvent element = eventReader.peek();
+ final XMLEvent element = eventReader.peek();
if (element.isStartDocument()) {
eventReader.nextEvent();
}
}
- if (eventReader.hasNext() && !isCompositeNodeEvent(eventReader.peek())) {
- throw new UnsupportedFormatException("Root element of XML has to be composite element.");
- }
-
final Stack<NodeWrapper<?>> processingQueue = new Stack<>();
- CompositeNodeWrapper root = null;
+ NodeWrapper<?> root = null;
NodeWrapper<?> element = null;
while (eventReader.hasNext()) {
final XMLEvent event = eventReader.nextEvent();
}
NodeWrapper<?> newNode = null;
if (isCompositeNodeEvent(event)) {
+ newNode = resolveCompositeNodeFromStartElement(startElement);
if (root == null) {
- root = resolveCompositeNodeFromStartElement(startElement);
- newNode = root;
- } else {
- newNode = resolveCompositeNodeFromStartElement(startElement);
+ root = newNode;
}
} else if (isSimpleNodeEvent(event)) {
+ newNode = resolveSimpleNodeFromStartElement(startElement);
if (root == null) {
- throw new UnsupportedFormatException("Root element of XML has to be composite element.");
+ root = newNode;
}
- newNode = resolveSimpleNodeFromStartElement(startElement);
}
if (newNode != null) {
throw new UnsupportedFormatException("XML should contain only one root element");
}
- return root;
+ return (Node<?>) root;
}
/**
return entityStream;
}
- private boolean isInputStreamEmpty(InputStream entityStream) throws IOException {
+ private boolean isInputStreamEmpty(final InputStream entityStream) throws IOException {
boolean isEmpty = false;
entityStream.mark(1);
if (entityStream.read() == -1) {
private boolean isSimpleNodeEvent(final XMLEvent event) throws XMLStreamException {
checkArgument(event != null, "XML Event cannot be NULL!");
if (event.isStartElement()) {
- XMLEvent innerEvent = skipCommentsAndWhitespace();
+ final XMLEvent innerEvent = skipCommentsAndWhitespace();
if (innerEvent != null && (innerEvent.isCharacters() || innerEvent.isEndElement())) {
return true;
}
private boolean isCompositeNodeEvent(final XMLEvent event) throws XMLStreamException {
checkArgument(event != null, "XML Event cannot be NULL!");
if (event.isStartElement()) {
- XMLEvent innerEvent = skipCommentsAndWhitespace();
+ final XMLEvent innerEvent = skipCommentsAndWhitespace();
if (innerEvent != null) {
if (innerEvent.isStartElement()) {
return true;
private XMLEvent skipCommentsAndWhitespace() throws XMLStreamException {
while (eventReader.hasNext()) {
- XMLEvent event = eventReader.peek();
+ final XMLEvent event = eventReader.peek();
if (event.getEventType() == XMLStreamConstants.COMMENT) {
eventReader.nextEvent();
continue;
}
if (event.isCharacters()) {
- Characters chars = event.asCharacters();
+ final Characters chars = event.asCharacters();
if (chars.isWhiteSpace()) {
eventReader.nextEvent();
continue;
private NodeWrapper<? extends Node<?>> resolveSimpleNodeFromStartElement(final StartElement startElement)
throws XMLStreamException {
checkArgument(startElement != null, "Start Element cannot be NULL!");
- String data = getValueOf(startElement);
+ final String data = getValueOf(startElement);
if (data == null) {
return new EmptyNodeWrapper(getNamespaceFor(startElement), getLocalNameFor(startElement));
}
resolveValueOfElement(data, startElement));
}
- private String getValueOf(StartElement startElement) throws XMLStreamException {
+ private String getValueOf(final StartElement startElement) throws XMLStreamException {
String data = null;
if (eventReader.hasNext()) {
final XMLEvent innerEvent = eventReader.peek();
return data == null ? null : data.trim();
}
- private String getAdditionalData(XMLEvent event) throws XMLStreamException {
+ private String getAdditionalData(final XMLEvent event) throws XMLStreamException {
String data = "";
if (eventReader.hasNext()) {
final XMLEvent innerEvent = eventReader.peek();
return data;
}
- private String getLocalNameFor(StartElement startElement) {
+ private String getLocalNameFor(final StartElement startElement) {
return startElement.getName().getLocalPart();
}
- private URI getNamespaceFor(StartElement startElement) {
- String namespaceURI = startElement.getName().getNamespaceURI();
+ private URI getNamespaceFor(final StartElement startElement) {
+ final String namespaceURI = startElement.getName().getNamespaceURI();
return namespaceURI.isEmpty() ? null : URI.create(namespaceURI);
}
- private Object resolveValueOfElement(String value, StartElement startElement) {
+ private Object resolveValueOfElement(final String value, final StartElement startElement) {
// it could be instance-identifier Built-In Type
if (value.startsWith("/")) {
- IdentityValuesDTO iiValue = RestUtil.asInstanceIdentifier(value, new RestUtil.PrefixMapingFromXml(
+ final IdentityValuesDTO iiValue = RestUtil.asInstanceIdentifier(value, new RestUtil.PrefixMapingFromXml(
startElement));
if (iiValue != null) {
return iiValue;
}
}
// it could be identityref Built-In Type
- String[] namespaceAndValue = value.split(":");
+ final String[] namespaceAndValue = value.split(":");
if (namespaceAndValue.length == 2) {
- String namespace = startElement.getNamespaceContext().getNamespaceURI(namespaceAndValue[0]);
+ final String namespace = startElement.getNamespaceContext().getNamespaceURI(namespaceAndValue[0]);
if (namespace != null && !namespace.isEmpty()) {
return new IdentityValuesDTO(namespace, namespaceAndValue[1], namespaceAndValue[0], value);
}
Code Review / controller.git / blobdiff