opendaylight/md-sal/sal-protocolbuffer-encoding/src/main/java/org/opendaylight/controller/cluster/datastore/node/NormalizedNodeToProtocolBufferNode.java

   1 package org.opendaylight.controller.cluster.datastore.node;
   2 import com.google.common.base.Preconditions;
   3 import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages;
   4 import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node;
   5 import org.opendaylight.yangtools.yang.common.QName;
   6 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
   7 import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
   8 import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
   9 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  10 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
  11 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
  12 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
  13 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
  14 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
  15 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  16 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
  17 import org.opendaylight.yangtools.yang.data.api.schema.MixinNode;
  18 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  19 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
  20 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
  21
  22 import java.util.Map;
  23
  24 /**
  25  * NormalizedNodeToProtocolBufferNode walks the NormalizedNode tree converting it to the
  26  * NormalizedMessage.Node
  27  *
  28  * {@link org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode } is a tree like structure that provides a generic structure for a yang data
  29  * model
  30  *
  31  *
  32  */
  33 public class NormalizedNodeToProtocolBufferNode {
  34
  35
  36   private final Node.Builder builderRoot;
  37   private NormalizedNodeMessages.Container container;
  38
  39   public NormalizedNodeToProtocolBufferNode() {
  40
  41     builderRoot = Node.newBuilder();
  42   }
  43
  44   public void encode(String parentPath, NormalizedNode<?, ?> normalizedNode) {
  45     if (parentPath == null) {
  46       parentPath = "";
  47     }
  48
  49     Preconditions.checkArgument(normalizedNode!=null);
  50
  51     navigateNormalizedNode(0, parentPath,normalizedNode, builderRoot);
  52     // here we need to put back the Node Tree in Container
  53     NormalizedNodeMessages.Container.Builder containerBuilder =
  54         NormalizedNodeMessages.Container.newBuilder();
  55     containerBuilder.setParentPath(parentPath).setNormalizedNode(
  56         builderRoot.build());
  57     container = containerBuilder.build();
  58
  59   }
  60
  61
  62   private void navigateDataContainerNode(int level,final String parentPath,
  63       final DataContainerNode<?> dataContainerNode, Node.Builder builderParent) {
  64
  65     String newParentPath = parentPath + "/" + dataContainerNode.getIdentifier().toString();
  66     String type = getDataContainerType(dataContainerNode).getSimpleName();
  67     builderParent.setPath(dataContainerNode.getIdentifier().toString())
  68         .setType(type);
  69
  70     final Iterable<DataContainerChild<? extends InstanceIdentifier.PathArgument, ?>> value =
  71         dataContainerNode.getValue();
  72     for (NormalizedNode<?, ?> node : value) {
  73       Node.Builder builderChild = Node.newBuilder();
  74       if (node instanceof MixinNode && node instanceof NormalizedNodeContainer) {
  75
  76         navigateNormalizedNodeContainerMixin(level, newParentPath,
  77             (NormalizedNodeContainer<?, ?, ?>) node, builderChild);
  78       } else {
  79         navigateNormalizedNode(level, newParentPath,node, builderChild);
  80       }
  81       builderParent.addChild(builderChild);
  82     }
  83
  84   }
  85
  86   private Class getDataContainerType(
  87       NormalizedNodeContainer<?, ?, ?> dataContainerNode) {
  88     if (dataContainerNode instanceof ChoiceNode) {
  89       return ChoiceNode.class;
  90     } else if (dataContainerNode instanceof AugmentationNode) {
  91       return AugmentationNode.class;
  92     } else if (dataContainerNode instanceof ContainerNode) {
  93       return ContainerNode.class;
  94     } else if (dataContainerNode instanceof MapEntryNode) {
  95       return MapEntryNode.class;
  96     } else if (dataContainerNode instanceof UnkeyedListEntryNode) {
  97       return UnkeyedListEntryNode.class;
  98     } else if (dataContainerNode instanceof MapNode) {
  99       return MapNode.class;
 100     } else if (dataContainerNode instanceof LeafSetNode){
 101       return LeafSetNode.class;
 102     }
 103     throw new IllegalArgumentException(
 104         "could not find the data container node type "
 105             + dataContainerNode.toString());
 106   }
 107
 108   private void navigateNormalizedNodeContainerMixin(int level, final String parentPath,
 109       NormalizedNodeContainer<?, ?, ?> node, Node.Builder builderParent) {
 110     String newParentPath = parentPath + "/" + node.getIdentifier().toString();
 111
 112     builderParent.setPath(node.getIdentifier().toString()).setType(
 113         this.getDataContainerType(node).getSimpleName());
 114     final Iterable<? extends NormalizedNode<?, ?>> value = node.getValue();
 115     for (NormalizedNode normalizedNode : value) {
 116       // child node builder
 117       Node.Builder builderChild = Node.newBuilder();
 118       if (normalizedNode instanceof MixinNode
 119           && normalizedNode instanceof NormalizedNodeContainer) {
 120         navigateNormalizedNodeContainerMixin(level + 1,newParentPath,
 121             (NormalizedNodeContainer) normalizedNode, builderChild);
 122       } else {
 123         navigateNormalizedNode(level,newParentPath, normalizedNode, builderChild);
 124       }
 125       builderParent.addChild(builderChild);
 126
 127     }
 128
 129
 130
 131   }
 132
 133
 134   private void navigateNormalizedNode(int level,
 135       String parentPath,NormalizedNode<?, ?> normalizedNode, Node.Builder builderParent) {
 136
 137     if (normalizedNode instanceof DataContainerNode) {
 138
 139       final DataContainerNode<?> dataContainerNode =
 140           (DataContainerNode) normalizedNode;
 141
 142       navigateDataContainerNode(level + 1, parentPath,dataContainerNode, builderParent);
 143     } else {
 144
 145       if (normalizedNode instanceof LeafNode) {
 146         buildLeafNode(parentPath,normalizedNode, builderParent);
 147       } else if (normalizedNode instanceof LeafSetEntryNode) {
 148         buildLeafSetEntryNode(parentPath,normalizedNode,builderParent);
 149       }
 150
 151     }
 152
 153   }
 154
 155   private void buildLeafSetEntryNode(String parentPath,NormalizedNode<?, ?> normalizedNode,
 156       Node.Builder builderParent) {
 157     String path = parentPath + "/" + normalizedNode.getIdentifier().toString();
 158     LeafSetEntryNode leafSetEntryNode = (LeafSetEntryNode) normalizedNode;
 159     Map<QName, String> attributes = leafSetEntryNode.getAttributes();
 160     if (!attributes.isEmpty()) {
 161       NormalizedNodeMessages.Attribute.Builder builder = null;
 162       for (Map.Entry<QName, String> attribute : attributes.entrySet()) {
 163         builder = NormalizedNodeMessages.Attribute.newBuilder();
 164         builder.setName(attribute.getKey().toString()).setValue(
 165             normalizedNode.getValue().toString());
 166         builderParent.addAttributes(builder.build());
 167       }
 168     }
 169     builderParent.setPath(normalizedNode.getIdentifier().toString()).setType(
 170         LeafSetEntryNode.class.getSimpleName()).setValue(normalizedNode.getValue().toString());
 171   }
 172
 173   private void buildLeafNode(String parentPath,NormalizedNode<?, ?> normalizedNode,
 174       Node.Builder builderParent) {
 175     String path = parentPath + "/" + normalizedNode.getIdentifier().toString();
 176     LeafNode leafNode = (LeafNode) normalizedNode;
 177     Map<QName, String> attributes = leafNode.getAttributes();
 178     if (!attributes.isEmpty()) {
 179       NormalizedNodeMessages.Attribute.Builder builder = null;
 180       for (Map.Entry<QName, String> attribute : attributes.entrySet()) {
 181         builder = NormalizedNodeMessages.Attribute.newBuilder();
 182         builder.setName(attribute.getKey().toString()).setValue(
 183             normalizedNode.getValue().toString());
 184         builderParent.addAttributes(builder.build());
 185       }
 186     }
 187     builderParent.setPath(normalizedNode.getIdentifier().toString()).setType(
 188         LeafNode.class.getSimpleName()).setValue(normalizedNode.getValue().toString());
 189   }
 190
 191   public NormalizedNodeMessages.Container getContainer() {
 192     return container;
 193   }
 194 }