opendaylight/md-sal/sal-common-impl/src/main/java/org/opendaylight/controller/md/sal/common/impl/util/compat/DataNormalizer.java

   1 package org.opendaylight.controller.md.sal.common.impl.util.compat;
   2
   3 import static com.google.common.base.Preconditions.checkArgument;
   4
   5 import java.util.AbstractMap;
   6 import java.util.ArrayList;
   7 import java.util.Iterator;
   8 import java.util.Map;
   9
  10 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
  11 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
  12 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier;
  13 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
  14 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
  15 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeWithValue;
  16 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
  17 import org.opendaylight.yangtools.yang.data.api.Node;
  18 import org.opendaylight.yangtools.yang.data.api.SimpleNode;
  19 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
  20 import org.opendaylight.yangtools.yang.data.api.schema.MixinNode;
  21 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  22 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
  23 import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
  24 import org.opendaylight.yangtools.yang.data.impl.SimpleNodeTOImpl;
  25 import org.opendaylight.yangtools.yang.data.impl.util.CompositeNodeBuilder;
  26 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  27
  28 import com.google.common.base.Preconditions;
  29 import com.google.common.base.Predicate;
  30 import com.google.common.collect.FluentIterable;
  31 import com.google.common.collect.ImmutableList;
  32 import com.google.common.collect.Iterables;
  33
  34 public class DataNormalizer {
  35
  36     private final DataNormalizationOperation<?> operation;
  37
  38     public DataNormalizer(final SchemaContext ctx) {
  39         operation = DataNormalizationOperation.from(ctx);
  40     }
  41
  42     public InstanceIdentifier toNormalized(final InstanceIdentifier legacy) {
  43         ImmutableList.Builder<PathArgument> normalizedArgs = ImmutableList.builder();
  44
  45         DataNormalizationOperation<?> currentOp = operation;
  46         Iterator<PathArgument> arguments = legacy.getPath().iterator();
  47         while ( arguments.hasNext() ) {
  48             PathArgument legacyArg = arguments.next();
  49             currentOp = currentOp.getChild(legacyArg);
  50             checkArgument(currentOp != null, "Legacy Instance Identifier %s is not correct. Normalized Instance Identifier so far %s",legacy,normalizedArgs.build());
  51             while (currentOp.isMixin()) {
  52                 normalizedArgs.add(currentOp.getIdentifier());
  53                 currentOp = currentOp.getChild(legacyArg.getNodeType());
  54             }
  55             if(arguments.hasNext() || (!currentOp.isKeyedEntry() || legacyArg instanceof NodeIdentifierWithPredicates || legacyArg instanceof NodeWithValue)) {
  56                 normalizedArgs.add(legacyArg);
  57             }
  58         }
  59         return new InstanceIdentifier(normalizedArgs.build());
  60     }
  61
  62     public Map.Entry<InstanceIdentifier,NormalizedNode<?, ?>> toNormalized(final Map.Entry<InstanceIdentifier,CompositeNode> legacy) {
  63         return toNormalized(legacy.getKey(), legacy.getValue());
  64     }
  65
  66     public Map.Entry<InstanceIdentifier,NormalizedNode<?, ?>> toNormalized(final InstanceIdentifier legacyPath, final CompositeNode legacyData) {
  67
  68         InstanceIdentifier normalizedPath = toNormalized(legacyPath);
  69
  70         DataNormalizationOperation<?> currentOp = operation;
  71         for (PathArgument arg : normalizedPath.getPath()) {
  72             currentOp = currentOp.getChild(arg);
  73         }
  74         // Write Augmentaiton data resolution
  75         if (legacyData.getChildren().size() == 1) {
  76             DataNormalizationOperation<?> potentialOp = currentOp.getChild(legacyData.getChildren().get(0)
  77                     .getNodeType());
  78             if(potentialOp.getIdentifier() instanceof AugmentationIdentifier) {
  79                 currentOp = potentialOp;
  80                 ArrayList<PathArgument> reworkedArgs = new ArrayList<>(normalizedPath.getPath());
  81                 reworkedArgs.add(potentialOp.getIdentifier());
  82                 normalizedPath = new InstanceIdentifier(reworkedArgs);
  83             }
  84         }
  85
  86         Preconditions.checkArgument(currentOp != null,
  87                 "Instance Identifier %s does not reference correct schema Node.", normalizedPath);
  88         return new AbstractMap.SimpleEntry<InstanceIdentifier,NormalizedNode<?, ?>>(normalizedPath,currentOp.normalize(legacyData));
  89     }
  90
  91     public InstanceIdentifier toLegacy(final InstanceIdentifier normalized) {
  92         ImmutableList.Builder<PathArgument> legacyArgs = ImmutableList.builder();
  93         PathArgument previous = null;
  94         for (PathArgument normalizedArg : normalized.getPath()) {
  95             if (normalizedArg instanceof NodeIdentifier) {
  96                 if (previous != null) {
  97                     legacyArgs.add(previous);
  98                 }
  99                 previous = normalizedArg;
 100             } else if (normalizedArg instanceof NodeIdentifierWithPredicates) {
 101                 // We skip previous node, which was mixin.
 102                 previous = normalizedArg;
 103             } else if (normalizedArg instanceof AugmentationIdentifier) {
 104                 // We ignore argument
 105             }
 106             // FIXME : Add option for reading choice
 107         }
 108         if (previous != null) {
 109             legacyArgs.add(previous);
 110         }
 111         return new InstanceIdentifier(legacyArgs.build());
 112     }
 113
 114     public CompositeNode toLegacy(final InstanceIdentifier normalizedPath, final NormalizedNode<?, ?> normalizedData) {
 115         // Preconditions.checkArgument(normalizedData instanceof
 116         // DataContainerNode<?>,"Node object %s, %s should be of type DataContainerNode",normalizedPath,normalizedData);
 117         if (normalizedData instanceof DataContainerNode<?>) {
 118             return toLegacyFromDataContainer((DataContainerNode<?>) normalizedData);
 119         }
 120         return null;
 121     }
 122
 123     public static Node<?> toLegacy(final NormalizedNode<?, ?> node) {
 124         if (node instanceof MixinNode) {
 125             /**
 126              * Direct reading of MixinNodes is not supported,
 127              * since it is not possible in legacy APIs create pointer
 128              * to Mixin Nodes.
 129              *
 130              */
 131             return null;
 132         }
 133
 134         if (node instanceof DataContainerNode<?>) {
 135             return toLegacyFromDataContainer((DataContainerNode<?>) node);
 136         }
 137         return toLegacySimple(node);
 138
 139     }
 140
 141     private static SimpleNode<?> toLegacySimple(final NormalizedNode<?, ?> node) {
 142         return new SimpleNodeTOImpl<Object>(node.getNodeType(), null, node.getValue());
 143     }
 144
 145     @SuppressWarnings({ "unchecked", "rawtypes" })
 146     private static CompositeNode toLegacyFromDataContainer(final DataContainerNode<?> node) {
 147         CompositeNodeBuilder<ImmutableCompositeNode> builder = ImmutableCompositeNode.builder();
 148         builder.setQName(node.getNodeType());
 149         for (NormalizedNode<?, ?> child : node.getValue()) {
 150             if (child instanceof MixinNode && child instanceof NormalizedNodeContainer<?, ?, ?>) {
 151                 builder.addAll(toLegacyNodesFromMixin((NormalizedNodeContainer) child));
 152             } else {
 153                 addToBuilder(builder, toLegacy(child));
 154             }
 155         }
 156         return builder.toInstance();
 157     }
 158
 159     private static void addToBuilder(final CompositeNodeBuilder<ImmutableCompositeNode> builder, final Node<?> legacy) {
 160         if (legacy != null) {
 161             builder.add(legacy);
 162         }
 163     }
 164
 165     @SuppressWarnings({ "rawtypes", "unchecked" })
 166     private static Iterable<Node<?>> toLegacyNodesFromMixin(
 167             final NormalizedNodeContainer<?, ?, NormalizedNode<?, ?>> mixin) {
 168         ArrayList<Node<?>> ret = new ArrayList<>();
 169         for (NormalizedNode<?, ?> child : mixin.getValue()) {
 170             if(child instanceof MixinNode && child instanceof NormalizedNodeContainer<?, ?, ?>) {
 171                 Iterables.addAll(ret,toLegacyNodesFromMixin((NormalizedNodeContainer) child));
 172             } else {
 173                 ret.add(toLegacy(child));
 174             }
 175         }
 176         return FluentIterable.from(ret).filter(new Predicate<Node<?>>() {
 177
 178             @Override
 179             public boolean apply(final Node<?> input) {
 180                 return input != null;
 181             }
 182         });
 183     }
 184
 185     public DataNormalizationOperation<?> getRootOperation() {
 186         return operation;
 187     }
 188
 189 }