yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/CompositeNodeTOImpl.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.io.IOException;
  11 import java.io.ObjectInputStream;
  12 import java.io.ObjectOutputStream;
  13 import java.io.Serializable;
  14 import java.util.ArrayList;
  15 import java.util.Collection;
  16 import java.util.Collections;
  17 import java.util.HashMap;
  18 import java.util.List;
  19 import java.util.Map;
  20 import java.util.Set;
  21
  22 import org.opendaylight.yangtools.yang.common.QName;
  23 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
  24 import org.opendaylight.yangtools.yang.data.api.ModifyAction;
  25 import org.opendaylight.yangtools.yang.data.api.MutableCompositeNode;
  26 import org.opendaylight.yangtools.yang.data.api.Node;
  27 import org.opendaylight.yangtools.yang.data.api.SimpleNode;
  28 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
  29
  30 /**
  31  * @author michal.rehak
  32  *
  33  * @deprecated Use one of the {@link NormalizedNodeContainer} implementations.
  34  */
  35 @Deprecated
  36 public class CompositeNodeTOImpl extends AbstractNodeTO<List<Node<?>>> implements CompositeNode, Serializable {
  37
  38     private static final long serialVersionUID = 100L;
  39
  40     private Map<QName, List<Node<?>>> nodeMap = new HashMap<>();
  41
  42     /**
  43      * @param qname
  44      * @param parent
  45      *            use null to create top composite node (without parent)
  46      * @param value
  47      */
  48     public CompositeNodeTOImpl(final QName qname, final CompositeNode parent, final List<Node<?>> value) {
  49         super(qname, parent, value);
  50         init();
  51     }
  52
  53     /**
  54      * @param qname
  55      * @param parent
  56      *            use null to create top composite node (without parent)
  57      * @param value
  58      * @param modifyAction
  59      */
  60     public CompositeNodeTOImpl(final QName qname, final CompositeNode parent, final List<Node<?>> value, final ModifyAction modifyAction) {
  61         super(qname, parent, value, modifyAction);
  62         init();
  63     }
  64
  65     protected void init() {
  66         if (getValue() != null) {
  67             nodeMap = NodeUtils.buildNodeMap(getValue());
  68         }
  69     }
  70
  71     protected Map<QName, List<Node<?>>> getNodeMap() {
  72         return nodeMap;
  73     }
  74
  75     @Override
  76     public List<Node<?>> getChildren() {
  77         return Collections.unmodifiableList(getValue() == null ? new ArrayList<Node<?>>() : getValue());
  78     }
  79
  80     @Override
  81     public SimpleNode<?> getFirstSimpleByName(final QName leafQName) {
  82         List<SimpleNode<?>> list = getSimpleNodesByName(leafQName);
  83         if (list.isEmpty()) {
  84             return null;
  85         }
  86         return list.get(0);
  87     }
  88
  89     @Override
  90     public List<CompositeNode> getCompositesByName(final QName children) {
  91         List<Node<?>> toFilter = getNodeMap().get(children);
  92         if(toFilter == null) {
  93             return Collections.emptyList();
  94         }
  95         List<CompositeNode> list = new ArrayList<CompositeNode>();
  96         for (Node<?> node : toFilter) {
  97             if (node instanceof CompositeNode) {
  98                 list.add((CompositeNode) node);
  99             }
 100         }
 101         return list;
 102     }
 103
 104     @Override
 105     public List<SimpleNode<?>> getSimpleNodesByName(final QName children) {
 106         List<Node<?>> toFilter = getNodeMap().get(children);
 107         if(toFilter == null) {
 108             return Collections.emptyList();
 109         }
 110         List<SimpleNode<?>> list = new ArrayList<SimpleNode<?>>();
 111
 112         for (Node<?> node : toFilter) {
 113             if (node instanceof SimpleNode<?>) {
 114                 list.add((SimpleNode<?>) node);
 115             }
 116         }
 117         return list;
 118     }
 119
 120     @Override
 121     public CompositeNode getFirstCompositeByName(final QName container) {
 122         List<CompositeNode> list = getCompositesByName(container);
 123         if (list.isEmpty()) {
 124             return null;
 125         }
 126         return list.get(0);
 127     }
 128
 129     /**
 130      * @param leaf
 131      * @return TODO:: do we need this method?
 132      */
 133     public SimpleNode<?> getFirstLeafByName(final QName leaf) {
 134         List<SimpleNode<?>> list = getSimpleNodesByName(leaf);
 135         if (list.isEmpty()) {
 136             return null;
 137         }
 138         return list.get(0);
 139     }
 140
 141     @Override
 142     public List<CompositeNode> getCompositesByName(final String children) {
 143         return getCompositesByName(QName.create(getNodeType(), children));
 144     }
 145
 146     @Override
 147     public List<SimpleNode<?>> getSimpleNodesByName(final String children) {
 148         return getSimpleNodesByName(QName.create(getNodeType(), children));
 149     }
 150
 151     @Override
 152     public MutableCompositeNode asMutable() {
 153         throw new IllegalAccessError("cast to mutable is not supported - " + getClass().getSimpleName());
 154     }
 155
 156     @Override
 157     public String toString() {
 158         return super.toString() + ", children.size = " + (!getChildren().isEmpty() ? getChildren().size() : "n/a");
 159     }
 160
 161     @Override
 162     public void clear() {
 163         nodeMap.clear();
 164     }
 165
 166     @Override
 167     public boolean containsKey(final Object key) {
 168         return nodeMap.containsKey(key);
 169     }
 170
 171     @Override
 172     public boolean containsValue(final Object value) {
 173         return nodeMap.containsValue(value);
 174     }
 175
 176     @Override
 177     public Set<java.util.Map.Entry<QName, List<Node<?>>>> entrySet() {
 178         return nodeMap.entrySet();
 179     }
 180
 181     @Override
 182     public int size() {
 183         return nodeMap.size();
 184     }
 185
 186     @Override
 187     public boolean isEmpty() {
 188         return nodeMap.isEmpty();
 189     }
 190
 191     @Override
 192     public List<Node<?>> get(final Object key) {
 193         return nodeMap.get(key);
 194     }
 195
 196     @Override
 197     public List<Node<?>> put(final QName key, final List<Node<?>> value) {
 198         return nodeMap.put(key, value);
 199     }
 200
 201     @Override
 202     public List<Node<?>> remove(final Object key) {
 203         return nodeMap.remove(key);
 204     }
 205
 206     @Override
 207     public void putAll(final Map<? extends QName, ? extends List<Node<?>>> m) {
 208         nodeMap.putAll(m);
 209     }
 210
 211     @Override
 212     public Set<QName> keySet() {
 213         return nodeMap.keySet();
 214     }
 215
 216     @Override
 217     public Collection<List<Node<?>>> values() {
 218         return nodeMap.values();
 219     }
 220
 221     // Serialization related
 222
 223     private void readObject(final ObjectInputStream aStream) throws IOException, ClassNotFoundException {
 224         aStream.defaultReadObject();
 225         QName qName = (QName)aStream.readObject();
 226         CompositeNode parent = (CompositeNode) aStream.readObject();
 227         @SuppressWarnings("unchecked")
 228         List<Node<?>> value = (List<Node<?>>) aStream.readObject();
 229         ModifyAction modifyAction = (ModifyAction) aStream.readObject();
 230
 231         init(qName, parent, value, modifyAction);
 232     }
 233
 234     private void writeObject(final ObjectOutputStream aStream) throws IOException {
 235         aStream.defaultWriteObject();
 236         //manually serialize superclass
 237         aStream.writeObject(getQName());
 238         aStream.writeObject(getParent());
 239         aStream.writeObject(getValue());
 240         aStream.writeObject(getModificationAction());
 241     }
 242 }