gerrit.onap Code Review - so.git/blob

   1 package org.openecomp.mso.yangDecoder.transform.impl;
   2
   3 //import org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec;
   4
   5 import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
   6 import org.opendaylight.netconf.sal.restconf.impl.InstanceIdentifierContext;
   7 import org.opendaylight.netconf.sal.restconf.impl.NormalizedNodeContext;
   8 import org.opendaylight.netconf.sal.restconf.impl.WriterParameters;
   9 import org.opendaylight.yangtools.binding.data.codec.api.BindingNormalizedNodeSerializer;
  10 import org.opendaylight.yangtools.yang.binding.DataContainer;
  11 import org.opendaylight.yangtools.yang.binding.DataObject;
  12 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  13 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  14 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  15 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  16 import org.opendaylight.yangtools.yang.model.api.*;
  17
  18 import java.util.Map;
  19
  20 /**
  21  * Created by Administrator on 2017/3/17.
  22  */
  23 public class YangDataTransformJava2NNServiceImpl {
  24     BindingNormalizedNodeSerializer mappingService;
  25     public YangDataTransformJava2NNServiceImpl(BindingNormalizedNodeSerializer mappingService)
  26     {
  27         this.mappingService=mappingService;
  28     }
  29     public  <T extends DataObject>  NormalizedNodeContext yangDataObjecttoNNC(InstanceIdentifier<T> identifier, String uri, T dobj)
  30     {
  31         final InstanceIdentifierContext<?> iiContext = ControllerContext.getInstance().toInstanceIdentifier(uri);
  32         Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> temp = mappingService.toNormalizedNode(identifier, dobj);
  33         WriterParameters.WriterParametersBuilder aa=new WriterParameters.WriterParametersBuilder();
  34         aa.setPrettyPrint(true);
  35         return new NormalizedNodeContext( iiContext, temp.getValue() ,aa.build());
  36     }
  37     public  <T extends DataObject> NormalizedNode yangDataObjecttoNN( InstanceIdentifier<T> identifier,T dobj) {
  38         Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> temp = mappingService.toNormalizedNode(identifier, dobj);
  39         if (null == temp) {
  40             return null;
  41         } else {
  42             return temp.getValue();
  43         }
  44     }
  45     public NormalizedNodeContext yangNNtoNNC(NormalizedNode nn, String uri){
  46         final InstanceIdentifierContext<?> iiContext = ControllerContext.getInstance().toInstanceIdentifier(uri);
  47         WriterParameters.WriterParametersBuilder aa=new WriterParameters.WriterParametersBuilder();
  48         aa.setPrettyPrint(true);
  49         return new NormalizedNodeContext(iiContext, nn,aa.build());
  50     }
  51     public  <T extends DataObject> T yangDataObjectfromNN(YangInstanceIdentifier identifier,NormalizedNode node) {
  52         Map.Entry<InstanceIdentifier<?>, DataObject> temp = mappingService.fromNormalizedNode(identifier, node);
  53         if (null == temp) {
  54             return null;
  55         } else {
  56             return (T) temp.getValue();
  57         }
  58     }
  59     public  <T extends DataObject> T yangDataObjectfromNNC(NormalizedNodeContext nnc)
  60     {
  61         return yangDataObjectfromNN(nnc.getInstanceIdentifierContext().getInstanceIdentifier(),nnc.getData());
  62     }
  63     public ContainerNode yangRpcDatatoNN(final DataContainer rpcdata){
  64         return mappingService.toNormalizedNodeRpcData(rpcdata);
  65     }
  66     public DataObject yangRpcDatafromNN(SchemaPath path, final ContainerNode data)
  67     {
  68         return mappingService.fromNormalizedNodeRpcData(path,data);
  69     }
  70     public static DataSchemaNode findDataSchemaNode(String uriPath,String inputoroutput)
  71     {
  72         final InstanceIdentifierContext<?> iicontext = ControllerContext.getInstance().toInstanceIdentifier(uriPath);
  73         DataSchemaNode dsn=JsonParserStream.getWrapSchemaNode( iicontext.getSchemaNode());
  74         return dsn;
  75     }
  76     public static SchemaNode findSchemaNode(final InstanceIdentifierContext<?> iicontext ,String inputoroutput)
  77     {
  78         SchemaNode schemaNode;
  79
  80         final SchemaNode schemaNode0 = iicontext.getSchemaNode();
  81         if (schemaNode0 instanceof RpcDefinition) {
  82             if (inputoroutput.contains("output")) {
  83                 schemaNode = ((RpcDefinition) schemaNode0).getOutput();
  84             } else {
  85                 schemaNode = ((RpcDefinition) schemaNode0).getInput();
  86             }
  87
  88         } else if(schemaNode0 instanceof NotificationDefinition)
  89         {
  90             schemaNode=schemaNode0;
  91         }
  92         else if (schemaNode0 instanceof DataSchemaNode) {
  93             schemaNode =  schemaNode0;
  94         } else {
  95             throw new IllegalStateException("Unknow SchemaNode");
  96         }
  97         return schemaNode;
  98     }
  99
 100     public static DataSchemaNode findRpcSchemaNode(final InstanceIdentifierContext<?> iicontext,String inputoroutput)
 101     {
 102         DataSchemaNode schemaNode;
 103         final SchemaNode schemaNode0 = iicontext.getSchemaNode();
 104         boolean isInput = false;
 105         if (schemaNode0 instanceof RpcDefinition) {
 106             if (inputoroutput.contains("output")) {
 107                 schemaNode = ((RpcDefinition) schemaNode0).getOutput();
 108                 isInput = false;
 109             } else {
 110                 schemaNode = ((RpcDefinition) schemaNode0).getInput();
 111                 isInput = true;
 112             }
 113
 114         } else if (schemaNode0 instanceof DataSchemaNode) {
 115             schemaNode = (DataSchemaNode) schemaNode0;
 116         } else {
 117             throw new IllegalStateException("Unknow SchemaNode");
 118         }
 119         return   schemaNode;
 120     }
 121     public DataObject yangRpcDatafromNN(final InstanceIdentifierContext<?> iicontext , final NormalizedNode data) {
 122        // final InstanceIdentifierContext<?> iicontext = ControllerContext.getInstance().toInstanceIdentifier(uriPath);
 123         ContainerNode contn= (ContainerNode)data;
 124         DataSchemaNode schemaNode= findRpcSchemaNode(iicontext,contn.getNodeType().getLocalName());;
 125     /*    final SchemaNode schemaNode0 = iicontext.getSchemaNode();
 126         boolean isInput = false;
 127         if (schemaNode0 instanceof RpcDefinition) {
 128             if (contn.getNodeType().getLocalName().contains("output")) {
 129                 schemaNode = ((RpcDefinition) schemaNode0).getOutput();
 130                 isInput = false;
 131             } else {
 132                 schemaNode = ((RpcDefinition) schemaNode0).getInput();
 133                 isInput = true;
 134             }
 135
 136         } else if (schemaNode0 instanceof DataSchemaNode) {
 137             schemaNode = (DataSchemaNode) schemaNode0;
 138         } else {
 139             throw new IllegalStateException("Unknow SchemaNode");
 140         }*/
 141         SchemaPath path=schemaNode.getPath();
 142         return  mappingService.fromNormalizedNodeRpcData(path,contn);
 143     }
 144 }