import java.io.Flushable;
import java.io.IOException;
import java.net.URI;
+import java.util.AbstractMap.SimpleImmutableEntry;
import java.util.ArrayDeque;
import java.util.Collections;
import java.util.Deque;
import java.util.HashSet;
+import java.util.Map.Entry;
import java.util.Set;
-import org.opendaylight.yangtools.yang.data.api.schema.stream.DataSchemaNodeAwareAdaptor;
+import javax.xml.transform.dom.DOMSource;
+import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.api.schema.stream.SchemaAwareNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.util.AbstractNodeDataWithSchema;
import org.opendaylight.yangtools.yang.data.util.AnyXmlNodeDataWithSchema;
import org.opendaylight.yangtools.yang.data.util.CompositeNodeDataWithSchema;
import org.opendaylight.yangtools.yang.data.util.ParserStreamUtils;
import org.opendaylight.yangtools.yang.data.util.RpcAsContainer;
import org.opendaylight.yangtools.yang.data.util.SimpleNodeDataWithSchema;
-import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
+import org.opendaylight.yangtools.yang.model.api.TypedSchemaNode;
import org.opendaylight.yangtools.yang.model.api.YangModeledAnyXmlSchemaNode;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Text;
/**
* This class parses JSON elements from a GSON JsonReader. It disallows multiple elements of the same name unlike the
*/
@Beta
public final class JsonParserStream implements Closeable, Flushable {
+ static final String ANYXML_ARRAY_ELEMENT_ID = "array-element";
+
private final Deque<URI> namespaces = new ArrayDeque<>();
- private final SchemaAwareNormalizedNodeStreamWriter writer;
+ private final NormalizedNodeStreamWriter writer;
private final JSONCodecFactory codecs;
private final SchemaContext schema;
private final DataSchemaNode parentNode;
private JsonParserStream(final NormalizedNodeStreamWriter writer, final SchemaContext schemaContext,
- final DataSchemaNode parentNode) {
+ final JSONCodecFactory codecs, final DataSchemaNode parentNode) {
this.schema = Preconditions.checkNotNull(schemaContext);
- this.writer = DataSchemaNodeAwareAdaptor.forWriter(writer);
- this.codecs = JSONCodecFactory.create(schemaContext);
+ this.writer = Preconditions.checkNotNull(writer);
+ this.codecs = Preconditions.checkNotNull(codecs);
this.parentNode = parentNode;
}
+ private JsonParserStream(final NormalizedNodeStreamWriter writer, final SchemaContext schemaContext,
+ final DataSchemaNode parentNode) {
+ this(writer, schemaContext, JSONCodecFactory.getShared(schemaContext), parentNode);
+ }
+
public static JsonParserStream create(final NormalizedNodeStreamWriter writer, final SchemaContext schemaContext,
- final SchemaNode parentNode ) {
+ final SchemaNode parentNode) {
if (parentNode instanceof RpcDefinition) {
return new JsonParserStream(writer, schemaContext, new RpcAsContainer((RpcDefinition) parentNode));
}
}
}
- private void setValue(final AbstractNodeDataWithSchema parent, final String value) {
- Preconditions.checkArgument(parent instanceof SimpleNodeDataWithSchema, "Node %s is not a simple type",
- parent.getSchema().getQName());
- final SimpleNodeDataWithSchema parentSimpleNode = (SimpleNodeDataWithSchema) parent;
- Preconditions.checkArgument(parentSimpleNode.getValue() == null, "Node '%s' has already set its value to '%s'",
- parentSimpleNode.getSchema().getQName(), parentSimpleNode.getValue());
+ private void traverseAnyXmlValue(final JsonReader in, final Document doc, final Element parentElement)
+ throws IOException {
+ switch (in.peek()) {
+ case STRING:
+ case NUMBER:
+ Text textNode = doc.createTextNode(in.nextString());
+ parentElement.appendChild(textNode);
+ break;
+ case BOOLEAN:
+ textNode = doc.createTextNode(Boolean.toString(in.nextBoolean()));
+ parentElement.appendChild(textNode);
+ break;
+ case NULL:
+ in.nextNull();
+ textNode = doc.createTextNode("null");
+ parentElement.appendChild(textNode);
+ break;
+ case BEGIN_ARRAY:
+ in.beginArray();
+ while (in.hasNext()) {
+ final Element childElement = doc.createElement(ANYXML_ARRAY_ELEMENT_ID);
+ parentElement.appendChild(childElement);
+ traverseAnyXmlValue(in, doc, childElement);
+ }
+ in.endArray();
+ break;
+ case BEGIN_OBJECT:
+ in.beginObject();
+ while (in.hasNext()) {
+ final Element childElement = doc.createElement(in.nextName());
+ parentElement.appendChild(childElement);
+ traverseAnyXmlValue(in, doc, childElement);
+ }
+ in.endObject();
+ break;
+ default:
+ break;
+ }
+ }
- final Object translatedValue = translateValueByType(value, parentSimpleNode.getSchema());
- parentSimpleNode.setValue(translatedValue);
+ private void readAnyXmlValue(final JsonReader in, final AnyXmlNodeDataWithSchema parent,
+ final String anyXmlObjectName) throws IOException {
+ final String anyXmlObjectNS = getCurrentNamespace().toString();
+ final Document doc = UntrustedXML.newDocumentBuilder().newDocument();
+ final Element rootElement = doc.createElementNS(anyXmlObjectNS, anyXmlObjectName);
+ doc.appendChild(rootElement);
+ traverseAnyXmlValue(in, doc, rootElement);
+
+ final DOMSource domSource = new DOMSource(doc.getDocumentElement());
+ parent.setValue(domSource);
}
public void read(final JsonReader in, AbstractNodeDataWithSchema parent) throws IOException {
switch (in.peek()) {
- case STRING:
- case NUMBER:
- setValue(parent, in.nextString());
- break;
- case BOOLEAN:
- setValue(parent, Boolean.toString(in.nextBoolean()));
- break;
- case NULL:
- in.nextNull();
- setValue(parent, null);
- break;
- case BEGIN_ARRAY:
- in.beginArray();
- while (in.hasNext()) {
- if (parent instanceof LeafNodeDataWithSchema) {
- read(in, parent);
- } else {
- final AbstractNodeDataWithSchema newChild = newArrayEntry(parent);
- read(in, newChild);
- }
- }
- in.endArray();
- return;
- case BEGIN_OBJECT:
- final Set<String> namesakes = new HashSet<>();
- in.beginObject();
- /*
- * This allows parsing of incorrectly /as showcased/
- * in testconf nesting of list items - eg.
- * lists with one value are sometimes serialized
- * without wrapping array.
- *
- */
- if (isArray(parent)) {
- parent = newArrayEntry(parent);
- }
- while (in.hasNext()) {
- final String jsonElementName = in.nextName();
- DataSchemaNode parentSchema = parent.getSchema();
- if (parentSchema instanceof YangModeledAnyXmlSchemaNode) {
- parentSchema = ((YangModeledAnyXmlSchemaNode) parentSchema).getSchemaOfAnyXmlData();
- }
- final NamespaceAndName namespaceAndName = resolveNamespace(jsonElementName, parentSchema);
- final String localName = namespaceAndName.getName();
- addNamespace(namespaceAndName.getUri());
- if (namesakes.contains(jsonElementName)) {
- throw new JsonSyntaxException("Duplicate name " + jsonElementName + " in JSON input.");
- }
- namesakes.add(jsonElementName);
-
- final Deque<DataSchemaNode> childDataSchemaNodes =
- ParserStreamUtils.findSchemaNodeByNameAndNamespace(parentSchema, localName, getCurrentNamespace());
- if (childDataSchemaNodes.isEmpty()) {
- throw new IllegalStateException("Schema for node with name " + localName + " and namespace "
- + getCurrentNamespace() + " doesn't exist.");
+ case STRING:
+ case NUMBER:
+ setValue(parent, in.nextString());
+ break;
+ case BOOLEAN:
+ setValue(parent, Boolean.toString(in.nextBoolean()));
+ break;
+ case NULL:
+ in.nextNull();
+ setValue(parent, null);
+ break;
+ case BEGIN_ARRAY:
+ in.beginArray();
+ while (in.hasNext()) {
+ if (parent instanceof LeafNodeDataWithSchema) {
+ read(in, parent);
+ } else {
+ final AbstractNodeDataWithSchema newChild = newArrayEntry(parent);
+ read(in, newChild);
+ }
}
-
- final AbstractNodeDataWithSchema newChild = ((CompositeNodeDataWithSchema) parent).addChild(childDataSchemaNodes);
+ in.endArray();
+ return;
+ case BEGIN_OBJECT:
+ final Set<String> namesakes = new HashSet<>();
+ in.beginObject();
/*
- * FIXME:anyxml data shouldn't be skipped but should be loaded somehow.
- * will be able to load anyxml which conforms to YANG data using these
- * parser, for other anyxml will be harder.
+ * This allows parsing of incorrectly /as showcased/
+ * in testconf nesting of list items - eg.
+ * lists with one value are sometimes serialized
+ * without wrapping array.
+ *
*/
- if (newChild instanceof AnyXmlNodeDataWithSchema) {
- in.skipValue();
- } else {
- read(in, newChild);
+ if (isArray(parent)) {
+ parent = newArrayEntry(parent);
}
- removeNamespace();
- }
- in.endObject();
- return;
- case END_DOCUMENT:
- case NAME:
- case END_OBJECT:
- case END_ARRAY:
- break;
+ while (in.hasNext()) {
+ final String jsonElementName = in.nextName();
+ DataSchemaNode parentSchema = parent.getSchema();
+ if (parentSchema instanceof YangModeledAnyXmlSchemaNode) {
+ parentSchema = ((YangModeledAnyXmlSchemaNode) parentSchema).getSchemaOfAnyXmlData();
+ }
+ final Entry<String, URI> namespaceAndName = resolveNamespace(jsonElementName, parentSchema);
+ final String localName = namespaceAndName.getKey();
+ addNamespace(namespaceAndName.getValue());
+ if (!namesakes.add(jsonElementName)) {
+ throw new JsonSyntaxException("Duplicate name " + jsonElementName + " in JSON input.");
+ }
+
+ final Deque<DataSchemaNode> childDataSchemaNodes =
+ ParserStreamUtils.findSchemaNodeByNameAndNamespace(parentSchema, localName,
+ getCurrentNamespace());
+ Preconditions.checkState(!childDataSchemaNodes.isEmpty(),
+ "Schema for node with name %s and namespace %s does not exist.", localName,
+ getCurrentNamespace());
+
+ final AbstractNodeDataWithSchema newChild = ((CompositeNodeDataWithSchema) parent)
+ .addChild(childDataSchemaNodes);
+ if (newChild instanceof AnyXmlNodeDataWithSchema) {
+ readAnyXmlValue(in, (AnyXmlNodeDataWithSchema) newChild, jsonElementName);
+ } else {
+ read(in, newChild);
+ }
+ removeNamespace();
+ }
+ in.endObject();
+ return;
+ default:
+ break;
}
}
} else if (parent instanceof LeafListNodeDataWithSchema) {
newChild = new LeafListEntryNodeDataWithSchema(parent.getSchema());
} else {
- throw new IllegalStateException("Found an unexpected array nested under "+ parent.getSchema().getQName());
+ throw new IllegalStateException("Found an unexpected array nested under " + parent.getSchema().getQName());
}
((CompositeNodeDataWithSchema) parent).addChild(newChild);
return newChild;
}
+ private void setValue(final AbstractNodeDataWithSchema parent, final String value) {
+ Preconditions.checkArgument(parent instanceof SimpleNodeDataWithSchema, "Node %s is not a simple type",
+ parent.getSchema().getQName());
+ final SimpleNodeDataWithSchema parentSimpleNode = (SimpleNodeDataWithSchema) parent;
+ Preconditions.checkArgument(parentSimpleNode.getValue() == null, "Node '%s' has already set its value to '%s'",
+ parentSimpleNode.getSchema().getQName(), parentSimpleNode.getValue());
+
+ final Object translatedValue = translateValueByType(value, parentSimpleNode.getSchema());
+ parentSimpleNode.setValue(translatedValue);
+ }
+
private Object translateValueByType(final String value, final DataSchemaNode node) {
- if (node instanceof AnyXmlSchemaNode) {
- /*
- * FIXME: Figure out some YANG extension dispatch, which will
- * reuse JSON parsing or XML parsing - anyxml is not well-defined in
- * JSON.
- */
- return value;
- }
- return codecs.codecFor(node).deserialize(value);
+ Preconditions.checkArgument(node instanceof TypedSchemaNode);
+ return codecs.codecFor((TypedSchemaNode) node).parseValue(null, value);
}
private void removeNamespace() {
namespaces.push(namespace);
}
- private NamespaceAndName resolveNamespace(final String childName, final DataSchemaNode dataSchemaNode) {
+ private Entry<String, URI> resolveNamespace(final String childName, final DataSchemaNode dataSchemaNode) {
final int lastIndexOfColon = childName.lastIndexOf(':');
String moduleNamePart = null;
String nodeNamePart = null;
} else if (potentialUris.size() == 1) {
namespace = potentialUris.iterator().next();
} else if (potentialUris.size() > 1) {
- throw new IllegalStateException("Choose suitable module name for element "+nodeNamePart+":"+toModuleNames(potentialUris));
+ throw new IllegalStateException("Choose suitable module name for element " + nodeNamePart + ":"
+ + toModuleNames(potentialUris));
} else if (potentialUris.isEmpty()) {
- throw new IllegalStateException("Schema node with name "+nodeNamePart+" wasn't found under "+dataSchemaNode.getQName()+".");
+ throw new IllegalStateException("Schema node with name " + nodeNamePart + " was not found under "
+ + dataSchemaNode.getQName() + ".");
}
}
- return new NamespaceAndName(nodeNamePart, namespace);
+ return new SimpleImmutableEntry<>(nodeNamePart, namespace);
}
private String toModuleNames(final Set<URI> potentialUris) {
final StringBuilder builder = new StringBuilder();
for (final URI potentialUri : potentialUris) {
- builder.append("\n");
+ builder.append('\n');
//FIXME how to get information about revision from JSON input? currently first available is used.
builder.append(schema.findModuleByNamespace(potentialUri).iterator().next().getName());
}
return namespaces.peek();
}
-
-
- private static class NamespaceAndName {
- private final URI uri;
- private final String name;
-
- public NamespaceAndName(final String name, final URI uri) {
- this.name = name;
- this.uri = uri;
- }
-
- public String getName() {
- return name;
- }
-
- public URI getUri() {
- return uri;
- }
- }
-
@Override
public void flush() throws IOException {
writer.flush();