yang/yang-data-util/src/main/java/org/opendaylight/yangtools/yang/data/util/Nodes.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.util;
   9
  10 import java.util.ArrayList;
  11 import java.util.Collection;
  12 import java.util.HashMap;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.Set;
  16
  17 import org.opendaylight.yangtools.yang.common.QName;
  18 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
  19 import org.opendaylight.yangtools.yang.data.api.MutableCompositeNode;
  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.SimpleNode;
  23
  24 public final class Nodes {
  25
  26     private Nodes() {
  27     }
  28
  29     public static <T> SimpleNode<T> leafNode(QName name, T value) {
  30         return new SimpleNodeTO<T>(name, value, null);
  31     }
  32
  33     public static CompositeNode containerNode(QName name, List<Node<?>> children) {
  34         return containerNode(name, children, null);
  35     }
  36
  37     public static CompositeNode containerNode(QName name, List<Node<?>> children, CompositeNode parent) {
  38         return new ContainerNodeTO(name, parent, nodeMapFromList(children));
  39     }
  40
  41     public static Map<QName, List<Node<?>>> nodeMapFromList(List<Node<?>> children) {
  42         Map<QName, List<Node<?>>> map = new HashMap<QName, List<Node<?>>>();
  43         for (Node<?> node : children) {
  44
  45             QName name = node.getNodeType();
  46             List<Node<?>> targetList = map.get(name);
  47             if (targetList == null) {
  48                 targetList = new ArrayList<Node<?>>();
  49                 map.put(name, targetList);
  50             }
  51             targetList.add(node);
  52         }
  53         return map;
  54     }
  55
  56     private static class ContainerNodeTO extends AbstractContainerNode {
  57
  58         private final Map<QName, List<Node<?>>> nodeMap;
  59
  60         public ContainerNodeTO(QName name, Map<QName, List<Node<?>>> nodeMap) {
  61             super(name);
  62             this.nodeMap = nodeMap;
  63         }
  64
  65         public ContainerNodeTO(QName name, CompositeNode parent, Map<QName, List<Node<?>>> nodeMap) {
  66             super(name, parent);
  67             this.nodeMap = nodeMap;
  68         }
  69
  70         @Override
  71         protected Map<QName, List<Node<?>>> getNodeMap() {
  72
  73             return nodeMap;
  74         }
  75
  76         /*
  77          * (non-Javadoc)
  78          *
  79          * @see
  80          * org.opendaylight.yangtools.yang.data.api.CompositeNode#asMutable()
  81          */
  82         @Override
  83         public MutableCompositeNode asMutable() {
  84             // TODO Auto-generated method stub
  85             return null;
  86         }
  87
  88         @Override
  89         public QName getKey() {
  90             return getNodeType();
  91         }
  92
  93         @Override
  94         public List<Node<?>> setValue(List<Node<?>> value) {
  95             return null;
  96         }
  97
  98         @Override
  99         public int size() {
 100             return nodeMap.size();
 101         }
 102
 103         @Override
 104         public boolean isEmpty() {
 105             return nodeMap.isEmpty();
 106         }
 107
 108         @Override
 109         public boolean containsKey(Object key) {
 110             return nodeMap.containsKey(key);
 111         }
 112
 113         @Override
 114         public boolean containsValue(Object value) {
 115             return nodeMap.containsValue(value);
 116         }
 117
 118         @Override
 119         public List<Node<?>> get(Object key) {
 120             return nodeMap.get(key);
 121         }
 122
 123         @Override
 124         public List<Node<?>> put(QName key, List<Node<?>> value) {
 125             return nodeMap.put(key, value);
 126         }
 127
 128         @Override
 129         public List<Node<?>> remove(Object key) {
 130             return nodeMap.remove(key);
 131         }
 132
 133         @Override
 134         public void putAll(Map<? extends QName, ? extends List<Node<?>>> m) {
 135             nodeMap.putAll(m);
 136         }
 137
 138         @Override
 139         public void clear() {
 140             nodeMap.clear();
 141         }
 142
 143         @Override
 144         public Set<QName> keySet() {
 145             return nodeMap.keySet();
 146         }
 147
 148         @Override
 149         public Collection<List<Node<?>>> values() {
 150             return nodeMap.values();
 151         }
 152
 153         @Override
 154         public Set<java.util.Map.Entry<QName, List<Node<?>>>> entrySet() {
 155
 156             return nodeMap.entrySet();
 157         }
 158
 159     }
 160
 161     private static class SimpleNodeTO<T> extends AbstractNode<T> implements SimpleNode<T> {
 162
 163         private final T value;
 164
 165         protected SimpleNodeTO(QName name, T val, CompositeNode parent) {
 166             super(name, parent);
 167             value = val;
 168
 169         }
 170
 171         @Override
 172         public T getValue() {
 173             return value;
 174         }
 175
 176         /*
 177          * (non-Javadoc)
 178          *
 179          * @see org.opendaylight.yangtools.yang.data.api.SimpleNode#asMutable()
 180          */
 181         @Override
 182         public MutableSimpleNode<T> asMutable() {
 183             // TODO Auto-generated method stub
 184             return null;
 185         }
 186
 187         @Override
 188         public T setValue(T value) {
 189             return null;
 190         }
 191
 192         @Override
 193         public QName getKey() {
 194             return getNodeType();
 195         }
 196     }
 197
 198 }