*/
package org.opendaylight.yangtools.yang.data.api.schema;
-import javax.xml.transform.dom.DOMSource;
import org.opendaylight.yangtools.yang.data.api.AttributesContainer;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.Node;
/**
* Anyxml normalizedNode.
+ *
+ * <p>
+ * This node contains values for anyxml as either SimpleNode or CompositeNode.
+ * The concrete value depends on the current value of anyxml node.
+ * </p>
+ *
+ * <p>
+ * For yang node: anyxml foo;
+ *
+ * <ul>
+ * <li>
+ * with xml value:
+ * <pre>
+ * {@code <foo>justSomeString</foo>}
+ * </pre>
+ * this AnyXmlNode returns SimpleNode with QName{namespace=someNamespace, revision=someRevision, localName=foo} and value="justSomeString"
+ * </li>
+ *
+ * <li>
+ * but with xml value:
+ * <pre>
+ * {@code <foo><bar>stringInXml</bar></foo>}
+ * </pre>
+ * this AnyXmlNode returns CompositeNode with QName{}namespace=someNamespace, revision=someRevision, localName=foo}
+ * and values [SimpleNode with QName{}namespace=someNamespace, revision=someRevision, localName=bar} and value="stringInXml"]
+ * </li>
+ *
+ * </ul>
*/
-public interface AnyXmlNode extends AttributesContainer, DataContainerChild<NodeIdentifier, DOMSource> {
+public interface AnyXmlNode extends AttributesContainer, DataContainerChild<NodeIdentifier, Node<?>> {
@Override
NodeIdentifier getIdentifier();
/**
- * @return anyxml node value represented as DOMSource.
- * Returned source contains top level element that duplicates the anyxml node.
+ * @return anyxml node value represented as SimpleNode or CompositeNode.
+ * Returned node contains top level element that duplicates the anyxml node.
*/
@Override
- DOMSource getValue();
+ Node<?> getValue();
}
context.emittingChild(codecs.getSchemaContext(), writer);
context.writeChildJsonIdentifier(codecs.getSchemaContext(), writer, name.getNodeType());
- // FIXME this kind of serialization is incorrect since the value for AnyXml is now a DOMSource
writer.value(String.valueOf(value));
}
*/
package org.opendaylight.yangtools.yang.data.composite.node.schema.cnsn.parser;
-import javax.xml.transform.dom.DOMSource;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.AnyXmlNodeBaseParser;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
}
@Override
- protected DOMSource parseAnyXml(Node<?> element, AnyXmlSchemaNode schema) {
- // This will be removed
- return null;
+ protected Node<?> parseAnyXml(Node<?> element, AnyXmlSchemaNode schema) {
+ return element;
}
}
@Override
protected Node<?> serializeAnyXml(AnyXmlNode node) {
- // This should be removed along with composite nodes
- return null;
+ return node.getValue();
}
}
.withNodeIdentifier(getNodeIdentifier(MODULE_AUGMENT, "lf31"))
.withValue("value in leaf in augment").build()).build()).build());
-// containerBuilder.withChild(Builders
-// .anyXmlBuilder()
-// .withNodeIdentifier(getNodeIdentifier("anxml-composite"))
-// .withValue(
-// ImmutableCompositeNode
-// .builder()
-// .setQName(QName.create("simple:container:yang", "2013-11-12", "anxml-composite"))
-// .add(NodeFactory.createImmutableSimpleNode(
-// QName.create("simple:container:yang", "2013-11-12", "anxml-cont"), null, null))
-// .build()).build());
-//
-// containerBuilder
-// .withChild(Builders
-// .anyXmlBuilder()
-// .withNodeIdentifier(getNodeIdentifier("anxml-simple"))
-// .withValue(
-// NodeFactory.createImmutableSimpleNode(
-// QName.create("simple:container:yang", "2013-11-12", "anxml-simple"), null, 43))
-// .build());
+ containerBuilder.withChild(Builders
+ .anyXmlBuilder()
+ .withNodeIdentifier(getNodeIdentifier("anxml-composite"))
+ .withValue(
+ ImmutableCompositeNode
+ .builder()
+ .setQName(QName.create("simple:container:yang", "2013-11-12", "anxml-composite"))
+ .add(NodeFactory.createImmutableSimpleNode(
+ QName.create("simple:container:yang", "2013-11-12", "anxml-cont"), null, null))
+ .build()).build());
+
+ containerBuilder
+ .withChild(Builders
+ .anyXmlBuilder()
+ .withNodeIdentifier(getNodeIdentifier("anxml-simple"))
+ .withValue(
+ NodeFactory.createImmutableSimpleNode(
+ QName.create("simple:container:yang", "2013-11-12", "anxml-simple"), null, 43))
+ .build());
ContainerNode build = containerBuilder.build();
return build;
package org.opendaylight.yangtools.yang.data.composite.node.schema.parser;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import java.net.URISyntaxException;
-import java.util.ArrayList;
-import java.util.Set;
import org.junit.Before;
-import org.junit.Ignore;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
-@Ignore
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Set;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
public class Bug2180Test {
private Module simpleContainerModule;
private Module bug2111TestModule;
import static org.junit.Assert.assertEquals;
-import org.junit.Ignore;
import org.opendaylight.yangtools.yang.data.composite.node.schema.cnsn.parser.CnSnToNormalizedNodeParserFactory;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
-@Ignore
public class ParseCnSnStructToNormalizedStructTest {
private static DataSchemaNode resolvedDataSchemaNode;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import org.junit.Ignore;
import org.opendaylight.yangtools.yang.data.composite.node.schema.cnsn.serializer.CnSnFromNormalizedNodeSerializerFactory;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
-@Ignore
public class SerializeNormalizedStructToCnSnStructTest {
private static DataSchemaNode resolvedDataSchemaNode;
schema = ((NotificationDefinition) parent);
}
} else if(parent instanceof ChoiceNode) {
- schema = findChildInCases((ChoiceNode) parent, qname);
+ for(final ChoiceCaseNode caze : ((ChoiceNode) parent).getCases()) {
+ final DataSchemaNode potential = caze.getDataChildByName(qname);
+ if(potential != null) {
+ schema = potential;
+ break;
+ }
+ }
} else {
throw new IllegalStateException("Unsupported schema type "+ parent.getClass() +" on stack.");
}
return schema;
}
- private SchemaNode findChildInCases(final ChoiceNode parent, final QName qname) {
- DataSchemaNode schema = null;
- for(final ChoiceCaseNode caze : parent.getCases()) {
- final DataSchemaNode potential = caze.getDataChildByName(qname);
- if(potential != null) {
- schema = potential;
- break;
- }
- }
- return schema;
- }
-
- private SchemaNode findCaseByChild(final ChoiceNode parent, final QName qname) {
- DataSchemaNode schema = null;
- for(final ChoiceCaseNode caze : parent.getCases()) {
- final DataSchemaNode potential = caze.getDataChildByName(qname);
- if(potential != null) {
- schema = caze;
- break;
- }
- }
- return schema;
- }
-
public void startList(final PathArgument name) {
final SchemaNode schema = getSchema(name);
Preconditions.checkArgument(schema instanceof ListSchemaNode, "Node %s is not a list", schema.getPath());
public AugmentationSchema startAugmentationNode(final AugmentationIdentifier identifier) {
LOG.debug("Enter augmentation {}", identifier);
- Object parent = getParent();
+ final Object parent = getParent();
Preconditions.checkArgument(parent instanceof AugmentationTarget, "Augmentation not allowed under %s", parent);
- if(parent instanceof ChoiceNode) {
- final QName name = Iterables.get(identifier.getPossibleChildNames(), 0);
- parent = findCaseByChild((ChoiceNode) parent, name);
- }
Preconditions.checkArgument(parent instanceof DataNodeContainer, "Augmentation allowed only in DataNodeContainer",parent);
final AugmentationSchema schema = SchemaUtils.findSchemaForAugment((AugmentationTarget) parent, identifier.getPossibleChildNames());
final HashSet<DataSchemaNode> realChildSchemas = new HashSet<>();
import com.google.common.base.Preconditions;
import java.io.IOException;
-import java.io.StringWriter;
-import javax.xml.namespace.NamespaceContext;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
-import javax.xml.transform.OutputKeys;
-import javax.xml.transform.Transformer;
-import javax.xml.transform.TransformerException;
-import javax.xml.transform.TransformerFactory;
-import javax.xml.transform.TransformerFactoryConfigurationError;
-import javax.xml.transform.dom.DOMSource;
-import javax.xml.transform.stax.StAXResult;
-import javax.xml.transform.stream.StreamResult;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.w3c.dom.Element;
/**
* A {@link NormalizedNodeStreamWriter} which translates the events into an
*/
public final class XMLStreamNormalizedNodeStreamWriter implements NormalizedNodeStreamWriter {
- private static final TransformerFactory TRANSFORMER_FACTORY = TransformerFactory.newInstance();
-
private final XMLStreamWriter writer;
private final SchemaTracker tracker;
private final XmlStreamUtils streamUtils;
@Override
public void anyxmlNode(final NodeIdentifier name, final Object value) throws IOException {
final AnyXmlSchemaNode schema = tracker.anyxmlNode(name);
- if (value != null) {
- Preconditions.checkArgument(value instanceof DOMSource, "AnyXML value must be DOMSource, not %s", value);
- final QName qname = schema.getQName();
- final DOMSource domSource = (DOMSource) value;
- Preconditions.checkNotNull(domSource.getNode());
- Preconditions.checkArgument(domSource.getNode().getNodeName().equals(qname.getLocalName()));
- Preconditions.checkArgument(domSource.getNode().getNamespaceURI().equals(qname.getNamespace().toString()));
- try {
- // TODO can the transformer be a constant ? is it thread safe ?
- final Transformer transformer = TRANSFORMER_FACTORY.newTransformer();
- // Writer has to be wrapped in a wrapper that ignores endDocument event
- // EndDocument event forbids any other modification to the writer so a nested anyXml breaks serialization
- transformer.transform(domSource, new StAXResult(new DelegateWriterNoEndDoc(writer)));
- } catch (final TransformerException e) {
- throw new IOException("Unable to transform anyXml(" + name + ") value: " + value, e);
- }
- }
- }
-
- public static String toString(final Element xml) {
+ final QName qname = schema.getQName();
try {
- final Transformer transformer = TransformerFactory.newInstance().newTransformer();
- transformer.setOutputProperty(OutputKeys.INDENT, "yes");
-
- final StreamResult result = new StreamResult(new StringWriter());
- final DOMSource source = new DOMSource(xml);
- transformer.transform(source, result);
-
- return result.getWriter().toString();
- } catch (IllegalArgumentException | TransformerFactoryConfigurationError | TransformerException e) {
- throw new RuntimeException("Unable to serialize xml element " + xml, e);
+ writeStartElement(qname);
+ if (value != null) {
+ streamUtils.writeValue(writer, (Node<?>)value, schema);
+ }
+ writer.writeEndElement();
+ } catch (XMLStreamException e) {
+ throw new IOException("Failed to emit element", e);
}
}
throw new IOException("Failed to flush writer", e);
}
}
-
- /**
- * Delegate writer that ignores writeEndDocument event. Used for AnyXml serialization.
- */
- private static final class DelegateWriterNoEndDoc implements XMLStreamWriter {
- private final XMLStreamWriter writer;
-
- public DelegateWriterNoEndDoc(final XMLStreamWriter writer) {
- this.writer = writer;
- }
-
- @Override
- public void writeStartElement(final String localName) throws XMLStreamException {
- writer.writeStartElement(localName);
- }
-
- @Override
- public void writeStartElement(final String namespaceURI, final String localName) throws XMLStreamException {
- writer.writeStartElement(namespaceURI, localName);
- }
-
- @Override
- public void writeStartElement(final String prefix, final String localName, final String namespaceURI) throws XMLStreamException {
- writer.writeStartElement(prefix, localName, namespaceURI);
- }
-
- @Override
- public void writeEmptyElement(final String namespaceURI, final String localName) throws XMLStreamException {
- writer.writeEmptyElement(namespaceURI, localName);
- }
-
- @Override
- public void writeEmptyElement(final String prefix, final String localName, final String namespaceURI) throws XMLStreamException {
- writer.writeEmptyElement(prefix, localName, namespaceURI);
- }
-
- @Override
- public void writeEmptyElement(final String localName) throws XMLStreamException {
- writer.writeEmptyElement(localName);
- }
-
- @Override
- public void writeEndElement() throws XMLStreamException {
- writer.writeEndElement();
-
- }
-
- @Override
- public void writeEndDocument() throws XMLStreamException {
- // End document is disabled
- }
-
- @Override
- public void close() throws XMLStreamException {
- writer.close();
- }
-
- @Override
- public void flush() throws XMLStreamException {
- writer.flush();
- }
-
- @Override
- public void writeAttribute(final String localName, final String value) throws XMLStreamException {
- writer.writeAttribute(localName, value);
- }
-
- @Override
- public void writeAttribute(final String prefix, final String namespaceURI, final String localName, final String value) throws XMLStreamException {
- writer.writeAttribute(prefix, namespaceURI, localName, value);
- }
-
- @Override
- public void writeAttribute(final String namespaceURI, final String localName, final String value) throws XMLStreamException {
- writer.writeAttribute(namespaceURI, localName, value);
- }
-
- @Override
- public void writeNamespace(final String prefix, final String namespaceURI) throws XMLStreamException {
- // Workaround for default namespace
- // If a namespace is not prefixed, it is is still treated as prefix namespace. This results in the NamespaceSupport class ignoring the namespace since xmlns is not a valid prefix
- // Write the namespace at least as an attribute
- // TODO this is a hotfix, the transformer itself should write namespaces passing the namespace in writeStartElement method
- if (prefix.equals("xml") || prefix.equals("xmlns")) {
- writer.writeAttribute(prefix, namespaceURI);
- } else {
- writer.writeNamespace(prefix, namespaceURI);
- }
- }
-
- @Override
- public void writeDefaultNamespace(final String namespaceURI) throws XMLStreamException {
- writer.writeDefaultNamespace(namespaceURI);
- }
-
- @Override
- public void writeComment(final String data) throws XMLStreamException {
- writer.writeComment(data);
- }
-
- @Override
- public void writeProcessingInstruction(final String target) throws XMLStreamException {
- writer.writeProcessingInstruction(target);
- }
-
- @Override
- public void writeProcessingInstruction(final String target, final String data) throws XMLStreamException {
- writer.writeProcessingInstruction(target, data);
- }
-
- @Override
- public void writeCData(final String data) throws XMLStreamException {
- writer.writeCData(data);
- }
-
- @Override
- public void writeDTD(final String dtd) throws XMLStreamException {
- writer.writeDTD(dtd);
- }
-
- @Override
- public void writeEntityRef(final String name) throws XMLStreamException {
- writer.writeEntityRef(name);
- }
-
- @Override
- public void writeStartDocument() throws XMLStreamException {
- }
-
- @Override
- public void writeStartDocument(final String version) throws XMLStreamException {
- }
-
- @Override
- public void writeStartDocument(final String encoding, final String version) throws XMLStreamException {
- }
-
- @Override
- public void writeCharacters(final String text) throws XMLStreamException {
- writer.writeCharacters(text);
- }
-
- @Override
- public void writeCharacters(final char[] text, final int start, final int len) throws XMLStreamException {
- writer.writeCharacters(text, start, len);
- }
-
- @Override
- public String getPrefix(final String uri) throws XMLStreamException {
- return writer.getPrefix(uri);
- }
-
- @Override
- public void setPrefix(final String prefix, final String uri) throws XMLStreamException {
- // Disabled since it causes exceptions in the underlying writer
- }
-
- @Override
- public void setDefaultNamespace(final String uri) throws XMLStreamException {
- writer.setDefaultNamespace(uri);
- }
-
- @Override
- public void setNamespaceContext(final NamespaceContext context) throws XMLStreamException {
- writer.setNamespaceContext(context);
- }
-
- @Override
- public NamespaceContext getNamespaceContext() {
- return writer.getNamespaceContext();
- }
-
- @Override
- public Object getProperty(final String name) throws IllegalArgumentException {
- return writer.getProperty(name);
- }
- }
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema;
-import javax.xml.transform.dom.DOMSource;
+import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
return ImmutableLeafSetEntryNodeSchemaAwareBuilder.create(schema);
}
- public static <T> NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, DOMSource, AnyXmlNode> anyXmlBuilder() {
+ public static <T> NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> anyXmlBuilder() {
return ImmutableAnyXmlNodeBuilder.create();
}
- public static <T> NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, DOMSource, AnyXmlNode> anyXmlBuilder(
+ public static <T> NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> anyXmlBuilder(
final AnyXmlSchemaNode schema) {
return ImmutableAnyXmlNodeSchemaAwareBuilder.create(schema);
}
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
import java.util.Map;
-import javax.xml.transform.dom.DOMSource;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.nodes.AbstractImmutableNormalizedValueAttrNode;
-public class ImmutableAnyXmlNodeBuilder extends AbstractImmutableNormalizedNodeBuilder<YangInstanceIdentifier.NodeIdentifier, DOMSource, AnyXmlNode> {
+public class ImmutableAnyXmlNodeBuilder extends AbstractImmutableNormalizedNodeBuilder<YangInstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> {
- public static NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, DOMSource, AnyXmlNode> create() {
+ public static NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> create() {
return new ImmutableAnyXmlNodeBuilder();
}
return new ImmutableXmlNode(getNodeIdentifier(), getValue(), getAttributes());
}
- private static final class ImmutableXmlNode extends AbstractImmutableNormalizedValueAttrNode<YangInstanceIdentifier.NodeIdentifier, DOMSource> implements AnyXmlNode {
+ private static final class ImmutableXmlNode extends AbstractImmutableNormalizedValueAttrNode<YangInstanceIdentifier.NodeIdentifier, Node<?>> implements AnyXmlNode {
- ImmutableXmlNode(final YangInstanceIdentifier.NodeIdentifier nodeIdentifier, final DOMSource value, final Map<QName, String> attributes) {
+ ImmutableXmlNode(final YangInstanceIdentifier.NodeIdentifier nodeIdentifier, final Node<?> value, final Map<QName, String> attributes) {
super(nodeIdentifier, value, attributes);
}
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
-import javax.xml.transform.dom.DOMSource;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
super.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(schema.getQName()));
}
- public static NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, DOMSource, AnyXmlNode> create(AnyXmlSchemaNode schema) {
+ public static NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> create(AnyXmlSchemaNode schema) {
return new ImmutableAnyXmlNodeSchemaAwareBuilder(schema);
}
@Override
- public NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, DOMSource, AnyXmlNode> withValue(DOMSource value) {
+ public NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> withValue(Node<?> value) {
return super.withValue(value);
}
@Override
- public NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, DOMSource, AnyXmlNode> withNodeIdentifier(YangInstanceIdentifier.NodeIdentifier nodeIdentifier) {
+ public NormalizedNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, Node<?>, AnyXmlNode> withNodeIdentifier(YangInstanceIdentifier.NodeIdentifier nodeIdentifier) {
throw new UnsupportedOperationException("Node identifier created from schema");
}
}
import com.google.common.base.Preconditions;
import com.google.common.collect.Iterables;
-import javax.xml.transform.dom.DOMSource;
+import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
Preconditions.checkArgument(size == 1, "Elements mapped to any-xml node illegal count: %s", size);
final E e = elements.iterator().next();
- DOMSource value = parseAnyXml(e, schema);
+ Node<?> value = parseAnyXml(e, schema);
- NormalizedNodeAttrBuilder<NodeIdentifier, DOMSource, AnyXmlNode> anyXmlBuilder = Builders.anyXmlBuilder(schema);
+ NormalizedNodeAttrBuilder<NodeIdentifier, Node<?>, AnyXmlNode> anyXmlBuilder = Builders.anyXmlBuilder(schema);
return anyXmlBuilder.withValue(value).build();
}
* @param schema schema for leaf
* @return parsed element as an Object
*/
- protected abstract DOMSource parseAnyXml(E element, AnyXmlSchemaNode schema);
+ protected abstract Node<?> parseAnyXml(E element, AnyXmlSchemaNode schema);
}
package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser;
-import com.google.common.base.Preconditions;
-import javax.xml.transform.dom.DOMSource;
+import com.google.common.base.Optional;
+import java.util.Collections;
+import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.AnyXmlNodeBaseParser;
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
+import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlCodecProvider;
+import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlDocumentUtils;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.w3c.dom.Element;
-public class AnyXmlDomParser extends AnyXmlNodeBaseParser<Element> {
+public class AnyXmlDomParser implements ToNormalizedNodeParser<Element,AnyXmlNode,AnyXmlSchemaNode> {
@Override
- protected DOMSource parseAnyXml(final Element element, final AnyXmlSchemaNode schema) {
- final QName qName = schema.getQName();
- Preconditions.checkArgument(element.getNodeName().equals(qName.getLocalName()));
- Preconditions.checkArgument(element.getNamespaceURI().equals(qName.getNamespace().toString()));
- return new DOMSource(element);
- }
+ public AnyXmlNode parse(final Iterable<Element> xmlDom, final AnyXmlSchemaNode schema) {
+ final Element value = xmlDom.iterator().next();
+ return new AnyXmlNode() {
+ @Override
+ public YangInstanceIdentifier.NodeIdentifier getIdentifier() {
+ return new YangInstanceIdentifier.NodeIdentifier(schema.getQName());
+ }
+
+ @Override
+ public Node<?> getValue() {
+ return XmlDocumentUtils.toDomNode(value, Optional.<DataSchemaNode>absent(), Optional.<XmlCodecProvider>absent());
+ }
+
+ @Override
+ public Map<QName, String> getAttributes() {
+ return Collections.emptyMap();
+ }
+
+ @Override
+ public Object getAttributeValue(final QName name) {
+ return null;
+ }
+
+ @Override
+ public QName getNodeType() {
+ return schema.getQName();
+ }
+ };
+ };
}
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-// TODO Is this used anywhere ? it is replaced by the NormalizedNode stream writer, COuld this be removed ?
-
public final class DomFromNormalizedNodeSerializerFactory implements FromNormalizedNodeSerializerFactory<Element> {
private final ContainerNodeDomSerializer containerSerializer;
private final ChoiceNodeDomSerializer choiceSerializer;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
-import javax.xml.stream.XMLOutputFactory;
-import javax.xml.stream.XMLStreamException;
-import javax.xml.stream.XMLStreamWriter;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
-import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
+import org.custommonkey.xmlunit.DetailedDiff;
import org.custommonkey.xmlunit.Diff;
import org.custommonkey.xmlunit.XMLUnit;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
-import org.opendaylight.yangtools.yang.data.impl.codec.xml.XMLStreamNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlDocumentUtils;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedDataBuilderTest;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
});
}
+
public static final String NAMESPACE = "urn:opendaylight:params:xml:ns:yang:controller:test";
private static Date revision;
static {
System.err.println(built);
logger.info("{}", built);
- final Element elementNS = XmlDocumentUtils.getDocument().createElementNS(containerNode.getQName().getNamespace().toString(), containerNode.getQName().getLocalName());
- writeNormalizedNode(built, new DOMResult(elementNS), SchemaPath.create(true), schema);
+ final Iterable<Element> els = DomFromNormalizedNodeSerializerFactory.getInstance(XmlDocumentUtils.getDocument(), DomUtils.defaultValueCodecProvider())
+ .getContainerNodeSerializer().serialize(containerNode, built);
+
+ final Element el = els.iterator().next();
XMLUnit.setIgnoreWhitespace(true);
XMLUnit.setIgnoreComments(true);
XMLUnit.setIgnoreAttributeOrder(true);
- XMLUnit.setNormalize(true);
System.err.println(toString(doc.getDocumentElement()));
- System.err.println(toString(elementNS));
+ System.err.println(toString(el));
- final Diff diff = new Diff(XMLUnit.buildControlDocument(toString(doc.getDocumentElement())), XMLUnit.buildTestDocument(toString(elementNS)));
+ final Diff diff = new Diff(XMLUnit.buildControlDocument(toString(doc.getDocumentElement())), XMLUnit.buildTestDocument(toString(el)));
+ DetailedDiff dd = new DetailedDiff(diff);
// FIXME the comparison cannot be performed, since the qualifiers supplied by XMlUnit do not work correctly in this case
// We need to implement custom qualifier so that the element ordering does not mess the DIFF
-// dd.overrideElementQualifier(new MultiLevelElementNameAndTextQualifier(100, true));
+// dd.overrideElementQualifier(new ElementNameAndAttributeQualifier());
// assertTrue(dd.toString(), dd.similar());
}
-
- static final XMLOutputFactory XML_FACTORY;
- static {
- XML_FACTORY = XMLOutputFactory.newFactory();
- XML_FACTORY.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, false);
- }
-
- private void writeNormalizedNode(final NormalizedNode<?, ?> normalized, final DOMResult result, final SchemaPath schemaPath, final SchemaContext context)
- throws IOException, XMLStreamException {
- NormalizedNodeWriter normalizedNodeWriter = null;
- NormalizedNodeStreamWriter normalizedNodeStreamWriter = null;
- XMLStreamWriter writer = null;
- try {
- writer = XML_FACTORY.createXMLStreamWriter(result);
- normalizedNodeStreamWriter = XMLStreamNormalizedNodeStreamWriter.create(writer, context, schemaPath);
- normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(normalizedNodeStreamWriter);
-
- normalizedNodeWriter.write(normalized);
-
- normalizedNodeWriter.flush();
- } finally {
- if(normalizedNodeWriter != null) {
- normalizedNodeWriter.close();
- }
- if(normalizedNodeStreamWriter != null) {
- normalizedNodeStreamWriter.close();
- }
- if(writer != null) {
- writer.close();
- }
- }
- }
-
private Document loadDocument(final String xmlPath) throws Exception {
final InputStream resourceAsStream = NormalizedDataBuilderTest.class.getResourceAsStream(xmlPath);
<uint32>32</uint32>
<uint16>16</uint16>
<identityr xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:test">prefix:b</identityr>
- <anyX xmlns="urn:opendaylight:params:xml:ns:yang:controller:test">direct Value</anyX>
<uint16-ref>16</uint16-ref>
<instance-id xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:test">/prefix:container/prefix:list[prefix:uint32InList="1"]</instance-id>
</containerInList>
<containerInList>
<uint32>32</uint32>
<uint16>16</uint16>
- <identityr>b</identityr>
- <anyX>
- <container xmlns="randomNamespace" xmlns:pref="prefixed:namespace">
- <pref:boolean>true</pref:boolean>
- <innerContainer xmlns:p="prefixed:namespace">
- <uint16 xmlns:pref2="prefixed:namespace">pref2:44</uint16>
- </innerContainer>
- </container>
- <container2 xmlns="randomNamespace2"/>
- </anyX>
</containerInList>
<!--<stringAugmentedToListInCase1>augmentInListCase1</stringAugmentedToListInCase1>-->
<stringAugmentedToListInCase2>augmentInListCase2</stringAugmentedToListInCase2>
</list>
- <list>
- <uint32InList>4</uint32InList>
- <containerInList>
- <anyX>
- <netconf-state xmlns="urn:ietf:params:xml:ns:yang:ietf-netconf-monitoring">
- <schemas>
- <schema>
- <identifier>module</identifier>
- <version>2012-12-12</version>
- <format xmlns:x="urn:ietf:params:xml:ns:yang:ietf-netconf-monitoring">x:yang</format>
- </schema>
- </schemas>
- </netconf-state>
- </anyX>
- </containerInList>
- </list>
<list>
<uint32InList>3</uint32InList>
</list>
leaf instance-id {
type instance-identifier;
}
-
- anyxml anyX;
}
}
}
Code Review / yangtools.git / commitdiff