Remove Augmentation{Identifier,Node}
[yangtools.git] / data / yang-data-impl / src / main / java / org / opendaylight / yangtools / yang / data / impl / schema / builder / impl / ImmutableMapEntryNodeBuilder.java
1 /*
2  * Copyright (c) 2013 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 package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
9
10 import java.util.Collection;
11 import java.util.LinkedHashMap;
12 import java.util.Map;
13 import java.util.Map.Entry;
14 import org.eclipse.jdt.annotation.NonNull;
15 import org.opendaylight.yangtools.yang.common.QName;
16 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
17 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
18 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
19 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
20 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
21 import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
22 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
23 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.valid.DataValidationException;
24 import org.opendaylight.yangtools.yang.data.impl.schema.nodes.AbstractImmutableDataContainerNode;
25 import org.slf4j.Logger;
26 import org.slf4j.LoggerFactory;
27
28 public class ImmutableMapEntryNodeBuilder
29         extends AbstractImmutableDataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> {
30     private static final Logger LOG = LoggerFactory.getLogger(ImmutableMapEntryNodeBuilder.class);
31     protected final Map<QName, PathArgument> childrenQNamesToPaths;
32
33     protected ImmutableMapEntryNodeBuilder() {
34         childrenQNamesToPaths = new LinkedHashMap<>();
35     }
36
37     protected ImmutableMapEntryNodeBuilder(final int sizeHint) {
38         super(sizeHint);
39         childrenQNamesToPaths = new LinkedHashMap<>(sizeHint);
40     }
41
42     protected ImmutableMapEntryNodeBuilder(final ImmutableMapEntryNode node) {
43         super(node);
44         childrenQNamesToPaths = new LinkedHashMap<>();
45         fillQNames(node.body(), childrenQNamesToPaths);
46     }
47
48     public static @NonNull DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> create() {
49         return new ImmutableMapEntryNodeBuilder();
50     }
51
52     public static @NonNull DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> create(
53             final int sizeHint) {
54         return new ImmutableMapEntryNodeBuilder(sizeHint);
55     }
56
57     public static @NonNull DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> create(
58             final MapEntryNode node) {
59         if (!(node instanceof ImmutableMapEntryNode immutableNode)) {
60             throw new UnsupportedOperationException("Cannot initialize from class " + node.getClass());
61         }
62         return new ImmutableMapEntryNodeBuilder(immutableNode);
63     }
64
65     private static void fillQNames(final Iterable<DataContainerChild> iterable, final Map<QName, PathArgument> out) {
66         for (final DataContainerChild child : iterable) {
67             putQName(out, child);
68         }
69     }
70
71     private static void putQName(final Map<QName, PathArgument> map, final DataContainerChild child) {
72         // Augmentation nodes cannot be keys, and do not have to be present in childrenQNamesToPaths map
73         final PathArgument identifier = child.getIdentifier();
74         map.put(identifier.getNodeType(), identifier);
75     }
76
77     @Override
78     public DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> withValue(
79             final Collection<DataContainerChild> withValue) {
80         fillQNames(withValue, childrenQNamesToPaths);
81         return super.withValue(withValue);
82     }
83
84     @Override
85     public DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> withChild(
86             final DataContainerChild child) {
87         putQName(childrenQNamesToPaths, child);
88         return super.withChild(child);
89     }
90
91     @Override
92     public MapEntryNode build() {
93         for (final Entry<QName, Object> key : getNodeIdentifier().entrySet()) {
94             final DataContainerChild childNode = getChild(childrenQNamesToPaths.get(key.getKey()));
95
96             // We have enough information to fill-in missing leaf nodes, so let's do that
97             if (childNode == null) {
98                 LeafNode<Object> leaf = ImmutableNodes.leafNode(key.getKey(), key.getValue());
99                 LOG.debug("Adding leaf {} implied by key {}", leaf, key);
100                 withChild(leaf);
101             } else {
102                 DataValidationException.checkListKey(getNodeIdentifier(), key.getKey(), key.getValue(),
103                     childNode.body());
104             }
105         }
106
107         return new ImmutableMapEntryNode(getNodeIdentifier(), buildValue());
108     }
109
110     private static final class ImmutableMapEntryNode
111             extends AbstractImmutableDataContainerNode<NodeIdentifierWithPredicates, MapEntryNode>
112             implements MapEntryNode {
113
114         ImmutableMapEntryNode(final NodeIdentifierWithPredicates nodeIdentifier,
115                 final Map<PathArgument, Object> children) {
116             super(children, nodeIdentifier);
117         }
118
119         @Override
120         protected Class<MapEntryNode> implementedType() {
121             return MapEntryNode.class;
122         }
123     }
124 }