if (gen == this) {
break;
}
- if (gen instanceof AbstractAugmentGenerator
- && target.equalRoot(((AbstractAugmentGenerator) gen).targetGenerator().getMember())) {
+ if (gen instanceof AbstractAugmentGenerator aug && target.equalRoot(aug.targetGenerator().getMember())) {
offset++;
}
}
@Override
public final boolean isAddedByUses() {
- return statement instanceof AddedByUsesAware && ((AddedByUsesAware) statement).isAddedByUses();
+ return statement instanceof AddedByUsesAware aware && aware.isAddedByUses();
}
@Override
public final boolean isAugmenting() {
- return statement instanceof CopyableNode && ((CopyableNode) statement).isAugmenting();
+ return statement instanceof CopyableNode copyable && copyable.isAugmenting();
}
/**
final @Nullable AbstractExplicitGenerator<?, ?> findLocalSchemaTreeGenerator(final QName qname) {
for (Generator child : this) {
- if (child instanceof AbstractExplicitGenerator) {
- final AbstractExplicitGenerator<?, ?> gen = (AbstractExplicitGenerator<?, ?>) child;
- final EffectiveStatement<?, ?> stmt = gen.statement();
- if (stmt instanceof SchemaTreeEffectiveStatement && qname.equals(stmt.argument())) {
- return gen;
- }
+ if (child instanceof AbstractExplicitGenerator<?, ?> gen
+ && gen.statement() instanceof SchemaTreeEffectiveStatement<?> stmt && qname.equals(stmt.argument())) {
+ return gen;
}
}
return null;
// - being a child of an augment (i.e. augmented into a choice)
final AbstractCompositeGenerator<?, ?> parent = getParent();
final ChoiceGenerator choice;
- if (parent instanceof AbstractAugmentGenerator) {
- final AbstractCompositeGenerator<?, ?> target = ((AbstractAugmentGenerator) parent).targetGenerator();
+ if (parent instanceof AbstractAugmentGenerator augGen) {
+ final AbstractCompositeGenerator<?, ?> target = augGen.targetGenerator();
verify(target instanceof ChoiceGenerator, "Unexpected parent augment %s target %s", parent, target);
choice = (ChoiceGenerator) target;
} else {
// those two we only generate things for 'module'.
if (!(statement instanceof ModuleEffectiveStatement)) {
for (var stmt : statement.effectiveSubstatements()) {
- if (stmt instanceof AugmentEffectiveStatement) {
- processAugment(resolver, resolver.getAugment((AugmentEffectiveStatement) stmt));
+ if (stmt instanceof AugmentEffectiveStatement augment) {
+ processAugment(resolver, resolver.getAugment(augment));
}
}
}
// Now construct RuntimeTypes for each schema tree child of stmt
for (var stmt : statement.effectiveSubstatements()) {
- if (stmt instanceof SchemaTreeEffectiveStatement) {
- final var child = (SchemaTreeEffectiveStatement<?>) stmt;
-
+ if (stmt instanceof SchemaTreeEffectiveStatement<?> child) {
// Try valid augments first: they should be empty most of the time and filter all the cases where we
// would not find the streamChild among our local and grouping statements. Note that unlike all others,
// such matches are not considered to be children in Binding DataObject tree, they are only considered
@SuppressWarnings("unchecked")
final AbstractExplicitGenerator<S, ?> gen = (AbstractExplicitGenerator<S, ?>) child;
final EffectiveStatement<?, ?> genStmt = gen.statement();
- if (genStmt instanceof SchemaTreeEffectiveStatement
- && localName.equals(((SchemaTreeEffectiveStatement<?>) genStmt).argument().getLocalName())) {
+ if (genStmt instanceof SchemaTreeEffectiveStatement<?> schemaStmt
+ && localName.equals(schemaStmt.argument().getLocalName())) {
return gen;
}
}
}
// if we into a choice we need to follow the hierararchy of that choice
- if (ancestor instanceof AbstractAugmentGenerator augment) {
- final AbstractCompositeGenerator<?, ?> target = augment.targetGenerator();
- if (target instanceof ChoiceGenerator) {
- ancestor = target;
- continue;
- }
+ if (ancestor instanceof AbstractAugmentGenerator augment
+ && augment.targetGenerator() instanceof ChoiceGenerator targetChoice) {
+ ancestor = targetChoice;
+ continue;
}
break;
final var augments = new ArrayList<AugmentRequirement>();
for (ModuleGenerator module : children) {
for (Generator gen : module) {
- if (gen instanceof ModuleAugmentGenerator) {
- augments.add(((ModuleAugmentGenerator) gen).startLinkage(this));
+ if (gen instanceof ModuleAugmentGenerator moduleGen) {
+ augments.add(moduleGen.startLinkage(this));
}
}
}
for (Generator gen : parent) {
gen.ensureMember();
collectCollisionDomains(result, gen);
- if (gen instanceof AbstractCompositeGenerator) {
- result.add(((AbstractCompositeGenerator<?, ?>) gen).domain());
+ if (gen instanceof AbstractCompositeGenerator<?, ?> compositeGen) {
+ result.add(compositeGen.domain());
}
}
}
// Now kick of the search
final List<EffectiveStatement<?, ?>> stmtPath = inferenceStack.toInference().statementPath();
final AbstractExplicitGenerator<?, ?> found = gen.findGenerator(stmtPath);
- if (found instanceof AbstractTypeAwareGenerator) {
- return (AbstractTypeAwareGenerator<?, ?, ?>) found;
+ if (found instanceof AbstractTypeAwareGenerator<?, ?, ?> typeAware) {
+ return typeAware;
}
throw new VerifyException("Statements " + stmtPath + " resulted in unexpected " + found);
}
// Note: unlike other methods, this method pushes matching child to the stack
private void linkUsesDependencies(final Iterable<? extends Generator> parent) {
for (Generator child : parent) {
- if (child instanceof AbstractCompositeGenerator) {
- LOG.trace("Visiting composite {}", child);
- final var composite = (AbstractCompositeGenerator<?, ?>) child;
+ if (child instanceof AbstractCompositeGenerator<?, ?> composite) {
+ LOG.trace("Visiting composite {}", composite);
stack.push(composite);
composite.linkUsesDependencies(this);
linkUsesDependencies(composite);
private void linkDependencies(final Iterable<? extends Generator> parent) {
for (Generator child : parent) {
- if (child instanceof AbstractDependentGenerator) {
- ((AbstractDependentGenerator<?, ?>) child).linkDependencies(this);
+ if (child instanceof AbstractDependentGenerator<?, ?> dependent) {
+ dependent.linkDependencies(this);
} else if (child instanceof AbstractCompositeGenerator) {
stack.push(child);
linkDependencies(child);
private void bindTypeDefinition(final Iterable<? extends Generator> parent) {
for (Generator child : parent) {
stack.push(child);
- if (child instanceof AbstractTypeObjectGenerator) {
- ((AbstractTypeObjectGenerator<?, ?>) child).bindTypeDefinition(this);
+ if (child instanceof AbstractTypeObjectGenerator<?, ?> typeObject) {
+ typeObject.bindTypeDefinition(this);
} else if (child instanceof AbstractCompositeGenerator) {
bindTypeDefinition(child);
}
AbstractExplicitGenerator<?, ?> findGenerator(final EffectiveStatement<?, ?> needle,
final Iterable<? extends Generator> haystack) {
for (Generator gen : haystack) {
- if (gen instanceof AbstractExplicitGenerator) {
- final AbstractExplicitGenerator<?, ?> ret = (AbstractExplicitGenerator<?, ?>) gen;
- if (needle == ret.statement()) {
- return ret;
- }
+ if (gen instanceof AbstractExplicitGenerator<?, ?> ret && needle == ret.statement()) {
+ return ret;
}
}
return null;
AbstractExplicitGenerator<?, ?> findGenerator(final QName needle,
final Iterable<? extends Generator> haystack) {
for (Generator gen : haystack) {
- if (gen instanceof AbstractExplicitGenerator) {
- final AbstractExplicitGenerator<?, ?> ret = (AbstractExplicitGenerator<?, ?>) gen;
- if (needle.equals(ret.statement().argument())) {
- return ret;
- }
+ if (gen instanceof AbstractExplicitGenerator<?, ?> ret && needle.equals(ret.statement().argument())) {
+ return ret;
}
}
return null;
}
final Type parentType = Type.of(parent.typeName());
- if (parent instanceof ListGenerator) {
- final KeyGenerator keyGen = ((ListGenerator) parent).keyGenerator();
+ if (parent instanceof ListGenerator listGen) {
+ final KeyGenerator keyGen = listGen.keyGenerator();
if (keyGen != null) {
return BindingTypes.keyedListNotification(builder, parentType, keyGen.getGeneratedType(builderFactory));
}
@Override
final GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
final AbstractCompositeGenerator<?, ?> parent = getParent();
- if (parent instanceof ActionGenerator && ((ActionGenerator) parent).isAddedByUses()) {
+ if (parent instanceof ActionGenerator actionParent && actionParent.isAddedByUses()) {
// final ActionDefinition orig = findOrigAction(parentSchema, action).get();
// // Original definition may live in a different module, make sure we account for that
// final ModuleContext origContext = moduleContext(
@Override
void addCodegenInformation(final EffectiveStatement<?, ?> stmt,
final GeneratedTypeBuilderBase<?> builder) {
- if (stmt instanceof DocumentedNode) {
- addCodegenInformation((DocumentedNode) stmt, builder);
+ if (stmt instanceof DocumentedNode documented) {
+ addCodegenInformation(documented, builder);
}
}
@Override
void addCodegenInformation(final ModuleGenerator module, final EffectiveStatement<?, ?> stmt,
final GeneratedTypeBuilderBase<?> builder) {
- if (stmt instanceof DocumentedNode) {
- final DocumentedNode node = (DocumentedNode) stmt;
- TypeComments.description(node).ifPresent(builder::addComment);
- node.getDescription().ifPresent(builder::setDescription);
- node.getReference().ifPresent(builder::setReference);
+ if (stmt instanceof DocumentedNode documented) {
+ TypeComments.description(documented).ifPresent(builder::addComment);
+ documented.getDescription().ifPresent(builder::setDescription);
+ documented.getReference().ifPresent(builder::setReference);
}
- if (stmt instanceof SchemaNode) {
- YangSourceDefinition.of(module.statement(), (SchemaNode) stmt)
- .ifPresent(builder::setYangSourceDefinition);
+ if (stmt instanceof SchemaNode schema) {
+ YangSourceDefinition.of(module.statement(), schema).ifPresent(builder::setYangSourceDefinition);
}
}