From: msunal <msunal@cisco.com>
Date: Wed, 27 Nov 2013 15:47:43 +0000 (+0100)
Subject: MutableCopomositeNodeTOImpl as mutable implementation of CompositeNode
X-Git-Tag: yangtools-0.6.0~163^2
X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=b398fbd5f6e7460368ab98920f0cf0a14fcde93b;p=yangtools.git

MutableCopomositeNodeTOImpl as mutable implementation of CompositeNode

- MutableCopomositeNodeTOImpl extends AbstractNodeTO instead of CompositeNodeTOImpl

Signed-off-by: Martin Sunal <msunal@cisco.com>
---

diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/CompositeNodeTOImpl.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/CompositeNodeTOImpl.java
index 54d550711a..33779221e8 100644
--- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/CompositeNodeTOImpl.java
+++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/CompositeNodeTOImpl.java
@@ -10,6 +10,7 @@ package org.opendaylight.yangtools.yang.data.impl;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -27,7 +28,7 @@ import org.opendaylight.yangtools.yang.data.api.SimpleNode;
  */
 public class CompositeNodeTOImpl extends AbstractNodeTO<List<Node<?>>> implements CompositeNode {
 
-    private Map<QName, List<Node<?>>> nodeMap;
+    private Map<QName, List<Node<?>>> nodeMap = new HashMap<>();
 
     /**
      * @param qname
@@ -37,9 +38,6 @@ public class CompositeNodeTOImpl extends AbstractNodeTO<List<Node<?>>> implement
      */
     public CompositeNodeTOImpl(QName qname, CompositeNode parent, List<Node<?>> value) {
         super(qname, parent, value);
-        if (value != null) {
-            nodeMap = NodeUtils.buildNodeMap(getValue());
-        }
         init();
     }
 
@@ -54,10 +52,13 @@ public class CompositeNodeTOImpl extends AbstractNodeTO<List<Node<?>>> implement
         super(qname, parent, value, modifyAction);
         init();
     }
+    
+    protected void init() {
+        if (getValue() != null) {
+            nodeMap = NodeUtils.buildNodeMap(getValue());
+        }
+    }
 
-    /**
-     * @return the nodeMap
-     */
     protected Map<QName, List<Node<?>>> getNodeMap() {
         return nodeMap;
     }
@@ -138,12 +139,6 @@ public class CompositeNodeTOImpl extends AbstractNodeTO<List<Node<?>>> implement
         return getSimpleNodesByName(new QName(getNodeType(), children));
     }
 
