HONEYCOMB-61: Add BA broker for context data tree

With broker, context data can be accessed in a transactional
manner, same as config data

+ Renamed data-api concepts to not include DataTree
+ Renamed context related concepts to better distinguish between them
+ Now passing full ReadContext to read customizers
+ Naming context is backed by context data broker

Change-Id: I0b2876dd74a31a9ced7d9b5145672868e12f8b82
Signed-off-by: Maros Marsalek <mmarsale@cisco.com>

1 files changed, 65 insertions, 24 deletions

diff --git a/v3po/vpp-translate-utils/src/main/java/io/fd/honeycomb/v3po/translate/v3po/util/NamingContext.java b/v3po/vpp-translate-utils/src/main/java/io/fd/honeycomb/v3po/translate/v3po/util/NamingContext.java
index 9affd0695..d32f27203 100644
--- a/v3po/vpp-translate-utils/src/main/java/io/fd/honeycomb/v3po/translate/v3po/util/NamingContext.java
+++ b/v3po/vpp-translate-utils/src/main/java/io/fd/honeycomb/v3po/translate/v3po/util/NamingContext.java
@@ -17,48 +17,88 @@
 package io.fd.honeycomb.v3po.translate.v3po.util;
 
 import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
 
-import com.google.common.collect.BiMap;
-import com.google.common.collect.HashBiMap;
+import com.google.common.base.Optional;
+import io.fd.honeycomb.v3po.translate.MappingContext;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
 import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.Contexts;
+import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.NamingContextKey;
+import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.naming.context.Mappings;
+import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.naming.context.mappings.Mapping;
+import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.naming.context.mappings.MappingBuilder;
+import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.naming.context.mappings.MappingKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
- * Naming context keeping a mapping between int index and string name.
- * Provides artificial names to unknown indices.
+ * Utility adapter on top of {@link MappingContext}
  */
-public class NamingContext implements AutoCloseable {
+public final class NamingContext implements AutoCloseable {
 
     private static final Logger LOG = LoggerFactory.getLogger(NamingContext.class);
 
-    private final BiMap<String, Integer> nameMapping = HashBiMap.create();
     private final String artificialNamePrefix;
+    private KeyedInstanceIdentifier<org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.NamingContext, NamingContextKey>
+        namingContextIid;
 
-    public NamingContext(final String artificialNamePrefix) {
+    /**
+     * Collector expecting only a single resulting item from a stream
+     */
+    private static final Collector<Mapping, ?, Mapping> SINGLE_ITEM_COLLECTOR = Collectors.collectingAndThen(
+        Collectors.toList(),
+        list -> {
+            if (list.size() != 1) {
+                throw new IllegalStateException("Unexpected size of list: " + list + ". Single item expected");
+            }
+            return list.get(0);
+        });
+
+    public NamingContext(final String artificialNamePrefix, final String instanceName) {
         this.artificialNamePrefix = artificialNamePrefix;
+        namingContextIid = InstanceIdentifier.create(Contexts.class).child(
+            org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.NamingContext.class,
+            new NamingContextKey(instanceName));
     }
 
     @Nonnull
-    public synchronized String getName(final int index) {
-        if(!nameMapping.inverse().containsKey(index)) {
+    public synchronized String getName(final int index, final MappingContext mappingContext) {
+        if (!containsName(index, mappingContext)) {
             final String artificialName = getArtificialName(index);
             LOG.info("Assigning artificial name: {} for index: {}", artificialName, index);
-            addName(index, artificialName);
+            addName(index, artificialName, mappingContext);
         }
-        return nameMapping.inverse().get(index);
+
+        final Optional<Mappings> read = mappingContext.read(namingContextIid.child(Mappings.class));
+        checkState(read.isPresent(), "Mapping for index: %s is not present. But should be", index);
+
+        return read.get().getMapping().stream()
+            .filter(mapping -> mapping.getIndex().equals(index))
+            .collect(SINGLE_ITEM_COLLECTOR).getName();
+    }
+
+    public synchronized boolean containsName(final int index, final MappingContext mappingContext) {
+        final Optional<Mappings> read = mappingContext.read(namingContextIid.child(Mappings.class));
+        return read.isPresent()
+            ? read.get().getMapping().stream().anyMatch(mapping -> mapping.getIndex().equals(index))
+            : false;
     }
 
-    public synchronized boolean containsName(final int index) {
-        return nameMapping.inverse().containsKey(index);
+    public synchronized void addName(final int index, final String name, final MappingContext mappingContext) {
+        final KeyedInstanceIdentifier<Mapping, MappingKey> mappingIid = getMappingIid(name);
+        mappingContext.put(mappingIid, new MappingBuilder().setIndex(index).setName(name).build());
     }
 
-    public synchronized void addName(final int index, final String name) {
-        nameMapping.put(name, index);
+    private KeyedInstanceIdentifier<Mapping, MappingKey> getMappingIid(final String name) {
+        return namingContextIid.child(Mappings.class).child(Mapping.class, new MappingKey(name));
     }
 
-    public synchronized int removeName(final String name) {
-        return nameMapping.remove(name);
+    public synchronized void removeName(final String name, final MappingContext mappingContext) {
+        mappingContext.delete(getMappingIid(name));
     }
 
     /**
@@ -68,14 +108,15 @@ public class NamingContext implements AutoCloseable {
      * @return integer index value matching supplied name
      * @throws IllegalArgumentException if name was not found
      */
-    public synchronized int getIndex(String name) {
-        checkArgument(nameMapping.containsKey(name), "Name %s not found. Known names: %s",
-                name, nameMapping);
-        return nameMapping.get(name);
+    public synchronized int getIndex(final String name, final MappingContext mappingContext) {
+        final Optional<Mapping> read = mappingContext.read(getMappingIid(name));
+        checkArgument(read.isPresent(), "No mapping stored for name: %s", name);
+        return read.get().getIndex();
+
     }
 
-    public synchronized boolean containsIndex(String interfaceName) {
-        return nameMapping.containsKey(interfaceName);
+    public synchronized boolean containsIndex(final String name, final MappingContext mappingContext) {
+        return mappingContext.read(getMappingIid(name)).isPresent();
     }
 
     private String getArtificialName(final int index) {
@@ -84,6 +125,6 @@ public class NamingContext implements AutoCloseable {
 
     @Override
     public void close() throws Exception {
-        nameMapping.clear();
+        /// Not removing the mapping from backing storage
     }
 }