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>
(cherry picked from commit
f356d00c296ceedabc3f8d9c27308a0dd2dbb088)
import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
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;
import org.opendaylight.mdsal.binding.model.api.Enumeration;
import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
// First try groupings/augments ...
final AbstractExplicitGenerator<?> found = findInferredGenerator(childQName);
if (found != null) {
// 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
}
// ... no luck, we really need to start looking at our origin
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.generator.impl.reactor.CollisionDomain.Member;
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;
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;
* <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>
* <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>
+ 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);
AbstractExplicitGenerator(final T statement) {
this.statement = requireNonNull(statement);
* @return Number of generators that remain unlinked.
*/
long linkOriginalGenerator() {
* @return Number of generators that remain unlinked.
*/
long linkOriginalGenerator() {
- final var local = prev;
- if (local instanceof AbstractExplicitGenerator) {
+ if (orig != null) {
+ // Original already linked
- } 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);
- prev = link;
- LOG.trace("Linked {} to intermediate {}", this, prev);
- return link.original() != null ? 0 : 1;
* @return Previous incarnation or {@code null}
*/
final @Nullable AbstractExplicitGenerator<?> previous() {
* @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;
* @return Original incarnation of this generator
*/
@NonNull AbstractExplicitGenerator<?> getOriginal() {
* @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);
final @NonNull OriginalLink originalLink() {
final var local = prev;
if (local == null) {
final @NonNull OriginalLink originalLink() {
final var local = prev;
if (local == null) {
- return new Partial(this);
+ return OriginalLink.partial(this);
} else if (local == this) {
} else if (local == this) {
- return new Complete(this);
- } else if (local instanceof Partial) {
- return (Partial) local;
+ return OriginalLink.complete(this);
- 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) {
@Nullable AbstractExplicitGenerator<?> findSchemaTreeGenerator(final QName qname) {
for (Generator child : this) {
if (child instanceof AbstractExplicitGenerator) {
*/
// FIXME: sealed when we have JDK17+
abstract class OriginalLink {
*/
// 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) {
private final @NonNull AbstractExplicitGenerator<?> original;
Complete(final AbstractExplicitGenerator<?> original) {
- static final class Partial extends OriginalLink {
+ private static final class Partial extends OriginalLink {
private final @NonNull AbstractExplicitGenerator<?> previous;
private AbstractExplicitGenerator<?> original;
private final @NonNull AbstractExplicitGenerator<?> previous;
private AbstractExplicitGenerator<?> original;
+ 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();
abstract @NonNull AbstractExplicitGenerator<?> previous();
abstract @Nullable AbstractExplicitGenerator<?> original();