1 files changed, 109 insertions, 22 deletions
diff --git a/v3po/translate-api/src/main/java/io/fd/honeycomb/v3po/translate/write/WriterRegistry.java b/v3po/translate-api/src/main/java/io/fd/honeycomb/v3po/translate/write/WriterRegistry.java
index d30f06d13..64735017f 100644
--- a/v3po/translate-api/src/main/java/io/fd/honeycomb/v3po/translate/write/WriterRegistry.java
+++ b/v3po/translate-api/src/main/java/io/fd/honeycomb/v3po/translate/write/WriterRegistry.java
@@ -19,47 +19,131 @@ package io.fd.honeycomb.v3po.translate.write;
 import static com.google.common.base.Preconditions.checkNotNull;
 
 import com.google.common.annotations.Beta;
-import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Sets;
 import io.fd.honeycomb.v3po.translate.TranslationException;
-import java.util.List;
-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;
 
 /**
- * Special {@link Writer} capable of performing bulk updates
+ * Special {@link Writer} capable of performing bulk updates.
  */
 @Beta
 public interface WriterRegistry extends Writer<DataObject> {
 
     /**
-     * Performs bulk update
+     * Performs bulk update.
      *
      * @throws BulkUpdateException in case bulk update fails
-     * @throws TranslationException        in case some other error occurs while processing update request
+     * @throws TranslationException in case some other error occurs while processing update request
      */
-    void update(@Nonnull final Map<InstanceIdentifier<?>, DataObject> dataBefore,
-                @Nonnull final Map<InstanceIdentifier<?>, DataObject> dataAfter,
-                @Nonnull final WriteContext ctx) throws TranslationException;
+    void update(@Nonnull DataObjectUpdates updates,
+                @Nonnull WriteContext ctx) throws TranslationException;
+
+    /**
+     * Simple DTO containing updates for {@link WriterRegistry}. Currently only deletes and updates (create + update)
+     * are distinguished.
+     */
+    @Beta
+    final class DataObjectUpdates {
+
+        private final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates;
+        private final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> deletes;
+
+        /**
+         * Create new instance.
+         *
+         * @param updates All updates indexed by their unkeyed {@link InstanceIdentifier}
+         * @param deletes All deletes indexed by their unkeyed {@link InstanceIdentifier}
+         */
+        public DataObjectUpdates(@Nonnull final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates,
+                                 @Nonnull final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> deletes) {
+            this.deletes = deletes;
+            this.updates = updates;
+        }
+
+        public Multimap<InstanceIdentifier<?>, DataObjectUpdate> getUpdates() {
+            return updates;
+        }
+
+        public Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> getDeletes() {
+            return deletes;
+        }
+
+        public boolean isEmpty() {
+            return updates.isEmpty() && deletes.isEmpty();
+        }
+
+        @Override
+        public String toString() {
+            return "DataObjectUpdates{" + "updates=" + updates + ", deletes=" + deletes + '}';
+        }
+
+        /**
+         * Get a {@link Set} containing all update types from both updates as well as deletes.
+         */
+        public Set<InstanceIdentifier<?>> getTypeIntersection() {
+            return Sets.union(deletes.keySet(), updates.keySet());
+        }
+
+        /**
+         * Check whether there is only a single type of data object to be updated.
+         *
+         * @return true if there is only a single type of updates (update + delete)
+         */
+        public boolean containsOnlySingleType() {
+            return getTypeIntersection().size() == 1;
+        }
+
+        @Override
+        public boolean equals(final Object other) {
+            if (this == other) {
+                return true;
+            }
+            if (other == null || getClass() != other.getClass()) {
+                return false;
+            }
+
+            final DataObjectUpdates that = (DataObjectUpdates) other;
+
+            if (!updates.equals(that.updates)) {
+                return false;
+            }
+            return deletes.equals(that.deletes);
+
+        }
+
+        @Override
+        public int hashCode() {
+            int result = updates.hashCode();
+            result = 31 * result + deletes.hashCode();
+            return result;
+        }
+
+    }
 
     /**
      * Thrown when bulk update failed.
      */
     @Beta
-    class BulkUpdateException extends WriteFailedException {
+    class BulkUpdateException extends TranslationException {
 
         private final Reverter reverter;
+        private final Set<InstanceIdentifier<?>> failedIds;
 
         /**
          * Constructs an BulkUpdateException.
-         *
-         * @param failedId instance identifier of the data object that caused bulk update to fail.
-         * @param cause    the cause of bulk update failure
+         * @param failedIds instance identifiers of the data objects that were not processed during bulk update.
+         * @param cause the cause of bulk update failure
          */
-        public BulkUpdateException(@Nonnull final InstanceIdentifier<?> failedId, @Nonnull final Reverter reverter,
-                                   final Throwable cause) {
-            super(failedId, "Bulk update failed at " + failedId, cause);
+        public BulkUpdateException(@Nonnull final Set<InstanceIdentifier<?>> failedIds,
+                                   @Nonnull final Reverter reverter,
+                                   @Nonnull final Throwable cause) {
+            super("Bulk update failed at: " + failedIds, cause);
+            this.failedIds = failedIds;
             this.reverter = checkNotNull(reverter, "reverter should not be null");
         }
 
@@ -72,10 +156,13 @@ public interface WriterRegistry extends Writer<DataObject> {
             reverter.revert();
         }
 
+        public Set<InstanceIdentifier<?>> getFailedIds() {
+            return failedIds;
+        }
     }
 
     /**
-     * Abstraction over revert mechanism in case of a bulk update failure
+     * Abstraction over revert mechanism in case of a bulk update failure.
      */
     @Beta
     interface Reverter {
@@ -95,19 +182,19 @@ public interface WriterRegistry extends Writer<DataObject> {
         class RevertFailedException extends TranslationException {
 
             // TODO change to list of VppDataModifications to make debugging easier
-            private final List<InstanceIdentifier<?>> notRevertedChanges;
+            private final Set<InstanceIdentifier<?>> notRevertedChanges;
 
             /**
-             * Constructs an RevertFailedException with the list of changes that were not reverted.
+             * Constructs a RevertFailedException with the list of changes that were not reverted.
              *
              * @param notRevertedChanges list of changes that were not reverted
              * @param cause              the cause of revert failure
              */
-            public RevertFailedException(@Nonnull final List<InstanceIdentifier<?>> notRevertedChanges,
+            public RevertFailedException(@Nonnull final Set<InstanceIdentifier<?>> notRevertedChanges,
                                          final Throwable cause) {
                 super(cause);
                 checkNotNull(notRevertedChanges, "notRevertedChanges should not be null");
-                this.notRevertedChanges = ImmutableList.copyOf(notRevertedChanges);
+                this.notRevertedChanges = ImmutableSet.copyOf(notRevertedChanges);
             }
 
             /**
@@ -116,7 +203,7 @@ public interface WriterRegistry extends Writer<DataObject> {
              * @return list of changes that were not reverted
              */
             @Nonnull
-            public List<InstanceIdentifier<?>> getNotRevertedChanges() {
+            public Set<InstanceIdentifier<?>> getNotRevertedChanges() {
                 return notRevertedChanges;
             }
         }