Allow DataObjectModification to address grouping nodes 06/74606/4
authorRobert Varga <robert.varga@pantheon.tech>
Sat, 28 Jul 2018 08:50:19 +0000 (10:50 +0200)
committerRobert Varga <nite@hq.sk>
Wed, 1 Aug 2018 12:06:44 +0000 (12:06 +0000)
This adds the API and implementation required to address child
nodes introduced in cases by the use of a grouping.

JIRA: MDSAL-342
Change-Id: I70871dcaa3441fbef81dfb15bfd965d133aa0894
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
benchmark/dsbenchmark/src/main/java/org/opendaylight/dsbenchmark/listener/DsbenchmarkListener.java
opendaylight/md-sal/sal-binding-api/src/main/java/org/opendaylight/controller/md/sal/binding/api/DataObjectModification.java
opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/md/sal/binding/impl/LazyDataObjectModification.java

index 14633c9..197d93d 100644 (file)
@@ -49,7 +49,7 @@ public class DsbenchmarkListener implements DataTreeChangeListener<TestExec> {
             final DataObjectModification<TestExec> rootNode = change.getRootNode();
             final ModificationType modType = rootNode.getModificationType();
             final PathArgument changeId = rootNode.getIdentifier();
-            final Collection<DataObjectModification<? extends DataObject>> modifications =
+            final Collection<? extends DataObjectModification<? extends DataObject>> modifications =
                     rootNode.getModifiedChildren();
 
             LOG.debug("    changeId {}, modType {}, mods: {}", changeId, modType, modifications.size());
index 2df4f8b..c43d42c 100644 (file)
@@ -8,14 +8,18 @@
 
 package org.opendaylight.controller.md.sal.binding.api;
 
+import com.google.common.collect.Collections2;
 import java.util.Collection;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import org.opendaylight.yangtools.yang.binding.Augmentation;
 import org.opendaylight.yangtools.yang.binding.ChildOf;
+import org.opendaylight.yangtools.yang.binding.ChoiceIn;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.Identifiable;
 import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.Item;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
 
 /**
@@ -82,7 +86,44 @@ public interface DataObjectModification<T extends DataObject>
      *
      * @return unmodifiable collection of modified direct children.
      */
-    @Nonnull Collection<DataObjectModification<? extends DataObject>> getModifiedChildren();
+    @Nonnull Collection<? extends DataObjectModification<? extends DataObject>> getModifiedChildren();
+
+    /**
+     * Returns child list item modification if {@code child} was modified by this modification. This method should be
+     * used if the child is defined in a grouping brought into a case inside this object.
+     *
+     * @param caseType Case type class
+     * @param childType Type of list item - must be list item with key
+     * @return Modification of {@code child} if {@code child} was modified, null otherwise.
+     * @throws IllegalArgumentException If supplied {@code childType} class is not valid child according
+     *         to generated model.
+     */
+    default <H extends ChoiceIn<? super T> & DataObject, C extends ChildOf<? super H>>
+        Collection<DataObjectModification<C>> getModifiedChildren(@Nonnull final Class<H> caseType,
+                @Nonnull final Class<C> childType) {
+        final Item<C> item = Item.of(caseType, childType);
+        return (Collection<DataObjectModification<C>>) Collections2.filter(getModifiedChildren(),
+            mod -> item.equals(mod.getIdentifier()));
+    }
+
+    /**
+     * Returns container child modification if {@code child} was modified by this modification. This method should be
+     * used if the child is defined in a grouping brought into a case inside this object.
+     *
+     * <p>
+     * For accessing all modified list items consider iterating over {@link #getModifiedChildren()}.
+     *
+     * @param caseType Case type class
+     * @param child Type of child - must be only container
+     * @return Modification of {@code child} if {@code child} was modified, null otherwise.
+     * @throws IllegalArgumentException If supplied {@code child} class is not valid child according
+     *         to generated model.
+     */
+    default @Nullable <H extends ChoiceIn<? super T> & DataObject, C extends ChildOf<? super H>>
+            DataObjectModification<C> getModifiedChildContainer(@Nonnull final Class<H> caseType,
+                    @Nonnull final Class<C> child) {
+        return (DataObjectModification<C>) getModifiedChild(Item.of(caseType, child));
+    }
 
     /**
      * Returns container child modification if {@code child} was modified by this modification.
@@ -112,18 +153,33 @@ public interface DataObjectModification<T extends DataObject>
     @Nullable <C extends Augmentation<T> & DataObject> DataObjectModification<C> getModifiedAugmentation(
             @Nonnull Class<C> augmentation);
 
+    /**
+     * Returns child list item modification if {@code child} was modified by this modification.
+     *
+     * @param listItem Type of list item - must be list item with key
+     * @param listKey List item key
+     * @return Modification of {@code child} if {@code child} was modified, null otherwise.
+     * @throws IllegalArgumentException If supplied {@code listItem} class is not valid child according
+     *         to generated model.
+     */
+    <N extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<N>> DataObjectModification<N>
+            getModifiedChildListItem(@Nonnull Class<N> listItem, @Nonnull K listKey);
 
     /**
      * Returns child list item modification if {@code child} was modified by this modification.
      *
+     * @param caseType Case type class
      * @param listItem Type of list item - must be list item with key
      * @param listKey List item key
      * @return Modification of {@code child} if {@code child} was modified, null otherwise.
      * @throws IllegalArgumentException If supplied {@code listItem} class is not valid child according
      *         to generated model.
      */
-    <C extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<C>> DataObjectModification<C>
-            getModifiedChildListItem(@Nonnull Class<C> listItem,@Nonnull  K listKey);
+    default <H extends ChoiceIn<? super T> & DataObject, C extends Identifiable<K> & ChildOf<? super H>,
+            K extends Identifier<C>> DataObjectModification<C> getModifiedChildListItem(
+                    @Nonnull final Class<H> caseType, @Nonnull final Class<C> listItem, @Nonnull final K listKey) {
+        return (DataObjectModification<C>) getModifiedChild(IdentifiableItem.of(caseType, listItem, listKey));
+    }
 
     /**
      * Returns a child modification if a node identified by {@code childArgument} was modified by
index eb2aed7..c3aff15 100644 (file)
@@ -13,11 +13,14 @@ import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
 import org.opendaylight.mdsal.binding.dom.adapter.BindingStructuralType;
 import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeNode;
 import org.opendaylight.yangtools.yang.binding.Augmentation;
 import org.opendaylight.yangtools.yang.binding.ChildOf;
+import org.opendaylight.yangtools.yang.binding.ChoiceIn;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.Identifiable;
 import org.opendaylight.yangtools.yang.binding.Identifier;
@@ -47,7 +50,7 @@ final class LazyDataObjectModification<T extends DataObject> implements DataObje
     private final DataTreeCandidateNode domData;
     private final PathArgument identifier;
 
-    private volatile Collection<DataObjectModification<? extends DataObject>> childNodesCache;
+    private volatile Collection<LazyDataObjectModification<? extends DataObject>> childNodesCache;
     private volatile ModificationType modificationType;
 
     private LazyDataObjectModification(final BindingCodecTreeNode<T> codec, final DataTreeCandidateNode domData) {
@@ -56,19 +59,19 @@ final class LazyDataObjectModification<T extends DataObject> implements DataObje
         this.identifier = codec.deserializePathArgument(domData.getIdentifier());
     }
 
-    static <T extends DataObject> DataObjectModification<T> create(final BindingCodecTreeNode<T> codec,
+    static <T extends DataObject> LazyDataObjectModification<T> create(final BindingCodecTreeNode<T> codec,
             final DataTreeCandidateNode domData) {
         return new LazyDataObjectModification<>(codec,domData);
     }
 
-    private static Collection<DataObjectModification<? extends DataObject>> from(
+    private static Collection<LazyDataObjectModification<? extends DataObject>> from(
             final BindingCodecTreeNode<?> parentCodec, final Collection<DataTreeCandidateNode> domChildNodes) {
-        final List<DataObjectModification<? extends DataObject>> result = new ArrayList<>(domChildNodes.size());
+        final List<LazyDataObjectModification<? extends DataObject>> result = new ArrayList<>(domChildNodes.size());
         populateList(result, parentCodec, domChildNodes);
         return result;
     }
 
-    private static void populateList(final List<DataObjectModification<? extends DataObject>> result,
+    private static void populateList(final List<LazyDataObjectModification<? extends DataObject>> result,
             final BindingCodecTreeNode<?> parentCodec, final Collection<DataTreeCandidateNode> domChildNodes) {
         for (final DataTreeCandidateNode domChildNode : domChildNodes) {
             final BindingStructuralType type = BindingStructuralType.from(domChildNode);
@@ -93,7 +96,7 @@ final class LazyDataObjectModification<T extends DataObject> implements DataObje
         }
     }
 
-    private static void populateList(final List<DataObjectModification<? extends DataObject>> result,
+    private static void populateList(final List<LazyDataObjectModification<? extends DataObject>> result,
             final BindingStructuralType type, final BindingCodecTreeNode<?> childCodec,
             final DataTreeCandidateNode domChildNode) {
         switch (type) {
@@ -113,7 +116,7 @@ final class LazyDataObjectModification<T extends DataObject> implements DataObje
         }
     }
 
-    private static void populateListWithSingleCodec(final List<DataObjectModification<? extends DataObject>> result,
+    private static void populateListWithSingleCodec(final List<LazyDataObjectModification<? extends DataObject>> result,
             final BindingCodecTreeNode<?> codec, final Collection<DataTreeCandidateNode> childNodes) {
         for (final DataTreeCandidateNode child : childNodes) {
             result.add(create(codec, child));
@@ -197,14 +200,31 @@ final class LazyDataObjectModification<T extends DataObject> implements DataObje
     }
 
     @Override
-    public Collection<DataObjectModification<? extends DataObject>> getModifiedChildren() {
-        Collection<DataObjectModification<? extends DataObject>> local = childNodesCache;
+    public Collection<LazyDataObjectModification<? extends DataObject>> getModifiedChildren() {
+        Collection<LazyDataObjectModification<? extends DataObject>> local = childNodesCache;
         if (local == null) {
             childNodesCache = local = from(codec, domData.getChildNodes());
         }
         return local;
     }
 
+    @Override
+    public <H extends ChoiceIn<? super T> & DataObject, C extends ChildOf<? super H>>
+            Collection<DataObjectModification<C>> getModifiedChildren(final Class<H> caseType,
+                    final Class<C> childType) {
+        return streamModifiedChildren(childType)
+                .filter(child -> caseType.equals(child.identifier.getCaseType().orElse(null)))
+                .collect(Collectors.toList());
+    }
+
+    @SuppressWarnings("unchecked")
+    private <C extends DataObject> Stream<LazyDataObjectModification<C>> streamModifiedChildren(
+            final Class<C> childType) {
+        return getModifiedChildren().stream()
+                .filter(child -> childType.isAssignableFrom(child.getDataType()))
+                .map(child -> (LazyDataObjectModification<C>) child);
+    }
+
     @Override
     public DataObjectModification<? extends DataObject> getModifiedChild(final PathArgument arg) {
         final List<YangInstanceIdentifier.PathArgument> domArgumentList = new ArrayList<>();
@@ -229,8 +249,23 @@ final class LazyDataObjectModification<T extends DataObject> implements DataObje
 
     @Override
     @SuppressWarnings("unchecked")
-    public <C extends ChildOf<? super T>> DataObjectModification<C> getModifiedChildContainer(final Class<C> arg) {
-        return (DataObjectModification<C>) getModifiedChild(Item.of(arg));
+    public <H extends ChoiceIn<? super T> & DataObject, C extends Identifiable<K> & ChildOf<? super H>,
+            K extends Identifier<C>> DataObjectModification<C> getModifiedChildListItem(final Class<H> caseType,
+                        final Class<C> listItem, final K listKey) {
+        return (DataObjectModification<C>) getModifiedChild(IdentifiableItem.of(caseType, listItem, listKey));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <C extends ChildOf<? super T>> DataObjectModification<C> getModifiedChildContainer(final Class<C> child) {
+        return (DataObjectModification<C>) getModifiedChild(Item.of(child));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <H extends ChoiceIn<? super T> & DataObject, C extends ChildOf<? super H>> DataObjectModification<C>
+            getModifiedChildContainer(final Class<H> caseType, final Class<C> child) {
+        return (DataObjectModification<C>) getModifiedChild(Item.of(caseType, child));
     }
 
     @Override
@@ -241,10 +276,7 @@ final class LazyDataObjectModification<T extends DataObject> implements DataObje
     }
 
     private T deserialize(final Optional<NormalizedNode<?, ?>> dataAfter) {
-        if (dataAfter.isPresent()) {
-            return codec.deserialize(dataAfter.get());
-        }
-        return null;
+        return dataAfter.map(codec::deserialize).orElse(null);
     }
 
     @Override

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.