BUG-1848 : OrderedNormalizedNodeWriter implementation
[controller.git] / opendaylight / netconf / netconf-util / src / main / java / org / opendaylight / controller / netconf / util / OrderedNormalizedNodeWriter.java
1 /*
2  * Copyright (c) 2015 Cisco Systems, Inc. and others.  All rights reserved.
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6  * and is available at http://www.eclipse.org/legal/epl-v10.html
7  */
8
9 package org.opendaylight.controller.netconf.util;
10
11 import static org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter.UNKNOWN_SIZE;
12
13 import com.google.common.base.Optional;
14 import com.google.common.base.Preconditions;
15 import com.google.common.base.Predicate;
16 import com.google.common.collect.ArrayListMultimap;
17 import com.google.common.collect.Iterables;
18 import java.io.Closeable;
19 import java.io.Flushable;
20 import java.io.IOException;
21 import java.util.Collection;
22 import java.util.List;
23 import org.opendaylight.yangtools.yang.common.QName;
24 import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
25 import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
26 import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
27 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
28 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
29 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
30 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
31 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
32 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
33 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
34 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
35 import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode;
36 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
37 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
38 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamAttributeWriter;
39 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
40 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
41 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
42 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
43 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
44 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
45 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
46 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
47 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
48 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
49
50 //TODO this does not extend NormalizedNodeWriter from yangtools due to api freeze, make this inherit common methods to avoid code duplication
51 //TODO move this to yangtools, since this is in netconf-util due to api freeze in lithium
52 public class OrderedNormalizedNodeWriter implements Closeable, Flushable{
53
54     private final SchemaContext schemaContext;
55     private final SchemaNode root;
56     private final NormalizedNodeStreamWriter writer;
57
58     public OrderedNormalizedNodeWriter(NormalizedNodeStreamWriter writer, SchemaContext schemaContext, SchemaPath path) {
59         this.writer = writer;
60         this.schemaContext = schemaContext;
61         this.root = findParentSchemaOnPath(schemaContext, path);
62     }
63
64     public OrderedNormalizedNodeWriter write(final NormalizedNode<?, ?> node) throws IOException {
65         if (root == schemaContext) {
66             return write(node, schemaContext.getDataChildByName(node.getNodeType()));
67         }
68
69         return write(node, root);
70     }
71
72     public OrderedNormalizedNodeWriter write(final Collection<DataContainerChild<?,?>> nodes) throws IOException {
73         if (writeChildren(nodes, root, false)) {
74             return this;
75         }
76
77         throw new IllegalStateException("It wasn't possible to serialize nodes " + nodes);
78
79     }
80
81     private OrderedNormalizedNodeWriter write(NormalizedNode<?, ?> node, SchemaNode dataSchemaNode) throws IOException {
82         if (node == null) {
83             return this;
84         }
85
86         if (wasProcessedAsCompositeNode(node, dataSchemaNode)) {
87             return this;
88         }
89
90         if (wasProcessAsSimpleNode(node)) {
91             return this;
92         }
93
94         throw new IllegalStateException("It wasn't possible to serialize node " + node);
95     }
96
97     private void write(List<NormalizedNode<?, ?>> nodes, SchemaNode dataSchemaNode) throws IOException {
98         for (NormalizedNode<?, ?> node : nodes) {
99             write(node, dataSchemaNode);
100         }
101     }
102
103     private OrderedNormalizedNodeWriter writeLeaf(final NormalizedNode<?, ?> node) throws IOException {
104         if (wasProcessAsSimpleNode(node)) {
105             return this;
106         }
107
108         throw new IllegalStateException("It wasn't possible to serialize node " + node);
109     }
110
111     private boolean writeChildren(final Iterable<? extends NormalizedNode<?, ?>> children, SchemaNode parentSchemaNode, boolean endParent) throws IOException {
112         //Augmentations cannot be gotten with node.getChild so create our own structure with augmentations resolved
113         ArrayListMultimap<QName, NormalizedNode<?, ?>> qNameToNodes = ArrayListMultimap.create();
114         for (NormalizedNode<?, ?> child : children) {
115             if (child instanceof AugmentationNode) {
116                 qNameToNodes.putAll(resolveAugmentations(child));
117             } else {
118                 qNameToNodes.put(child.getNodeType(), child);
119             }
120         }
121
122         if (parentSchemaNode instanceof DataNodeContainer) {
123             if (parentSchemaNode instanceof ListSchemaNode && qNameToNodes.containsKey(parentSchemaNode.getQName())) {
124                 write(qNameToNodes.get(parentSchemaNode.getQName()), parentSchemaNode);
125             } else {
126                 for (DataSchemaNode schemaNode : ((DataNodeContainer) parentSchemaNode).getChildNodes()) {
127                     write(qNameToNodes.get(schemaNode.getQName()), schemaNode);
128                 }
129             }
130         } else if(parentSchemaNode instanceof ChoiceSchemaNode) {
131             for (ChoiceCaseNode ccNode : ((ChoiceSchemaNode) parentSchemaNode).getCases()) {
132                 for (DataSchemaNode dsn : ccNode.getChildNodes()) {
133                     if (qNameToNodes.containsKey(dsn.getQName())) {
134                         write(qNameToNodes.get(dsn.getQName()), dsn);
135                     }
136                 }
137             }
138         } else {
139             for (NormalizedNode<?, ?> child : children) {
140                 writeLeaf(child);
141             }
142         }
143         if (endParent) {
144             writer.endNode();
145         }
146         return true;
147     }
148
149     private ArrayListMultimap<QName, NormalizedNode<?, ?>> resolveAugmentations(NormalizedNode<?, ?> child) {
150         final ArrayListMultimap<QName, NormalizedNode<?, ?>> resolvedAugs = ArrayListMultimap.create();
151         for (NormalizedNode<?, ?> node : ((AugmentationNode) child).getValue()) {
152             if (node instanceof AugmentationNode) {
153                 resolvedAugs.putAll(resolveAugmentations(node));
154             } else {
155                 resolvedAugs.put(node.getNodeType(), node);
156             }
157         }
158         return resolvedAugs;
159     }
160
161     private boolean writeMapEntryNode(final MapEntryNode node, final SchemaNode dataSchemaNode) throws IOException {
162         if(writer instanceof NormalizedNodeStreamAttributeWriter) {
163             ((NormalizedNodeStreamAttributeWriter) writer)
164                     .startMapEntryNode(node.getIdentifier(), OrderedNormalizedNodeWriter.childSizeHint(node.getValue()), node.getAttributes());
165         } else {
166             writer.startMapEntryNode(node.getIdentifier(), OrderedNormalizedNodeWriter.childSizeHint(node.getValue()));
167         }
168         return writeChildren(node.getValue(), dataSchemaNode, true);
169     }
170
171     private boolean wasProcessAsSimpleNode(final NormalizedNode<?, ?> node) throws IOException {
172         if (node instanceof LeafSetEntryNode) {
173             final LeafSetEntryNode<?> nodeAsLeafList = (LeafSetEntryNode<?>)node;
174             if(writer instanceof NormalizedNodeStreamAttributeWriter) {
175                 ((NormalizedNodeStreamAttributeWriter) writer).leafSetEntryNode(nodeAsLeafList.getValue(), nodeAsLeafList.getAttributes());
176             } else {
177                 writer.leafSetEntryNode(nodeAsLeafList.getValue());
178             }
179             return true;
180         } else if (node instanceof LeafNode) {
181             final LeafNode<?> nodeAsLeaf = (LeafNode<?>)node;
182             if(writer instanceof NormalizedNodeStreamAttributeWriter) {
183                 ((NormalizedNodeStreamAttributeWriter) writer).leafNode(nodeAsLeaf.getIdentifier(), nodeAsLeaf.getValue(), nodeAsLeaf.getAttributes());
184             } else {
185                 writer.leafNode(nodeAsLeaf.getIdentifier(), nodeAsLeaf.getValue());
186             }
187             return true;
188         } else if (node instanceof AnyXmlNode) {
189             final AnyXmlNode anyXmlNode = (AnyXmlNode)node;
190             writer.anyxmlNode(anyXmlNode.getIdentifier(), anyXmlNode.getValue());
191             return true;
192         }
193
194         return false;
195     }
196
197     private boolean wasProcessedAsCompositeNode(final NormalizedNode<?, ?> node, SchemaNode dataSchemaNode) throws IOException {
198         if (node instanceof ContainerNode) {
199             final ContainerNode n = (ContainerNode) node;
200             if(writer instanceof NormalizedNodeStreamAttributeWriter) {
201                 ((NormalizedNodeStreamAttributeWriter) writer).startContainerNode(n.getIdentifier(), OrderedNormalizedNodeWriter.childSizeHint(n.getValue()), n.getAttributes());
202             } else {
203                 writer.startContainerNode(n.getIdentifier(), OrderedNormalizedNodeWriter.childSizeHint(n.getValue()));
204             }
205             return writeChildren(n.getValue(), dataSchemaNode, true);
206         }
207         if (node instanceof MapEntryNode) {
208             return writeMapEntryNode((MapEntryNode) node, dataSchemaNode);
209         }
210         if (node instanceof UnkeyedListEntryNode) {
211             final UnkeyedListEntryNode n = (UnkeyedListEntryNode) node;
212             writer.startUnkeyedListItem(n.getIdentifier(), OrderedNormalizedNodeWriter.childSizeHint(n.getValue()));
213             return writeChildren(n.getValue(), dataSchemaNode, true);
214         }
215         if (node instanceof ChoiceNode) {
216             final ChoiceNode n = (ChoiceNode) node;
217             writer.startChoiceNode(n.getIdentifier(), OrderedNormalizedNodeWriter.childSizeHint(n.getValue()));
218             return writeChildren(n.getValue(), dataSchemaNode, true);
219         }
220         if (node instanceof AugmentationNode) {
221             final AugmentationNode n = (AugmentationNode) node;
222             writer.startAugmentationNode(n.getIdentifier());
223             return writeChildren(n.getValue(), dataSchemaNode, true);
224         }
225         if (node instanceof UnkeyedListNode) {
226             final UnkeyedListNode n = (UnkeyedListNode) node;
227             writer.startUnkeyedList(n.getIdentifier(), OrderedNormalizedNodeWriter.childSizeHint(n.getValue()));
228             return writeChildren(n.getValue(), dataSchemaNode, true);
229         }
230         if (node instanceof OrderedMapNode) {
231             final OrderedMapNode n = (OrderedMapNode) node;
232             writer.startOrderedMapNode(n.getIdentifier(), OrderedNormalizedNodeWriter.childSizeHint(n.getValue()));
233             return writeChildren(n.getValue(), dataSchemaNode, true);
234         }
235         if (node instanceof MapNode) {
236             final MapNode n = (MapNode) node;
237             writer.startMapNode(n.getIdentifier(), OrderedNormalizedNodeWriter.childSizeHint(n.getValue()));
238             return writeChildren(n.getValue(), dataSchemaNode, true);
239         }
240         if (node instanceof LeafSetNode) {
241             //covers also OrderedLeafSetNode for which doesn't exist start* method
242             final LeafSetNode<?> n = (LeafSetNode<?>) node;
243             writer.startLeafSet(n.getIdentifier(), OrderedNormalizedNodeWriter.childSizeHint(n.getValue()));
244             return writeChildren(n.getValue(), dataSchemaNode, true);
245         }
246
247         return false;
248     }
249
250     private static final int childSizeHint(final Iterable<?> children) {
251         return (children instanceof Collection) ? ((Collection<?>) children).size() : UNKNOWN_SIZE;
252     }
253
254     //TODO similar code is already present in schemaTracker, unify this when this writer is moved back to yangtools
255     private SchemaNode findParentSchemaOnPath(SchemaContext schemaContext, SchemaPath path) {
256         SchemaNode current = Preconditions.checkNotNull(schemaContext);
257         for (final QName qname : path.getPathFromRoot()) {
258             SchemaNode child;
259             if(current instanceof DataNodeContainer) {
260                 child = ((DataNodeContainer) current).getDataChildByName(qname);
261
262                 if (child == null && current instanceof SchemaContext) {
263                     child = tryFindGroupings((SchemaContext) current, qname).orNull();
264                 }
265
266                 if(child == null && current instanceof SchemaContext) {
267                     child = tryFindNotification((SchemaContext) current, qname)
268                             .or(tryFindRpc(((SchemaContext) current), qname)).orNull();
269                 }
270             } else if (current instanceof ChoiceSchemaNode) {
271                 child = ((ChoiceSchemaNode) current).getCaseNodeByName(qname);
272             } else if (current instanceof RpcDefinition) {
273                 switch (qname.getLocalName()) {
274                 case "input":
275                     child = ((RpcDefinition) current).getInput();
276                     break;
277                 case "output":
278                     child = ((RpcDefinition) current).getOutput();
279                     break;
280                 default:
281                     child = null;
282                     break;
283                 }
284             } else {
285                 throw new IllegalArgumentException(String.format("Schema node %s does not allow children.", current));
286             }
287             current = child;
288         }
289         return current;
290     }
291
292     //TODO this method is already present in schemaTracker, unify this when this writer is moved back to yangtools
293     private Optional<SchemaNode> tryFindGroupings(final SchemaContext ctx, final QName qname) {
294         return Optional.<SchemaNode> fromNullable(Iterables.find(ctx.getGroupings(), new SchemaNodePredicate(qname), null));
295     }
296
297     //TODO this method is already present in schemaTracker, unify this when this writer is moved back to yangtools
298     private Optional<SchemaNode> tryFindRpc(final SchemaContext ctx, final QName qname) {
299         return Optional.<SchemaNode>fromNullable(Iterables.find(ctx.getOperations(), new SchemaNodePredicate(qname), null));
300     }
301
302     //TODO this method is already present in schemaTracker, unify this when this writer is moved back to yangtools
303     private Optional<SchemaNode> tryFindNotification(final SchemaContext ctx, final QName qname) {
304         return Optional.<SchemaNode>fromNullable(Iterables.find(ctx.getNotifications(), new SchemaNodePredicate(qname), null));
305     }
306
307     @Override
308     public void flush() throws IOException {
309         writer.flush();
310     }
311
312     @Override
313     public void close() throws IOException {
314         writer.flush();
315         writer.close();
316     }
317
318     //TODO this class is already present in schemaTracker, unify this when this writer is moved back to yangtools
319     private static final class SchemaNodePredicate implements Predicate<SchemaNode> {
320         private final QName qname;
321
322         public SchemaNodePredicate(final QName qname) {
323             this.qname = qname;
324         }
325
326         @Override
327         public boolean apply(final SchemaNode input) {
328             return input.getQName().equals(qname);
329         }
330     }
331 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.