The links to previous and original statement need to match our
statement, otherwise we are in trouble. While we do not verify this
at runtime (yet), improve type definitions to carry these around.
JIRA: MDSAL-696
Change-Id: I3bcc1c3b0d2e3f74a0727f8bfa6b2f1e1c578f67
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
- final AbstractCompositeGenerator<?> getOriginal() {
- return (AbstractCompositeGenerator<?>) super.getOriginal();
+ final AbstractCompositeGenerator<T> getOriginal() {
+ return (AbstractCompositeGenerator<T>) super.getOriginal();
- final AbstractCompositeGenerator<?> tryOriginal() {
- return (AbstractCompositeGenerator<?>) super.tryOriginal();
+ final AbstractCompositeGenerator<T> tryOriginal() {
+ return (AbstractCompositeGenerator<T>) super.tryOriginal();
- final @Nullable OriginalLink originalChild(final QName childQName) {
+ final <S extends EffectiveStatement<?, ?>> @Nullable OriginalLink<S> originalChild(final QName childQName) {
// First try groupings/augments ...
var found = findInferredGenerator(childQName);
if (found != null) {
// First try groupings/augments ...
var found = findInferredGenerator(childQName);
if (found != null) {
- return OriginalLink.partial(found);
+ return (OriginalLink<S>) 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
final QName prevQName = childQName.bindTo(prev.getQName().getModule());
found = prev.findSchemaTreeGenerator(prevQName);
if (found != null) {
final QName prevQName = childQName.bindTo(prev.getQName().getModule());
found = prev.findSchemaTreeGenerator(prevQName);
if (found != null) {
- return found.originalLink();
+ return (OriginalLink<S>) found.originalLink();
* <li>a generator which is one step closer to the original definition</li>
* </ul>
*/
* <li>a generator which is one step closer to the original definition</li>
* </ul>
*/
- private AbstractExplicitGenerator<?> prev;
+ private AbstractExplicitGenerator<T> prev;
/**
* Field holding the original incarnation, i.e. the terminal node along {@link #prev} links.
*/
/**
* Field holding the original incarnation, i.e. the terminal node along {@link #prev} links.
*/
- private AbstractExplicitGenerator<?> orig;
+ private AbstractExplicitGenerator<T> orig;
AbstractExplicitGenerator(final T statement) {
this.statement = requireNonNull(statement);
AbstractExplicitGenerator(final T statement) {
this.statement = requireNonNull(statement);
- final var link = getParent().originalChild(getQName());
+ final var link = getParent().<T>originalChild(getQName());
if (link == null) {
LOG.trace("Cannot link {} yet", this);
return false;
if (link == null) {
LOG.trace("Cannot link {} yet", this);
return false;
*
* @return Previous incarnation or {@code null}
*/
*
* @return Previous incarnation or {@code null}
*/
- final @Nullable AbstractExplicitGenerator<?> previous() {
+ final @Nullable AbstractExplicitGenerator<T> previous() {
final var local = verifyNotNull(prev, "Generator %s does not have linkage to previous instance resolved", this);
return local == this ? null : 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
*/
*
* @return Original incarnation of this generator
*/
- @NonNull AbstractExplicitGenerator<?> getOriginal() {
+ @NonNull AbstractExplicitGenerator<T> getOriginal() {
return verifyNotNull(orig, "Generator %s does not have linkage to original instance resolved", this);
}
return verifyNotNull(orig, "Generator %s does not have linkage to original instance resolved", this);
}
- @Nullable AbstractExplicitGenerator<?> tryOriginal() {
+ @Nullable AbstractExplicitGenerator<T> tryOriginal() {
*
* @return Link towards the original generator.
*/
*
* @return Link towards the original generator.
*/
- final @NonNull OriginalLink originalLink() {
+ final @NonNull OriginalLink<T> originalLink() {
final var local = prev;
if (local == null) {
return OriginalLink.partial(this);
final var local = prev;
if (local == null) {
return OriginalLink.partial(this);
import com.google.common.base.MoreObjects.ToStringHelper;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import com.google.common.base.MoreObjects.ToStringHelper;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
/**
* Link to the original definition of an {@link AbstractExplicitGenerator}.
*/
// FIXME: sealed when we have JDK17+
/**
* Link to the original definition of an {@link AbstractExplicitGenerator}.
*/
// FIXME: sealed when we have JDK17+
-abstract class OriginalLink {
- private static final class Complete extends OriginalLink {
- private final @NonNull AbstractExplicitGenerator<?> original;
+abstract class OriginalLink<T extends EffectiveStatement<?, ?>> {
+ private static final class Complete<T extends EffectiveStatement<?, ?>> extends OriginalLink<T> {
+ private final @NonNull AbstractExplicitGenerator<T> original;
- Complete(final AbstractExplicitGenerator<?> original) {
+ Complete(final AbstractExplicitGenerator<T> original) {
this.original = requireNonNull(original);
}
@Override
this.original = requireNonNull(original);
}
@Override
- AbstractExplicitGenerator<?> previous() {
+ AbstractExplicitGenerator<T> previous() {
return original;
}
@Override
return original;
}
@Override
- @NonNull AbstractExplicitGenerator<?> original() {
+ @NonNull AbstractExplicitGenerator<T> original() {
- private static final class Partial extends OriginalLink {
- private final @NonNull AbstractExplicitGenerator<?> previous;
- private AbstractExplicitGenerator<?> original;
+ private static final class Partial<T extends EffectiveStatement<?, ?>> extends OriginalLink<T> {
+ private final @NonNull AbstractExplicitGenerator<T> previous;
+ private AbstractExplicitGenerator<T> original;
- Partial(final AbstractExplicitGenerator<?> previous) {
+ Partial(final AbstractExplicitGenerator<T> previous) {
this.previous = requireNonNull(previous);
}
@Override
this.previous = requireNonNull(previous);
}
@Override
- AbstractExplicitGenerator<?> previous() {
+ AbstractExplicitGenerator<T> previous() {
return previous;
}
@Override
return previous;
}
@Override
- AbstractExplicitGenerator<?> original() {
+ AbstractExplicitGenerator<T> original() {
if (original == null) {
final var link = previous.originalLink();
if (link instanceof Complete || link.previous() != previous) {
if (original == null) {
final var link = previous.originalLink();
if (link instanceof Complete || link.previous() != previous) {
- static @NonNull OriginalLink complete(final AbstractExplicitGenerator<?> original) {
- return new Complete(original);
+ static <T extends EffectiveStatement<?, ?>> @NonNull OriginalLink<T> complete(
+ final AbstractExplicitGenerator<T> original) {
+ return new Complete<>(original);
- static @NonNull OriginalLink partial(final AbstractExplicitGenerator<?> previous) {
- return new Partial(previous);
+ static <T extends EffectiveStatement<?, ?>> @NonNull OriginalLink<T> partial(
+ final AbstractExplicitGenerator<T> previous) {
+ return new Partial<>(previous);
- abstract @NonNull AbstractExplicitGenerator<?> previous();
+ abstract @NonNull AbstractExplicitGenerator<T> previous();
- abstract @Nullable AbstractExplicitGenerator<?> original();
+ abstract @Nullable AbstractExplicitGenerator<T> original();
abstract ToStringHelper addToStringAttributes(ToStringHelper helper);
abstract ToStringHelper addToStringAttributes(ToStringHelper helper);