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.api.schema.OrderedMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
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;
private final LeafSetNodeCnSnParser leafSetNodeCnSnParser;
private final MapNodeCnSnParser mapNodeCnSnParser;
private final MapEntryNodeCnSnParser mapEntryNodeCnSnParser;
+ private final UnkeyedListNodeCnSnParser unkeyedListNodeCnSnParser;
+ private final UnkeyedListEntryNodeCnSnParser unkeyedListEntryNodeCnSnParser;
private final ChoiceNodeCnSnParser choiceNodeCnSnParser;
private final AugmentationNodeCnSnParser augmentationNodeCnSnParser;
private final AnyXmlNodeCnSnParser anyXmlNodeCnSnParser;
+ private final OrderedListNodeCnSnParser orderedListNodeCnSnParser;
private CnSnToNormalizedNodeParserFactory() {
leafNodeCnSnParser = new LeafNodeCnSnParser();
containerNodeCnSnParser = new ContainerNodeCnSnParser(dispatcher);
mapEntryNodeCnSnParser = new MapEntryNodeCnSnParser(dispatcher);
mapNodeCnSnParser = new MapNodeCnSnParser(mapEntryNodeCnSnParser);
+ orderedListNodeCnSnParser = new OrderedListNodeCnSnParser(mapEntryNodeCnSnParser);
+ unkeyedListEntryNodeCnSnParser = new UnkeyedListEntryNodeCnSnParser(dispatcher);
+ unkeyedListNodeCnSnParser = new UnkeyedListNodeCnSnParser(unkeyedListEntryNodeCnSnParser);
choiceNodeCnSnParser = new ChoiceNodeCnSnParser(dispatcher);
augmentationNodeCnSnParser = new AugmentationNodeCnSnParser(dispatcher);
public ToNormalizedNodeParser<Node<?>, AnyXmlNode, AnyXmlSchemaNode> getAnyXmlNodeParser() {
return anyXmlNodeCnSnParser;
}
+
+ @Override
+ public ToNormalizedNodeParser<Node<?>, UnkeyedListNode, ListSchemaNode> getUnkeyedListNodeParser() {
+ return unkeyedListNodeCnSnParser;
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Node<?>, UnkeyedListEntryNode, ListSchemaNode> getUnkeyedListEntryNodeParser() {
+ return unkeyedListEntryNodeCnSnParser;
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Node<?>, OrderedMapNode, ListSchemaNode> getOrderedListNodeParser() {
+ return orderedListNodeCnSnParser;
+ }
+
}
--- /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.composite.node.schema.cnsn.parser;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.LinkedListMultimap;
+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.api.schema.DataContainerNode;
+import org.opendaylight.yangtools.yang.data.composite.node.schema.json.CnSnToNormalizedNodesUtils;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.ListEntryNodeBaseParser;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher;
+
+abstract class ListEntryNodeCnSnParser<N extends DataContainerNode<?>> extends ListEntryNodeBaseParser<Node<?>, N> {
+
+ private final NodeParserDispatcher<Node<?>> dispatcher;
+
+ ListEntryNodeCnSnParser(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();
+ }
+
+}
*/
package org.opendaylight.yangtools.yang.data.composite.node.schema.cnsn.parser;
-import org.opendaylight.yangtools.yang.data.composite.node.schema.json.CnSnToNormalizedNodesUtils;
-
-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.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-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 final class MapEntryNodeCnSnParser extends ListEntryNodeCnSnParser<MapEntryNode> {
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());
+ super(dispatcher);
}
@Override
- protected NodeParserDispatcher<Node<?>> getDispatcher() {
- return dispatcher;
+ protected final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> getBuilder(
+ ListSchemaNode schema) {
+ return Builders.mapEntryBuilder(schema);
}
- @Override
- protected Map<QName, String> getAttributes(Node<?> e) {
- return Collections.emptyMap();
- }
}
}
@Override
- protected ToNormalizedNodeParser<Node<?>, MapEntryNode, ListSchemaNode> getMapEntryNodeParser() {
+ protected ToNormalizedNodeParser<Node<?>, MapEntryNode, ListSchemaNode> getListEntryNodeParser() {
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.composite.node.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.OrderedListNodeBaseParser;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+
+public final class OrderedListNodeCnSnParser extends OrderedListNodeBaseParser<Node<?>> {
+
+ private final MapEntryNodeCnSnParser mapEntryNodeCnSnParser;
+
+ public OrderedListNodeCnSnParser(MapEntryNodeCnSnParser mapEntryNodeCnSnParser) {
+ this.mapEntryNodeCnSnParser = mapEntryNodeCnSnParser;
+ }
+
+ @Override
+ protected ToNormalizedNodeParser<Node<?>, MapEntryNode, ListSchemaNode> getListEntryNodeParser() {
+ 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.composite.node.schema.cnsn.parser;
+
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+
+final class UnkeyedListEntryNodeCnSnParser extends ListEntryNodeCnSnParser<UnkeyedListEntryNode> {
+
+ UnkeyedListEntryNodeCnSnParser(final NodeParserDispatcher<Node<?>> dispatcher) {
+ super(dispatcher);
+ }
+
+ @Override
+ protected final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, UnkeyedListEntryNode> getBuilder(
+ ListSchemaNode schema) {
+ return Builders.unkeyedListEntryBuilder().withNodeIdentifier(new NodeIdentifier(schema.getQName()));
+ }
+
+}
--- /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.composite.node.schema.cnsn.parser;
+
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.UnkeyedListNodeBaseParser;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+
+final class UnkeyedListNodeCnSnParser extends UnkeyedListNodeBaseParser<Node<?>> {
+
+ private final UnkeyedListEntryNodeCnSnParser unkeyedListEntryNodeParser;
+
+ UnkeyedListNodeCnSnParser(UnkeyedListEntryNodeCnSnParser unkeyedListEntryNodeParser) {
+ this.unkeyedListEntryNodeParser = unkeyedListEntryNodeParser;
+ }
+
+ @Override
+ protected ToNormalizedNodeParser<Node<?>, UnkeyedListEntryNode, ListSchemaNode> getListEntryNodeParser() {
+ return unkeyedListEntryNodeParser;
+ }
+}
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.api.schema.UnkeyedListNode;
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;
private final LeafSetEntryNodeCnSnSerializer leafSetEntryNodeSerializer;
private final MapEntryNodeCnSnSerializer mapEntryNodeSerializer;
private final AnyXmlNodeCnSnSerializer anyXmlNodeSerializer;
+ private final UnkeyedListNodeCnSnSerializer unkeyedListNodeSerializer;
+ private final UnkeyedListEntryNodeCnSnSerializer unkeyedListEntryNodeSerializer;
private CnSnFromNormalizedNodeSerializerFactory() {
final NodeSerializerDispatcher.BaseNodeSerializerDispatcher<Node<?>> dispatcher = new NodeSerializerDispatcher.BaseNodeSerializerDispatcher<Node<?>>(
mapEntryNodeSerializer = new MapEntryNodeCnSnSerializer(dispatcher);
mapNodeSerializer = new MapNodeCnSnSerializer(mapEntryNodeSerializer);
+
+ unkeyedListEntryNodeSerializer = new UnkeyedListEntryNodeCnSnSerializer(dispatcher);
+ unkeyedListNodeSerializer = new UnkeyedListNodeCnSnSerializer(unkeyedListEntryNodeSerializer);
}
public FromNormalizedNodeSerializer<Node<?>, AnyXmlNode, AnyXmlSchemaNode> getAnyXmlNodeSerializer() {
return anyXmlNodeSerializer;
}
+
+ @Override
+ public FromNormalizedNodeSerializer<Node<?>, UnkeyedListNode, ListSchemaNode> getUnkeyedListNodeSerializer() {
+ return unkeyedListNodeSerializer;
+ }
}
--- /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.composite.node.schema.cnsn.serializer;
+
+import com.google.common.base.Preconditions;
+import java.util.Collections;
+import java.util.List;
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
+import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.ListEntryNodeBaseSerializer;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.NodeSerializerDispatcher;
+import org.opendaylight.yangtools.yang.data.impl.util.CompositeNodeBuilder;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+
+/**
+ *
+ * Common class for list entry node serialization (MapEntry, UnkeyedListEntry nodes)
+ *
+ * @param <N>
+ * concrete entry node type
+ */
+abstract class ListEntryNodeCnSnSerializer<N extends DataContainerNode<?>> extends
+ ListEntryNodeBaseSerializer<Node<?>, N> {
+ private final NodeSerializerDispatcher<Node<?>> dispatcher;
+
+ ListEntryNodeCnSnSerializer(final NodeSerializerDispatcher<Node<?>> dispatcher) {
+ this.dispatcher = Preconditions.checkNotNull(dispatcher);
+ }
+
+ @Override
+ public List<Node<?>> serialize(ListSchemaNode schema, N node) {
+ CompositeNodeBuilder<ImmutableCompositeNode> compNodeBuilder = ImmutableCompositeNode.builder();
+ compNodeBuilder.setQName(node.getNodeType());
+ compNodeBuilder.addAll(super.serialize(schema, node));
+ return Collections.<Node<?>> singletonList(compNodeBuilder.toInstance());
+ }
+
+ @Override
+ protected NodeSerializerDispatcher<Node<?>> getNodeDispatcher() {
+ return dispatcher;
+ }
+}
*/
package org.opendaylight.yangtools.yang.data.composite.node.schema.cnsn.serializer;
-import com.google.common.base.Preconditions;
-import java.util.Collections;
-import java.util.List;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
-import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
-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.data.impl.util.CompositeNodeBuilder;
-import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-public class MapEntryNodeCnSnSerializer extends MapEntryNodeBaseSerializer<Node<?>> {
-
- private final NodeSerializerDispatcher<Node<?>> dispatcher;
+public class MapEntryNodeCnSnSerializer extends ListEntryNodeCnSnSerializer<MapEntryNode> {
MapEntryNodeCnSnSerializer(final NodeSerializerDispatcher<Node<?>> dispatcher) {
- this.dispatcher = Preconditions.checkNotNull(dispatcher);
- }
-
- @Override
- public List<Node<?>> serialize(ListSchemaNode schema, MapEntryNode node) {
- CompositeNodeBuilder<ImmutableCompositeNode> compNodeBuilder = ImmutableCompositeNode.builder();
- compNodeBuilder.setQName(node.getNodeType());
- compNodeBuilder.addAll(super.serialize(schema, node));
- return Collections.<Node<?>> singletonList(compNodeBuilder.build());
- }
-
- @Override
- protected NodeSerializerDispatcher<Node<?>> getNodeDispatcher() {
- return dispatcher;
+ super(dispatcher);
}
}
import org.opendaylight.yangtools.yang.data.api.Node;
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.base.serializer.MapNodeBaseSerializer;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.ListNodeBaseSerializer;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-public class MapNodeCnSnSerializer extends MapNodeBaseSerializer<Node<?>> {
+public class MapNodeCnSnSerializer extends ListNodeBaseSerializer<Node<?>, MapNode, MapEntryNode> {
private final FromNormalizedNodeSerializer<Node<?>, MapEntryNode, ListSchemaNode> mapEntrySerializer;
}
@Override
- protected FromNormalizedNodeSerializer<Node<?>, MapEntryNode, ListSchemaNode> getMapEntryNodeDomSerializer() {
+ protected FromNormalizedNodeSerializer<Node<?>, MapEntryNode, ListSchemaNode> getListEntryNodeSerializer() {
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.composite.node.schema.cnsn.serializer;
+
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.NodeSerializerDispatcher;
+
+final class UnkeyedListEntryNodeCnSnSerializer extends ListEntryNodeCnSnSerializer<UnkeyedListEntryNode> {
+
+ UnkeyedListEntryNodeCnSnSerializer(final NodeSerializerDispatcher<Node<?>> dispatcher) {
+ super(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.composite.node.schema.cnsn.serializer;
+
+import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.FromNormalizedNodeSerializer;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.ListNodeBaseSerializer;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+
+final class UnkeyedListNodeCnSnSerializer extends
+ ListNodeBaseSerializer<Node<?>, UnkeyedListNode, UnkeyedListEntryNode> {
+
+ private final FromNormalizedNodeSerializer<Node<?>, UnkeyedListEntryNode, ListSchemaNode> unkeyedListEntrySerializer;
+
+ UnkeyedListNodeCnSnSerializer(UnkeyedListEntryNodeCnSnSerializer unkeyedListEntrySerializer) {
+ this.unkeyedListEntrySerializer = unkeyedListEntrySerializer;
+ }
+
+ @Override
+ protected FromNormalizedNodeSerializer<Node<?>, UnkeyedListEntryNode, ListSchemaNode> getListEntryNodeSerializer() {
+ return unkeyedListEntrySerializer;
+ }
+}
\ No newline at end of file
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.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
import org.opendaylight.yangtools.yang.data.impl.NodeFactory;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("lf21"))
.withValue("value in cont2/lf21").build()).build());
- CollectionNodeBuilder<MapEntryNode, MapNode> lst1 = Builders.mapBuilder().withNodeIdentifier(
+ CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> lst1 = Builders.unkeyedListBuilder().withNodeIdentifier(
getNodeIdentifier("lst1"));
- lst1.withChild(Builders.mapEntryBuilder()
- .withNodeIdentifier(getNodeIdentifierPredicate("lst1", new HashMap<String, Object>()))
+ lst1.withChild(Builders.unkeyedListEntryBuilder()
+ .withNodeIdentifier(getNodeIdentifier("lst1"))
.withValue(Collections.<DataContainerChild<? extends PathArgument, ?>> emptyList()).build());
containerBuilder.withChild(lst1.build());
- CollectionNodeBuilder<MapEntryNode, MapNode> lst2 = Builders.mapBuilder().withNodeIdentifier(
+ CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> lst2 = Builders.unkeyedListBuilder().withNodeIdentifier(
getNodeIdentifier("lst2"));
Map<String, Object> lst2_1 = new HashMap<>();
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))
+ lst2.withChild(Builders.unkeyedListEntryBuilder().withNodeIdentifier(getNodeIdentifier("lst2"))
.withValue(lst2_1_values).build());
Map<String, Object> lst2_2 = new HashMap<>();
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))
+ lst2.withChild(Builders.unkeyedListEntryBuilder().withNodeIdentifier(getNodeIdentifier("lst2"))
.withValue(lst2_2_values).build());
containerBuilder.withChild(lst2.build());
public void orderedListParseTest() throws DataValidationFailedException, URISyntaxException {
ContainerSchemaNode topContainerSchemaNode = (ContainerSchemaNode) TestUtils.resolveDataSchemaNode("top", bug2111TestModule);
ListSchemaNode aceListSchemaNode = (ListSchemaNode) topContainerSchemaNode.getDataChildByName("ordered-list");
- ToNormalizedNodeParser<Node<?>, MapNode, ListSchemaNode> mapNodeParser =
- CnSnToNormalizedNodeParserFactory.getInstance().getMapNodeParser();
- MapNode mapNode = mapNodeParser.parse(new ArrayList<Node<?>>(), aceListSchemaNode);
+ ToNormalizedNodeParser<Node<?>, OrderedMapNode, ListSchemaNode> orderedListNodeParser =
+ CnSnToNormalizedNodeParserFactory.getInstance().getOrderedListNodeParser();
+ MapNode mapNode = orderedListNodeParser.parse(new ArrayList<Node<?>>(), aceListSchemaNode);
assertTrue(mapNode instanceof OrderedMapNode);
}
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.api.schema.UnkeyedListNode;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
* type of resulting/serialized element from NormalizedNode
*/
public interface FromNormalizedNodeSerializerFactory<E> {
- FromNormalizedNodeSerializer<E, AugmentationNode, AugmentationSchema> getAugmentationNodeSerializer();
- FromNormalizedNodeSerializer<E, ChoiceNode, org.opendaylight.yangtools.yang.model.api.ChoiceNode> getChoiceNodeSerializer();
- FromNormalizedNodeSerializer<E, ContainerNode, ContainerSchemaNode> getContainerNodeSerializer();
- FromNormalizedNodeSerializer<E, LeafNode<?>, LeafSchemaNode> getLeafNodeSerializer();
- FromNormalizedNodeSerializer<E, LeafSetEntryNode<?>, LeafListSchemaNode> getLeafSetEntryNodeSerializer();
- FromNormalizedNodeSerializer<E, LeafSetNode<?>, LeafListSchemaNode> getLeafSetNodeSerializer();
- FromNormalizedNodeSerializer<E, MapEntryNode, ListSchemaNode> getMapEntryNodeSerializer();
- FromNormalizedNodeSerializer<E, MapNode, ListSchemaNode> getMapNodeSerializer();
- FromNormalizedNodeSerializer<E, AnyXmlNode, AnyXmlSchemaNode> getAnyXmlNodeSerializer();
+ FromNormalizedNodeSerializer<E, AugmentationNode, AugmentationSchema> getAugmentationNodeSerializer();
+ FromNormalizedNodeSerializer<E, ChoiceNode, org.opendaylight.yangtools.yang.model.api.ChoiceNode> getChoiceNodeSerializer();
+ FromNormalizedNodeSerializer<E, ContainerNode, ContainerSchemaNode> getContainerNodeSerializer();
+ FromNormalizedNodeSerializer<E, LeafNode<?>, LeafSchemaNode> getLeafNodeSerializer();
+ FromNormalizedNodeSerializer<E, LeafSetEntryNode<?>, LeafListSchemaNode> getLeafSetEntryNodeSerializer();
+ FromNormalizedNodeSerializer<E, LeafSetNode<?>, LeafListSchemaNode> getLeafSetNodeSerializer();
+ FromNormalizedNodeSerializer<E, MapEntryNode, ListSchemaNode> getMapEntryNodeSerializer();
+ FromNormalizedNodeSerializer<E, MapNode, ListSchemaNode> getMapNodeSerializer();
+ FromNormalizedNodeSerializer<E, UnkeyedListNode, ListSchemaNode> getUnkeyedListNodeSerializer();
+ FromNormalizedNodeSerializer<E, AnyXmlNode, AnyXmlSchemaNode> getAnyXmlNodeSerializer();
}
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.api.schema.OrderedMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
* type of element to be parsed into NormalizedNode
*/
public interface ToNormalizedNodeParserFactory<E> {
- ToNormalizedNodeParser<E, AugmentationNode, AugmentationSchema> getAugmentationNodeParser();
- ToNormalizedNodeParser<E, ChoiceNode, org.opendaylight.yangtools.yang.model.api.ChoiceNode> getChoiceNodeParser();
- ToNormalizedNodeParser<E, ContainerNode, ContainerSchemaNode> getContainerNodeParser();
- ToNormalizedNodeParser<E, LeafNode<?>, LeafSchemaNode> getLeafNodeParser();
- ToNormalizedNodeParser<E, LeafSetEntryNode<?>, LeafListSchemaNode> getLeafSetEntryNodeParser();
- ToNormalizedNodeParser<E, LeafSetNode<?>, LeafListSchemaNode> getLeafSetNodeParser();
- ToNormalizedNodeParser<E, MapEntryNode, ListSchemaNode> getMapEntryNodeParser();
- ToNormalizedNodeParser<E, MapNode, ListSchemaNode> getMapNodeParser();
- ToNormalizedNodeParser<E, AnyXmlNode, AnyXmlSchemaNode> getAnyXmlNodeParser();
+ ToNormalizedNodeParser<E, AugmentationNode, AugmentationSchema> getAugmentationNodeParser();
+ ToNormalizedNodeParser<E, ChoiceNode, org.opendaylight.yangtools.yang.model.api.ChoiceNode> getChoiceNodeParser();
+ ToNormalizedNodeParser<E, ContainerNode, ContainerSchemaNode> getContainerNodeParser();
+ ToNormalizedNodeParser<E, LeafNode<?>, LeafSchemaNode> getLeafNodeParser();
+ ToNormalizedNodeParser<E, LeafSetEntryNode<?>, LeafListSchemaNode> getLeafSetEntryNodeParser();
+ ToNormalizedNodeParser<E, LeafSetNode<?>, LeafListSchemaNode> getLeafSetNodeParser();
+ ToNormalizedNodeParser<E, MapEntryNode, ListSchemaNode> getMapEntryNodeParser();
+ ToNormalizedNodeParser<E, MapNode, ListSchemaNode> getMapNodeParser();
+ ToNormalizedNodeParser<E, UnkeyedListNode, ListSchemaNode> getUnkeyedListNodeParser();
+ ToNormalizedNodeParser<E, UnkeyedListEntryNode, ListSchemaNode> getUnkeyedListEntryNodeParser();
+ ToNormalizedNodeParser<E, AnyXmlNode, AnyXmlSchemaNode> getAnyXmlNodeParser();
+ ToNormalizedNodeParser<E, OrderedMapNode, ListSchemaNode> getOrderedListNodeParser();
}
import java.util.Map;
import java.util.Set;
-
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
+import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.opendaylight.yangtools.yang.data.impl.schema.SchemaUtils;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
/**
- * Abstract(base) parser for MapEntryNodes, parses elements of type E.
+ * Abstract(base) parser for ListNodes (MapNode, UnkeyedListNode), parses elements of type E.
*
- * @param <E> type of elements to be parsed
+ * @param <E>
+ * type of elements to be parsed
*/
-public abstract class MapEntryNodeBaseParser<E> extends BaseDispatcherParser<E, MapEntryNode, ListSchemaNode> {
-
- @Override
- protected final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> getBuilder(
- ListSchemaNode schema) {
- return Builders.mapEntryBuilder(schema);
- }
-
- @Override
- public final MapEntryNode parse(Iterable<E> elements, ListSchemaNode schema) {
- checkOnlyOneNode(schema, elements);
- return super.parse(elements, schema);
- }
+public abstract class ListEntryNodeBaseParser<E, N extends DataContainerNode<?>> extends
+ BaseDispatcherParser<E, N, ListSchemaNode> {
@Override
protected final Set<DataSchemaNode> getRealSchemasForAugment(ListSchemaNode schema, AugmentationSchema augmentSchema) {
return SchemaUtils.mapChildElementsFromAugments(schema);
}
+ @Override
+ public final N parse(Iterable<E> elements, ListSchemaNode schema) {
+ checkOnlyOneNode(schema, elements);
+ return super.parse(elements, schema);
+ }
+
@Override
protected abstract Map<QName, String> getAttributes(E e);
-}
+}
\ No newline at end of file
--- /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.impl.schema.transform.base.parser;
+
+import java.util.Collections;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+
+/**
+ * Abstract(base) parser for ListNodes (MapNode, UnkeyedListNode), parses elements of type E.
+ *
+ * @param <E>
+ * type of elements to be parsed
+ */
+public abstract class ListNodeBaseParser<E, N extends NormalizedNode<?, ?>, O extends NormalizedNode<YangInstanceIdentifier.NodeIdentifier, ?>, S extends ListSchemaNode>
+ implements ToNormalizedNodeParser<E, O, S> {
+
+ @Override
+ public final O parse(Iterable<E> childNodes, S schema) {
+ CollectionNodeBuilder<N, O> listBuilder = provideBuilder(schema);
+ for (E childNode : childNodes) {
+ N listChild = getListEntryNodeParser().parse(Collections.singletonList(childNode), schema);
+ listBuilder.withChild(listChild);
+ }
+
+ return listBuilder.build();
+ }
+
+ /**
+ *
+ * @return parser for inner ListEntryNodes used to parse every entry of ListNode, might be the same instance in case
+ * its immutable
+ */
+ protected abstract ToNormalizedNodeParser<E, N, S> getListEntryNodeParser();
+
+ /**
+ *
+ * @return prepares builder which will contain entries of list according to concrete list type
+ */
+ protected abstract CollectionNodeBuilder<N, O> provideBuilder(S schema);
+}
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.OrderedMapNode;
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.transform.ToNormalizedNodeParser;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import java.util.Collections;
-
/**
* Abstract(base) parser for MapNodes, parses elements of type E.
*
- * @param <E> type of elements to be parsed
+ * @param <E>
+ * type of elements to be parsed
*/
-public abstract class MapNodeBaseParser<E> implements ToNormalizedNodeParser<E, MapNode, ListSchemaNode> {
-
- @Override
- public final MapNode parse(Iterable<E> childNodes, ListSchemaNode schema) {
- if (schema.isUserOrdered()) {
- CollectionNodeBuilder<MapEntryNode, OrderedMapNode> listBuilder = Builders.orderedMapBuilder(schema);
-
- for (E childNode : childNodes) {
- MapEntryNode listChild = getMapEntryNodeParser().parse(Collections.singletonList(childNode), schema);
- listBuilder.withChild(listChild);
- }
+public abstract class MapNodeBaseParser<E> extends ListNodeBaseParser<E, MapEntryNode, MapNode, ListSchemaNode> {
- return listBuilder.build();
- } else {
- CollectionNodeBuilder<MapEntryNode, MapNode> listBuilder = Builders.mapBuilder(schema);
-
- for (E childNode : childNodes) {
- MapEntryNode listChild = getMapEntryNodeParser().parse(Collections.singletonList(childNode), schema);
- listBuilder.withChild(listChild);
- }
-
- return listBuilder.build();
- }
+ protected CollectionNodeBuilder<MapEntryNode, MapNode> provideBuilder(ListSchemaNode schema) {
+ return Builders.mapBuilder(schema);
}
- /**
- *
- * @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> getMapEntryNodeParser();
-
-}
+}
\ No newline at end of file
} else if (schema instanceof LeafListSchemaNode) {
return factory.getLeafSetNodeParser().parse(childNodes, (LeafListSchemaNode) schema);
} else if (schema instanceof ListSchemaNode) {
- return factory.getMapNodeParser().parse(childNodes, (ListSchemaNode) schema);
+ final ListSchemaNode listSchemaNode = (ListSchemaNode)schema;
+ if (listSchemaNode.isUserOrdered()) {
+ return factory.getOrderedListNodeParser().parse(childNodes, listSchemaNode);
+ } else if (listSchemaNode.getKeyDefinition().isEmpty()) {
+ return factory.getUnkeyedListNodeParser().parse(childNodes, listSchemaNode);
+ } else {
+ return factory.getMapNodeParser().parse(childNodes, listSchemaNode);
+ }
} else if (schema instanceof ChoiceNode) {
return factory.getChoiceNodeParser().parse(childNodes, (ChoiceNode) schema);
} else if (schema instanceof AugmentationSchema) {
--- /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.impl.schema.transform.base.parser;
+
+import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode;
+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.model.api.ListSchemaNode;
+
+/**
+ * Abstract(base) parser for OrderedListNodes, parses elements of type E.
+ *
+ * @param <E>
+ * type of elements to be parsed
+ */
+public abstract class OrderedListNodeBaseParser<E> extends
+ ListNodeBaseParser<E, MapEntryNode, OrderedMapNode, ListSchemaNode> {
+ @Override
+ protected CollectionNodeBuilder<MapEntryNode, OrderedMapNode> provideBuilder(ListSchemaNode schema) {
+ return Builders.orderedMapBuilder(schema);
+ }
+}
--- /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.impl.schema.transform.base.parser;
+
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
+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.model.api.ListSchemaNode;
+
+/**
+ * Abstract(base) parser for UnkeyedListNodes, parses elements of type E.
+ *
+ * @param <E>
+ * type of elements to be parsed
+ */
+public abstract class UnkeyedListNodeBaseParser<E> extends
+ ListNodeBaseParser<E, UnkeyedListEntryNode, UnkeyedListNode, ListSchemaNode> {
+ @Override
+ protected CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> provideBuilder(ListSchemaNode schema) {
+ CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> listBuilder = Builders.unkeyedListBuilder();
+ return listBuilder.withNodeIdentifier(new NodeIdentifier(schema.getQName()));
+ }
+}
package org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer;
import java.util.Set;
-
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
-import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.opendaylight.yangtools.yang.data.impl.schema.SchemaUtils;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
/**
- * Abstract(base) serializer for MapEntryNodes, serializes elements of type E.
+ * Abstract(base) serializer for ListEntryNodes (MapEntryNode, UnkeyedListEntryNode), serializes elements of type E.
*
- * @param <E> type of serialized elements
+ * @param <E>
+ * type of serialized elements
*/
-public abstract class MapEntryNodeBaseSerializer<E> extends
- BaseDispatcherSerializer<E, MapEntryNode, ListSchemaNode> {
+public abstract class ListEntryNodeBaseSerializer<E, N extends DataContainerNode<?>> extends
+ BaseDispatcherSerializer<E, N, ListSchemaNode> {
@Override
protected final DataSchemaNode getSchemaForChild(ListSchemaNode schema,
- DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> childNode) {
+ DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> childNode) {
return SchemaUtils.findSchemaForChild(schema, childNode.getNodeType());
}
}
@Override
- protected final Set<DataSchemaNode> getRealSchemasForAugment(ListSchemaNode schema, AugmentationSchema augmentationSchema) {
+ protected final Set<DataSchemaNode> getRealSchemasForAugment(ListSchemaNode schema,
+ AugmentationSchema augmentationSchema) {
return SchemaUtils.getRealSchemasForAugment((AugmentationTarget) schema, augmentationSchema);
}
--- /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.impl.schema.transform.base.serializer;
+
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Iterables;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
+import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.FromNormalizedNodeSerializer;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+
+/**
+ * Abstract(base) serializer for ListNodes (MapNode, UnkeyedListNode), serializes elements of type E.
+ *
+ * @param <E>
+ * type of serialized elements
+ * @param <N>
+ * containing node type
+ * @param <O>
+ * entry node type which is inside containing (N) type
+ */
+public abstract class ListNodeBaseSerializer<E, N extends DataContainerChild<NodeIdentifier, Iterable<O>>, O extends DataContainerNode<?>>
+ implements FromNormalizedNodeSerializer<E, N, ListSchemaNode> {
+
+ @Override
+ public final Iterable<E> serialize(final ListSchemaNode schema, final N node) {
+ return Iterables.concat(Iterables.transform(node.getValue(), new Function<O, Iterable<E>>() {
+ @Override
+ public Iterable<E> apply(O input) {
+ final Iterable<E> serializedChild = getListEntryNodeSerializer().serialize(schema, input);
+ final int size = Iterables.size(serializedChild);
+
+ Preconditions.checkState(size == 1,
+ "Unexpected count of entries for list serialized from: %s, should be 1, was: %s", input, size);
+ return serializedChild;
+ }
+ }));
+ }
+
+ /**
+ *
+ * @return serializer for inner ListEntryNodes (MapEntryNode, UnkeyedListEntryNode) used to serialize every entry of
+ * ListNode, might be the same instance in case its immutable
+ */
+ protected abstract FromNormalizedNodeSerializer<E, O, ListSchemaNode> getListEntryNodeSerializer();
+}
+++ /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.impl.schema.transform.base.serializer;
-
-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.model.api.ListSchemaNode;
-
-import com.google.common.base.Function;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Iterables;
-
-/**
- * Abstract(base) serializer for MapNodes, serializes elements of type E.
- *
- * @param <E> type of serialized elements
- */
-public abstract class MapNodeBaseSerializer<E> implements FromNormalizedNodeSerializer<E, MapNode, ListSchemaNode> {
-
- @Override
- public final Iterable<E> serialize(final ListSchemaNode schema, final MapNode node) {
- return Iterables.concat(Iterables.transform(node.getValue(), new Function<MapEntryNode, Iterable<E>>() {
- @Override
- public Iterable<E> apply(MapEntryNode input) {
- final Iterable<E> serializedChild = getMapEntryNodeDomSerializer().serialize(schema, input);
- final int size = Iterables.size(serializedChild);
-
- Preconditions.checkState(size == 1,
- "Unexpected count of entries for list serialized from: %s, should be 1, was: %s",
- input, size);
- return serializedChild;
- }
- }));
- }
-
- /**
- *
- * @return serializer for inner MapEntryNodes used to serialize every entry of MapNode, might be the same instance in case its immutable
- */
- protected abstract FromNormalizedNodeSerializer<E, MapEntryNode, ListSchemaNode> getMapEntryNodeDomSerializer();
-}
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.MixinNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.FromNormalizedNodeSerializerFactory;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
if (dataContainerChild instanceof LeafSetNode<?>) {
return onLeafListNode(childSchema, dataContainerChild);
} else if (dataContainerChild instanceof MapNode) {
- return onListNode(childSchema, dataContainerChild);
+ return onMapNode(childSchema, dataContainerChild);
+ } else if (dataContainerChild instanceof UnkeyedListNode) {
+ return onUnkeyedListNode(childSchema, dataContainerChild);
} else if (dataContainerChild instanceof ChoiceNode) {
return onChoiceNode(childSchema, dataContainerChild);
} else if (dataContainerChild instanceof AugmentationNode) {
(ChoiceNode) dataContainerChild);
}
- private Iterable<E> onListNode(Object childSchema,
+ private Iterable<E> onMapNode(Object childSchema,
DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, ListSchemaNode.class, dataContainerChild);
return factory.getMapNodeSerializer().serialize((ListSchemaNode) childSchema, (MapNode) dataContainerChild);
}
+ private Iterable<E> onUnkeyedListNode(Object childSchema,
+ DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
+ checkSchemaCompatibility(childSchema, ListSchemaNode.class, dataContainerChild);
+ return factory.getUnkeyedListNodeSerializer().serialize((ListSchemaNode) childSchema, (UnkeyedListNode) dataContainerChild);
+ }
+
private Iterable<E> onLeafListNode(Object childSchema,
DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, LeafListSchemaNode.class, dataContainerChild);
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.api.schema.OrderedMapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlCodecProvider;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParserFactory;
private final LeafSetNodeDomParser leafSetNodeParser;
private final MapNodeDomParser mapNodeParser;
private final MapEntryNodeDomParser mapEntryNodeParser;
+ private final UnkeyedListEntryNodeDomParser unkeyedListEntryNodeParser;
+ private final UnkeyedListNodeDomParser unkeyedListNodeParser;
+ private final OrderedListNodeDomParser orderedListNodeParser;
private DomToNormalizedNodeParserFactory(final XmlCodecProvider codecProvider) {
leafNodeParser = new LeafNodeDomParser(codecProvider);
containerNodeParser = new ContainerNodeDomParser(dispatcher);
mapEntryNodeParser = new MapEntryNodeDomParser(dispatcher);
mapNodeParser = new MapNodeDomParser(mapEntryNodeParser);
+ orderedListNodeParser = new OrderedListNodeDomParser(mapEntryNodeParser);
+ unkeyedListEntryNodeParser = new UnkeyedListEntryNodeDomParser(dispatcher);
+ unkeyedListNodeParser = new UnkeyedListNodeDomParser(unkeyedListEntryNodeParser);
choiceNodeParser = new ChoiceNodeDomParser(dispatcher);
augmentationNodeParser = new AugmentationNodeDomParser(dispatcher);
}
return mapNodeParser;
}
+ @Override
+ public ToNormalizedNodeParser<Element, UnkeyedListNode, ListSchemaNode> getUnkeyedListNodeParser() {
+ return unkeyedListNodeParser;
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Element, UnkeyedListEntryNode, ListSchemaNode> getUnkeyedListEntryNodeParser() {
+ return unkeyedListEntryNodeParser;
+ }
+
+ @Override
+ public ToNormalizedNodeParser<Element, OrderedMapNode, ListSchemaNode> getOrderedListNodeParser() {
+ return orderedListNodeParser;
+ }
+
@Override
public ToNormalizedNodeParser<Element, AnyXmlNode, AnyXmlSchemaNode> getAnyXmlNodeParser() {
throw new UnsupportedOperationException();
--- /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.impl.schema.transform.dom.parser;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.LinkedListMultimap;
+import java.util.Map;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.ListEntryNodeBaseParser;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils;
+import org.w3c.dom.Element;
+
+abstract class ListEntryNodeDomParser<N extends DataContainerNode<?>> extends ListEntryNodeBaseParser<Element, N> {
+
+ private final NodeParserDispatcher<Element> dispatcher;
+
+ ListEntryNodeDomParser(final NodeParserDispatcher<Element> dispatcher) {
+ this.dispatcher = Preconditions.checkNotNull(dispatcher);
+ }
+
+ @Override
+ protected LinkedListMultimap<QName, Element> mapChildElements(Iterable<Element> elements) {
+ return DomUtils.mapChildElementsForSingletonNode(elements.iterator().next());
+ }
+
+ @Override
+ protected NodeParserDispatcher<Element> getDispatcher() {
+ return dispatcher;
+ }
+
+ @Override
+ protected Map<QName, String> getAttributes(Element element) {
+ return DomUtils.toAttributes(element.getAttributes());
+ }
+}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser;
-import java.util.Map;
-
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.MapEntryNodeBaseParser;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher;
-import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.DomUtils;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.w3c.dom.Element;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.LinkedListMultimap;
-
-final class MapEntryNodeDomParser extends MapEntryNodeBaseParser<Element> {
-
- private final NodeParserDispatcher<Element> dispatcher;
+final class MapEntryNodeDomParser extends ListEntryNodeDomParser<MapEntryNode> {
MapEntryNodeDomParser(final NodeParserDispatcher<Element> dispatcher) {
- this.dispatcher = Preconditions.checkNotNull(dispatcher);
- }
-
- @Override
- protected LinkedListMultimap<QName, Element> mapChildElements(Iterable<Element> elements) {
- return DomUtils.mapChildElementsForSingletonNode(elements.iterator().next());
- }
-
- @Override
- protected NodeParserDispatcher<Element> getDispatcher() {
- return dispatcher;
+ super(dispatcher);
}
@Override
- protected Map<QName, String> getAttributes(Element element) {
- return DomUtils.toAttributes(element.getAttributes());
+ protected final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> getBuilder(
+ ListSchemaNode schema) {
+ return Builders.mapEntryBuilder(schema);
}
}
}
@Override
- protected ToNormalizedNodeParser<Element, MapEntryNode, ListSchemaNode> getMapEntryNodeParser() {
+ protected ToNormalizedNodeParser<Element, MapEntryNode, ListSchemaNode> getListEntryNodeParser() {
return mapEntryParser;
}
}
--- /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.impl.schema.transform.dom.parser;
+
+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.OrderedListNodeBaseParser;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+import org.w3c.dom.Element;
+
+final class OrderedListNodeDomParser extends OrderedListNodeBaseParser<Element> {
+
+ private final MapEntryNodeDomParser mapEntryNodeParser;
+
+ OrderedListNodeDomParser(MapEntryNodeDomParser mapEntryNodeParser) {
+ this.mapEntryNodeParser = mapEntryNodeParser;
+ }
+
+ @Override
+ protected ToNormalizedNodeParser<Element, MapEntryNode, ListSchemaNode> getListEntryNodeParser() {
+ return mapEntryNodeParser;
+ }
+}
--- /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.impl.schema.transform.dom.parser;
+
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.NodeParserDispatcher;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+import org.w3c.dom.Element;
+
+final class UnkeyedListEntryNodeDomParser extends ListEntryNodeDomParser<UnkeyedListEntryNode> {
+
+ UnkeyedListEntryNodeDomParser(final NodeParserDispatcher<Element> dispatcher) {
+ super(dispatcher);
+ }
+
+ @Override
+ protected final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, UnkeyedListEntryNode> getBuilder(
+ ListSchemaNode schema) {
+ return Builders.unkeyedListEntryBuilder().withNodeIdentifier(new NodeIdentifier(schema.getQName()));
+ }
+
+}
--- /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.impl.schema.transform.dom.parser;
+
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.ToNormalizedNodeParser;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.parser.UnkeyedListNodeBaseParser;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+import org.w3c.dom.Element;
+
+final class UnkeyedListNodeDomParser extends UnkeyedListNodeBaseParser<Element> {
+
+ private final UnkeyedListEntryNodeDomParser unkeyedListEntryNodeParser;
+
+ UnkeyedListNodeDomParser(UnkeyedListEntryNodeDomParser unkeyedListEntryNodeParser) {
+ this.unkeyedListEntryNodeParser = unkeyedListEntryNodeParser;
+ }
+
+ @Override
+ protected ToNormalizedNodeParser<Element, UnkeyedListEntryNode, ListSchemaNode> getListEntryNodeParser() {
+ return unkeyedListEntryNodeParser;
+ }
+}
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.api.schema.UnkeyedListNode;
import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlCodecProvider;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.FromNormalizedNodeSerializer;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.FromNormalizedNodeSerializerFactory;
private final LeafNodeDomSerializer leafNodeSerializer;
private final LeafSetNodeDomSerializer leafSetSerializer;
private final MapNodeDomSerializer mapNodeSerializer;
+ private final UnkeyedListNodeDomSerializer unkeyedListNodeSerializer;
private final LeafSetEntryNodeDomSerializer leafSetEntryNodeSerializer;
- private final MapEntryNodeDomSerializer mapEntryNodeSerializer;
+ private final MapEntryNodeDomSerializer mapEntryNodeSerializer;
+ private final UnkeyedListEntryNodeDomSerializer unkeyedListEntryNodeSerializer;
private DomFromNormalizedNodeSerializerFactory(final Document doc, final XmlCodecProvider codecProvider) {
final NodeSerializerDispatcher.BaseNodeSerializerDispatcher<Element> dispatcher = new NodeSerializerDispatcher.BaseNodeSerializerDispatcher<Element>(this) {
mapEntryNodeSerializer = new MapEntryNodeDomSerializer(doc, dispatcher);
mapNodeSerializer = new MapNodeDomSerializer(mapEntryNodeSerializer);
+
+ unkeyedListEntryNodeSerializer = new UnkeyedListEntryNodeDomSerializer(doc, dispatcher);
+ unkeyedListNodeSerializer = new UnkeyedListNodeDomSerializer(unkeyedListEntryNodeSerializer);
}
public static DomFromNormalizedNodeSerializerFactory getInstance(final Document doc, final XmlCodecProvider codecProvider) {
return mapNodeSerializer;
}
+ @Override
+ public FromNormalizedNodeSerializer<Element, UnkeyedListNode, ListSchemaNode> getUnkeyedListNodeSerializer() {
+ return unkeyedListNodeSerializer;
+ }
+
@Override
public FromNormalizedNodeSerializer<Element, AnyXmlNode, AnyXmlSchemaNode> getAnyXmlNodeSerializer() {
throw new UnsupportedOperationException();
--- /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.impl.schema.transform.dom.serializer;
+
+import com.google.common.base.Preconditions;
+import java.util.Collections;
+import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
+import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlDocumentUtils;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.ListEntryNodeBaseSerializer;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.NodeSerializerDispatcher;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+/**
+ *
+ * Common class for list entry node serialization (MapEntry, UnkeyedListEntry nodes)
+ *
+ * @param <N>
+ * concrete entry node type
+ */
+abstract class ListEntryNodeDomSerializer<N extends DataContainerNode<?>> extends
+ ListEntryNodeBaseSerializer<Element, N> {
+ private final NodeSerializerDispatcher<Element> dispatcher;
+ private final Document doc;
+
+ ListEntryNodeDomSerializer(final Document doc, final NodeSerializerDispatcher<Element> dispatcher) {
+ this.doc = Preconditions.checkNotNull(doc);
+ this.dispatcher = Preconditions.checkNotNull(dispatcher);
+ }
+
+ @Override
+ public Iterable<Element> serialize(ListSchemaNode schema, N node) {
+ Element itemEl = XmlDocumentUtils.createElementFor(doc, node);
+
+ for (Element element : super.serialize(schema, node)) {
+ itemEl.appendChild(element);
+ }
+
+ return Collections.singletonList(itemEl);
+ }
+
+ @Override
+ protected NodeSerializerDispatcher<Element> getNodeDispatcher() {
+ return dispatcher;
+ }
+}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.serializer;
-import java.util.Collections;
-
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
-import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlDocumentUtils;
-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 org.w3c.dom.Document;
import org.w3c.dom.Element;
-import com.google.common.base.Preconditions;
-
-final class MapEntryNodeDomSerializer extends MapEntryNodeBaseSerializer<Element> {
- private final NodeSerializerDispatcher<Element> dispatcher;
- private final Document doc;
-
+final class MapEntryNodeDomSerializer extends ListEntryNodeDomSerializer<MapEntryNode> {
MapEntryNodeDomSerializer(final Document doc, final NodeSerializerDispatcher<Element> dispatcher) {
- this.doc = Preconditions.checkNotNull(doc);
- this.dispatcher = Preconditions.checkNotNull(dispatcher);
- }
-
- @Override
- public Iterable<Element> serialize(ListSchemaNode schema, MapEntryNode node) {
- Element itemEl = XmlDocumentUtils.createElementFor(doc, node);
-
- for (Element element : super.serialize(schema, node)) {
- itemEl.appendChild(element);
- }
-
- return Collections.singletonList(itemEl);
- }
-
- @Override
- protected NodeSerializerDispatcher<Element> getNodeDispatcher() {
- return dispatcher;
+ super(doc, dispatcher);
}
}
package org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.serializer;
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.base.serializer.MapNodeBaseSerializer;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.ListNodeBaseSerializer;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.w3c.dom.Element;
-final class MapNodeDomSerializer extends MapNodeBaseSerializer<Element> {
+final class MapNodeDomSerializer extends ListNodeBaseSerializer<Element, MapNode, MapEntryNode> {
private final FromNormalizedNodeSerializer<Element, MapEntryNode, ListSchemaNode> mapEntrySerializer;
}
@Override
- protected FromNormalizedNodeSerializer<Element, MapEntryNode, ListSchemaNode> getMapEntryNodeDomSerializer() {
+ protected FromNormalizedNodeSerializer<Element, MapEntryNode, ListSchemaNode> getListEntryNodeSerializer() {
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.impl.schema.transform.dom.serializer;
+
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.NodeSerializerDispatcher;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+final class UnkeyedListEntryNodeDomSerializer extends ListEntryNodeDomSerializer<UnkeyedListEntryNode> {
+
+ UnkeyedListEntryNodeDomSerializer(final Document doc, final NodeSerializerDispatcher<Element> dispatcher) {
+ super(doc, 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.impl.schema.transform.dom.serializer;
+
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.FromNormalizedNodeSerializer;
+import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.ListNodeBaseSerializer;
+import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+import org.w3c.dom.Element;
+
+final class UnkeyedListNodeDomSerializer extends ListNodeBaseSerializer<Element, UnkeyedListNode, UnkeyedListEntryNode> {
+
+ private final FromNormalizedNodeSerializer<Element, UnkeyedListEntryNode, ListSchemaNode> unkeyedListEntrySerializer;
+
+ UnkeyedListNodeDomSerializer(UnkeyedListEntryNodeDomSerializer unkeyedListEntrySerializer) {
+ this.unkeyedListEntrySerializer = unkeyedListEntrySerializer;
+ }
+
+ @Override
+ protected FromNormalizedNodeSerializer<Element, UnkeyedListEntryNode, ListSchemaNode> getListEntryNodeSerializer() {
+ return unkeyedListEntrySerializer;
+ }
+}
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
private static final LeafSetNodeModification LEAF_SET_NODE_MODIFICATION = new LeafSetNodeModification();
private static final AugmentationNodeModification AUGMENTATION_NODE_MODIFICATION = new AugmentationNodeModification();
private static final MapNodeModification MAP_NODE_MODIFICATION = new MapNodeModification();
+ private static final UnkeyedListNodeModification UNKEYED_LIST_NODE_MODIFICATION = new UnkeyedListNodeModification();
private static final ContainerNodeModification CONTAINER_NODE_MODIFICATION = new ContainerNodeModification();
private static final ChoiceNodeModification CHOICE_NODE_MODIFICATION = new ChoiceNodeModification();
} else if (schemaChild instanceof AugmentationSchema) {
return onAugmentationNode((AugmentationSchema) schemaChild, actual, modification, operations);
} else if (schemaChild instanceof ListSchemaNode) {
- return onMapNode((ListSchemaNode) schemaChild, actual, modification, operations);
+ if (((ListSchemaNode)schemaChild).getKeyDefinition().isEmpty()) {
+ return onUnkeyedNode((ListSchemaNode) schemaChild, actual, modification, operations);
+ } else {
+ return onMapNode((ListSchemaNode) schemaChild, actual, modification, operations);
+ }
} else if (schemaChild instanceof org.opendaylight.yangtools.yang.model.api.ChoiceNode) {
return onChoiceNode((org.opendaylight.yangtools.yang.model.api.ChoiceNode) schemaChild, actual,
modification, operations);
(Optional<MapNode>) modification, operations);
}
+ private static Optional<? extends DataContainerChild<?, ?>> onUnkeyedNode(ListSchemaNode schemaChild,
+ Optional<? extends DataContainerChild<?, ?>> actual,
+ Optional<? extends DataContainerChild<?, ?>> modification, OperationStack operations)
+ throws DataModificationException {
+ checkType(actual, UnkeyedListNode.class);
+ checkType(modification, UnkeyedListNode.class);
+ return UNKEYED_LIST_NODE_MODIFICATION.modify(schemaChild, (Optional<UnkeyedListNode>) actual,
+ (Optional<UnkeyedListNode>) modification, operations);
+ }
+
private static Optional<? extends DataContainerChild<?, ?>> onAugmentationNode(AugmentationSchema schemaChild,
Optional<? extends DataContainerChild<?, ?>> actual,
Optional<? extends DataContainerChild<?, ?>> modification, OperationStack operations)
--- /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.operations;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.Lists;
+import java.util.List;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
+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.model.api.ListSchemaNode;
+
+public class UnkeyedListNodeModification implements Modification<ListSchemaNode, UnkeyedListNode> {
+
+ public static final MapEntryNodeModification MAP_ENTRY_NODE_MODIFICATION = new MapEntryNodeModification();
+
+ @Override
+ public Optional<UnkeyedListNode> modify(ListSchemaNode schema, Optional<UnkeyedListNode> actual,
+ Optional<UnkeyedListNode> modification, OperationStack operationStack) throws DataModificationException {
+
+ // Merge or None operation on parent, leaving actual if modification not present
+ if (modification.isPresent() == false)
+ return actual;
+
+ List<UnkeyedListEntryNode> resultNodes = Lists.newArrayList();
+ if (actual.isPresent())
+ resultNodes = unkeyedListEntries(actual.get());
+
+ // TODO implement ordering for modification nodes
+
+ for (UnkeyedListEntryNode unkeyedListEntryModification : modification.get().getValue()) {
+
+ operationStack.enteringNode(unkeyedListEntryModification);
+
+ YangInstanceIdentifier.NodeIdentifier entryKey = unkeyedListEntryModification.getIdentifier();
+
+ switch (operationStack.getCurrentOperation()) {
+ case NONE:
+ break;
+ // DataModificationException.DataMissingException.check(schema.getQName(), actual, mapEntryModification);
+ case MERGE:
+ case CREATE: {
+ DataModificationException.DataExistsException.check(schema.getQName(), actual,
+ unkeyedListEntryModification);
+ resultNodes.add(unkeyedListEntryModification);
+ }
+ case REPLACE: {
+ break;
+ }
+ case DELETE: {
+ // DataModificationException.DataMissingException.check(schema.getQName(), actual,
+ // unkeyedListEntryModification);
+ break;
+ }
+ case REMOVE: {
+ break;
+ }
+ default:
+ throw new UnsupportedOperationException(
+ String.format("Unable to perform operation: %s on: %s, unknown",
+ operationStack.getCurrentOperation(), schema));
+ }
+
+ operationStack.exitingNode(unkeyedListEntryModification);
+ }
+ return build(schema, resultNodes);
+ }
+
+ private Optional<UnkeyedListNode> build(ListSchemaNode schema, List<UnkeyedListEntryNode> resultNodes) {
+ if (resultNodes.isEmpty())
+ return Optional.absent();
+
+ CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> b = Builders.unkeyedListBuilder();
+ b.withNodeIdentifier(new NodeIdentifier(schema.getQName()));
+
+ for (UnkeyedListEntryNode child : resultNodes) {
+ b.withChild(child);
+ }
+
+ return Optional.of(b.build());
+ }
+
+ private List<UnkeyedListEntryNode> unkeyedListEntries(UnkeyedListNode unkeyedListNode) {
+ List<UnkeyedListEntryNode> unkeyedListEntries = Lists.newArrayList();
+
+ for (UnkeyedListEntryNode unkeyedListEntryNode : unkeyedListNode.getValue()) {
+ unkeyedListEntries.add(unkeyedListEntryNode);
+ }
+
+ return unkeyedListEntries;
+ }
+
+}
Code Review / yangtools.git / commitdiff