opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/impl/DataReaderRouter.xtend

   1 package org.opendaylight.controller.sal.dom.broker.impl
   2
   3 import org.opendaylight.controller.md.sal.common.impl.routing.AbstractDataReadRouter
   4 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier
   5 import org.opendaylight.yangtools.yang.data.api.CompositeNode
   6 import org.opendaylight.controller.md.sal.common.api.data.DataReader
   7 import org.opendaylight.yangtools.yang.common.QName
   8 import java.net.URI
   9 import java.util.List
  10 import org.opendaylight.yangtools.yang.data.api.Node
  11 import java.util.ArrayList
  12 import org.opendaylight.yangtools.yang.data.impl.SimpleNodeTOImpl
  13 import java.util.Map
  14 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument
  15 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier
  16 import org.opendaylight.yangtools.yang.data.api.SimpleNode
  17 import java.util.Collections
  18 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates
  19 import java.util.HashMap
  20 import static com.google.common.base.Preconditions.*;
  21 import java.util.Collection
  22 import java.util.Set
  23 import java.util.Map.Entry
  24 import org.slf4j.LoggerFactory
  25 import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl
  26
  27 class DataReaderRouter extends AbstractDataReadRouter<InstanceIdentifier, CompositeNode> {
  28     private static val LOG = LoggerFactory.getLogger(DataReaderRouter);
  29     private static val NETCONF_NAMESPACE = URI.create("urn:ietf:params:xml:ns:netconf:base:1.0")
  30     private static val NETCONF_DATA = new QName(NETCONF_NAMESPACE,"data");
  31
  32     override protected merge(InstanceIdentifier path, Iterable<CompositeNode> data) {
  33         val pathArgument = path.path.last;
  34         var empty = true;
  35         var name = pathArgument?.nodeType;
  36         val nodes = new ArrayList<Node<?>>();
  37         val keyNodes = new HashMap<QName, SimpleNode<?>>();
  38         val iterator = data.iterator;
  39         for(dataBit : data) {
  40             try {
  41                 if(pathArgument != null && dataBit != null) {
  42                     empty = false;
  43                     val keyNodesLocal = getKeyNodes(pathArgument,dataBit);
  44                     nodes.addAll(dataBit.childrenWithout(keyNodesLocal.entrySet));
  45                 } else if (dataBit != null) {
  46                     empty = false;
  47                     nodes.addAll(dataBit.children)
  48                 }
  49             }   catch (IllegalStateException e) {
  50                 LOG.error("BUG: Readed data for path {} was invalid",path,e);
  51             }
  52         }
  53         if(empty) {
  54             return null;
  55         }
  56         /**
  57          * Reading from Root
  58          *
  59          */
  60         if(pathArgument == null) {
  61             return new CompositeNodeTOImpl(NETCONF_DATA,null,nodes);
  62         }
  63         val finalNodes = new ArrayList<Node<?>>();
  64         finalNodes.addAll(keyNodes.values);
  65         finalNodes.addAll(nodes);
  66         return new CompositeNodeTOImpl(name,null,finalNodes);
  67     }
  68
  69
  70
  71     dispatch def Map<QName, SimpleNode<?>> getKeyNodes(PathArgument argument, CompositeNode node) {
  72         return Collections.emptyMap();
  73     }
  74
  75     dispatch def getKeyNodes(NodeIdentifierWithPredicates argument, CompositeNode node) {
  76         val ret = new HashMap<QName, SimpleNode<?>>();
  77         for (keyValue : argument.keyValues.entrySet) {
  78             val simpleNode = node.getSimpleNodesByName(keyValue.key);
  79             if(simpleNode !== null && !simpleNode.empty) {
  80                 checkState(simpleNode.size <= 1,"Only one simple node for key $s is allowed in node $s",keyValue.key,node);
  81                 checkState(simpleNode.get(0).value == keyValue.value,"Key node must equals to instance identifier value");
  82                 ret.put(keyValue.key,simpleNode.get(0));
  83             }
  84             val compositeNode = node.getCompositesByName(keyValue.key);
  85             checkState(compositeNode === null || compositeNode.empty,"Key node must be Simple Node, not composite node.");
  86         }
  87         return ret;
  88     }
  89
  90     def Collection<? extends Node<?>> childrenWithout(CompositeNode node, Set<Entry<QName, SimpleNode<?>>> entries) {
  91         if(entries.empty) {
  92             return node.children;
  93         }
  94         val filteredNodes = new ArrayList<Node<?>>();
  95         for(scannedNode : node.children) {
  96             if(!entries.contains(scannedNode.nodeType)) {
  97                 filteredNodes.add(scannedNode);
  98             }
  99         }
 100         return filteredNodes;
 101     }
 102
 103 }