}
@Override
- final AbstractCompositeGenerator<?> getOriginal() {
- return (AbstractCompositeGenerator<?>) super.getOriginal();
+ final AbstractCompositeGenerator<T> getOriginal() {
+ return (AbstractCompositeGenerator<T>) super.getOriginal();
}
@Override
- 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) {
- return OriginalLink.partial(found);
+ return (OriginalLink<S>) OriginalLink.partial(found);
}
// ... 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) {
- return found.originalLink();
+ return (OriginalLink<S>) found.originalLink();
}
}
* <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.
*/
- private AbstractExplicitGenerator<?> orig;
+ private AbstractExplicitGenerator<T> orig;
AbstractExplicitGenerator(final T statement) {
this.statement = requireNonNull(statement);
return true;
}
- final var link = getParent().originalChild(getQName());
+ final var link = getParent().<T>originalChild(getQName());
if (link == null) {
LOG.trace("Cannot link {} yet", this);
return false;
*
* @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;
}
*
* @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);
}
- @Nullable AbstractExplicitGenerator<?> tryOriginal() {
+ @Nullable AbstractExplicitGenerator<T> tryOriginal() {
return orig;
}
*
* @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);
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+
-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
- AbstractExplicitGenerator<?> previous() {
+ AbstractExplicitGenerator<T> previous() {
return original;
}
@Override
- @NonNull AbstractExplicitGenerator<?> original() {
+ @NonNull AbstractExplicitGenerator<T> original() {
return 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
- AbstractExplicitGenerator<?> previous() {
+ AbstractExplicitGenerator<T> previous() {
return previous;
}
@Override
- AbstractExplicitGenerator<?> original() {
+ AbstractExplicitGenerator<T> original() {
if (original == null) {
final var link = previous.originalLink();
if (link instanceof Complete || link.previous() != previous) {
// Hidden on purpose
}
- 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);