<module>yang-model-util</module>
<module>yang-parser-api</module>
<module>yang-parser-impl</module>
+ <module>yang-data-json</module>
</modules>
<properties>
<artifactId>maven-plugin-api</artifactId>
<version>3.0.5</version>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-json</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-impl</artifactId>
+ <version>${project.version}</version>
+ </dependency>
</dependencies>
</dependencyManagement>
</project>
ListNodeBuilder<Object, LeafSetEntryNode<Object>> leafListBuilder = Builders.leafSetBuilder(schema);
for (E childNode : childNodes) {
- LeafSetEntryNode<?> builtChild = getLeafSetEntryNodeBaseParser().parse(
+ LeafSetEntryNode<?> builtChild = getLeafSetEntryNodeParser().parse(
Collections.singletonList(childNode), schema);
// TODO: can we get rid of this cast/SuppressWarnings somehow?
*
* @return parser for inner LeafSetEntryNodes used to parse every entry of LeafSetNode, might be the same instance in case its immutable
*/
- protected abstract ToNormalizedNodeParser<E, LeafSetEntryNode<?>, LeafListSchemaNode> getLeafSetEntryNodeBaseParser();
+ protected abstract ToNormalizedNodeParser<E, LeafSetEntryNode<?>, LeafListSchemaNode> getLeafSetEntryNodeParser();
}
CollectionNodeBuilder<MapEntryNode, MapNode> listBuilder = Builders.mapBuilder(schema);
for (E childNode : childNodes) {
- MapEntryNode listChild = getMapEntryNodeDomParser().parse(Collections.singletonList(childNode), schema);
+ MapEntryNode listChild = getMapEntryNodeParser().parse(Collections.singletonList(childNode), schema);
listBuilder.withChild(listChild);
}
*
* @return parser for inner MapEntryNodes used to parse every entry of MapNode, might be the same instance in case its immutable
*/
- protected abstract ToNormalizedNodeParser<E, MapEntryNode, ListSchemaNode> getMapEntryNodeDomParser();
+ protected abstract ToNormalizedNodeParser<E, MapEntryNode, ListSchemaNode> getMapEntryNodeParser();
}
}
@Override
- protected ToNormalizedNodeParser<Element, LeafSetEntryNode<?>, LeafListSchemaNode> getLeafSetEntryNodeBaseParser() {
+ protected ToNormalizedNodeParser<Element, LeafSetEntryNode<?>, LeafListSchemaNode> getLeafSetEntryNodeParser() {
return leafSetEntryNodeBaseParser;
}
}
}
@Override
- protected ToNormalizedNodeParser<Element, MapEntryNode, ListSchemaNode> getMapEntryNodeDomParser() {
+ protected ToNormalizedNodeParser<Element, MapEntryNode, ListSchemaNode> getMapEntryNodeParser() {
return mapEntryParser;
}
}
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- vi: set et smarttab sw=4 tabstop=4: -->
+<!-- Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ and is available at http://www.eclipse.org/legal/epl-v10.html -->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+ <parent>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang</artifactId>
+ <version>0.6.2-SNAPSHOT</version>
+ </parent>
+
+ <modelVersion>4.0.0</modelVersion>
+ <artifactId>yang-data-json</artifactId>
+ <name>${project.artifactId}</name>
+ <description>${project.artifactId}</description>
+
+ <dependencies>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>yang-data-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>yang-data-impl</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>yang-model-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+
+</project>
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.parser;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.AugmentationNodeBaseParser;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher;
+import org.opendaylight.yangtools.yang.data.json.schema.json.CnSnToNormalizedNodesUtils;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.LinkedListMultimap;
+
+public final class AugmentationNodeCnSnParser extends AugmentationNodeBaseParser<Node<?>> {
+
+ private final NodeParserDispatcher<Node<?>> dispatcher;
+
+ public AugmentationNodeCnSnParser(final NodeParserDispatcher<Node<?>> dispatcher) {
+ this.dispatcher = Preconditions.checkNotNull(dispatcher);
+ }
+
+ @Override
+ protected LinkedListMultimap<QName, Node<?>> mapChildElements(Iterable<Node<?>> elements) {
+ return CnSnToNormalizedNodesUtils.mapChildElements(elements);
+ }
+
+ @Override
+ protected NodeParserDispatcher<Node<?>> getDispatcher() {
+ return dispatcher;
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.parser;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.ChoiceNodeBaseParser;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher;
+import org.opendaylight.yangtools.yang.data.json.schema.json.CnSnToNormalizedNodesUtils;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.LinkedListMultimap;
+
+public final class ChoiceNodeCnSnParser extends ChoiceNodeBaseParser<Node<?>> {
+
+ private final NodeParserDispatcher<Node<?>> dispatcher;
+
+ public ChoiceNodeCnSnParser(final NodeParserDispatcher<Node<?>> dispatcher) {
+ this.dispatcher = Preconditions.checkNotNull(dispatcher);
+ }
+
+ @Override
+ protected LinkedListMultimap<QName, Node<?>> mapChildElements(Iterable<Node<?>> elements) {
+ return CnSnToNormalizedNodesUtils.mapChildElements(elements);
+ }
+
+ @Override
+ protected NodeParserDispatcher<Node<?>> getDispatcher() {
+ return dispatcher;
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.parser;
+
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParserFactory;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher;
+import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
+import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+
+public class CnSnToNormalizedNodeParserFactory implements ToNormalizedNodeParserFactory<Node<?>> {
+
+ private final ContainerNodeCnSnParser containerNodeCnSnParser;
+ private final LeafNodeCnSnParser leafNodeCnSnParser;
+ private final LeafSetEntryNodeCnSnParser leafSetEntryNodeCnSnParser;
+ private final LeafSetNodeCnSnParser leafSetNodeCnSnParser;
+ private final MapNodeCnSnParser mapNodeCnSnParser;
+ private final MapEntryNodeCnSnParser mapEntryNodeCnSnParser;
+ private final ChoiceNodeCnSnParser choiceNodeCnSnParser;
+ private final AugmentationNodeCnSnParser augmentationNodeCnSnParser;
+
+ private CnSnToNormalizedNodeParserFactory() {
+ leafNodeCnSnParser = new LeafNodeCnSnParser();
+ leafSetEntryNodeCnSnParser = new LeafSetEntryNodeCnSnParser();
+ leafSetNodeCnSnParser = new LeafSetNodeCnSnParser(leafSetEntryNodeCnSnParser);
+
+ final NodeParserDispatcher<Node<?>> dispatcher = new NodeParserDispatcher.BaseNodeParserDispatcher<Node<?>>(
+ this) {
+
+ };
+
+ containerNodeCnSnParser = new ContainerNodeCnSnParser(dispatcher);
+ mapEntryNodeCnSnParser = new MapEntryNodeCnSnParser(dispatcher);
+ mapNodeCnSnParser = new MapNodeCnSnParser(mapEntryNodeCnSnParser);
+ choiceNodeCnSnParser = new ChoiceNodeCnSnParser(dispatcher);
+ augmentationNodeCnSnParser = new AugmentationNodeCnSnParser(dispatcher);
+ }
+
+ public static CnSnToNormalizedNodeParserFactory getInstance() {
+ return new CnSnToNormalizedNodeParserFactory();
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Node<?>, ContainerNode, ContainerSchemaNode> getContainerNodeParser() {
+ return containerNodeCnSnParser;
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Node<?>, LeafNode<?>, LeafSchemaNode> getLeafNodeParser() {
+ return leafNodeCnSnParser;
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Node<?>, LeafSetNode<?>, LeafListSchemaNode> getLeafSetNodeParser() {
+ return leafSetNodeCnSnParser;
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Node<?>, MapNode, ListSchemaNode> getMapNodeParser() {
+ return mapNodeCnSnParser;
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Node<?>, org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode, ChoiceNode> getChoiceNodeParser() {
+ return choiceNodeCnSnParser;
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Node<?>, AugmentationNode, AugmentationSchema> getAugmentationNodeParser() {
+ return augmentationNodeCnSnParser;
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Node<?>, LeafSetEntryNode<?>, LeafListSchemaNode> getLeafSetEntryNodeParser() {
+ return leafSetEntryNodeCnSnParser;
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Node<?>, MapEntryNode, ListSchemaNode> getMapEntryNodeParser() {
+ return mapEntryNodeCnSnParser;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.parser;
+
+import java.util.Collections;
+import java.util.Map;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.ContainerNodeBaseParser;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher;
+import org.opendaylight.yangtools.yang.data.json.schema.json.CnSnToNormalizedNodesUtils;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.LinkedListMultimap;
+
+public final class ContainerNodeCnSnParser extends ContainerNodeBaseParser<Node<?>> {
+
+ private final NodeParserDispatcher<Node<?>> dispatcher;
+
+ public ContainerNodeCnSnParser(final NodeParserDispatcher<Node<?>> dispatcher) {
+ this.dispatcher = Preconditions.checkNotNull(dispatcher);
+ }
+
+ @Override
+ protected NodeParserDispatcher<Node<?>> getDispatcher() {
+ return dispatcher;
+ }
+
+ @Override
+ protected LinkedListMultimap<QName, Node<?>> mapChildElements(Iterable<Node<?>> elements) {
+ return CnSnToNormalizedNodesUtils.mapChildElementsForSingletonNode(elements.iterator().next());
+ }
+
+ @Override
+ protected Map<QName, String> getAttributes(Node<?> e) {
+ return Collections.emptyMap();
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.parser;
+
+import java.util.Collections;
+import java.util.Map;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.LeafNodeBaseParser;
+import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+
+public class LeafNodeCnSnParser extends LeafNodeBaseParser<Node<?>> {
+
+ public LeafNodeCnSnParser() {
+ super();
+ }
+
+ @Override
+ protected Object parseLeaf(Node<?> elements, LeafSchemaNode schema) {
+ return elements.getValue();
+ }
+
+ @Override
+ protected Map<QName, String> getAttributes(Node<?> e) {
+ return Collections.emptyMap();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.parser;
+
+import java.util.Collections;
+import java.util.Map;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.LeafSetEntryNodeBaseParser;
+import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
+
+public class LeafSetEntryNodeCnSnParser extends LeafSetEntryNodeBaseParser<Node<?>> {
+
+ public LeafSetEntryNodeCnSnParser() {
+ super();
+ }
+
+ @Override
+ protected Object parseLeafListEntry(Node<?> elements, LeafListSchemaNode schema) {
+ return elements.getValue();
+ }
+
+ @Override
+ protected Map<QName, String> getAttributes(Node<?> e) {
+ return Collections.emptyMap();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.parser;
+
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.LeafSetNodeBaseParser;
+import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
+
+public class LeafSetNodeCnSnParser extends LeafSetNodeBaseParser<Node<?>> {
+
+ private final LeafSetEntryNodeCnSnParser leafSetEntryNodeCnSnParser;
+
+ public LeafSetNodeCnSnParser(LeafSetEntryNodeCnSnParser leafSetEntryNodeCnSnParser) {
+ this.leafSetEntryNodeCnSnParser = leafSetEntryNodeCnSnParser;
+ }
+
+ @Override
+ protected ToNormalizedNodeParser<Node<?>, LeafSetEntryNode<?>, LeafListSchemaNode> getLeafSetEntryNodeParser() {
+ return leafSetEntryNodeCnSnParser;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.parser;
+
+import java.util.Collections;
+import java.util.Map;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.MapEntryNodeBaseParser;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher;
+import org.opendaylight.yangtools.yang.data.json.schema.json.CnSnToNormalizedNodesUtils;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.LinkedListMultimap;
+
+public final class MapEntryNodeCnSnParser extends MapEntryNodeBaseParser<Node<?>> {
+
+ private final NodeParserDispatcher<Node<?>> dispatcher;
+
+ public MapEntryNodeCnSnParser(final NodeParserDispatcher<Node<?>> dispatcher) {
+ this.dispatcher = Preconditions.checkNotNull(dispatcher);
+ }
+
+
+ @Override
+ protected LinkedListMultimap<QName, Node<?>> mapChildElements(Iterable<Node<?>> elements) {
+ return CnSnToNormalizedNodesUtils.mapChildElementsForSingletonNode(elements.iterator().next());
+ }
+
+ @Override
+ protected NodeParserDispatcher<Node<?>> getDispatcher() {
+ return dispatcher;
+ }
+
+ @Override
+ protected Map<QName, String> getAttributes(Node<?> e) {
+ return Collections.emptyMap();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.parser;
+
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.MapNodeBaseParser;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+
+public final class MapNodeCnSnParser extends MapNodeBaseParser<Node<?>> {
+
+ private final MapEntryNodeCnSnParser mapEntryNodeCnSnParser;
+
+ public MapNodeCnSnParser(MapEntryNodeCnSnParser mapEntryNodeCnSnParser) {
+ this.mapEntryNodeCnSnParser = mapEntryNodeCnSnParser;
+ }
+
+ @Override
+ protected ToNormalizedNodeParser<Node<?>, MapEntryNode, ListSchemaNode> getMapEntryNodeParser() {
+ return mapEntryNodeCnSnParser;
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.serializer;
+
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.AugmentationNodeBaseSerializer;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.NodeSerializerDispatcher;
+
+import com.google.common.base.Preconditions;
+
+public class AugmentationNodeCnSnSerializer extends AugmentationNodeBaseSerializer<Node<?>> {
+
+ private NodeSerializerDispatcher<Node<?>> dispatcher;
+
+ AugmentationNodeCnSnSerializer(final NodeSerializerDispatcher<Node<?>> dispatcher) {
+ this.dispatcher = Preconditions.checkNotNull(dispatcher);
+ }
+
+ @Override
+ protected NodeSerializerDispatcher<Node<?>> getNodeDispatcher() {
+ return dispatcher;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.serializer;
+
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.ChoiceNodeBaseSerializer;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.NodeSerializerDispatcher;
+
+import com.google.common.base.Preconditions;
+
+public class ChoiceNodeCnSnSerializer
+ extends
+ ChoiceNodeBaseSerializer<Node<?>> {
+
+ private final NodeSerializerDispatcher<Node<?>> dispatcher;
+
+ ChoiceNodeCnSnSerializer(final NodeSerializerDispatcher<Node<?>> dispatcher) {
+ this.dispatcher = Preconditions.checkNotNull(dispatcher);
+ }
+
+ @Override
+ protected NodeSerializerDispatcher<Node<?>> getNodeDispatcher() {
+ return dispatcher;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.serializer;
+
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.FromNormalizedNodeSerializer;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.FromNormalizedNodeSerializerFactory;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.NodeSerializerDispatcher;
+import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+
+public final class CnSnFromNormalizedNodeSerializerFactory implements FromNormalizedNodeSerializerFactory<Node<?>> {
+ private final ContainerNodeCnSnSerializer containerSerializer;
+ private final ChoiceNodeCnSnSerializer choiceSerializer;
+ private final AugmentationNodeCnSnSerializer augmentSerializer;
+ private final LeafNodeCnSnSerializer leafNodeSerializer;
+ private final LeafSetNodeCnSnSerializer leafSetSerializer;
+ private final MapNodeCnSnSerializer mapNodeSerializer;
+ private final LeafSetEntryNodeCnSnSerializer leafSetEntryNodeSerializer;
+ private final MapEntryNodeCnSnSerializer mapEntryNodeSerializer;
+
+ private CnSnFromNormalizedNodeSerializerFactory() {
+ final NodeSerializerDispatcher.BaseNodeSerializerDispatcher<Node<?>> dispatcher = new NodeSerializerDispatcher.BaseNodeSerializerDispatcher<Node<?>>(
+ this) {
+
+ };
+
+ containerSerializer = new ContainerNodeCnSnSerializer(dispatcher);
+ choiceSerializer = new ChoiceNodeCnSnSerializer(dispatcher);
+ augmentSerializer = new AugmentationNodeCnSnSerializer(dispatcher);
+ leafNodeSerializer = new LeafNodeCnSnSerializer();
+
+ leafSetEntryNodeSerializer = new LeafSetEntryNodeCnSnSerializer();
+ leafSetSerializer = new LeafSetNodeCnSnSerializer(leafSetEntryNodeSerializer);
+
+ mapEntryNodeSerializer = new MapEntryNodeCnSnSerializer(dispatcher);
+ mapNodeSerializer = new MapNodeCnSnSerializer(mapEntryNodeSerializer);
+ }
+
+
+ public static CnSnFromNormalizedNodeSerializerFactory getInstance() {
+ return new CnSnFromNormalizedNodeSerializerFactory();
+}
+
+ @Override
+ public FromNormalizedNodeSerializer<Node<?>, ContainerNode, ContainerSchemaNode> getContainerNodeSerializer() {
+ return containerSerializer;
+ }
+
+ @Override
+ public FromNormalizedNodeSerializer<Node<?>, LeafNode<?>, LeafSchemaNode> getLeafNodeSerializer() {
+ return leafNodeSerializer;
+ }
+
+ @Override
+ public FromNormalizedNodeSerializer<Node<?>, LeafSetNode<?>, LeafListSchemaNode> getLeafSetNodeSerializer() {
+ return leafSetSerializer;
+ }
+
+ @Override
+ public FromNormalizedNodeSerializer<Node<?>, MapNode, ListSchemaNode> getMapNodeSerializer() {
+ return mapNodeSerializer;
+ }
+
+ @Override
+ public FromNormalizedNodeSerializer<Node<?>, ChoiceNode, org.opendaylight.yangtools.yang.model.api.ChoiceNode> getChoiceNodeSerializer() {
+ return choiceSerializer;
+ }
+
+ @Override
+ public FromNormalizedNodeSerializer<Node<?>, AugmentationNode, AugmentationSchema> getAugmentationNodeSerializer() {
+ return augmentSerializer;
+ }
+
+
+ @Override
+ public FromNormalizedNodeSerializer<Node<?>, LeafSetEntryNode<?>, LeafListSchemaNode> getLeafSetEntryNodeSerializer() {
+ return leafSetEntryNodeSerializer;
+ }
+
+
+ @Override
+ public FromNormalizedNodeSerializer<Node<?>, MapEntryNode, ListSchemaNode> getMapEntryNodeSerializer() {
+ return mapEntryNodeSerializer;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.serializer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.opendaylight.yangtools.yang.data.api.MutableCompositeNode;
+import org.opendaylight.yangtools.yang.data.api.MutableNode;
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.impl.NodeFactory;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.ContainerNodeBaseSerializer;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.NodeSerializerDispatcher;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+
+import com.google.common.base.Preconditions;
+
+public class ContainerNodeCnSnSerializer extends ContainerNodeBaseSerializer<Node<?>> {
+
+ private NodeSerializerDispatcher<Node<?>> dispatcher;
+
+ ContainerNodeCnSnSerializer(final NodeSerializerDispatcher<Node<?>> dispatcher) {
+ this.dispatcher = Preconditions.checkNotNull(dispatcher);;
+ }
+
+ @Override
+ public List<Node<?>> serialize(ContainerSchemaNode schema, ContainerNode containerNode) {
+
+ MutableCompositeNode mutCompNode = NodeFactory.createMutableCompositeNode(containerNode.getNodeType(), null,
+ null, null, null);
+
+ for (Node<?> element : super.serialize(schema, containerNode)) {
+ if (element instanceof MutableNode<?>) {
+ ((MutableNode<?>) element).setParent(mutCompNode);
+ }
+ mutCompNode.getValue().add(element);
+ }
+
+ List<Node<?>> lst = new ArrayList<>();
+ lst.add(mutCompNode);
+ return lst;
+ }
+
+ @Override
+ protected NodeSerializerDispatcher<Node<?>> getNodeDispatcher() {
+ return dispatcher;
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.serializer;
+
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
+import org.opendaylight.yangtools.yang.data.impl.NodeFactory;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.LeafNodeBaseSerializer;
+import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+
+public class LeafNodeCnSnSerializer extends LeafNodeBaseSerializer<Node<?>> {
+
+ @Override
+ protected Node<?> serializeLeaf(LeafSchemaNode schema, LeafNode<?> node) {
+ return NodeFactory.createMutableSimpleNode(node.getNodeType(), null, node.getValue(), null, null);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.serializer;
+
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
+import org.opendaylight.yangtools.yang.data.impl.NodeFactory;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.LeafSetEntryNodeBaseSerializer;
+import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
+
+public class LeafSetEntryNodeCnSnSerializer extends
+ LeafSetEntryNodeBaseSerializer<Node<?>> {
+
+ @Override
+ protected Node<?> serializeLeaf(LeafListSchemaNode schema, LeafSetEntryNode<?> node) {
+ return NodeFactory.createMutableSimpleNode(
+ node.getNodeType(), null, node.getValue(), null, null);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.serializer;
+
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.FromNormalizedNodeSerializer;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.LeafSetNodeBaseSerializer;
+import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
+
+public class LeafSetNodeCnSnSerializer extends
+ LeafSetNodeBaseSerializer<Node<?>> {
+
+ private FromNormalizedNodeSerializer<Node<?>, LeafSetEntryNode<?>, LeafListSchemaNode> leafSetEntryNodeSerializer;
+
+ public LeafSetNodeCnSnSerializer(final LeafSetEntryNodeCnSnSerializer leafSetEntryNodeSerializer) {
+ this.leafSetEntryNodeSerializer = leafSetEntryNodeSerializer;
+ }
+
+ @Override
+ protected FromNormalizedNodeSerializer<Node<?>, LeafSetEntryNode<?>, LeafListSchemaNode> getLeafSetEntryNodeSerializer() {
+ return leafSetEntryNodeSerializer;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.serializer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.opendaylight.yangtools.yang.data.api.MutableCompositeNode;
+import org.opendaylight.yangtools.yang.data.api.MutableNode;
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.impl.NodeFactory;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.MapEntryNodeBaseSerializer;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.NodeSerializerDispatcher;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+
+import com.google.common.base.Preconditions;
+
+public class MapEntryNodeCnSnSerializer extends MapEntryNodeBaseSerializer<Node<?>> {
+
+ private NodeSerializerDispatcher<Node<?>> dispatcher;
+
+ MapEntryNodeCnSnSerializer(final NodeSerializerDispatcher<Node<?>> dispatcher) {
+ this.dispatcher = Preconditions.checkNotNull(dispatcher);
+ }
+
+ public List<Node<?>> serialize(ListSchemaNode schema, MapEntryNode node) {
+
+ MutableCompositeNode mutCompNode = NodeFactory.createMutableCompositeNode(node.getNodeType(), null, null, null,
+ null);
+
+ for (Node<?> element : super.serialize(schema, node)) {
+ if (element instanceof MutableNode<?>) {
+ ((MutableNode<?>) element).setParent(mutCompNode);
+ }
+ mutCompNode.getValue().add(element);
+ }
+
+ List<Node<?>> lst = new ArrayList<>();
+ lst.add(mutCompNode);
+ return lst;
+ }
+
+ @Override
+ protected NodeSerializerDispatcher<Node<?>> getNodeDispatcher() {
+ return dispatcher;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.serializer;
+
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.FromNormalizedNodeSerializer;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.MapNodeBaseSerializer;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+
+public class MapNodeCnSnSerializer extends MapNodeBaseSerializer<Node<?>> {
+
+ private final FromNormalizedNodeSerializer<Node<?>, MapEntryNode, ListSchemaNode> mapEntrySerializer;
+
+ public MapNodeCnSnSerializer(final MapEntryNodeCnSnSerializer mapEntrySerializer) {
+ this.mapEntrySerializer = mapEntrySerializer;
+ }
+
+ @Override
+ protected FromNormalizedNodeSerializer<Node<?>, MapEntryNode, ListSchemaNode> getMapEntryNodeDomSerializer() {
+ return mapEntrySerializer;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.json;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.CompositeNode;
+import org.opendaylight.yangtools.yang.data.api.Node;
+
+import com.google.common.collect.LinkedListMultimap;
+
+public class CnSnToNormalizedNodesUtils {
+
+ public static LinkedListMultimap<QName, Node<?>> mapChildElementsForSingletonNode(Node<?> node) {
+ return mapChildElements( ((CompositeNode)node).getValue());
+ }
+
+ public static LinkedListMultimap<QName, Node<?>> mapChildElements(Iterable<Node<?>> childNodesCollection) {
+ LinkedListMultimap<QName, Node<?>> mappedChildElements = LinkedListMultimap.create();
+
+ for (Node<?> node : childNodesCollection) {
+ mappedChildElements.put(node.getNodeType(), node);
+ }
+
+ return mappedChildElements;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema;
+
+import static org.junit.Assert.assertNotNull;
+import static org.opendaylight.yangtools.yang.data.impl.NodeFactory.createMutableCompositeNode;
+import static org.opendaylight.yangtools.yang.data.impl.NodeFactory.createMutableSimpleNode;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.CompositeNode;
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.MutableCompositeNode;
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
+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.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;
+import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TestUtils {
+
+ private static final Logger LOG = LoggerFactory.getLogger(TestUtils.class);
+
+ private final static YangModelParser parser = new YangParserImpl();
+
+ private static final String NAMESPACE_BASE = "simple:container:yang";
+ private static final String NAMESPACE_AUGMENT = "augment:container:yang";
+ private static Date revision_base;
+ private static Date revision_augment;
+
+ static {
+ try {
+ revision_base = new SimpleDateFormat("yyyy-MM-dd").parse("2013-11-12");
+ revision_augment = new SimpleDateFormat("yyyy-MM-dd").parse("2014-03-19");
+ } catch (ParseException e) {
+ e.printStackTrace();
+ }
+ }
+
+ private static Set<Module> loadModules(String resourceDirectory) throws FileNotFoundException {
+ final File testDir = new File(resourceDirectory);
+ final String[] fileList = testDir.list();
+ final List<File> testFiles = new ArrayList<File>();
+ if (fileList == null) {
+ throw new FileNotFoundException(resourceDirectory);
+ }
+ for (int i = 0; i < fileList.length; i++) {
+ String fileName = fileList[i];
+ if (new File(testDir, fileName).isDirectory() == false) {
+ testFiles.add(new File(testDir, fileName));
+ }
+ }
+ return parser.parseYangModels(testFiles);
+ }
+
+ public static Set<Module> loadModulesFrom(String yangPath) {
+ try {
+ return loadModules(TestUtils.class.getResource(yangPath).getPath());
+ } catch (FileNotFoundException e) {
+ LOG.error("Yang files at path: " + yangPath + " weren't loaded.");
+ }
+
+ return null;
+ }
+
+ public static DataSchemaNode resolveDataSchemaNode(String searchedDataSchemaName, Module module) {
+ assertNotNull("Module can't be null", module);
+
+ if (searchedDataSchemaName != null) {
+ for (DataSchemaNode dsn : module.getChildNodes()) {
+ if (dsn.getQName().getLocalName().equals(searchedDataSchemaName)) {
+ return dsn;
+ }
+ }
+ } else if (module.getChildNodes().size() == 1) {
+ return module.getChildNodes().iterator().next();
+ }
+ return null;
+ }
+
+ public static Module resolveModule(String searchedModuleName, Set<Module> modules) {
+ assertNotNull("Modules can't be null.", modules);
+ if (searchedModuleName != null) {
+ for (Module m : modules) {
+ if (m.getName().equals(searchedModuleName)) {
+ return m;
+ }
+ }
+ } else if (modules.size() == 1) {
+ return modules.iterator().next();
+ }
+ return null;
+ }
+
+ /**
+ * Prepare composite node structure according to
+ * /cnsn-to-normalized-node/simple-conainer.json
+ */
+ public static CompositeNode prepareCompositeNodeStruct() {
+ MutableCompositeNode cont = createMutableCompositeNode(new QName(URI.create(NAMESPACE_BASE), revision_base,
+ "cont"), null, null, null, null);
+
+ // cont1
+ List<Node<?>> contChilds = new ArrayList<>();
+ contChilds.add(createMutableCompositeNode(new QName(URI.create(NAMESPACE_BASE), revision_base, "cont1"), cont,
+ Collections.<Node<?>> emptyList(), null, null));
+
+ // cont2
+ MutableCompositeNode cont2 = createMutableCompositeNode(new QName(URI.create(NAMESPACE_BASE), revision_base,
+ "cont2"), cont, null, null, null);
+ List<Node<?>> cont2Childs = new ArrayList<>();
+ cont2Childs.add(createMutableSimpleNode(new QName(URI.create(NAMESPACE_BASE), revision_base, "lf21"), cont2,
+ "value in cont2/lf21", null, null));
+ cont2.setValue(cont2Childs);
+ contChilds.add(cont2);
+
+ // lst1
+ contChilds.add(createMutableCompositeNode(new QName(URI.create(NAMESPACE_BASE), revision_base, "lst1"), cont,
+ Collections.<Node<?>> emptyList(), null, null));
+
+ // lst2
+ MutableCompositeNode lst2_1 = createMutableCompositeNode(new QName(URI.create(NAMESPACE_BASE), revision_base,
+ "lst2"), cont, null, null, null);
+ List<Node<?>> lst2_1Childs = new ArrayList<>();
+ lst2_1Childs.add(createMutableSimpleNode(new QName(URI.create(NAMESPACE_BASE), revision_base, "lf21"), lst2_1,
+ "some value21", null, null));
+ lst2_1.setValue(lst2_1Childs);
+ contChilds.add(lst2_1);
+
+ MutableCompositeNode lst2_2 = createMutableCompositeNode(new QName(URI.create(NAMESPACE_BASE), revision_base,
+ "lst2"), cont, null, null, null);
+ List<Node<?>> lst2_2Childs = new ArrayList<>();
+ lst2_2Childs.add(createMutableSimpleNode(new QName(URI.create(NAMESPACE_BASE), revision_base, "lf22"), lst2_2,
+ "some value22", null, null));
+ lst2_2.setValue(lst2_2Childs);
+ contChilds.add(lst2_2);
+
+ // lflst1
+ contChilds.add(createMutableSimpleNode(new QName(URI.create(NAMESPACE_BASE), revision_base, "lflst1"), cont,
+ "lflst1_1", null, null));
+ contChilds.add(createMutableSimpleNode(new QName(URI.create(NAMESPACE_BASE), revision_base, "lflst1"), cont,
+ "lflst1_2", null, null));
+
+ // lf1
+ contChilds.add(createMutableSimpleNode(new QName(URI.create(NAMESPACE_BASE), revision_base, "lf1"), cont,
+ "lf1", null, null));
+
+ // lf11
+ contChilds.add(createMutableSimpleNode(new QName(URI.create(NAMESPACE_BASE), revision_base, "lf11"), cont,
+ "value from case (cs1)", null, null));
+
+ // cont3
+ MutableCompositeNode cont3 = createMutableCompositeNode(new QName(URI.create(NAMESPACE_AUGMENT),
+ revision_augment, "cont3"), cont, null, null, null);
+ List<Node<?>> cont3Childs = new ArrayList<>();
+ cont3Childs.add(createMutableSimpleNode(new QName(URI.create(NAMESPACE_AUGMENT), revision_augment, "lf31"),
+ cont3, "value in leaf in augment", null, null));
+ cont3.setValue(cont3Childs);
+ contChilds.add(cont3);
+
+ cont.setValue(contChilds);
+ return cont;
+ }
+
+ /**
+ * Prepare composite node structure according to
+ * /cnsn-to-normalized-node/simple-conainer.json
+ */
+ public static ContainerNode prepareNormalizedNodeStruct() throws URISyntaxException {
+ DataContainerNodeBuilder<NodeIdentifier, ContainerNode> containerBuilder = Builders.containerBuilder();
+ containerBuilder.withNodeIdentifier(getNodeIdentifier("cont"));
+ containerBuilder.withChild(Builders.containerBuilder().withNodeIdentifier(getNodeIdentifier("cont1")).build());
+ containerBuilder.withChild(Builders
+ .containerBuilder()
+ .withNodeIdentifier(getNodeIdentifier("cont2"))
+ .withChild(
+ Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("lf21"))
+ .withValue("value in cont2/lf21").build()).build());
+
+
+ CollectionNodeBuilder<MapEntryNode, MapNode> lst1 = Builders.mapBuilder().withNodeIdentifier(
+ getNodeIdentifier("lst1"));
+ lst1.withChild(Builders.mapEntryBuilder()
+ .withNodeIdentifier(getNodeIdentifierPredicate("lst1", new HashMap<String, Object>()))
+ .withValue(Collections.<DataContainerChild<? extends PathArgument, ?>> emptyList()).build());
+ containerBuilder.withChild(lst1.build());
+
+ CollectionNodeBuilder<MapEntryNode, MapNode> lst2 = Builders.mapBuilder().withNodeIdentifier(
+ getNodeIdentifier("lst2"));
+
+ Map<String, Object> lst2_1 = new HashMap<>();
+ lst2_1.put("lf21", "some value21");
+
+ List<DataContainerChild<? extends PathArgument, ?>> lst2_1_values = new ArrayList<>();
+ lst2_1_values.add(Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("lf21"))
+ .withValue("some value21").build());
+ lst2.withChild(Builders.mapEntryBuilder().withNodeIdentifier(getNodeIdentifierPredicate("lst2", lst2_1))
+ .withValue(lst2_1_values).build());
+
+ Map<String, Object> lst2_2 = new HashMap<>();
+ lst2_2.put("lf22", "some value22");
+ List<DataContainerChild<? extends PathArgument, ?>> lst2_2_values = new ArrayList<>();
+ lst2_2_values.add(Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("lf22"))
+ .withValue("some value22").build());
+ lst2.withChild(Builders.mapEntryBuilder().withNodeIdentifier(getNodeIdentifierPredicate("lst2", lst2_2))
+ .withValue(lst2_2_values).build());
+ containerBuilder.withChild(lst2.build());
+
+ ListNodeBuilder<Object, LeafSetEntryNode<Object>> lflst1 = Builders.leafSetBuilder().withNodeIdentifier(
+ getNodeIdentifier("lflst1"));
+ lflst1.withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(getNodeIdentifier("lflst1", "lflst1_1"))
+ .withValue("lflst1_1").build());
+ lflst1.withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(getNodeIdentifier("lflst1", "lflst1_2"))
+ .withValue("lflst1_2").build());
+ containerBuilder.withChild(lflst1.build());
+
+ containerBuilder.withChild(Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("lf1")).withValue("lf1")
+ .build());
+
+ containerBuilder.withChild(Builders
+ .choiceBuilder()
+ .withNodeIdentifier(getNodeIdentifier("chc"))
+ .withChild(
+ Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("lf11"))
+ .withValue("value from case (cs1)").build()).build());
+
+ Set<QName> children = new HashSet<>();
+ children.add(new QName(new URI(NAMESPACE_AUGMENT), revision_augment, "cont3"));
+
+ containerBuilder.withChild(Builders
+ .augmentationBuilder()
+ .withNodeIdentifier(getAugmentationIdentifier(null, null, null, children))
+ .withChild(
+ Builders.containerBuilder()
+ .withNodeIdentifier(getNodeIdentifier("cont3", NAMESPACE_AUGMENT, revision_augment))
+ .withChild(
+ Builders.leafBuilder()
+ .withNodeIdentifier(
+ getNodeIdentifier("lf31", NAMESPACE_AUGMENT, revision_augment))
+ .withValue("value in leaf in augment").build()).build()).build());
+
+
+ ContainerNode build = containerBuilder.build();
+ return build;
+ }
+
+ private static InstanceIdentifier.NodeIdentifier getNodeIdentifier(String localName) {
+ return new InstanceIdentifier.NodeIdentifier(new QName(URI.create(NAMESPACE_BASE), revision_base, localName));
+ }
+
+ private static InstanceIdentifier.NodeIdentifier getNodeIdentifier(String localName, String namespace, Date revision) {
+ return new InstanceIdentifier.NodeIdentifier(new QName(URI.create(namespace), revision, localName));
+ }
+
+ private static InstanceIdentifier.NodeWithValue getNodeIdentifier(String localName, Object value) {
+ return new InstanceIdentifier.NodeWithValue(new QName(URI.create(NAMESPACE_BASE), revision_base, localName),
+ value);
+ }
+
+ private static InstanceIdentifier.NodeIdentifierWithPredicates getNodeIdentifierPredicate(String localName,
+ Map<String, Object> keys) {
+ Map<QName, Object> predicate = new HashMap<>();
+ for (String key : keys.keySet()) {
+ predicate.put(new QName(URI.create(NAMESPACE_BASE), revision_base, key), keys.get(key));
+ }
+
+ return new InstanceIdentifier.NodeIdentifierWithPredicates(
+
+ new QName(URI.create(NAMESPACE_BASE), revision_base, localName), predicate);
+ }
+
+ private static InstanceIdentifier.AugmentationIdentifier getAugmentationIdentifier(String localName,
+ String namespace, Date revision, Set<QName> children) {
+ return new InstanceIdentifier.AugmentationIdentifier(null, children);
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.parser;
+
+import static org.junit.Assert.assertEquals;
+
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.opendaylight.yangtools.yang.data.api.CompositeNode;
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.json.schema.TestUtils;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.Module;
+
+public class ParseCnSnStructToNormalizedStructTest {
+
+ private static DataSchemaNode resolvedDataSchemaNode;
+
+ @BeforeClass
+ public static void loadData() {
+ Set<Module> modules = TestUtils.loadModulesFrom("/cnsn-to-normalized-node/yang");
+ Module resolvedModule = TestUtils.resolveModule("simple-container-yang", modules);
+ resolvedDataSchemaNode = TestUtils.resolveDataSchemaNode("cont", resolvedModule);
+ }
+
+ @Test
+ public void testCnSnToNormalizedNode() throws URISyntaxException {
+
+ CompositeNode compNode = TestUtils.prepareCompositeNodeStruct();
+
+ List<Node<?>> lst = new ArrayList<Node<?>>();
+ lst.add(compNode);
+ ContainerNode parsed = CnSnToNormalizedNodeParserFactory.getInstance().getContainerNodeParser()
+ .parse(lst, (ContainerSchemaNode) resolvedDataSchemaNode);
+
+ ContainerNode prepareExpectedStruct = TestUtils.prepareNormalizedNodeStruct();
+ assertEquals(prepareExpectedStruct, parsed);
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.json.schema.cnsn.serializer;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.net.URISyntaxException;
+import java.util.Set;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.opendaylight.yangtools.yang.data.api.CompositeNode;
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.json.schema.TestUtils;
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.Module;
+
+public class SerializeNormalizedStructToCnSnStructTest {
+
+ private static DataSchemaNode resolvedDataSchemaNode;
+
+ @BeforeClass
+ public static void loadData() {
+ Set<Module> modules = TestUtils.loadModulesFrom("/cnsn-to-normalized-node/yang");
+ Module resolvedModule = TestUtils.resolveModule("simple-container-yang", modules);
+ resolvedDataSchemaNode = TestUtils.resolveDataSchemaNode("cont", resolvedModule);
+ }
+
+ @Test
+ public void testCnSnToNormalizedNode() throws URISyntaxException {
+ ContainerNode containerNode = TestUtils.prepareNormalizedNodeStruct();
+
+ Iterable<Node<?>> serialized = CnSnFromNormalizedNodeSerializerFactory.getInstance()
+ .getContainerNodeSerializer().serialize((ContainerSchemaNode) resolvedDataSchemaNode, containerNode);
+
+ assertNotNull(serialized);
+ assertNotNull(serialized.iterator());
+ assertNotNull(serialized.iterator().hasNext());
+
+ CompositeNode compNode = TestUtils.prepareCompositeNodeStruct();
+ assertEquals(serialized.iterator().next(), compNode);
+ }
+}
--- /dev/null
+{
+ "simple-container-yang:cont":{
+ "cont1":{
+ },
+ "cont2":{
+ "lf21":"value in cont2/lf21"
+ },
+ "augment-container-yang:cont3":{
+ "lf31":"value in leaf in augment"
+ },
+ "lst1": [
+ {
+ }
+ ],
+ "lst2": [
+ {
+ "lf21":"some value21"
+ },
+ {
+ "lf22":"some value22"
+ }
+ ],
+ "lflst1":[
+ "lflst1_1",
+ "lflst1_2"
+ ],
+ "lf1":"lf1",
+
+ "lf11":"value from case (cs1)"
+ }
+}
\ No newline at end of file
--- /dev/null
+module augment-container-yang {
+ namespace "augment:container:yang";
+
+ prefix "auconyang";
+ import simple-container-yang { prefix "simple"; revision-date 2013-11-12; }
+
+ revision 2014-03-19 {
+ }
+
+ augment "/simple:cont" {
+ container cont3 {
+ leaf lf31 {
+ type string;
+ }
+ }
+ }
+
+}
--- /dev/null
+module simple-container-yang {
+ namespace "simple:container:yang";
+
+ prefix "smpdtp";
+ revision 2013-11-12 {
+ }
+
+ container cont {
+ container cont1 {
+ }
+ container cont2 {
+ leaf lf21 {
+ type string;
+ }
+ }
+ list lst1 {
+ }
+ list lst2 {
+ leaf lf21 {
+ type string;
+ }
+ leaf lf22 {
+ type string;
+ }
+ }
+ leaf-list lflst1 {
+ type string;
+ }
+ leaf lf1 {
+ type string;
+ }
+
+ choice chc {
+ case cs1 {
+ leaf lf11 {
+ type string;
+ }
+ }
+ case cs2 {
+ leaf lf21 {
+ type string;
+ }
+ }
+ }
+
+ }
+}
Code Review / yangtools.git / commitdiff