From 9e6332763770afdc04dc7f09ce09102500ef382c Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Wed, 8 Nov 2017 23:48:27 +0100 Subject: [PATCH] YANGTOOLS-706: Reduce inter-statement implementation coupling Now that we have proper model.api.stmt interfaces we can reduce reliance on effective statement implementation classes, leading a more streamlined implementation. This patch does not eliminate all of the reliance, as that requires updating model.api.stmt interfaces to carry enough information to allow cross-statement inference. Change-Id: Ib39d8578c954a6e8ecede53ce5a7420e7dd0f2aa Signed-off-by: Robert Varga --- .../AbstractEffectiveContainerSchemaNode.java | 3 +- ...tEffectiveDocumentedDataNodeContainer.java | 5 ++-- .../AbstractEffectiveDocumentedNode.java | 9 ++++-- .../effective/AbstractEffectiveModule.java | 20 +++++++------ .../AugmentEffectiveStatementImpl.java | 3 +- .../ChoiceEffectiveStatementImpl.java | 3 +- .../DeviateEffectiveStatementImpl.java | 14 +++++---- .../DeviationEffectiveStatementImpl.java | 6 ++-- .../EffectiveConstraintDefinitionImpl.java | 13 ++++---- .../ExtensionEffectiveStatementImpl.java | 5 ++-- .../ImportEffectiveStatementImpl.java | 15 ++++++---- .../effective/LeafEffectiveStatementImpl.java | 25 +++++++++------- .../LeafListEffectiveStatementImpl.java | 28 ++++++++++------- .../effective/ListEffectiveStatementImpl.java | 6 ++-- .../effective/MustEffectiveStatementImpl.java | 12 +++++--- .../RevisionEffectiveStatementImpl.java | 6 ++-- .../effective/RpcEffectiveStatementImpl.java | 5 ++-- .../SubmoduleEffectiveStatementImpl.java | 3 +- .../TypeDefEffectiveStatementImpl.java | 25 +++++++++------- .../effective/UsesEffectiveStatementImpl.java | 3 +- .../AbstractConstraintEffectiveStatement.java | 30 +++++++++---------- .../type/BitEffectiveStatementImpl.java | 6 ++-- ...64SpecificationEffectiveStatementImpl.java | 6 ++-- .../DecimalTypeEffectiveStatementImpl.java | 6 ++-- .../type/EnumEffectiveStatementImpl.java | 6 ++-- ...efSpecificationEffectiveStatementImpl.java | 7 ++--- ...erSpecificationEffectiveStatementImpl.java | 6 ++-- ...eIdentifierTypeEffectiveStatementImpl.java | 6 ++-- ...efSpecificationEffectiveStatementImpl.java | 12 ++++---- .../LeafrefTypeEffectiveStatementImpl.java | 6 ++-- .../StringTypeEffectiveStatementImpl.java | 5 ++-- .../ActionEffectiveStatementImpl.java | 6 ++-- .../yang/parser/stmt/rfc7950/Bug6874Test.java | 21 +++++++------ .../yang/stmt/Bug3874ExtensionTest.java | 7 ++--- .../yangtools/yang/stmt/Bug4610Test.java | 17 +++++------ .../yangtools/yang/stmt/Bug6972Test.java | 7 +++-- .../plugin/ThirdPartyExtensionPluginTest.java | 7 ++--- 37 files changed, 207 insertions(+), 163 deletions(-) diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveContainerSchemaNode.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveContainerSchemaNode.java index 4f23d11331..ec21e16eb0 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveContainerSchemaNode.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveContainerSchemaNode.java @@ -10,6 +10,7 @@ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.PresenceEffectiveStatement; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; abstract class AbstractEffectiveContainerSchemaNode> extends @@ -19,7 +20,7 @@ abstract class AbstractEffectiveContainerSchemaNode ctx) { super(ctx); - this.presence = firstEffective(PresenceEffectiveStatementImpl.class) != null; + this.presence = firstEffective(PresenceEffectiveStatement.class) != null; } @Override diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveDocumentedDataNodeContainer.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveDocumentedDataNodeContainer.java index 9cbb9c5766..94ccfa60af 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveDocumentedDataNodeContainer.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveDocumentedDataNodeContainer.java @@ -28,6 +28,7 @@ import org.opendaylight.yangtools.yang.model.api.TypeDefinition; import org.opendaylight.yangtools.yang.model.api.UsesNode; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.source.AugmentToChoiceNamespace; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangValidationBundles; @@ -82,8 +83,8 @@ abstract class AbstractEffectiveDocumentedDataNodeContainer type = typeDef.getTypeDefinition(); if (!mutableTypeDefinitions.contains(type)) { mutableTypeDefinitions.add(type); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveDocumentedNode.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveDocumentedNode.java index f058b44b1d..7afaa4cb37 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveDocumentedNode.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveDocumentedNode.java @@ -12,6 +12,9 @@ import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.model.api.DocumentedNode; import org.opendaylight.yangtools.yang.model.api.Status; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; public abstract class AbstractEffectiveDocumentedNode> @@ -30,21 +33,21 @@ public abstract class AbstractEffectiveDocumentedNode ctx) { super(ctx); - final DescriptionEffectiveStatementImpl descStmt = firstEffective(DescriptionEffectiveStatementImpl.class); + final DescriptionEffectiveStatement descStmt = firstEffective(DescriptionEffectiveStatement.class); if (descStmt != null) { description = descStmt.argument(); } else { description = null; } - final ReferenceEffectiveStatementImpl refStmt = firstEffective(ReferenceEffectiveStatementImpl.class); + final ReferenceEffectiveStatement refStmt = firstEffective(ReferenceEffectiveStatement.class); if (refStmt != null) { reference = refStmt.argument(); } else { reference = null; } - final StatusEffectiveStatementImpl statusStmt = firstEffective(StatusEffectiveStatementImpl.class); + final StatusEffectiveStatement statusStmt = firstEffective(StatusEffectiveStatement.class); if (statusStmt != null) { status = statusStmt.argument(); } else { diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveModule.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveModule.java index 6d4b993bfa..73ec27113a 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveModule.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveModule.java @@ -50,7 +50,12 @@ import org.opendaylight.yangtools.yang.model.api.UsesNode; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ContactEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.PrefixEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionEffectiveStatement; import org.opendaylight.yangtools.yang.parser.spi.meta.MutableStatement; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable; @@ -98,25 +103,22 @@ abstract class AbstractEffectiveModule> exte "Unable to find belongs-to statement in submodule %s.", ctx.getStatementArgument()); } - final PrefixEffectiveStatementImpl prefixStmt = parentOfPrefix - .firstEffective(PrefixEffectiveStatementImpl.class); + final PrefixEffectiveStatement prefixStmt = parentOfPrefix.firstEffective(PrefixEffectiveStatement.class); SourceException.throwIfNull(prefixStmt, ctx.getStatementSourceReference(), "Unable to resolve prefix for module or submodule %s.", ctx.getStatementArgument()); this.prefix = prefixStmt.argument(); - final YangVersionEffectiveStatementImpl yangVersionStmt = - firstEffective(YangVersionEffectiveStatementImpl.class); + final YangVersionEffectiveStatement yangVersionStmt = firstEffective(YangVersionEffectiveStatement.class); this.yangVersion = yangVersionStmt == null ? YangVersion.VERSION_1 : yangVersionStmt.argument(); final OpenconfigVersionEffectiveStatement semanticVersionStmt = firstEffective(OpenconfigVersionEffectiveStatement.class); this.semanticVersion = semanticVersionStmt == null ? null : semanticVersionStmt.argument(); - final OrganizationEffectiveStatementImpl organizationStmt = - firstEffective(OrganizationEffectiveStatementImpl.class); + final OrganizationEffectiveStatement organizationStmt = firstEffective(OrganizationEffectiveStatement.class); this.organization = organizationStmt == null ? null : organizationStmt.argument(); - final ContactEffectiveStatementImpl contactStmt = firstEffective(ContactEffectiveStatementImpl.class); + final ContactEffectiveStatement contactStmt = firstEffective(ContactEffectiveStatement.class); this.contact = contactStmt == null ? null : contactStmt.argument(); // init submodules and substatements of submodules @@ -239,8 +241,8 @@ abstract class AbstractEffectiveModule> exte throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, effectiveStatement); } } - if (effectiveStatement instanceof TypeDefEffectiveStatementImpl) { - final TypeDefEffectiveStatementImpl typeDef = (TypeDefEffectiveStatementImpl) effectiveStatement; + if (effectiveStatement instanceof TypedefEffectiveStatement) { + final TypedefEffectiveStatement typeDef = (TypedefEffectiveStatement) effectiveStatement; final TypeDefinition type = typeDef.getTypeDefinition(); if (!mutableTypeDefinitions.contains(type)) { mutableTypeDefinitions.add(type); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AugmentEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AugmentEffectiveStatementImpl.java index 1198b9c2a5..acb6492654 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AugmentEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AugmentEffectiveStatementImpl.java @@ -28,6 +28,7 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.AugmentEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement; import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier; +import org.opendaylight.yangtools.yang.model.api.stmt.WhenEffectiveStatement; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils; @@ -55,7 +56,7 @@ public final class AugmentEffectiveStatementImpl this.copyOf = (AugmentationSchemaNode) ctx.getOriginalCtx().map(StmtContext::buildEffective).orElse(null); - final WhenEffectiveStatementImpl whenStmt = firstEffective(WhenEffectiveStatementImpl.class); + final WhenEffectiveStatement whenStmt = firstEffective(WhenEffectiveStatement.class); this.whenCondition = whenStmt == null ? null : whenStmt.argument(); // initSubstatementCollections diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ChoiceEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ChoiceEffectiveStatementImpl.java index 1920f407da..1269e9eb44 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ChoiceEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ChoiceEffectiveStatementImpl.java @@ -24,6 +24,7 @@ import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.DefaultEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryEffectiveStatement; import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @@ -72,7 +73,7 @@ public final class ChoiceEffectiveStatementImpl extends AbstractEffectiveDataSch this.augmentations = ImmutableSet.copyOf(augmentationsInit); this.cases = ImmutableSortedMap.copyOfSorted(casesInit); - final DefaultEffectiveStatementImpl defaultStmt = firstEffective(DefaultEffectiveStatementImpl.class); + final DefaultEffectiveStatement defaultStmt = firstEffective(DefaultEffectiveStatement.class); if (defaultStmt != null) { final QName qname; try { diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/DeviateEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/DeviateEffectiveStatementImpl.java index 3391592d55..9975dee031 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/DeviateEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/DeviateEffectiveStatementImpl.java @@ -19,11 +19,15 @@ import org.opendaylight.yangtools.yang.model.api.MustDefinition; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; import org.opendaylight.yangtools.yang.model.api.UniqueConstraint; import org.opendaylight.yangtools.yang.model.api.stmt.ConfigEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.DefaultEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.DeviateEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.DeviateStatement; import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; public final class DeviateEffectiveStatementImpl extends DeclaredEffectiveStatementBase @@ -48,19 +52,17 @@ public final class DeviateEffectiveStatementImpl extends DeclaredEffectiveStatem final ConfigEffectiveStatement configStmt = firstEffective(ConfigEffectiveStatement.class); this.deviatedConfig = OptionalBoolean.ofNullable(configStmt == null ? null : configStmt.argument()); - final DefaultEffectiveStatementImpl defaultStmt = firstEffective(DefaultEffectiveStatementImpl.class); + final DefaultEffectiveStatement defaultStmt = firstEffective(DefaultEffectiveStatement.class); this.deviatedDefault = defaultStmt == null ? null : defaultStmt.argument(); final MandatoryEffectiveStatement mandatoryStmt = firstEffective(MandatoryEffectiveStatement.class); this.deviatedMandatory = OptionalBoolean.ofNullable(mandatoryStmt == null ? null : mandatoryStmt.argument()); - final MaxElementsEffectiveStatementImpl maxElementsStmt = - firstEffective(MaxElementsEffectiveStatementImpl.class); + final MaxElementsEffectiveStatement maxElementsStmt = firstEffective(MaxElementsEffectiveStatement.class); this.deviatedMaxElements = maxElementsStmt == null ? null : Integer.valueOf(maxElementsStmt.argument()); - final MinElementsEffectiveStatementImpl minElementsStmt = - firstEffective(MinElementsEffectiveStatementImpl.class); + final MinElementsEffectiveStatement minElementsStmt = firstEffective(MinElementsEffectiveStatement.class); this.deviatedMinElements = minElementsStmt == null ? null : minElementsStmt.argument(); final TypeEffectiveStatement typeStmt = firstEffective(TypeEffectiveStatement.class); this.deviatedType = typeStmt == null ? null : typeStmt.getTypeDefinition(); - final UnitsEffectiveStatementImpl unitsStmt = firstEffective(UnitsEffectiveStatementImpl.class); + final UnitsEffectiveStatement unitsStmt = firstEffective(UnitsEffectiveStatement.class); this.deviatedUnits = unitsStmt == null ? null : unitsStmt.argument(); this.deviatedMustDefinitions = ImmutableSet.copyOf(allSubstatementsOfType(MustDefinition.class)); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/DeviationEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/DeviationEffectiveStatementImpl.java index 1e651e7065..8bb8ca5f9a 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/DeviationEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/DeviationEffectiveStatementImpl.java @@ -18,8 +18,10 @@ import org.opendaylight.yangtools.yang.model.api.Deviation; import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.DeviationEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.DeviationStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @@ -38,10 +40,10 @@ public class DeviationEffectiveStatementImpl this.deviateDefinitions = ImmutableList.copyOf(allSubstatementsOfType(DeviateDefinition.class)); - DescriptionEffectiveStatementImpl descriptionStmt = firstEffective(DescriptionEffectiveStatementImpl.class); + DescriptionEffectiveStatement descriptionStmt = firstEffective(DescriptionEffectiveStatement.class); this.description = descriptionStmt == null ? null : descriptionStmt.argument(); - ReferenceEffectiveStatementImpl referenceStmt = firstEffective(ReferenceEffectiveStatementImpl.class); + ReferenceEffectiveStatement referenceStmt = firstEffective(ReferenceEffectiveStatement.class); this.reference = referenceStmt == null ? null : referenceStmt.argument(); List unknownSchemaNodesInit = new ArrayList<>(); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/EffectiveConstraintDefinitionImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/EffectiveConstraintDefinitionImpl.java index 6d6bfbcac1..bf796146df 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/EffectiveConstraintDefinitionImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/EffectiveConstraintDefinitionImpl.java @@ -17,6 +17,9 @@ import org.opendaylight.yangtools.yang.data.util.EmptyConstraintDefinition; import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition; import org.opendaylight.yangtools.yang.model.api.MustDefinition; import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath; +import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.WhenEffectiveStatement; final class EffectiveConstraintDefinitionImpl implements ConstraintDefinition { private static final String UNBOUNDED_STR = "unbounded"; @@ -35,8 +38,8 @@ final class EffectiveConstraintDefinitionImpl implements ConstraintDefinition { } static ConstraintDefinition forParent(final EffectiveStatementBase parent) { - final MinElementsEffectiveStatementImpl firstMinElementsStmt = parent - .firstEffective(MinElementsEffectiveStatementImpl.class); + final MinElementsEffectiveStatement firstMinElementsStmt = parent + .firstEffective(MinElementsEffectiveStatement.class); final Integer minElements; if (firstMinElementsStmt != null) { final Integer m = firstMinElementsStmt.argument(); @@ -45,8 +48,8 @@ final class EffectiveConstraintDefinitionImpl implements ConstraintDefinition { minElements = null; } - final MaxElementsEffectiveStatementImpl firstMaxElementsStmt = parent - .firstEffective(MaxElementsEffectiveStatementImpl.class); + final MaxElementsEffectiveStatement firstMaxElementsStmt = parent + .firstEffective(MaxElementsEffectiveStatement.class); final String maxElementsArg = firstMaxElementsStmt == null ? UNBOUNDED_STR : firstMaxElementsStmt.argument(); final Integer maxElements; if (!UNBOUNDED_STR.equals(maxElementsArg)) { @@ -58,7 +61,7 @@ final class EffectiveConstraintDefinitionImpl implements ConstraintDefinition { final Set mustSubstatements = ImmutableSet.copyOf(parent.allSubstatementsOfType( MustDefinition.class)); - final WhenEffectiveStatementImpl firstWhenStmt = parent.firstEffective(WhenEffectiveStatementImpl.class); + final WhenEffectiveStatement firstWhenStmt = parent.firstEffective(WhenEffectiveStatement.class); // Check for singleton instances if (minElements == null && maxElements == null && mustSubstatements.isEmpty() && firstWhenStmt == null) { diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ExtensionEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ExtensionEffectiveStatementImpl.java index 54782250b1..4dca3fb9ee 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ExtensionEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ExtensionEffectiveStatementImpl.java @@ -23,6 +23,7 @@ import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.YinElementEffectiveStatement; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; public class ExtensionEffectiveStatementImpl extends AbstractEffectiveDocumentedNode @@ -87,8 +88,8 @@ public class ExtensionEffectiveStatementImpl extends AbstractEffectiveDocumented if (argumentSubstatement != null) { this.argument = argumentSubstatement.argument().getLocalName(); - YinElementEffectiveStatementImpl yinElement = argumentSubstatement - .firstEffective(YinElementEffectiveStatementImpl.class); + YinElementEffectiveStatement yinElement = argumentSubstatement + .firstEffective(YinElementEffectiveStatement.class); if (yinElement != null) { this.yin = yinElement.argument(); } else { diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ImportEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ImportEffectiveStatementImpl.java index ef1fab226a..4852dd1ada 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ImportEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ImportEffectiveStatementImpl.java @@ -14,8 +14,12 @@ import org.opendaylight.yangtools.concepts.SemVer; import org.opendaylight.yangtools.yang.common.QNameModule; import org.opendaylight.yangtools.yang.common.Revision; import org.opendaylight.yangtools.yang.model.api.ModuleImport; +import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ImportEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ImportStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.PrefixEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateEffectiveStatement; import org.opendaylight.yangtools.yang.model.repo.api.SemVerSourceIdentifier; import org.opendaylight.yangtools.yang.parser.spi.meta.MissingSubstatementException; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @@ -37,7 +41,7 @@ public class ImportEffectiveStatementImpl extends DeclaredEffectiveStatementBase super(ctx); moduleName = ctx.getStatementArgument(); - final PrefixEffectiveStatementImpl prefixStmt = firstEffective(PrefixEffectiveStatementImpl.class); + final PrefixEffectiveStatement prefixStmt = firstEffective(PrefixEffectiveStatement.class); if (prefixStmt != null) { this.prefix = prefixStmt.argument(); } else { @@ -46,8 +50,8 @@ public class ImportEffectiveStatementImpl extends DeclaredEffectiveStatementBase } if (!ctx.isEnabledSemanticVersioning()) { - final RevisionDateEffectiveStatementImpl revisionDateStmt = firstEffective( - RevisionDateEffectiveStatementImpl.class); + final RevisionDateEffectiveStatement revisionDateStmt = firstEffective( + RevisionDateEffectiveStatement.class); this.revision = revisionDateStmt == null ? getImportedRevision(ctx) : revisionDateStmt.argument(); this.semVer = null; } else { @@ -57,11 +61,10 @@ public class ImportEffectiveStatementImpl extends DeclaredEffectiveStatementBase semVer = importedModuleIdentifier.getSemanticVersion().orElse(null); } - final DescriptionEffectiveStatementImpl descriptionStmt = firstEffective( - DescriptionEffectiveStatementImpl.class); + final DescriptionEffectiveStatement descriptionStmt = firstEffective(DescriptionEffectiveStatement.class); this.description = descriptionStmt != null ? descriptionStmt.argument() : null; - final ReferenceEffectiveStatementImpl referenceStmt = firstEffective(ReferenceEffectiveStatementImpl.class); + final ReferenceEffectiveStatement referenceStmt = firstEffective(ReferenceEffectiveStatement.class); this.reference = referenceStmt != null ? referenceStmt.argument() : null; } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/LeafEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/LeafEffectiveStatementImpl.java index 8189a71a04..1f8140246c 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/LeafEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/LeafEffectiveStatementImpl.java @@ -14,10 +14,15 @@ import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode; import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.DefaultEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.LeafEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.LeafStatement; import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement; import org.opendaylight.yangtools.yang.model.util.type.ConcreteTypeBuilder; import org.opendaylight.yangtools.yang.model.util.type.ConcreteTypes; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @@ -46,17 +51,17 @@ public final class LeafEffectiveStatementImpl extends AbstractEffectiveDataSchem final ConcreteTypeBuilder builder = ConcreteTypes.concreteTypeBuilder(typeStmt.getTypeDefinition(), ctx.getSchemaPath().get()); for (final EffectiveStatement stmt : effectiveSubstatements()) { - if (stmt instanceof DefaultEffectiveStatementImpl) { - dflt = ((DefaultEffectiveStatementImpl)stmt).argument(); + if (stmt instanceof DefaultEffectiveStatement) { + dflt = ((DefaultEffectiveStatement)stmt).argument(); builder.setDefaultValue(stmt.argument()); - } else if (stmt instanceof DescriptionEffectiveStatementImpl) { - builder.setDescription(((DescriptionEffectiveStatementImpl)stmt).argument()); - } else if (stmt instanceof ReferenceEffectiveStatementImpl) { - builder.setReference(((ReferenceEffectiveStatementImpl)stmt).argument()); - } else if (stmt instanceof StatusEffectiveStatementImpl) { - builder.setStatus(((StatusEffectiveStatementImpl)stmt).argument()); - } else if (stmt instanceof UnitsEffectiveStatementImpl) { - units = ((UnitsEffectiveStatementImpl)stmt).argument(); + } else if (stmt instanceof DescriptionEffectiveStatement) { + builder.setDescription(((DescriptionEffectiveStatement)stmt).argument()); + } else if (stmt instanceof ReferenceEffectiveStatement) { + builder.setReference(((ReferenceEffectiveStatement)stmt).argument()); + } else if (stmt instanceof StatusEffectiveStatement) { + builder.setStatus(((StatusEffectiveStatement)stmt).argument()); + } else if (stmt instanceof UnitsEffectiveStatement) { + units = ((UnitsEffectiveStatement)stmt).argument(); builder.setUnits(units); } } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/LeafListEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/LeafListEffectiveStatementImpl.java index 1ead65a54d..8a81f884d3 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/LeafListEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/LeafListEffectiveStatementImpl.java @@ -17,9 +17,15 @@ import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode; import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.DefaultEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.LeafListEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.LeafListStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement; import org.opendaylight.yangtools.yang.model.util.type.ConcreteTypeBuilder; import org.opendaylight.yangtools.yang.model.util.type.ConcreteTypes; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @@ -50,20 +56,20 @@ public final class LeafListEffectiveStatementImpl extends AbstractEffectiveDataS final ImmutableSet.Builder defaultValuesBuilder = ImmutableSet.builder(); boolean isUserOrdered = false; for (final EffectiveStatement stmt : effectiveSubstatements()) { - if (stmt instanceof OrderedByEffectiveStatementImpl) { + if (stmt instanceof OrderedByEffectiveStatement) { isUserOrdered = ORDER_BY_USER_KEYWORD.equals(stmt.argument()); } - if (stmt instanceof DefaultEffectiveStatementImpl) { - defaultValuesBuilder.add(((DefaultEffectiveStatementImpl) stmt).argument()); - } else if (stmt instanceof DescriptionEffectiveStatementImpl) { - builder.setDescription(((DescriptionEffectiveStatementImpl)stmt).argument()); - } else if (stmt instanceof ReferenceEffectiveStatementImpl) { - builder.setReference(((ReferenceEffectiveStatementImpl)stmt).argument()); - } else if (stmt instanceof StatusEffectiveStatementImpl) { - builder.setStatus(((StatusEffectiveStatementImpl)stmt).argument()); - } else if (stmt instanceof UnitsEffectiveStatementImpl) { - builder.setUnits(((UnitsEffectiveStatementImpl)stmt).argument()); + if (stmt instanceof DefaultEffectiveStatement) { + defaultValuesBuilder.add(((DefaultEffectiveStatement) stmt).argument()); + } else if (stmt instanceof DescriptionEffectiveStatement) { + builder.setDescription(((DescriptionEffectiveStatement)stmt).argument()); + } else if (stmt instanceof ReferenceEffectiveStatement) { + builder.setReference(((ReferenceEffectiveStatement)stmt).argument()); + } else if (stmt instanceof StatusEffectiveStatement) { + builder.setStatus(((StatusEffectiveStatement)stmt).argument()); + } else if (stmt instanceof UnitsEffectiveStatement) { + builder.setUnits(((UnitsEffectiveStatement)stmt).argument()); } } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ListEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ListEffectiveStatementImpl.java index c23b411a38..e7f02e55fc 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ListEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/ListEffectiveStatementImpl.java @@ -26,8 +26,10 @@ import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; import org.opendaylight.yangtools.yang.model.api.NotificationDefinition; import org.opendaylight.yangtools.yang.model.api.UniqueConstraint; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.KeyEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ListEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ListStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier; import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @@ -49,7 +51,7 @@ public final class ListEffectiveStatementImpl extends AbstractEffectiveSimpleDat this.original = (ListSchemaNode) ctx.getOriginalCtx().map(StmtContext::buildEffective).orElse(null); - final OrderedByEffectiveStatementImpl orderedByStmt = firstEffective(OrderedByEffectiveStatementImpl.class); + final OrderedByEffectiveStatement orderedByStmt = firstEffective(OrderedByEffectiveStatement.class); if (orderedByStmt != null && ORDER_BY_USER_KEYWORD.equals(orderedByStmt.argument())) { this.userOrdered = true; } else { @@ -58,7 +60,7 @@ public final class ListEffectiveStatementImpl extends AbstractEffectiveSimpleDat // initKeyDefinition final List keyDefinitionInit = new LinkedList<>(); - final KeyEffectiveStatementImpl keyEffectiveSubstatement = firstEffective(KeyEffectiveStatementImpl.class); + final KeyEffectiveStatement keyEffectiveSubstatement = firstEffective(KeyEffectiveStatement.class); if (keyEffectiveSubstatement != null) { final Set possibleLeafQNamesForKey = new HashSet<>(); for (final EffectiveStatement effectiveStatement : effectiveSubstatements()) { diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/MustEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/MustEffectiveStatementImpl.java index 4159a687d9..a556868056 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/MustEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/MustEffectiveStatementImpl.java @@ -11,8 +11,12 @@ import java.util.Objects; import java.util.Optional; import org.opendaylight.yangtools.yang.model.api.MustDefinition; import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath; +import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.MustEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; public class MustEffectiveStatementImpl extends DeclaredEffectiveStatementBase @@ -28,16 +32,16 @@ public class MustEffectiveStatementImpl extends DeclaredEffectiveStatementBase ctx) { super(ctx); - final DescriptionEffectiveStatementImpl descStmt = firstEffective(DescriptionEffectiveStatementImpl.class); + final DescriptionEffectiveStatement descStmt = firstEffective(DescriptionEffectiveStatement.class); if (descStmt != null) { this.description = descStmt.argument(); } else { this.description = null; } - final ReferenceEffectiveStatementImpl refStmt = firstEffective(ReferenceEffectiveStatementImpl.class); + final ReferenceEffectiveStatement refStmt = firstEffective(ReferenceEffectiveStatement.class); if (refStmt != null) { this.reference = refStmt.argument(); } else { diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/RpcEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/RpcEffectiveStatementImpl.java index 1bda50660f..c5162c4895 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/RpcEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/RpcEffectiveStatementImpl.java @@ -20,6 +20,7 @@ import org.opendaylight.yangtools.yang.model.api.TypeDefinition; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.RpcEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.RpcStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; public class RpcEffectiveStatementImpl extends AbstractEffectiveSchemaNode @@ -43,8 +44,8 @@ public class RpcEffectiveStatementImpl extends AbstractEffectiveSchemaNode type = typeDef.getTypeDefinition(); if (!mutableTypeDefinitions.contains(type)) { mutableTypeDefinitions.add(type); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/SubmoduleEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/SubmoduleEffectiveStatementImpl.java index 29eb72a327..3b374a2899 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/SubmoduleEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/SubmoduleEffectiveStatementImpl.java @@ -13,6 +13,7 @@ import java.util.Objects; import org.opendaylight.yangtools.yang.common.QNameModule; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.RevisionEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @@ -30,7 +31,7 @@ public final class SubmoduleEffectiveStatementImpl extends AbstractEffectiveModu final String belongsToModuleName = firstAttributeOf(ctx.declaredSubstatements(), BelongsToStatement.class); final QNameModule belongsToModuleQName = ctx.getFromNamespace(ModuleNameToModuleQName.class, belongsToModuleName); - final RevisionEffectiveStatementImpl submoduleRevision = firstEffective(RevisionEffectiveStatementImpl.class); + final RevisionEffectiveStatement submoduleRevision = firstEffective(RevisionEffectiveStatement.class); this.qnameModule = QNameModule.create(belongsToModuleQName.getNamespace(), submoduleRevision == null ? null : submoduleRevision.argument()).intern(); } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/TypeDefEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/TypeDefEffectiveStatementImpl.java index d3162517d2..cb00df7153 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/TypeDefEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/TypeDefEffectiveStatementImpl.java @@ -17,10 +17,15 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace; import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; import org.opendaylight.yangtools.yang.model.api.meta.StatementSource; +import org.opendaylight.yangtools.yang.model.api.stmt.DefaultEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypedefStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement; import org.opendaylight.yangtools.yang.model.util.type.DerivedTypeBuilder; import org.opendaylight.yangtools.yang.model.util.type.DerivedTypes; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @@ -45,17 +50,17 @@ public final class TypeDefEffectiveStatementImpl extends AbstractEffectiveSchema ctx.getSchemaPath().get()); String defaultValue = null; for (final EffectiveStatement stmt : effectiveSubstatements()) { - if (stmt instanceof DefaultEffectiveStatementImpl) { - defaultValue = ((DefaultEffectiveStatementImpl) stmt).argument(); + if (stmt instanceof DefaultEffectiveStatement) { + defaultValue = ((DefaultEffectiveStatement) stmt).argument(); builder.setDefaultValue(defaultValue); - } else if (stmt instanceof DescriptionEffectiveStatementImpl) { - builder.setDescription(((DescriptionEffectiveStatementImpl)stmt).argument()); - } else if (stmt instanceof ReferenceEffectiveStatementImpl) { - builder.setReference(((ReferenceEffectiveStatementImpl)stmt).argument()); - } else if (stmt instanceof StatusEffectiveStatementImpl) { - builder.setStatus(((StatusEffectiveStatementImpl)stmt).argument()); - } else if (stmt instanceof UnitsEffectiveStatementImpl) { - builder.setUnits(((UnitsEffectiveStatementImpl)stmt).argument()); + } else if (stmt instanceof DescriptionEffectiveStatement) { + builder.setDescription(((DescriptionEffectiveStatement)stmt).argument()); + } else if (stmt instanceof ReferenceEffectiveStatement) { + builder.setReference(((ReferenceEffectiveStatement)stmt).argument()); + } else if (stmt instanceof StatusEffectiveStatement) { + builder.setStatus(((StatusEffectiveStatement)stmt).argument()); + } else if (stmt instanceof UnitsEffectiveStatement) { + builder.setUnits(((UnitsEffectiveStatement)stmt).argument()); } else if (stmt instanceof UnknownEffectiveStatementImpl) { // FIXME: should not directly implement, I think builder.addUnknownSchemaNode((UnknownEffectiveStatementImpl)stmt); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/UsesEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/UsesEffectiveStatementImpl.java index 88eea28764..a3e49f1dbd 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/UsesEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/UsesEffectiveStatementImpl.java @@ -31,6 +31,7 @@ import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement; import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier; import org.opendaylight.yangtools.yang.model.api.stmt.UsesEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.WhenEffectiveStatement; import org.opendaylight.yangtools.yang.parser.spi.GroupingNamespace; import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @@ -79,7 +80,7 @@ public final class UsesEffectiveStatementImpl extends AbstractEffectiveDocumente this.augmentations = ImmutableSet.copyOf(augmentationsInit); this.refines = ImmutableMap.copyOf(refinesInit); - final WhenEffectiveStatementImpl whenStmt = firstEffective(WhenEffectiveStatementImpl.class); + final WhenEffectiveStatement whenStmt = firstEffective(WhenEffectiveStatement.class); this.whenCondition = whenStmt == null ? null : whenStmt.argument(); } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/AbstractConstraintEffectiveStatement.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/AbstractConstraintEffectiveStatement.java index 324c9ea7bb..0bc246fa83 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/AbstractConstraintEffectiveStatement.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/AbstractConstraintEffectiveStatement.java @@ -11,14 +11,14 @@ import java.util.Optional; import org.opendaylight.yangtools.yang.model.api.ConstraintMetaDefinition; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ModifierEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.type.ModifierKind; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DeclaredEffectiveStatementBase; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DescriptionEffectiveStatementImpl; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ErrorAppTagEffectiveStatementImpl; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ErrorMessageEffectiveStatementImpl; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ReferenceEffectiveStatementImpl; -import org.opendaylight.yangtools.yang.parser.stmt.rfc7950.effective.ModifierEffectiveStatementImpl; abstract class AbstractConstraintEffectiveStatement> extends DeclaredEffectiveStatementBase implements ConstraintMetaDefinition { @@ -38,20 +38,20 @@ abstract class AbstractConstraintEffectiveStatement stmt : effectiveSubstatements()) { - if (stmt instanceof DescriptionEffectiveStatementImpl) { - descriptionInit = ((DescriptionEffectiveStatementImpl) stmt).argument(); + if (stmt instanceof DescriptionEffectiveStatement) { + descriptionInit = ((DescriptionEffectiveStatement) stmt).argument(); } - if (stmt instanceof ReferenceEffectiveStatementImpl) { - referenceInit = ((ReferenceEffectiveStatementImpl) stmt).argument(); + if (stmt instanceof ReferenceEffectiveStatement) { + referenceInit = ((ReferenceEffectiveStatement) stmt).argument(); } - if (stmt instanceof ErrorAppTagEffectiveStatementImpl) { - errorAppTagInit = ((ErrorAppTagEffectiveStatementImpl) stmt).argument(); + if (stmt instanceof ErrorAppTagEffectiveStatement) { + errorAppTagInit = ((ErrorAppTagEffectiveStatement) stmt).argument(); } - if (stmt instanceof ErrorMessageEffectiveStatementImpl) { - errorMessageInit = ((ErrorMessageEffectiveStatementImpl) stmt).argument(); + if (stmt instanceof ErrorMessageEffectiveStatement) { + errorMessageInit = ((ErrorMessageEffectiveStatement) stmt).argument(); } - if (stmt instanceof ModifierEffectiveStatementImpl) { - modifierInit = ((ModifierEffectiveStatementImpl) stmt).argument(); + if (stmt instanceof ModifierEffectiveStatement) { + modifierInit = ((ModifierEffectiveStatement) stmt).argument(); } } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BitEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BitEffectiveStatementImpl.java index e19e7a40d2..f6a81583c4 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BitEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/BitEffectiveStatementImpl.java @@ -18,10 +18,10 @@ import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.BitEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.BitStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.PositionEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.AbstractEffectiveDocumentedNode; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.PositionEffectiveStatementImpl; public class BitEffectiveStatementImpl extends AbstractEffectiveDocumentedNode implements BitEffectiveStatement { @@ -40,8 +40,8 @@ public class BitEffectiveStatementImpl extends AbstractEffectiveDocumentedNode unknownSchemaNodesInit = new ArrayList<>(); Long declaredPositionInit = null; for (final EffectiveStatement effectiveStatement : effectiveSubstatements()) { - if (effectiveStatement instanceof PositionEffectiveStatementImpl) { - declaredPositionInit = ((PositionEffectiveStatementImpl) effectiveStatement).argument(); + if (effectiveStatement instanceof PositionEffectiveStatement) { + declaredPositionInit = ((PositionEffectiveStatement) effectiveStatement).argument(); } if (effectiveStatement instanceof UnknownSchemaNode) { unknownSchemaNodesInit.add((UnknownSchemaNode) effectiveStatement); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/Decimal64SpecificationEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/Decimal64SpecificationEffectiveStatementImpl.java index a0db7f284a..5f07bf5d5f 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/Decimal64SpecificationEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/Decimal64SpecificationEffectiveStatementImpl.java @@ -9,6 +9,7 @@ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type; import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.Decimal64Specification; import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition; @@ -16,7 +17,6 @@ import org.opendaylight.yangtools.yang.model.util.type.BaseTypes; import org.opendaylight.yangtools.yang.model.util.type.DecimalTypeBuilder; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DeclaredEffectiveStatementBase; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.FractionDigitsEffectiveStatementImpl; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UnknownEffectiveStatementImpl; public final class Decimal64SpecificationEffectiveStatementImpl extends @@ -32,8 +32,8 @@ public final class Decimal64SpecificationEffectiveStatementImpl extends final DecimalTypeBuilder builder = BaseTypes.decimalTypeBuilder(ctx.getSchemaPath().get()); for (final EffectiveStatement stmt : effectiveSubstatements()) { - if (stmt instanceof FractionDigitsEffectiveStatementImpl) { - builder.setFractionDigits(((FractionDigitsEffectiveStatementImpl) stmt).argument()); + if (stmt instanceof FractionDigitsEffectiveStatement) { + builder.setFractionDigits(((FractionDigitsEffectiveStatement) stmt).argument()); } if (stmt instanceof RangeEffectiveStatementImpl) { final RangeEffectiveStatementImpl range = (RangeEffectiveStatementImpl) stmt; diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/DecimalTypeEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/DecimalTypeEffectiveStatementImpl.java index 411542c446..d8a6c54d8c 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/DecimalTypeEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/DecimalTypeEffectiveStatementImpl.java @@ -11,6 +11,7 @@ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type; import java.math.BigDecimal; import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement; import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition; @@ -20,7 +21,6 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DeclaredEffectiveStatementBase; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.FractionDigitsEffectiveStatementImpl; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UnknownEffectiveStatementImpl; public final class DecimalTypeEffectiveStatementImpl extends DeclaredEffectiveStatementBase @@ -43,8 +43,8 @@ public final class DecimalTypeEffectiveStatementImpl extends DeclaredEffectiveSt if (stmt instanceof UnknownEffectiveStatementImpl) { builder.addUnknownSchemaNode((UnknownEffectiveStatementImpl)stmt); } - if (stmt instanceof FractionDigitsEffectiveStatementImpl) { - final Integer digits = ((FractionDigitsEffectiveStatementImpl)stmt).argument(); + if (stmt instanceof FractionDigitsEffectiveStatement) { + final Integer digits = ((FractionDigitsEffectiveStatement)stmt).argument(); SourceException.throwIf(baseType.getFractionDigits() != digits, ctx.getStatementSourceReference(), "Cannot override fraction-digits from base type %s to %s", baseType, digits); } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/EnumEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/EnumEffectiveStatementImpl.java index 78fa35a2a9..20a491d568 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/EnumEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/EnumEffectiveStatementImpl.java @@ -15,9 +15,9 @@ import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.EnumEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.EnumStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ValueEffectiveStatement; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.AbstractEffectiveDocumentedNode; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ValueEffectiveStatementImpl; public class EnumEffectiveStatementImpl extends AbstractEffectiveDocumentedNode implements EnumEffectiveStatement { @@ -33,8 +33,8 @@ public class EnumEffectiveStatementImpl extends AbstractEffectiveDocumentedNode< final List unknownSchemaNodesInit = new ArrayList<>(); Integer declaredValueInit = null; for (final EffectiveStatement effectiveStatement : effectiveSubstatements()) { - if (effectiveStatement instanceof ValueEffectiveStatementImpl) { - declaredValueInit = ((ValueEffectiveStatementImpl) effectiveStatement).argument(); + if (effectiveStatement instanceof ValueEffectiveStatement) { + declaredValueInit = ((ValueEffectiveStatement) effectiveStatement).argument(); } if (effectiveStatement instanceof UnknownSchemaNode) { unknownSchemaNodesInit.add((UnknownSchemaNode) effectiveStatement); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IdentityRefSpecificationEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IdentityRefSpecificationEffectiveStatementImpl.java index 6ff87b969e..a404f36723 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IdentityRefSpecificationEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/IdentityRefSpecificationEffectiveStatementImpl.java @@ -11,6 +11,7 @@ import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.BaseEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.IdentityRefSpecification; @@ -19,7 +20,6 @@ import org.opendaylight.yangtools.yang.model.util.type.BaseTypes; import org.opendaylight.yangtools.yang.model.util.type.IdentityrefTypeBuilder; import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.BaseEffectiveStatementImpl; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DeclaredEffectiveStatementBase; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UnknownEffectiveStatementImpl; @@ -35,9 +35,8 @@ public final class IdentityRefSpecificationEffectiveStatementImpl extends final IdentityrefTypeBuilder builder = BaseTypes.identityrefTypeBuilder(ctx.getSchemaPath().get()); for (final EffectiveStatement stmt : effectiveSubstatements()) { - if (stmt instanceof BaseEffectiveStatementImpl) { - final BaseEffectiveStatementImpl base = (BaseEffectiveStatementImpl) stmt; - final QName identityQName = base.argument(); + if (stmt instanceof BaseEffectiveStatement) { + final QName identityQName = ((BaseEffectiveStatement) stmt).argument(); final StmtContext> identityCtx = ctx.getFromNamespace(IdentityNamespace.class, identityQName); builder.addIdentity((IdentitySchemaNode) identityCtx.buildEffective()); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/InstanceIdentifierSpecificationEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/InstanceIdentifierSpecificationEffectiveStatementImpl.java index cb31229932..ab7cbabc52 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/InstanceIdentifierSpecificationEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/InstanceIdentifierSpecificationEffectiveStatementImpl.java @@ -9,6 +9,7 @@ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type; import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.InstanceIdentifierSpecification; import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition; @@ -17,7 +18,6 @@ import org.opendaylight.yangtools.yang.model.util.type.InstanceIdentifierTypeBui import org.opendaylight.yangtools.yang.model.util.type.RestrictedTypes; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DeclaredEffectiveStatementBase; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RequireInstanceEffectiveStatementImpl; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UnknownEffectiveStatementImpl; public final class InstanceIdentifierSpecificationEffectiveStatementImpl @@ -34,8 +34,8 @@ public final class InstanceIdentifierSpecificationEffectiveStatementImpl BaseTypes.instanceIdentifierType(), ctx.getSchemaPath().get()); for (EffectiveStatement stmt : effectiveSubstatements()) { - if (stmt instanceof RequireInstanceEffectiveStatementImpl) { - builder.setRequireInstance(((RequireInstanceEffectiveStatementImpl)stmt).argument()); + if (stmt instanceof RequireInstanceEffectiveStatement) { + builder.setRequireInstance(((RequireInstanceEffectiveStatement)stmt).argument()); } if (stmt instanceof UnknownEffectiveStatementImpl) { builder.addUnknownSchemaNode((UnknownEffectiveStatementImpl)stmt); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/InstanceIdentifierTypeEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/InstanceIdentifierTypeEffectiveStatementImpl.java index 0156fe9487..1f922e4dd4 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/InstanceIdentifierTypeEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/InstanceIdentifierTypeEffectiveStatementImpl.java @@ -10,6 +10,7 @@ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type; import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement; import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition; @@ -18,7 +19,6 @@ import org.opendaylight.yangtools.yang.model.util.type.RestrictedTypes; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DeclaredEffectiveStatementBase; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RequireInstanceEffectiveStatementImpl; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UnknownEffectiveStatementImpl; public final class InstanceIdentifierTypeEffectiveStatementImpl @@ -34,8 +34,8 @@ public final class InstanceIdentifierTypeEffectiveStatementImpl RestrictedTypes.newInstanceIdentifierBuilder(baseType, TypeUtils.typeEffectiveSchemaPath(ctx)); for (EffectiveStatement stmt : effectiveSubstatements()) { - if (stmt instanceof RequireInstanceEffectiveStatementImpl) { - builder.setRequireInstance(((RequireInstanceEffectiveStatementImpl)stmt).argument()); + if (stmt instanceof RequireInstanceEffectiveStatement) { + builder.setRequireInstance(((RequireInstanceEffectiveStatement)stmt).argument()); } if (stmt instanceof UnknownEffectiveStatementImpl) { builder.addUnknownSchemaNode((UnknownEffectiveStatementImpl)stmt); diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/LeafrefSpecificationEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/LeafrefSpecificationEffectiveStatementImpl.java index 8f84cfefec..6b9d520c43 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/LeafrefSpecificationEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/LeafrefSpecificationEffectiveStatementImpl.java @@ -9,6 +9,8 @@ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type; import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.PathEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement.LeafrefSpecification; import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition; @@ -16,8 +18,6 @@ import org.opendaylight.yangtools.yang.model.util.type.BaseTypes; import org.opendaylight.yangtools.yang.model.util.type.LeafrefTypeBuilder; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DeclaredEffectiveStatementBase; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.PathEffectiveStatementImpl; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RequireInstanceEffectiveStatementImpl; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UnknownEffectiveStatementImpl; public final class LeafrefSpecificationEffectiveStatementImpl @@ -32,10 +32,10 @@ public final class LeafrefSpecificationEffectiveStatementImpl final LeafrefTypeBuilder builder = BaseTypes.leafrefTypeBuilder(ctx.getSchemaPath().get()); for (final EffectiveStatement stmt : effectiveSubstatements()) { - if (stmt instanceof PathEffectiveStatementImpl) { - builder.setPathStatement(((PathEffectiveStatementImpl) stmt).argument()); - } else if (stmt instanceof RequireInstanceEffectiveStatementImpl) { - builder.setRequireInstance(((RequireInstanceEffectiveStatementImpl)stmt).argument()); + if (stmt instanceof PathEffectiveStatement) { + builder.setPathStatement(((PathEffectiveStatement) stmt).argument()); + } else if (stmt instanceof RequireInstanceEffectiveStatement) { + builder.setRequireInstance(((RequireInstanceEffectiveStatement)stmt).argument()); } else if (stmt instanceof UnknownEffectiveStatementImpl) { builder.addUnknownSchemaNode((UnknownEffectiveStatementImpl)stmt); } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/LeafrefTypeEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/LeafrefTypeEffectiveStatementImpl.java index 2d9f4eb04c..37f6076cd0 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/LeafrefTypeEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/LeafrefTypeEffectiveStatementImpl.java @@ -10,6 +10,7 @@ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type; import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement; import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition; @@ -18,7 +19,6 @@ import org.opendaylight.yangtools.yang.model.util.type.RestrictedTypes; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.TypeUtils; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.DeclaredEffectiveStatementBase; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.RequireInstanceEffectiveStatementImpl; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UnknownEffectiveStatementImpl; public final class LeafrefTypeEffectiveStatementImpl extends DeclaredEffectiveStatementBase @@ -35,8 +35,8 @@ public final class LeafrefTypeEffectiveStatementImpl extends DeclaredEffectiveSt RestrictedTypes.newLeafrefBuilder(baseType, TypeUtils.typeEffectiveSchemaPath(ctx)); for (final EffectiveStatement stmt : effectiveSubstatements()) { - if (stmt instanceof RequireInstanceEffectiveStatementImpl) { - builder.setRequireInstance(((RequireInstanceEffectiveStatementImpl) stmt).argument()); + if (stmt instanceof RequireInstanceEffectiveStatement) { + builder.setRequireInstance(((RequireInstanceEffectiveStatement) stmt).argument()); } else if (stmt instanceof UnknownEffectiveStatementImpl) { builder.addUnknownSchemaNode((UnknownEffectiveStatementImpl)stmt); } diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/StringTypeEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/StringTypeEffectiveStatementImpl.java index 9292ff7555..167f60a4f1 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/StringTypeEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/type/StringTypeEffectiveStatementImpl.java @@ -10,6 +10,7 @@ package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.type; import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.PatternEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.TypeStatement; import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; @@ -52,8 +53,8 @@ public final class StringTypeEffectiveStatementImpl extends DeclaredEffectiveSta length.argument()); } } - if (stmt instanceof PatternEffectiveStatementImpl) { - final PatternConstraint pattern = ((PatternEffectiveStatementImpl)stmt).argument(); + if (stmt instanceof PatternEffectiveStatement) { + final PatternConstraint pattern = ((PatternEffectiveStatement)stmt).argument(); if (pattern != null) { builder.addPatternConstraint(pattern); } else { diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc7950/effective/ActionEffectiveStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc7950/effective/ActionEffectiveStatementImpl.java index 1fe32f7913..196a0a0ba4 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc7950/effective/ActionEffectiveStatementImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc7950/effective/ActionEffectiveStatementImpl.java @@ -22,6 +22,7 @@ import org.opendaylight.yangtools.yang.model.api.TypeDefinition; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ActionEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement; import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory; import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @@ -29,7 +30,6 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.AbstractEff import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.EffectiveStmtUtils; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.InputEffectiveStatementImpl; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.OutputEffectiveStatementImpl; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.TypeDefEffectiveStatementImpl; public class ActionEffectiveStatementImpl extends AbstractEffectiveSchemaNode implements ActionDefinition, ActionEffectiveStatement { @@ -54,8 +54,8 @@ public class ActionEffectiveStatementImpl extends AbstractEffectiveSchemaNode type = typeDef.getTypeDefinition(); if (!mutableTypeDefinitions.contains(type)) { mutableTypeDefinitions.add(type); diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/stmt/rfc7950/Bug6874Test.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/stmt/rfc7950/Bug6874Test.java index 80967d484e..80113ae8f7 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/stmt/rfc7950/Bug6874Test.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/stmt/rfc7950/Bug6874Test.java @@ -19,13 +19,13 @@ import org.opendaylight.yangtools.yang.model.api.Module; import org.opendaylight.yangtools.yang.model.api.ModuleImport; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.IncludeStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement; import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException; import org.opendaylight.yangtools.yang.parser.spi.meta.SomeModifiersUnresolvedException; import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.DescriptionStatementImpl; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.IncludeStatementImpl; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ModuleStatementImpl; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.ReferenceStatementImpl; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline; import org.opendaylight.yangtools.yang.stmt.StmtTestUtils; @@ -87,10 +87,9 @@ public class Bug6874Test { YangInferencePipeline.RFC6020_REACTOR.newBuild() .addSources(ROOT_MODULE, CHILD_MODULE, CHILD_MODULE_1, IMPORTED_MODULE) .build().getRootStatements().forEach(declaredStmt -> { - if (declaredStmt instanceof ModuleStatementImpl) { + if (declaredStmt instanceof ModuleStatement) { declaredStmt.declaredSubstatements().forEach(subStmt -> { - if (subStmt instanceof IncludeStatementImpl - && subStmt.rawArgument().equals("child-module")) { + if (subStmt instanceof IncludeStatement && subStmt.rawArgument().equals("child-module")) { subStmt.declaredSubstatements().forEach(Bug6874Test::verifyDescAndRef); } }); @@ -100,12 +99,12 @@ public class Bug6874Test { @SuppressWarnings("rawtypes") private static void verifyDescAndRef(final DeclaredStatement stmt) { - if (stmt instanceof DescriptionStatementImpl) { + if (stmt instanceof DescriptionStatement) { assertEquals("Yang 1.1: Allow description and reference in include and import.", - ((DescriptionStatementImpl) stmt).argument()); + ((DescriptionStatement) stmt).argument()); } - if (stmt instanceof ReferenceStatementImpl) { - assertEquals("https://tools.ietf.org/html/rfc7950 section-7.1.5/6", ((ReferenceStatementImpl) stmt).argument()); + if (stmt instanceof ReferenceStatement) { + assertEquals("https://tools.ietf.org/html/rfc7950 section-7.1.5/6", ((ReferenceStatement) stmt).argument()); } } } diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/Bug3874ExtensionTest.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/Bug3874ExtensionTest.java index e6912b0b79..0984657990 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/Bug3874ExtensionTest.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/Bug3874ExtensionTest.java @@ -21,10 +21,10 @@ import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaNode; import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode; +import org.opendaylight.yangtools.yang.model.api.YangModeledAnyXmlSchemaNode; import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil; import org.opendaylight.yangtools.yang.parser.stmt.anyxmlschema.AnyxmlSchemaLocationEffectiveStatementImpl; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.SupportedExtensionsMapping; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.YangModeledAnyXmlEffectiveStatementImpl; public class Bug3874ExtensionTest { @@ -37,9 +37,8 @@ public class Bug3874ExtensionTest { QName myAnyXmlDataQName = QName.create(foo, "my-anyxml-data"); DataSchemaNode dataChildByName = context.getDataChildByName(myAnyXmlDataQName); - assertTrue(dataChildByName instanceof YangModeledAnyXmlEffectiveStatementImpl); - YangModeledAnyXmlEffectiveStatementImpl yangModeledAnyXml = - (YangModeledAnyXmlEffectiveStatementImpl) dataChildByName; + assertTrue(dataChildByName instanceof YangModeledAnyXmlSchemaNode); + YangModeledAnyXmlSchemaNode yangModeledAnyXml = (YangModeledAnyXmlSchemaNode) dataChildByName; SchemaNode myContainer2 = SchemaContextUtil.findDataSchemaNode(context, SchemaPath.create(true, myContainer2QName)); diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/Bug4610Test.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/Bug4610Test.java index 3ede8a5c8b..02b319a6ce 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/Bug4610Test.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/Bug4610Test.java @@ -18,9 +18,9 @@ import org.opendaylight.yangtools.yang.common.Revision; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaNode; import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.api.stmt.ContainerEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ContainerStatement; import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.ContainerEffectiveStatementImpl; public class Bug4610Test { @@ -40,10 +40,10 @@ public class Bug4610Test { QName g3 = QName.create(foo, "g3"); QName root = QName.create(foo, "root"); - ContainerEffectiveStatementImpl effectiveContainerStatementG1 = findContainer(context, g1, c1Bar); - ContainerEffectiveStatementImpl effectiveContainerStatementG2 = findContainer(context, g2, c1Bar); - ContainerEffectiveStatementImpl effectiveContainerStatementG3 = findContainer(context, g3, c1Foo); - ContainerEffectiveStatementImpl effectiveContainerStatementRoot = findContainer(context, root, c1Foo); + ContainerEffectiveStatement effectiveContainerStatementG1 = findContainer(context, g1, c1Bar); + ContainerEffectiveStatement effectiveContainerStatementG2 = findContainer(context, g2, c1Bar); + ContainerEffectiveStatement effectiveContainerStatementG3 = findContainer(context, g3, c1Foo); + ContainerEffectiveStatement effectiveContainerStatementRoot = findContainer(context, root, c1Foo); // check arguments QName originalStatementArgument = effectiveContainerStatementG1.argument(); @@ -63,10 +63,9 @@ public class Bug4610Test { } - private static ContainerEffectiveStatementImpl findContainer(final SchemaContext context, final QName... path) { + private static ContainerEffectiveStatement findContainer(final SchemaContext context, final QName... path) { SchemaNode node = SchemaContextUtil.findDataSchemaNode(context, SchemaPath.create(true, path)); - assertTrue(node instanceof ContainerEffectiveStatementImpl); - ContainerEffectiveStatementImpl container = (ContainerEffectiveStatementImpl) node; - return container; + assertTrue(node instanceof ContainerEffectiveStatement); + return (ContainerEffectiveStatement) node; } } diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/Bug6972Test.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/Bug6972Test.java index f7d0021db2..108fbdf62a 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/Bug6972Test.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/stmt/Bug6972Test.java @@ -21,7 +21,8 @@ import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; import org.opendaylight.yangtools.yang.model.api.Module; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; -import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.LeafEffectiveStatementImpl; +import org.opendaylight.yangtools.yang.model.api.stmt.LeafEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement; import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UnitsEffectiveStatementImpl; public class Bug6972Test { @@ -64,8 +65,8 @@ public class Bug6972Test { final LeafSchemaNode leaf = (LeafSchemaNode) cont.getDataChildByName(leafQName); assertNotNull(leaf); - for (EffectiveStatement effStmt : ((LeafEffectiveStatementImpl) leaf).effectiveSubstatements()) { - if (effStmt instanceof UnitsEffectiveStatementImpl) { + for (EffectiveStatement effStmt : ((LeafEffectiveStatement) leaf).effectiveSubstatements()) { + if (effStmt instanceof UnitsEffectiveStatement) { units = (UnitsEffectiveStatementImpl) effStmt; break; } diff --git a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/thirdparty/plugin/ThirdPartyExtensionPluginTest.java b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/thirdparty/plugin/ThirdPartyExtensionPluginTest.java index 25629d16b0..5f825b4f18 100644 --- a/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/thirdparty/plugin/ThirdPartyExtensionPluginTest.java +++ b/yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/thirdparty/plugin/ThirdPartyExtensionPluginTest.java @@ -43,10 +43,9 @@ public class ThirdPartyExtensionPluginTest { assertEquals(1, unknownSchemaNodes.size()); final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.get(0); - assertTrue(unknownSchemaNode instanceof ThirdPartyExtensionEffectiveStatementImpl); - - final ThirdPartyExtensionEffectiveStatementImpl thirdPartyExtensionStmt = - (ThirdPartyExtensionEffectiveStatementImpl) unknownSchemaNode; + assertTrue(unknownSchemaNode instanceof ThirdPartyExtensionEffectiveStatement); + final ThirdPartyExtensionEffectiveStatement thirdPartyExtensionStmt = + (ThirdPartyExtensionEffectiveStatement) unknownSchemaNode; assertEquals("Third-party namespace test.", thirdPartyExtensionStmt.getValueFromNamespace()); assertEquals("plugin test", thirdPartyExtensionStmt.argument()); } -- 2.36.6