From 9779f4b3ffe24bb2338630c66169da92c880ffbb Mon Sep 17 00:00:00 2001
From: Jan Srnicek <jsrnicek@cisco.com>
Date: Fri, 3 Nov 2017 13:33:53 +0100
Subject: HONEYCOMB-359 - Wildcarded writers

Adds option to specify subtree writer that can handle whole subtree
of nodes without having whole subtree specified. Its checking
if node is children at runtime, rather than having pre-computed tree

Change-Id: Ic46f2bd6de84f0dd14865825399f5a90a1f80859
Signed-off-by: Jan Srnicek <jsrnicek@cisco.com>
---
 ...stractSubtreeManagerRegistryBuilderBuilder.java | 38 ++++++++++++++++++++--
 1 file changed, 35 insertions(+), 3 deletions(-)

(limited to 'infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/AbstractSubtreeManagerRegistryBuilderBuilder.java')

diff --git a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/AbstractSubtreeManagerRegistryBuilderBuilder.java b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/AbstractSubtreeManagerRegistryBuilderBuilder.java
index fe2f1178f..181d71727 100644
--- a/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/AbstractSubtreeManagerRegistryBuilderBuilder.java
+++ b/infra/translate-utils/src/main/java/io/fd/honeycomb/translate/util/AbstractSubtreeManagerRegistryBuilderBuilder.java
@@ -21,13 +21,14 @@ import com.google.common.collect.ImmutableMap;
 import io.fd.honeycomb.translate.ModifiableSubtreeManagerRegistryBuilder;
 import io.fd.honeycomb.translate.SubtreeManager;
 import io.fd.honeycomb.translate.SubtreeManagerRegistryBuilder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import javax.annotation.Nonnull;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 
 public abstract class AbstractSubtreeManagerRegistryBuilderBuilder<S extends SubtreeManager<? extends DataObject>, R>
         implements ModifiableSubtreeManagerRegistryBuilder<S>, SubtreeManagerRegistryBuilder<R> {
@@ -64,6 +65,12 @@ public abstract class AbstractSubtreeManagerRegistryBuilderBuilder<S extends Sub
         return this;
     }
 
+    @Override
+    public ModifiableSubtreeManagerRegistryBuilder<S> wildcardedSubtreeAdd(@Nonnull S handler) {
+        add(getWildcardedSubtreeHandler(handler));
+        return this;
+    }
+
     private void checkWriterNotPresentYet(final InstanceIdentifier<?> targetType) {
         Preconditions.checkArgument(!handlersMap.containsKey(targetType),
                 "Writer for type: %s already present: %s", targetType, handlersMap.get(targetType));
@@ -109,6 +116,12 @@ public abstract class AbstractSubtreeManagerRegistryBuilderBuilder<S extends Sub
         return addBefore(getSubtreeHandler(handledChildren, handler), relatedType);
     }
 
+    @Override
+    public ModifiableSubtreeManagerRegistryBuilder<S> wildcardedSubtreeAddBefore(@Nonnull final S handler,
+                                                                                 @Nonnull final InstanceIdentifier<?> relatedType) {
+        return addBefore(getWildcardedSubtreeHandler(handler), relatedType);
+    }
+
     @Override
     public AbstractSubtreeManagerRegistryBuilderBuilder<S, R> subtreeAddBefore(
             @Nonnull final Set<InstanceIdentifier<?>> handledChildren,
@@ -117,9 +130,17 @@ public abstract class AbstractSubtreeManagerRegistryBuilderBuilder<S extends Sub
         return addBefore(getSubtreeHandler(handledChildren, handler), relatedTypes);
     }
 
+    @Override
+    public ModifiableSubtreeManagerRegistryBuilder<S> wildcardedSubtreeAddBefore(@Nonnull final S handler,
+                                                                                 @Nonnull final Collection<InstanceIdentifier<?>> relatedTypes) {
+        return addBefore(getWildcardedSubtreeHandler(handler), relatedTypes);
+    }
+
     protected abstract S getSubtreeHandler(@Nonnull final Set<InstanceIdentifier<?>> handledChildren,
                                            @Nonnull final S handler);
 
+    protected abstract S getWildcardedSubtreeHandler(@Nonnull final S handler);
+
     /**
      * Add handler with relationship: to be executed after handler handling relatedType.
      */
@@ -162,6 +183,12 @@ public abstract class AbstractSubtreeManagerRegistryBuilderBuilder<S extends Sub
         return addAfter(getSubtreeHandler(handledChildren, handler), relatedType);
     }
 
+    @Override
+    public ModifiableSubtreeManagerRegistryBuilder<S> wildcardedSubtreeAddAfter(@Nonnull final S handler,
+                                                                                @Nonnull final InstanceIdentifier<?> relatedType) {
+        return addAfter(getWildcardedSubtreeHandler(handler), relatedType);
+    }
+
     @Override
     public AbstractSubtreeManagerRegistryBuilderBuilder<S, R> subtreeAddAfter(
             @Nonnull final Set<InstanceIdentifier<?>> handledChildren,
@@ -170,6 +197,11 @@ public abstract class AbstractSubtreeManagerRegistryBuilderBuilder<S extends Sub
         return addAfter(getSubtreeHandler(handledChildren, handler), relatedTypes);
     }
 
+    @Override
+    public ModifiableSubtreeManagerRegistryBuilder<S> wildcardedSubtreeAddAfter(@Nonnull S handler, @Nonnull Collection<InstanceIdentifier<?>> relatedTypes) {
+        return addAfter(getWildcardedSubtreeHandler(handler), relatedTypes);
+    }
+
     protected ImmutableMap<InstanceIdentifier<?>, S> getMappedHandlers() {
         final ImmutableMap.Builder<InstanceIdentifier<?>, S> builder = ImmutableMap.builder();
         // Iterate writer types according to their relationships from graph
-- 
cgit 1.2.3-korg