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