test-common/src/main/java/org/opendaylight/transportpce/test/converter/AbstractDataObjectConverter.java

   1 /*
   2  * Copyright © 2016 AT&T 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 package org.opendaylight.transportpce.test.converter;
   9
  10 import java.util.Map;
  11 import java.util.Optional;
  12 import org.eclipse.jdt.annotation.NonNull;
  13 import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
  14 import org.opendaylight.yangtools.yang.binding.DataContainer;
  15 import org.opendaylight.yangtools.yang.binding.DataObject;
  16 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  17 import org.opendaylight.yangtools.yang.binding.Notification;
  18 import org.opendaylight.yangtools.yang.common.QName;
  19 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  20 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  21 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  22 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodes;
  23 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  24 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
  25 import org.slf4j.Logger;
  26 import org.slf4j.LoggerFactory;
  27
  28 /**
  29  * Converts XML and {@link DataObject} vice versa.
  30  *
  31  */
  32 public abstract class AbstractDataObjectConverter implements DataObjectConverter {
  33
  34     private static final Logger LOG = LoggerFactory.getLogger(AbstractDataObjectConverter.class);
  35
  36     private final EffectiveModelContext schemaContext;
  37     private final BindingNormalizedNodeSerializer codecRegistry;
  38
  39     /**
  40      * This is the default constructor, which should be used.
  41      *
  42      * @param schemaContext schema context for converter
  43      * @param codecRegistry codec registry used for converting
  44      *
  45      */
  46     protected AbstractDataObjectConverter(EffectiveModelContext schemaContext,
  47             BindingNormalizedNodeSerializer codecRegistry) {
  48         this.schemaContext = schemaContext;
  49         this.codecRegistry = codecRegistry;
  50     }
  51
  52     public EffectiveModelContext getSchemaContext() {
  53         return schemaContext;
  54     }
  55
  56     public BindingNormalizedNodeSerializer getCodecRegistry() {
  57         return codecRegistry;
  58     }
  59
  60     /**
  61      * Transforms the given input {@link NormalizedNode} into the given
  62      * {@link DataObject}.
  63      *
  64      * @param normalizedNode normalized node you want to convert
  65      * @param rootNode {@link QName} of converted normalized node root
  66      *
  67      *     <p>
  68      *     The input object should be {@link ContainerNode}
  69      *     </p>
  70      */
  71     @Override
  72     @SuppressWarnings("unchecked")
  73     public <T extends DataObject> Optional<T> getDataObject(
  74             @NonNull NormalizedNode normalizedNode,
  75             @NonNull QName rootNode) {
  76         //Preconditions.checkNotNull(normalizedNode);
  77         if (normalizedNode instanceof ContainerNode) {
  78             YangInstanceIdentifier.PathArgument directChildIdentifier =
  79                     YangInstanceIdentifier.of(rootNode).getLastPathArgument();
  80             Optional<NormalizedNode> directChild =
  81                     NormalizedNodes.getDirectChild(normalizedNode, directChildIdentifier);
  82             if (!directChild.isPresent()) {
  83                 throw new IllegalStateException(String.format("Could not get the direct child of %s", rootNode));
  84             }
  85             normalizedNode = directChild.orElseThrow();
  86         }
  87         YangInstanceIdentifier rootNodeYangInstanceIdentifier = YangInstanceIdentifier.of(rootNode);
  88
  89         Map.Entry<?, ?> bindingNodeEntry =
  90                 codecRegistry.fromNormalizedNode(rootNodeYangInstanceIdentifier, normalizedNode);
  91         if (bindingNodeEntry == null) {
  92             return Optional.empty();
  93         }
  94         return Optional.ofNullable((T) bindingNodeEntry.getValue());
  95     }
  96
  97     @Override
  98     @SuppressWarnings("unchecked")
  99     public <T extends DataObject> Optional<T> getDataObjectFromRpc(@NonNull NormalizedNode normalizedNode) {
 100
 101         if (! (normalizedNode instanceof ContainerNode)) {
 102             LOG.error("converting normalized node is not ContainerNode. It's actual type is {}",
 103                     normalizedNode.getClass().getSimpleName());
 104             return Optional.empty();
 105         }
 106         T rpcDataObject = (T) codecRegistry
 107             .fromNormalizedNodeRpcData(Absolute.of(EffectiveModelContext.NAME), (ContainerNode) normalizedNode);
 108         return Optional.ofNullable(rpcDataObject);
 109     }
 110
 111     @Override
 112     @SuppressWarnings({"rawtypes","unchecked"})
 113     public <T extends DataObject> Optional<NormalizedNode> toNormalizedNodes(@NonNull T object,
 114             Class dataObjectClass) {
 115         return Optional.of(codecRegistry.toNormalizedDataObject(InstanceIdentifier.create(dataObjectClass), object)
 116             .node());
 117     }
 118
 119     @Override
 120     public <T extends DataObject> ConvertType<T> dataContainer() {
 121 //        return (object, objectClass) -> {
 122 //            NormalizedNode value =
 123 //                    getCodecRegistry().toNormalizedNode(InstanceIdentifier.create(objectClass), object).getValue();
 124 //            return Optional.ofNullable(value);
 125 //        };
 126         return null;
 127     }
 128
 129     @Override
 130     public <T extends DataContainer> ConvertType<T> rpcData() {
 131         return (object, objectClass) -> {
 132             ContainerNode normalizedNodeRpcData = getCodecRegistry().toNormalizedNodeRpcData(object);
 133             return Optional.ofNullable(normalizedNodeRpcData);
 134         };
 135     }
 136
 137     @Override
 138     @SuppressWarnings("rawtypes")
 139     public <T extends Notification> ConvertType<T> notification() {
 140         return (object, objectClass) -> {
 141             ContainerNode normalizedNodeNotification = getCodecRegistry().toNormalizedNodeNotification(object);
 142             return Optional.ofNullable(normalizedNodeNotification);
 143         };
 144     }
 145 }