-    protected void init() {
-        if (getValue() != null) {
-            nodeMap = NodeUtils.buildNodeMap(getValue());
-        }
-    }
-
     @Override
     public MutableCompositeNode asMutable() {
         throw new IllegalAccessError("cast to mutable is not supported - " + getClass().getSimpleName());
diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/MutableCompositeNodeTOImpl.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/MutableCompositeNodeTOImpl.java
index 014c788386..6c29fca336 100644
--- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/MutableCompositeNodeTOImpl.java
+++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/MutableCompositeNodeTOImpl.java
@@ -8,34 +8,32 @@
 package org.opendaylight.yangtools.yang.data.impl;
 
 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
 import org.opendaylight.yangtools.yang.data.api.ModifyAction;
 import org.opendaylight.yangtools.yang.data.api.MutableCompositeNode;
 import org.opendaylight.yangtools.yang.data.api.Node;
+import org.opendaylight.yangtools.yang.data.api.SimpleNode;
 
 /**
  * @author michal.rehak
- *
+ * 
  */
-public class MutableCompositeNodeTOImpl extends CompositeNodeTOImpl
-        implements MutableCompositeNode {
+public class MutableCompositeNodeTOImpl extends AbstractNodeTO<List<Node<?>>> implements MutableCompositeNode {
 
-    private Map<QName, List<Node<?>>> nodeMap;
+    private Map<QName, List<Node<?>>> nodeMap = new HashMap<>();
     private CompositeNode original;
 
-    /**
-     * @param qname
-     * @param parent
-     * @param value
-     * @param modifyAction
-     */
-    public MutableCompositeNodeTOImpl(QName qname, CompositeNode parent,
-            List<Node<?>> value, ModifyAction modifyAction) {
+    public MutableCompositeNodeTOImpl(QName qname, CompositeNode parent, List<Node<?>> value, ModifyAction modifyAction) {
         super(qname, parent, value, modifyAction);
+        init();
     }
 
     /**
@@ -47,7 +45,7 @@ public class MutableCompositeNodeTOImpl extends CompositeNodeTOImpl
             nodeMap = NodeUtils.buildNodeMap(getChildren());
         }
     }
-    
+
     @Override
     public List<Node<?>> getChildren() {
         return getValue() == null ? new ArrayList<Node<?>>() : getValue();
@@ -65,7 +63,6 @@ public class MutableCompositeNodeTOImpl extends CompositeNodeTOImpl
         super.setModificationAction(action);
     }
 
-    @Override
     protected Map<QName, List<Node<?>>> getNodeMap() {
         return nodeMap;
     }
@@ -81,9 +78,151 @@ public class MutableCompositeNodeTOImpl extends CompositeNodeTOImpl
     }
 
     /**
-     * @param original the original to set
+     * @param original
+     *            the original to set
      */
     public void setOriginal(CompositeNode original) {
         this.original = original;
     }
+
+    @Override
+    public SimpleNode<?> getFirstSimpleByName(QName leafQName) {
+        List<SimpleNode<?>> list = getSimpleNodesByName(leafQName);
+        if (list.isEmpty()) {
+            return null;
+        }
+        return list.get(0);
+    }
+
+    @Override
+    public List<CompositeNode> getCompositesByName(QName children) {
+        List<Node<?>> toFilter = getNodeMap().get(children);
+        if (toFilter == null) {
+            return Collections.emptyList();
+        }
+        List<CompositeNode> list = new ArrayList<CompositeNode>();
+        for (Node<?> node : toFilter) {
+            if (node instanceof CompositeNode) {
+                list.add((CompositeNode) node);
+            }
+        }
+        return list;
+    }
+
+    @Override
+    public List<SimpleNode<?>> getSimpleNodesByName(QName children) {
+        List<Node<?>> toFilter = getNodeMap().get(children);
+        if (toFilter == null) {
+            return Collections.emptyList();
+        }
+        List<SimpleNode<?>> list = new ArrayList<SimpleNode<?>>();
+
+        for (Node<?> node : toFilter) {
+            if (node instanceof SimpleNode<?>) {
+                list.add((SimpleNode<?>) node);
+            }
+        }
+        return list;
+    }
+
+    @Override
+    public CompositeNode getFirstCompositeByName(QName container) {
+        List<CompositeNode> list = getCompositesByName(container);
+        if (list.isEmpty()) {
+            return null;
+        }
+        return list.get(0);
+    }
+
+    /**
+     * @param leaf
+     * @return TODO:: do we need this method?
+     */
+    public SimpleNode<?> getFirstLeafByName(QName leaf) {
+        List<SimpleNode<?>> list = getSimpleNodesByName(leaf);
+        if (list.isEmpty()) {
+            return null;
+        }
+        return list.get(0);
+    }
+
+    @Override
+    public List<CompositeNode> getCompositesByName(String children) {
+        return getCompositesByName(new QName(getNodeType(), children));
+    }
+
+    @Override
+    public List<SimpleNode<?>> getSimpleNodesByName(String children) {
+        return getSimpleNodesByName(new QName(getNodeType(), children));
+    }
+
+    @Override
+    public String toString() {
+        return super.toString() + ", children.size = " + (getChildren() != null ? getChildren().size() : "n/a");
+    }
+
+    @Override
+    public void clear() {
+        nodeMap.clear();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return nodeMap.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return nodeMap.containsValue(value);
+    }
+
+    @Override
+    public Set<java.util.Map.Entry<QName, List<Node<?>>>> entrySet() {
+        return nodeMap.entrySet();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        return super.equals(obj);
+    }
+
+    @Override
+    public int size() {
+        return nodeMap.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return nodeMap.isEmpty();
+    }
+
+    @Override
+    public List<Node<?>> get(Object key) {
+        return nodeMap.get(key);
+    }
+
+    @Override
+    public List<Node<?>> put(QName key, List<Node<?>> value) {
+        return nodeMap.put(key, value);
+    }
+
+    @Override
+    public List<Node<?>> remove(Object key) {
+        return nodeMap.remove(key);
+    }
+
+    @Override
+    public void putAll(Map<? extends QName, ? extends List<Node<?>>> m) {
+        nodeMap.putAll(m);
+    }
+
+    @Override
+    public Set<QName> keySet() {
+        return nodeMap.keySet();
+    }
+
+    @Override
+    public Collection<List<Node<?>>> values() {
+        return nodeMap.values();
+    }
 }