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

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