Simplify original tracking

Rather that having a quad-state 'prev' field typed to Object, potentially
containing an OriginalLink, make its state logically tri-state typed
with AbstractExplicitGenerator. The resolved generator is then carried in
an explicit field.

JIRA: MDSAL-718
Change-Id: I357a1ad6037a9c5288bdf2ec84dd90882cbcf76a
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractCompositeGenerator.java b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractCompositeGenerator.java
index 1828410a19d55086ba40b3a86ca9d31ddf549a1a..6dae9ac58423207f2d426e9f13d6523fbccda3d2 100644 (file)
--- a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractCompositeGenerator.java
+++ b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractCompositeGenerator.java
@@ -17,7 +17,6 @@ import java.util.List;
 import java.util.stream.Collectors;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.mdsal.binding.generator.impl.reactor.OriginalLink.Partial;
 import org.opendaylight.mdsal.binding.model.api.Enumeration;
 import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
@@ -193,7 +192,7 @@ abstract class AbstractCompositeGenerator<T extends EffectiveStatement<?, ?>> ex
         // First try groupings/augments ...
         final AbstractExplicitGenerator<?> found = findInferredGenerator(childQName);
         if (found != null) {
-            return new Partial(found);
+            return OriginalLink.partial(found);
         }
 
         // ... no luck, we really need to start looking at our origin

diff --git a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractExplicitGenerator.java b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractExplicitGenerator.java
index b3e542f6ee7aea511ac80d4e5b54638bf1c0d9e2..69a2f217e51e242d9408940958e1f232935ec471 100644 (file)
--- a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractExplicitGenerator.java
+++ b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractExplicitGenerator.java
@@ -15,8 +15,6 @@ import com.google.common.base.MoreObjects.ToStringHelper;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
 import org.opendaylight.mdsal.binding.generator.impl.reactor.CollisionDomain.Member;
-import org.opendaylight.mdsal.binding.generator.impl.reactor.OriginalLink.Complete;
-import org.opendaylight.mdsal.binding.generator.impl.reactor.OriginalLink.Partial;
 import org.opendaylight.mdsal.binding.model.api.MethodSignature.ValueMechanics;
 import org.opendaylight.mdsal.binding.model.api.Type;
 import org.opendaylight.mdsal.binding.model.api.TypeMemberComment;
@@ -49,11 +47,14 @@ public abstract class AbstractExplicitGenerator<T extends EffectiveStatement<?,
      * <ul>
      *   <li>{@code null} when not resolved, i.e. access is not legal, or</li>
      *   <li>{@code this} object if this is the original definition, or</li>
-     *   <li>an {@link AbstractExplicitGenerator} pointing to the original definition, or</li>
-     *   <li>a {@link Partial} link pointing to a generator closer to the original definition</li>
+     *   <li>a generator which is one step closer to the original definition</li>
      * </ul>
      */
