yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/NodeModificationBuilderImpl.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;
   9
  10 import java.util.HashSet;
  11 import java.util.List;
  12 import java.util.Map;
  13 import java.util.Set;
  14
  15 import org.opendaylight.yangtools.yang.common.QName;
  16 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
  17 import org.opendaylight.yangtools.yang.data.api.ModifyAction;
  18 import org.opendaylight.yangtools.yang.data.api.MutableCompositeNode;
  19 import org.opendaylight.yangtools.yang.data.api.MutableNode;
  20 import org.opendaylight.yangtools.yang.data.api.MutableSimpleNode;
  21 import org.opendaylight.yangtools.yang.data.api.Node;
  22 import org.opendaylight.yangtools.yang.data.api.NodeModificationBuilder;
  23 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  24 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  25 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  26
  27 /**
  28  * @author michal.rehak
  29  *
  30  * @deprecated Use {@link Builders} instead.
  31  */
  32 @Deprecated
  33 public class NodeModificationBuilderImpl implements NodeModificationBuilder {
  34
  35     private final SchemaContext context;
  36
  37     private final Set<MutableNode<?>> changeLog;
  38     private final LazyNodeToNodeMap originalToMutable;
  39
  40     /**
  41      * @param context
  42      */
  43     public NodeModificationBuilderImpl(final SchemaContext context) {
  44         this.context = context;
  45         originalToMutable = new LazyNodeToNodeMap();
  46         changeLog = new HashSet<>();
  47     }
  48
  49     /**
  50      * @param modNode
  51      * @param action
  52      */
  53     private void addModificationToLog(final MutableNode<?> modNode, final ModifyAction action) {
  54         modNode.setModifyAction(action);
  55         changeLog.add(modNode);
  56     }
  57
  58     @Override
  59     public void addNode(final MutableSimpleNode<?> newNode) {
  60         NodeUtils.fixParentRelation(newNode);
  61         addModificationToLog(newNode, ModifyAction.CREATE);
  62     }
  63
  64     @Override
  65     public void addNode(final MutableCompositeNode newNode) {
  66         NodeUtils.fixParentRelation(newNode);
  67         addModificationToLog(newNode, ModifyAction.CREATE);
  68     }
  69
  70     @Override
  71     public void replaceNode(final MutableSimpleNode<?> replacementNode) {
  72         addModificationToLog(replacementNode, ModifyAction.REPLACE);
  73     }
  74
  75     @Override
  76     public void replaceNode(final MutableCompositeNode replacementNode) {
  77         addModificationToLog(replacementNode, ModifyAction.REPLACE);
  78     }
  79
  80     @Override
  81     public void deleteNode(final MutableCompositeNode deadNode) {
  82         addModificationToLog(deadNode, ModifyAction.DELETE);
  83     }
  84
  85     @Override
  86     public void deleteNode(final MutableSimpleNode<?> deadNode) {
  87         addModificationToLog(deadNode, ModifyAction.DELETE);
  88     }
  89
  90     @Override
  91     public void removeNode(final MutableSimpleNode<?> deadNode) {
  92         addModificationToLog(deadNode, ModifyAction.REMOVE);
  93     }
  94
  95     @Override
  96     public void removeNode(final MutableCompositeNode deadNode) {
  97         addModificationToLog(deadNode, ModifyAction.REMOVE);
  98     }
  99
 100     @Override
 101     public void mergeNode(final MutableCompositeNode alteredNode) {
 102         addModificationToLog(alteredNode, ModifyAction.MERGE);
 103     }
 104
 105     /**
 106      * @return minimalistic tree containing diffs only
 107      */
 108     @Override
 109     public CompositeNode buildDiffTree() {
 110         Set<Node<?>> wanted = new HashSet<>();
 111
 112         // walk changeLog, collect all required nodes
 113         for (MutableNode<?> mutant : changeLog) {
 114             wanted.addAll(collectSelfAndAllParents(mutant));
 115         }
 116
 117         // walk wanted and add relevant keys
 118         Map<String, ListSchemaNode> mapOfLists = NodeUtils.buildMapOfListNodes(context);
 119         for (Node<?> outlaw : wanted) {
 120             if (outlaw instanceof CompositeNode) {
 121                 String path = NodeUtils.buildPath(outlaw);
 122                 if (mapOfLists.containsKey(path)) {
 123                     ListSchemaNode listSchema = mapOfLists.get(path);
 124                     if (listSchema.getQName().equals(outlaw.getNodeType())) {
 125                         // try to add key subnode to wanted list
 126                         List<QName> supportedKeys = listSchema.getKeyDefinition();
 127                         CompositeNode outlawOriginal = ((MutableCompositeNode) outlaw).getOriginal();
 128                         for (Node<?> outlawOriginalChild : outlawOriginal.getValue()) {
 129                             if (supportedKeys.contains(outlawOriginalChild.getNodeType())) {
 130                                 originalToMutable.getMutableEquivalent(outlawOriginalChild);
 131                             }
 132                         }
 133                     }
 134                 }
 135             }
 136         }
 137
 138         return originalToMutable.getMutableRoot();
 139     }
 140
 141     /**
 142      * @param focusedDescendant
 143      * @return set of parents and focusedAncestor itself
 144      */
 145     private static Set<Node<?>> collectSelfAndAllParents(final Node<?> focusedDescendant) {
 146         Set<Node<?>> family = new HashSet<>();
 147         Node<?> tmpNode = focusedDescendant;
 148         while (tmpNode != null) {
 149             family.add(tmpNode);
 150             tmpNode = tmpNode.getParent();
 151         }
 152         return family;
 153     }
 154
 155     /**
 156      * @param originalNode
 157      * @return mutable version of given node
 158      */
 159     @Override
 160     public Node<?> getMutableEquivalent(final Node<?> originalNode) {
 161         return originalToMutable.getMutableEquivalent(originalNode);
 162     }
 163
 164 }