opendaylight/md-sal/sal-clustering-commons/src/main/java/org/opendaylight/controller/cluster/datastore/node/NormalizedNodeToNodeCodec.java

   1 /*
   2  *
   3  *  Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   4  *
   5  *  This program and the accompanying materials are made available under the
   6  *  terms of the Eclipse Public License v1.0 which accompanies this distribution,
   7  *  and is available at http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  */
  10
  11 package org.opendaylight.controller.cluster.datastore.node;
  12
  13 import org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeSerializer;
  14 import org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeSerializer.DeSerializer;
  15 import org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeSerializer.Serializer;
  16 import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages;
  17 import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Container;
  18 import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.InstanceIdentifier;
  19 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  20 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  21 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  22
  23 public class NormalizedNodeToNodeCodec {
  24     public interface Encoded {
  25         NormalizedNodeMessages.Container getEncodedNode();
  26
  27         NormalizedNodeMessages.InstanceIdentifier getEncodedPath();
  28     }
  29
  30     public interface Decoded {
  31         NormalizedNode<?,?> getDecodedNode();
  32
  33         YangInstanceIdentifier getDecodedPath();
  34     }
  35
  36     private final SchemaContext ctx;
  37
  38     public NormalizedNodeToNodeCodec(final SchemaContext ctx){
  39         this.ctx = ctx;
  40     }
  41
  42     public NormalizedNodeMessages.Container encode(NormalizedNode<?,?> node){
  43         return encode(null, node).getEncodedNode();
  44     }
  45
  46     public Encoded encode(YangInstanceIdentifier path, NormalizedNode<?,?> node) {
  47
  48         NormalizedNodeMessages.InstanceIdentifier serializedPath = null;
  49
  50         NormalizedNodeMessages.Container.Builder builder = NormalizedNodeMessages.Container.newBuilder();
  51
  52         // Note: parent path is no longer used
  53         builder.setParentPath("");
  54
  55         if(node != null) {
  56             if(path == null) {
  57                 builder.setNormalizedNode(NormalizedNodeSerializer.serialize(node));
  58             } else {
  59                 Serializer serializer = NormalizedNodeSerializer.newSerializer(node);
  60                 builder.setNormalizedNode(serializer.serialize(path));
  61                 serializedPath = serializer.getSerializedPath();
  62             }
  63         }
  64
  65         return new EncodedImpl(builder.build(), serializedPath);
  66     }
  67
  68
  69     public NormalizedNode<?,?> decode(NormalizedNodeMessages.Node node){
  70         return decode(null, node).getDecodedNode();
  71     }
  72
  73     public Decoded decode(NormalizedNodeMessages.InstanceIdentifier path,
  74             NormalizedNodeMessages.Node node) {
  75         if(node.getIntType() < 0 || node.getSerializedSize() == 0){
  76             return new DecodedImpl(null, null);
  77         }
  78
  79         DeSerializer deSerializer = NormalizedNodeSerializer.newDeSerializer(path, node);
  80         NormalizedNode<?,?> decodedNode = deSerializer.deSerialize();
  81         return new DecodedImpl(decodedNode, deSerializer.getDeserializedPath());
  82     }
  83
  84     private static class DecodedImpl implements Decoded {
  85
  86         private final NormalizedNode<?, ?> decodedNode;
  87         private final YangInstanceIdentifier decodedPath;
  88
  89         public DecodedImpl(NormalizedNode<?, ?> decodedNode, YangInstanceIdentifier decodedPath) {
  90             this.decodedNode = decodedNode;
  91             this.decodedPath = decodedPath;
  92         }
  93
  94         @Override
  95         public NormalizedNode<?, ?> getDecodedNode() {
  96             return decodedNode;
  97         }
  98
  99         @Override
 100         public YangInstanceIdentifier getDecodedPath() {
 101             return decodedPath;
 102         }
 103     }
 104
 105     private static class EncodedImpl implements Encoded {
 106
 107         private final Container encodedNode;
 108         private final InstanceIdentifier encodedPath;
 109
 110         EncodedImpl(Container encodedNode, InstanceIdentifier encodedPath) {
 111             this.encodedNode = encodedNode;
 112             this.encodedPath = encodedPath;
 113         }
 114
 115         @Override
 116         public Container getEncodedNode() {
 117             return encodedNode;
 118         }
 119
 120         @Override
 121         public InstanceIdentifier getEncodedPath() {
 122             return encodedPath;
 123         }
 124     }
 125 }