-    private Object prev;
+    private AbstractExplicitGenerator<?> prev;
+    /**
+     * Field holding the original incarnation, i.e. the terminal node along {@link #prev} links.
+     */
+    private AbstractExplicitGenerator<?> orig;
 
     AbstractExplicitGenerator(final T statement) {
         this.statement = requireNonNull(statement);
@@ -90,30 +91,38 @@ public abstract class AbstractExplicitGenerator<T extends EffectiveStatement<?,
      * @return Number of generators that remain unlinked.
      */
     long linkOriginalGenerator() {
-        final var local = prev;
-        if (local instanceof AbstractExplicitGenerator) {
+        if (orig != null) {
+            // Original already linked
             return 0;
-        } else if (local instanceof Partial) {
-            return ((Partial) local).original() != null ? 0 : 1;
         }
-        verify(local == null, "Unexpected link %s", local);
 
-        if (!isAddedByUses() && !isAugmenting()) {
-            prev = this;
-            LOG.trace("Linked {} to self", this);
-            return 0;
+        if (prev == null) {
+            LOG.trace("Linking {}", this);
+
+            if (!isAddedByUses() && !isAugmenting()) {
+                orig = prev = this;
+                LOG.trace("Linked {} to self", this);
+                return 0;
+            }
+
+            final var link = getParent().getOriginalChild(getQName());
+            prev = link.previous();
+            orig = link.original();
+            if (orig != null) {
+                LOG.trace("Linked {} to {} original {}", this, prev, orig);
+                return 0;
+            }
+
+            LOG.trace("Linked {} to intermediate {}", this, prev);
+            return 1;
         }
 
-        LOG.trace("Linking {}", this);
-        final var link = getParent().getOriginalChild(getQName());
-        if (link instanceof Complete) {
-            prev = ((Complete) link).original();
-            LOG.trace("Linked {} to {}", this, prev);
+        orig = prev.originalLink().original();
+        if (orig != null) {
+            LOG.trace("Linked {} to original {}", this, orig);
             return 0;
         }
-        prev = link;
-        LOG.trace("Linked {} to intermediate {}", this, prev);
-        return link.original() != null ? 0 : 1;
+        return 1;
     }
 
     /**
@@ -122,14 +131,8 @@ public abstract class AbstractExplicitGenerator<T extends EffectiveStatement<?,
      * @return Previous incarnation or {@code null}
      */
     final @Nullable AbstractExplicitGenerator<?> previous() {
-        final var local = prev();
-        if (local == this) {
-            return null;
-        } else if (local instanceof Partial) {
-            return ((Partial) local).previous();
-        } else {
-            return verifyExplicit(local);
-        }
+        final var local = verifyNotNull(prev, "Generator %s does not have linkage to previous instance resolved", this);
+        return local == this ? null : local;
     }
 
     /**
@@ -138,8 +141,7 @@ public abstract class AbstractExplicitGenerator<T extends EffectiveStatement<?,
      * @return Original incarnation of this generator
      */
     @NonNull AbstractExplicitGenerator<?> getOriginal() {
-        final var local = prev();
-        return local == this ? this : verifyExplicit(local).getOriginal();
+        return verifyNotNull(orig, "Generator %s does not have linkage to original instance resolved", this);
     }
 
     /**
@@ -150,25 +152,14 @@ public abstract class AbstractExplicitGenerator<T extends EffectiveStatement<?,
     final @NonNull OriginalLink originalLink() {
         final var local = prev;
         if (local == null) {
-            return new Partial(this);
+            return OriginalLink.partial(this);
         } else if (local == this) {
-            return new Complete(this);
-        } else if (local instanceof Partial) {
-            return (Partial) local;
+            return OriginalLink.complete(this);
         } else {
-            return verifyExplicit(local).originalLink();
+            return OriginalLink.partial(local);
         }
     }
 
-    private static @NonNull AbstractExplicitGenerator<?> verifyExplicit(final Object prev) {
-        verify(prev instanceof AbstractExplicitGenerator, "Unexpected previous %s", prev);
-        return (AbstractExplicitGenerator<?>) prev;
-    }
-
-    private @NonNull Object prev() {
-        return verifyNotNull(prev, "Generator %s does not have linkage to previous instance resolved", this);
-    }
-
     @Nullable AbstractExplicitGenerator<?> findSchemaTreeGenerator(final QName qname) {
         for (Generator child : this) {
             if (child instanceof AbstractExplicitGenerator) {

diff --git a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/OriginalLink.java b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/OriginalLink.java
index e51fe4b936c65ddb473f971ffd35f81674a40760..9794da4cf8e8d839f5c1f40bc8a934922a3aefd5 100644 (file)
--- a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/OriginalLink.java
+++ b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/OriginalLink.java
@@ -19,7 +19,7 @@ import org.eclipse.jdt.annotation.Nullable;
  */
 // FIXME: sealed when we have JDK17+
 abstract class OriginalLink {
-    static final class Complete extends OriginalLink {
+    private static final class Complete extends OriginalLink {
         private final @NonNull AbstractExplicitGenerator<?> original;
 
         Complete(final AbstractExplicitGenerator<?> original) {
@@ -42,7 +42,7 @@ abstract class OriginalLink {
         }
     }
 
-    static final class Partial extends OriginalLink {
+    private static final class Partial extends OriginalLink {
         private final @NonNull AbstractExplicitGenerator<?> previous;
         private AbstractExplicitGenerator<?> original;
 
@@ -76,6 +76,14 @@ abstract class OriginalLink {
         // Hidden on purpose
     }
 
+    static @NonNull OriginalLink complete(final AbstractExplicitGenerator<?> original) {
+        return new Complete(original);
+    }
+
+    static @NonNull OriginalLink partial(final AbstractExplicitGenerator<?> previous) {
+        return new Partial(previous);
+    }
+
     abstract @NonNull AbstractExplicitGenerator<?> previous();
 
     abstract @Nullable AbstractExplicitGenerator<?> original();