From df63456107dfc68cde61ce4b57e408a017cf2131 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Sat, 13 Feb 2021 13:37:03 +0100 Subject: [PATCH] Move more simple statements This is big code movement, making most effective statement implementations available outside of yang-parser-rfc7950. JIRA: YANGTOOL-1241 Change-Id: Ica9f785552d78c9f89f10ef9172df7bf5d4f79db Signed-off-by: Robert Varga --- .../model/spi/stmt/DeclaredStatements.java | 32 +- .../model/spi/stmt/EffectiveStatements.java | 280 ++++++++++++++++++ .../decl/EmptyFractionDigitsStatement.java | 21 +- .../decl/EmptyRequireInstanceStatement.java | 6 +- .../stmt/impl/decl/EmptyStatusStatement.java | 7 +- .../impl/decl/EmptyYangVersionStatement.java | 8 +- .../impl/decl/EmptyYinElementStatement.java | 6 +- .../EmptyBelongsToEffectiveStatement.java | 6 +- .../EmptyErrorAppTagEffectiveStatement.java | 6 +- .../EmptyErrorMessageEffectiveStatement.java | 6 +- ...EmptyFractionDigitsEffectiveStatement.java | 6 +- .../EmptyIfFeatureEffectiveStatement.java | 6 +- .../eff}/EmptyIncludeEffectiveStatement.java | 6 +- .../EmptyMandatoryEffectiveStatement.java | 6 +- .../EmptyMaxElementsEffectiveStatement.java | 6 +- .../EmptyMinElementsEffectiveStatement.java | 6 +- .../EmptyNamespaceEffectiveStatement.java | 6 +- .../EmptyOrderedByEffectiveStatement.java | 6 +- .../EmptyOrganizationEffectiveStatement.java | 6 +- .../eff}/EmptyPathEffectiveStatement.java | 6 +- .../eff}/EmptyPositionEffectiveStatement.java | 6 +- .../EmptyReferenceEffectiveStatement.java | 6 +- ...mptyRequireInstanceEffectiveStatement.java | 26 ++ .../eff/EmptyStatusEffectiveStatement.java | 33 +++ .../eff}/EmptyValueEffectiveStatement.java | 6 +- .../EmptyYangVersionEffectiveStatement.java | 27 ++ .../EmptyYinElementEffectiveStatement.java | 6 +- .../RegularBelongsToEffectiveStatement.java | 6 +- .../RegularErrorAppTagEffectiveStatement.java | 6 +- ...RegularErrorMessageEffectiveStatement.java | 6 +- ...gularFractionDigitsEffectiveStatement.java | 6 +- .../RegularIfFeatureEffectiveStatement.java | 6 +- .../RegularIncludeEffectiveStatement.java | 6 +- .../RegularMandatoryEffectiveStatement.java | 6 +- .../RegularMaxElementsEffectiveStatement.java | 6 +- .../RegularMinElementsEffectiveStatement.java | 6 +- .../RegularNamespaceEffectiveStatement.java | 6 +- .../RegularOrderedByEffectiveStatement.java | 6 +- ...RegularOrganizationEffectiveStatement.java | 6 +- .../eff}/RegularPathEffectiveStatement.java | 6 +- .../RegularPositionEffectiveStatement.java | 6 +- .../RegularReferenceEffectiveStatement.java | 6 +- ...ularRequireInstanceEffectiveStatement.java | 6 +- .../eff}/RegularStatusEffectiveStatement.java | 6 +- .../eff}/RegularValueEffectiveStatement.java | 6 +- .../RegularYangVersionEffectiveStatement.java | 6 +- .../RegularYinElementEffectiveStatement.java | 6 +- .../stmt/EffectiveStatementMixins.java | 2 +- .../belongs_to/BelongsToStatementSupport.java | 4 +- .../ErrorAppTagStatementSupport.java | 4 +- .../ErrorMessageStatementSupport.java | 4 +- .../FractionDigitsStatementSupport.java | 29 +- .../AbstractIfFeatureStatementSupport.java | 4 +- .../stmt/include/IncludeStatementSupport.java | 4 +- .../mandatory/MandatoryStatementSupport.java | 9 +- .../MaxElementsStatementSupport.java | 4 +- .../MinElementsStatementSupport.java | 5 +- .../namespace/NamespaceStatementSupport.java | 4 +- .../ordered_by/OrderedByStatementSupport.java | 14 +- .../OrganizationStatementSupport.java | 5 +- .../stmt/path/PathStatementSupport.java | 4 +- .../position/PositionStatementSupport.java | 5 +- .../reference/ReferenceStatementSupport.java | 5 +- ...mptyRequireInstanceEffectiveStatement.java | 19 -- .../RequireInstanceStatementSupport.java | 10 +- .../status/EmptyStatusEffectiveStatement.java | 20 -- .../stmt/status/StatusStatementSupport.java | 55 +--- .../stmt/value/ValueStatementSupport.java | 5 +- .../EmptyYangVersionEffectiveStatement.java | 20 -- .../YangVersionStatementSupport.java | 39 +-- .../YinElementStatementSupport.java | 9 +- 71 files changed, 619 insertions(+), 332 deletions(-) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/EmptyBelongsToEffectiveStatement.java (72%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/EmptyErrorAppTagEffectiveStatement.java (71%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/EmptyErrorMessageEffectiveStatement.java (71%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/fraction_digits => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/EmptyFractionDigitsEffectiveStatement.java (71%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/if_feature => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/EmptyIfFeatureEffectiveStatement.java (73%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/include => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/EmptyIncludeEffectiveStatement.java (72%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/mandatory => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/EmptyMandatoryEffectiveStatement.java (72%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/max_elements => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/EmptyMaxElementsEffectiveStatement.java (71%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/min_elements => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/EmptyMinElementsEffectiveStatement.java (71%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/namespace => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/EmptyNamespaceEffectiveStatement.java (73%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/EmptyOrderedByEffectiveStatement.java (73%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/organization => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/EmptyOrganizationEffectiveStatement.java (71%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/path => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/EmptyPathEffectiveStatement.java (74%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/position => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/EmptyPositionEffectiveStatement.java (74%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/EmptyReferenceEffectiveStatement.java (72%) create mode 100644 yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyRequireInstanceEffectiveStatement.java create mode 100644 yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyStatusEffectiveStatement.java rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/value => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/EmptyValueEffectiveStatement.java (73%) create mode 100644 yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyYangVersionEffectiveStatement.java rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yin_element => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/EmptyYinElementEffectiveStatement.java (72%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularBelongsToEffectiveStatement.java (77%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularErrorAppTagEffectiveStatement.java (77%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularErrorMessageEffectiveStatement.java (77%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/fraction_digits => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularFractionDigitsEffectiveStatement.java (76%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/if_feature => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularIfFeatureEffectiveStatement.java (78%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/include => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularIncludeEffectiveStatement.java (78%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/mandatory => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularMandatoryEffectiveStatement.java (77%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/max_elements => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularMaxElementsEffectiveStatement.java (77%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/min_elements => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularMinElementsEffectiveStatement.java (77%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/namespace => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularNamespaceEffectiveStatement.java (78%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularOrderedByEffectiveStatement.java (78%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/organization => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularOrganizationEffectiveStatement.java (77%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/path => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularPathEffectiveStatement.java (79%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/position => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularPositionEffectiveStatement.java (79%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularReferenceEffectiveStatement.java (77%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/require_instance => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularRequireInstanceEffectiveStatement.java (76%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/status => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularStatusEffectiveStatement.java (79%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/value => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularValueEffectiveStatement.java (78%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yang_version => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularYangVersionEffectiveStatement.java (78%) rename yang/{yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yin_element => yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff}/RegularYinElementEffectiveStatement.java (77%) delete mode 100644 yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/require_instance/EmptyRequireInstanceEffectiveStatement.java delete mode 100644 yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/status/EmptyStatusEffectiveStatement.java delete mode 100644 yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yang_version/EmptyYangVersionEffectiveStatement.java diff --git a/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/DeclaredStatements.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/DeclaredStatements.java index c8c125b45a..e2ecc308ab 100644 --- a/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/DeclaredStatements.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/DeclaredStatements.java @@ -438,8 +438,8 @@ public final class DeclaredStatements { return substatements.isEmpty() ? createFeature(argument) : new RegularFeatureStatement(argument, substatements); } - public static FractionDigitsStatement createFractionDigits(final Integer argument) { - return new EmptyFractionDigitsStatement(argument); + public static FractionDigitsStatement createFractionDigits(final int argument) { + return EmptyFractionDigitsStatement.of(argument); } public static FractionDigitsStatement createFractionDigits(final Integer argument, @@ -736,8 +736,8 @@ public final class DeclaredStatements { return new RefineStatementImpl(rawArgument, argument, substatements); } - public static RequireInstanceStatement createRequireInstance(final Boolean argument) { - return new EmptyRequireInstanceStatement(argument); + public static RequireInstanceStatement createRequireInstance(final boolean argument) { + return argument ? EmptyRequireInstanceStatement.TRUE : EmptyRequireInstanceStatement.FALSE; } public static RequireInstanceStatement createRequireInstance(final Boolean argument, @@ -776,7 +776,16 @@ public final class DeclaredStatements { } public static StatusStatement createStatus(final Status argument) { - return new EmptyStatusStatement(argument); + switch (argument) { + case CURRENT: + return EmptyStatusStatement.CURRENT; + case DEPRECATED: + return EmptyStatusStatement.DEPRECATED; + case OBSOLETE: + return EmptyStatusStatement.OBSOLETE; + default: + throw new IllegalStateException("Unhandled argument " + argument); + } } public static StatusStatement createStatus(final Status argument, @@ -856,7 +865,14 @@ public final class DeclaredStatements { } public static YangVersionStatement createYangVersion(final YangVersion argument) { - return new EmptyYangVersionStatement(argument); + switch (argument) { + case VERSION_1: + return EmptyYangVersionStatement.VERSION_1; + case VERSION_1_1: + return EmptyYangVersionStatement.VERSION_1_1; + default: + throw new IllegalStateException("Unhandled version " + argument); + } } public static YangVersionStatement createYangVersion(final YangVersion argument, @@ -865,8 +881,8 @@ public final class DeclaredStatements { : new RegularYangVersionStatement(argument, substatements); } - public static YinElementStatement createYinElement(final Boolean argument) { - return new EmptyYinElementStatement(argument); + public static YinElementStatement createYinElement(final boolean argument) { + return argument ? EmptyYinElementStatement.TRUE : EmptyYinElementStatement.FALSE; } public static YinElementStatement createYinElement(final Boolean argument, diff --git a/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/EffectiveStatements.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/EffectiveStatements.java index cefa5ecbf3..59d3b1891d 100644 --- a/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/EffectiveStatements.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/EffectiveStatements.java @@ -15,34 +15,117 @@ import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentEffectiveStatement import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentStatement; import org.opendaylight.yangtools.yang.model.api.stmt.BaseEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.BaseStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement; import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.IncludeEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.IncludeStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ModifierEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ModifierStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.PathEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.PathStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.PositionEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.PositionStatement; import org.opendaylight.yangtools.yang.model.api.stmt.PresenceEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.PresenceStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement; import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement; import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ValueEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.ValueStatement; import org.opendaylight.yangtools.yang.model.api.stmt.WhenEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.YinElementEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.decl.EmptyRequireInstanceStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.decl.EmptyStatusStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.decl.EmptyYangVersionStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyArgumentEffectiveStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyBaseEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyBelongsToEffectiveStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyDescriptionEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyErrorAppTagEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyErrorMessageEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyFractionDigitsEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyIfFeatureEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyIncludeEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyMandatoryEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyMaxElementsEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyMinElementsEffectiveStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyModifierEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyNamespaceEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyOrderedByEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyOrganizationEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyPathEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyPositionEffectiveStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyPresenceEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyReferenceEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyRequireInstanceEffectiveStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyRevisionDateEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyStatusEffectiveStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyUnitsEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyValueEffectiveStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyWhenEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyYangVersionEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.EmptyYinElementEffectiveStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularArgumentEffectiveStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularBaseEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularBelongsToEffectiveStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularDescriptionEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularErrorAppTagEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularErrorMessageEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularFractionDigitsEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularIfFeatureEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularIncludeEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularMandatoryEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularMaxElementsEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularMinElementsEffectiveStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularModifierEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularNamespaceEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularOrderedByEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularOrganizationEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularPathEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularPositionEffectiveStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularPresenceEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularReferenceEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularRequireInstanceEffectiveStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularRevisionDateEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularStatusEffectiveStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularUnitsEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularValueEffectiveStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularWhenEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularYangVersionEffectiveStatement; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff.RegularYinElementEffectiveStatement; /** * Static entry point to instantiating {@link EffectiveStatement} covered in the {@code RFC7950} metamodel. @@ -66,39 +149,236 @@ public final class EffectiveStatements { : new RegularBaseEffectiveStatement(declared, substatements); } + public static BelongsToEffectiveStatement createBelongsTo(final BelongsToStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? new EmptyBelongsToEffectiveStatement(declared) + : new RegularBelongsToEffectiveStatement(declared, substatements); + } + public static DescriptionEffectiveStatement createDescription(final DescriptionStatement declared, final ImmutableList> substatements) { return substatements.isEmpty() ? new EmptyDescriptionEffectiveStatement(declared) : new RegularDescriptionEffectiveStatement(declared, substatements); } + public static ErrorAppTagEffectiveStatement createErrorAppTag(final ErrorAppTagStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? new EmptyErrorAppTagEffectiveStatement(declared) + : new RegularErrorAppTagEffectiveStatement(declared, substatements); + } + + public static ErrorMessageEffectiveStatement createErrorMessage(final ErrorMessageStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? new EmptyErrorMessageEffectiveStatement(declared) + : new RegularErrorMessageEffectiveStatement(declared, substatements); + } + + public static FractionDigitsEffectiveStatement createFractionDigits(final FractionDigitsStatement declared) { + return new EmptyFractionDigitsEffectiveStatement(declared); + } + + public static FractionDigitsEffectiveStatement createFractionDigits(final FractionDigitsStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? createFractionDigits(declared) + : new RegularFractionDigitsEffectiveStatement(declared, substatements); + } + + public static IfFeatureEffectiveStatement createIfFeature(final IfFeatureStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? new EmptyIfFeatureEffectiveStatement(declared) + : new RegularIfFeatureEffectiveStatement(declared, substatements); + } + + public static IncludeEffectiveStatement createInclude(final IncludeStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? new EmptyIncludeEffectiveStatement(declared) + : new RegularIncludeEffectiveStatement(declared, substatements); + } + + public static MandatoryEffectiveStatement createMandatory(final MandatoryStatement declared) { + return new EmptyMandatoryEffectiveStatement(declared); + } + + public static MandatoryEffectiveStatement createMandatory(final MandatoryStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? createMandatory(declared) + : new RegularMandatoryEffectiveStatement(declared, substatements); + } + + public static MaxElementsEffectiveStatement createMaxElements(final MaxElementsStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? new EmptyMaxElementsEffectiveStatement(declared) + : new RegularMaxElementsEffectiveStatement(declared, substatements); + } + + public static MinElementsEffectiveStatement createMinElements(final MinElementsStatement declared) { + return new EmptyMinElementsEffectiveStatement(declared); + } + + public static MinElementsEffectiveStatement createMinElements(final MinElementsStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? createMinElements(declared) + : new RegularMinElementsEffectiveStatement(declared, substatements); + } + public static ModifierEffectiveStatement createModifier(final ModifierStatement declared, final ImmutableList> substatements) { return substatements.isEmpty() ? new EmptyModifierEffectiveStatement(declared) : new RegularModifierEffectiveStatement(declared, substatements); } + public static NamespaceEffectiveStatement createNamespace(final NamespaceStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? new EmptyNamespaceEffectiveStatement(declared) + : new RegularNamespaceEffectiveStatement(declared, substatements); + } + + public static OrderedByEffectiveStatement createOrderedBy(final OrderedByStatement declared) { + return new EmptyOrderedByEffectiveStatement(declared); + } + + public static OrderedByEffectiveStatement createOrderedBy(final OrderedByStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? createOrderedBy(declared) + : new RegularOrderedByEffectiveStatement(declared, substatements); + } + + public static OrganizationEffectiveStatement createOrganization(final OrganizationStatement declared) { + return new EmptyOrganizationEffectiveStatement(declared); + } + + public static OrganizationEffectiveStatement createOrganization(final OrganizationStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? createOrganization(declared) + : new RegularOrganizationEffectiveStatement(declared, substatements); + } + + public static PathEffectiveStatement createPath(final PathStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? new EmptyPathEffectiveStatement(declared) + : new RegularPathEffectiveStatement(declared, substatements); + } + + public static PositionEffectiveStatement createPosition(final PositionStatement declared) { + return new EmptyPositionEffectiveStatement(declared); + } + + public static PositionEffectiveStatement createPosition(final PositionStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? createPosition(declared) + : new RegularPositionEffectiveStatement(declared, substatements); + } + + public static ReferenceEffectiveStatement createReference(final ReferenceStatement declared) { + return new EmptyReferenceEffectiveStatement(declared); + } + + public static ReferenceEffectiveStatement createReference(final ReferenceStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? createReference(declared) + : new RegularReferenceEffectiveStatement(declared, substatements); + } + public static PresenceEffectiveStatement createPresence(final PresenceStatement declared, final ImmutableList> substatements) { return substatements.isEmpty() ? new EmptyPresenceEffectiveStatement(declared) : new RegularPresenceEffectiveStatement(declared, substatements); } + public static RequireInstanceEffectiveStatement createRequireInstance(final boolean argument) { + return argument ? EmptyRequireInstanceEffectiveStatement.TRUE : EmptyRequireInstanceEffectiveStatement.FALSE; + } + + public static RequireInstanceEffectiveStatement createRequireInstance(final RequireInstanceStatement declared) { + if (EmptyRequireInstanceStatement.TRUE.equals(declared)) { + return EmptyRequireInstanceEffectiveStatement.TRUE; + } else if (EmptyRequireInstanceStatement.FALSE.equals(declared)) { + return EmptyRequireInstanceEffectiveStatement.FALSE; + } else { + return new EmptyRequireInstanceEffectiveStatement(declared); + } + } + + public static RequireInstanceEffectiveStatement createRequireInstance(final RequireInstanceStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? createRequireInstance(declared) + : new RegularRequireInstanceEffectiveStatement(declared, substatements); + } + public static RevisionDateEffectiveStatement createRevisionDate(final RevisionDateStatement declared, final ImmutableList> substatements) { return substatements.isEmpty() ? new EmptyRevisionDateEffectiveStatement(declared) : new RegularRevisionDateEffectiveStatement(declared, substatements); } + public static StatusEffectiveStatement createStatus(final StatusStatement declared) { + // Aggressively reuse effective instances which are backed by the corresponding empty declared instance, as this + // is the case unless there is a weird extension in use. + if (EmptyStatusStatement.DEPRECATED.equals(declared)) { + // Most likely to be seen (as current is the default) + return EmptyStatusEffectiveStatement.DEPRECATED; + } else if (EmptyStatusStatement.OBSOLETE.equals(declared)) { + // less likely + return EmptyStatusEffectiveStatement.OBSOLETE; + } else if (EmptyStatusStatement.CURRENT.equals(declared)) { + // ... okay, why is this there? :) + return EmptyStatusEffectiveStatement.CURRENT; + } else { + return new EmptyStatusEffectiveStatement(declared); + } + } + + public static StatusEffectiveStatement createStatus(final StatusStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? createStatus(declared) + : new RegularStatusEffectiveStatement(declared, substatements); + } + public static UnitsEffectiveStatement createUnits(final UnitsStatement declared, final ImmutableList> substatements) { return substatements.isEmpty() ? new EmptyUnitsEffectiveStatement(declared) : new RegularUnitsEffectiveStatement(declared, substatements); } + public static ValueEffectiveStatement createValue(final ValueStatement declared) { + return new EmptyValueEffectiveStatement(declared); + } + + public static ValueEffectiveStatement createValue(final ValueStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? createValue(declared) + : new RegularValueEffectiveStatement(declared, substatements); + } + public static WhenEffectiveStatement createWhen(final WhenStatement declared, final ImmutableList> substatements) { return substatements.isEmpty() ? new EmptyWhenEffectiveStatement(declared) : new RegularWhenEffectiveStatement(declared, substatements); } + + public static YangVersionEffectiveStatement createYangVersion(final YangVersionStatement declared) { + if (EmptyYangVersionStatement.VERSION_1.equals(declared)) { + return EmptyYangVersionEffectiveStatement.VERSION_1; + } else if (EmptyYangVersionStatement.VERSION_1_1.equals(declared)) { + return EmptyYangVersionEffectiveStatement.VERSION_1_1; + } else { + return new EmptyYangVersionEffectiveStatement(declared); + } + } + + public static YangVersionEffectiveStatement createYangVersion(final YangVersionStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? createYangVersion(declared) + : new RegularYangVersionEffectiveStatement(declared, substatements); + } + + public static YinElementEffectiveStatement createYinElement(final YinElementStatement declared) { + return new EmptyYinElementEffectiveStatement(declared); + } + + public static YinElementEffectiveStatement createYinElement(final YinElementStatement declared, + final ImmutableList> substatements) { + return substatements.isEmpty() ? createYinElement(declared) + : new RegularYinElementEffectiveStatement(declared, substatements); + } } diff --git a/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyFractionDigitsStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyFractionDigitsStatement.java index f693f7ca1f..b283a88e27 100644 --- a/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyFractionDigitsStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyFractionDigitsStatement.java @@ -7,11 +7,30 @@ */ package org.opendaylight.yangtools.yang.model.spi.stmt.impl.decl; +import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.ArgumentToString; public final class EmptyFractionDigitsStatement extends ArgumentToString implements FractionDigitsStatement { - public EmptyFractionDigitsStatement(final Integer argument) { + private static final @NonNull EmptyFractionDigitsStatement[] INSTANCES; + + static { + final EmptyFractionDigitsStatement[] inst = new EmptyFractionDigitsStatement[18]; + for (int i = 0; i < 18; ++i) { + inst[i] = new EmptyFractionDigitsStatement(i + 1); + } + INSTANCES = inst; + } + + private EmptyFractionDigitsStatement(final int argument) { super(argument); } + + public static @NonNull EmptyFractionDigitsStatement of(final int argument) { + try { + return INSTANCES[argument - 1]; + } catch (IndexOutOfBoundsException e) { + throw new IllegalArgumentException("Invalid fraction-digits argument " + argument, e); + } + } } diff --git a/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyRequireInstanceStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyRequireInstanceStatement.java index bd50ca72ba..97b6814ab2 100644 --- a/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyRequireInstanceStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyRequireInstanceStatement.java @@ -7,11 +7,15 @@ */ package org.opendaylight.yangtools.yang.model.spi.stmt.impl.decl; +import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.ArgumentToString; public final class EmptyRequireInstanceStatement extends ArgumentToString implements RequireInstanceStatement { - public EmptyRequireInstanceStatement(final Boolean argument) { + public static final @NonNull EmptyRequireInstanceStatement FALSE = new EmptyRequireInstanceStatement(false); + public static final @NonNull EmptyRequireInstanceStatement TRUE = new EmptyRequireInstanceStatement(true); + + private EmptyRequireInstanceStatement(final boolean argument) { super(argument); } } diff --git a/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyStatusStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyStatusStatement.java index f59e9159a4..9e7de9029f 100644 --- a/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyStatusStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyStatusStatement.java @@ -7,10 +7,15 @@ */ package org.opendaylight.yangtools.yang.model.spi.stmt.impl.decl; +import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.yangtools.yang.model.api.Status; public final class EmptyStatusStatement extends AbstractStatusStatement { - public EmptyStatusStatement(final Status argument) { + public static final @NonNull EmptyStatusStatement CURRENT = new EmptyStatusStatement(Status.CURRENT); + public static final @NonNull EmptyStatusStatement DEPRECATED = new EmptyStatusStatement(Status.DEPRECATED); + public static final @NonNull EmptyStatusStatement OBSOLETE = new EmptyStatusStatement(Status.OBSOLETE); + + private EmptyStatusStatement(final Status argument) { super(argument); } } diff --git a/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyYangVersionStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyYangVersionStatement.java index 37bf0d3ef8..55bb48470e 100644 --- a/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyYangVersionStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyYangVersionStatement.java @@ -7,12 +7,18 @@ */ package org.opendaylight.yangtools.yang.model.spi.stmt.impl.decl; +import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.yangtools.yang.common.YangVersion; import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.ArgumentToString; public final class EmptyYangVersionStatement extends ArgumentToString implements YangVersionStatement { - public EmptyYangVersionStatement(final YangVersion argument) { + public static final @NonNull EmptyYangVersionStatement VERSION_1 = + new EmptyYangVersionStatement(YangVersion.VERSION_1); + public static final @NonNull EmptyYangVersionStatement VERSION_1_1 = + new EmptyYangVersionStatement(YangVersion.VERSION_1_1); + + private EmptyYangVersionStatement(final @NonNull YangVersion argument) { super(argument); } } diff --git a/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyYinElementStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyYinElementStatement.java index 30c33b7666..9607437054 100644 --- a/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyYinElementStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/decl/EmptyYinElementStatement.java @@ -7,11 +7,15 @@ */ package org.opendaylight.yangtools.yang.model.spi.stmt.impl.decl; +import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.ArgumentToString; public final class EmptyYinElementStatement extends ArgumentToString implements YinElementStatement { - public EmptyYinElementStatement(final Boolean argument) { + public static final @NonNull EmptyYinElementStatement FALSE = new EmptyYinElementStatement(false); + public static final @NonNull EmptyYinElementStatement TRUE = new EmptyYinElementStatement(true); + + private EmptyYinElementStatement(final boolean argument) { super(argument); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/EmptyBelongsToEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyBelongsToEffectiveStatement.java similarity index 72% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/EmptyBelongsToEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyBelongsToEffectiveStatement.java index b365270cab..1b2886e51a 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/EmptyBelongsToEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyBelongsToEffectiveStatement.java @@ -5,15 +5,15 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.belongs_to; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; -final class EmptyBelongsToEffectiveStatement extends DefaultArgument +public final class EmptyBelongsToEffectiveStatement extends DefaultArgument implements BelongsToEffectiveStatement { - EmptyBelongsToEffectiveStatement(final BelongsToStatement declared) { + public EmptyBelongsToEffectiveStatement(final BelongsToStatement declared) { super(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/EmptyErrorAppTagEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyErrorAppTagEffectiveStatement.java similarity index 71% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/EmptyErrorAppTagEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyErrorAppTagEffectiveStatement.java index 920d65a4be..c811eefc4c 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/EmptyErrorAppTagEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyErrorAppTagEffectiveStatement.java @@ -5,15 +5,15 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_app_tag; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; -final class EmptyErrorAppTagEffectiveStatement extends DefaultArgument +public final class EmptyErrorAppTagEffectiveStatement extends DefaultArgument implements ErrorAppTagEffectiveStatement { - EmptyErrorAppTagEffectiveStatement(final ErrorAppTagStatement declared) { + public EmptyErrorAppTagEffectiveStatement(final ErrorAppTagStatement declared) { super(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/EmptyErrorMessageEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyErrorMessageEffectiveStatement.java similarity index 71% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/EmptyErrorMessageEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyErrorMessageEffectiveStatement.java index e192a80f09..9f531ab3b9 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/EmptyErrorMessageEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyErrorMessageEffectiveStatement.java @@ -5,15 +5,15 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_message; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; -final class EmptyErrorMessageEffectiveStatement extends DefaultArgument +public final class EmptyErrorMessageEffectiveStatement extends DefaultArgument implements ErrorMessageEffectiveStatement { - EmptyErrorMessageEffectiveStatement(final ErrorMessageStatement declared) { + public EmptyErrorMessageEffectiveStatement(final ErrorMessageStatement declared) { super(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/fraction_digits/EmptyFractionDigitsEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyFractionDigitsEffectiveStatement.java similarity index 71% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/fraction_digits/EmptyFractionDigitsEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyFractionDigitsEffectiveStatement.java index f854e6bf8c..c1c1c4311a 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/fraction_digits/EmptyFractionDigitsEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyFractionDigitsEffectiveStatement.java @@ -5,15 +5,15 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.fraction_digits; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; -final class EmptyFractionDigitsEffectiveStatement extends DefaultArgument +public final class EmptyFractionDigitsEffectiveStatement extends DefaultArgument implements FractionDigitsEffectiveStatement { - EmptyFractionDigitsEffectiveStatement(final FractionDigitsStatement declared) { + public EmptyFractionDigitsEffectiveStatement(final FractionDigitsStatement declared) { super(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/if_feature/EmptyIfFeatureEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyIfFeatureEffectiveStatement.java similarity index 73% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/if_feature/EmptyIfFeatureEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyIfFeatureEffectiveStatement.java index 94cdf4dabf..ae93545d6e 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/if_feature/EmptyIfFeatureEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyIfFeatureEffectiveStatement.java @@ -5,16 +5,16 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.if_feature; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureExpr; import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; -final class EmptyIfFeatureEffectiveStatement extends DefaultArgument +public final class EmptyIfFeatureEffectiveStatement extends DefaultArgument implements IfFeatureEffectiveStatement { - EmptyIfFeatureEffectiveStatement(final IfFeatureStatement declared) { + public EmptyIfFeatureEffectiveStatement(final IfFeatureStatement declared) { super(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/include/EmptyIncludeEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyIncludeEffectiveStatement.java similarity index 72% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/include/EmptyIncludeEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyIncludeEffectiveStatement.java index 77672de03d..d188c44a74 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/include/EmptyIncludeEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyIncludeEffectiveStatement.java @@ -5,15 +5,15 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.include; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import org.opendaylight.yangtools.yang.model.api.stmt.IncludeEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.IncludeStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; -final class EmptyIncludeEffectiveStatement extends DefaultArgument +public final class EmptyIncludeEffectiveStatement extends DefaultArgument implements IncludeEffectiveStatement { - EmptyIncludeEffectiveStatement(final IncludeStatement declared) { + public EmptyIncludeEffectiveStatement(final IncludeStatement declared) { super(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/mandatory/EmptyMandatoryEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyMandatoryEffectiveStatement.java similarity index 72% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/mandatory/EmptyMandatoryEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyMandatoryEffectiveStatement.java index 4a4d56a3f1..8b4712f9d9 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/mandatory/EmptyMandatoryEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyMandatoryEffectiveStatement.java @@ -5,15 +5,15 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.mandatory; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; -final class EmptyMandatoryEffectiveStatement extends DefaultArgument +public final class EmptyMandatoryEffectiveStatement extends DefaultArgument implements MandatoryEffectiveStatement { - EmptyMandatoryEffectiveStatement(final MandatoryStatement declared) { + public EmptyMandatoryEffectiveStatement(final MandatoryStatement declared) { super(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/max_elements/EmptyMaxElementsEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyMaxElementsEffectiveStatement.java similarity index 71% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/max_elements/EmptyMaxElementsEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyMaxElementsEffectiveStatement.java index 4f7e0c6fb8..77ba843040 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/max_elements/EmptyMaxElementsEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyMaxElementsEffectiveStatement.java @@ -5,15 +5,15 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.max_elements; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; -final class EmptyMaxElementsEffectiveStatement extends DefaultArgument +public final class EmptyMaxElementsEffectiveStatement extends DefaultArgument implements MaxElementsEffectiveStatement { - EmptyMaxElementsEffectiveStatement(final MaxElementsStatement declared) { + public EmptyMaxElementsEffectiveStatement(final MaxElementsStatement declared) { super(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/min_elements/EmptyMinElementsEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyMinElementsEffectiveStatement.java similarity index 71% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/min_elements/EmptyMinElementsEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyMinElementsEffectiveStatement.java index bed7a7543f..601a4597e3 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/min_elements/EmptyMinElementsEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyMinElementsEffectiveStatement.java @@ -5,15 +5,15 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.min_elements; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; -final class EmptyMinElementsEffectiveStatement extends DefaultArgument +public final class EmptyMinElementsEffectiveStatement extends DefaultArgument implements MinElementsEffectiveStatement { - EmptyMinElementsEffectiveStatement(final MinElementsStatement declared) { + public EmptyMinElementsEffectiveStatement(final MinElementsStatement declared) { super(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/namespace/EmptyNamespaceEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyNamespaceEffectiveStatement.java similarity index 73% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/namespace/EmptyNamespaceEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyNamespaceEffectiveStatement.java index 2da41242e1..cbac674046 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/namespace/EmptyNamespaceEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyNamespaceEffectiveStatement.java @@ -5,16 +5,16 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.namespace; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import org.opendaylight.yangtools.yang.common.XMLNamespace; import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; -final class EmptyNamespaceEffectiveStatement extends DefaultArgument +public final class EmptyNamespaceEffectiveStatement extends DefaultArgument implements NamespaceEffectiveStatement { - EmptyNamespaceEffectiveStatement(final NamespaceStatement declared) { + public EmptyNamespaceEffectiveStatement(final NamespaceStatement declared) { super(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/EmptyOrderedByEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyOrderedByEffectiveStatement.java similarity index 73% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/EmptyOrderedByEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyOrderedByEffectiveStatement.java index e71e9def90..13fbc9cdf5 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/EmptyOrderedByEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyOrderedByEffectiveStatement.java @@ -5,16 +5,16 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ordered_by; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import org.opendaylight.yangtools.yang.common.Ordering; import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; -final class EmptyOrderedByEffectiveStatement extends DefaultArgument +public final class EmptyOrderedByEffectiveStatement extends DefaultArgument implements OrderedByEffectiveStatement { - EmptyOrderedByEffectiveStatement(final OrderedByStatement declared) { + public EmptyOrderedByEffectiveStatement(final OrderedByStatement declared) { super(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/organization/EmptyOrganizationEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyOrganizationEffectiveStatement.java similarity index 71% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/organization/EmptyOrganizationEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyOrganizationEffectiveStatement.java index 023c11ccce..7789b7a8e3 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/organization/EmptyOrganizationEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyOrganizationEffectiveStatement.java @@ -5,15 +5,15 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.organization; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; -final class EmptyOrganizationEffectiveStatement extends DefaultArgument +public final class EmptyOrganizationEffectiveStatement extends DefaultArgument implements OrganizationEffectiveStatement { - EmptyOrganizationEffectiveStatement(final OrganizationStatement declared) { + public EmptyOrganizationEffectiveStatement(final OrganizationStatement declared) { super(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/path/EmptyPathEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyPathEffectiveStatement.java similarity index 74% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/path/EmptyPathEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyPathEffectiveStatement.java index 6e4d564683..faf3a05e9f 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/path/EmptyPathEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyPathEffectiveStatement.java @@ -5,16 +5,16 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.path; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import org.opendaylight.yangtools.yang.model.api.PathExpression; import org.opendaylight.yangtools.yang.model.api.stmt.PathEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.PathStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; -final class EmptyPathEffectiveStatement extends DefaultArgument +public final class EmptyPathEffectiveStatement extends DefaultArgument implements PathEffectiveStatement { - EmptyPathEffectiveStatement(final PathStatement declared) { + public EmptyPathEffectiveStatement(final PathStatement declared) { super(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/position/EmptyPositionEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyPositionEffectiveStatement.java similarity index 74% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/position/EmptyPositionEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyPositionEffectiveStatement.java index c99e192a56..8f1e6ff4f3 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/position/EmptyPositionEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyPositionEffectiveStatement.java @@ -5,16 +5,16 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.position; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import org.opendaylight.yangtools.yang.common.Uint32; import org.opendaylight.yangtools.yang.model.api.stmt.PositionEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.PositionStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; -final class EmptyPositionEffectiveStatement extends DefaultArgument +public final class EmptyPositionEffectiveStatement extends DefaultArgument implements PositionEffectiveStatement { - EmptyPositionEffectiveStatement(final PositionStatement declared) { + public EmptyPositionEffectiveStatement(final PositionStatement declared) { super(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/EmptyReferenceEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyReferenceEffectiveStatement.java similarity index 72% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/EmptyReferenceEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyReferenceEffectiveStatement.java index 497a94910a..c89b1c2a01 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/EmptyReferenceEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyReferenceEffectiveStatement.java @@ -5,15 +5,15 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.reference; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; -final class EmptyReferenceEffectiveStatement extends DefaultArgument +public final class EmptyReferenceEffectiveStatement extends DefaultArgument implements ReferenceEffectiveStatement { - EmptyReferenceEffectiveStatement(final ReferenceStatement declared) { + public EmptyReferenceEffectiveStatement(final ReferenceStatement declared) { super(declared); } } diff --git a/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyRequireInstanceEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyRequireInstanceEffectiveStatement.java new file mode 100644 index 0000000000..b0c7851197 --- /dev/null +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyRequireInstanceEffectiveStatement.java @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; + +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.decl.EmptyRequireInstanceStatement; + +public final class EmptyRequireInstanceEffectiveStatement extends DefaultArgument + implements RequireInstanceEffectiveStatement { + public static final @NonNull EmptyRequireInstanceEffectiveStatement FALSE = + new EmptyRequireInstanceEffectiveStatement(EmptyRequireInstanceStatement.FALSE); + public static final @NonNull EmptyRequireInstanceEffectiveStatement TRUE = + new EmptyRequireInstanceEffectiveStatement(EmptyRequireInstanceStatement.TRUE); + + public EmptyRequireInstanceEffectiveStatement(final RequireInstanceStatement declared) { + super(declared); + } +} diff --git a/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyStatusEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyStatusEffectiveStatement.java new file mode 100644 index 0000000000..eb904ecccb --- /dev/null +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyStatusEffectiveStatement.java @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; + +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.Status; +import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.decl.EmptyStatusStatement; + +public final class EmptyStatusEffectiveStatement extends DefaultArgument + implements StatusEffectiveStatement { + /* + * status has low argument cardinality, hence we can reuse them in case declaration does not have any + * substatements (which is the usual case). Yeah, we could consider an EnumMap, but this is not too bad, either. + */ + public static final @NonNull EmptyStatusEffectiveStatement CURRENT = + new EmptyStatusEffectiveStatement(EmptyStatusStatement.CURRENT); + public static final @NonNull EmptyStatusEffectiveStatement DEPRECATED = + new EmptyStatusEffectiveStatement(EmptyStatusStatement.DEPRECATED); + public static final @NonNull EmptyStatusEffectiveStatement OBSOLETE = + new EmptyStatusEffectiveStatement(EmptyStatusStatement.OBSOLETE); + + public EmptyStatusEffectiveStatement(final StatusStatement declared) { + super(declared); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/value/EmptyValueEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyValueEffectiveStatement.java similarity index 73% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/value/EmptyValueEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyValueEffectiveStatement.java index a10c4e5330..947b6ae768 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/value/EmptyValueEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyValueEffectiveStatement.java @@ -5,15 +5,15 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.value; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import org.opendaylight.yangtools.yang.model.api.stmt.ValueEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ValueStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; -final class EmptyValueEffectiveStatement extends DefaultArgument +public final class EmptyValueEffectiveStatement extends DefaultArgument implements ValueEffectiveStatement { - EmptyValueEffectiveStatement(final ValueStatement declared) { + public EmptyValueEffectiveStatement(final ValueStatement declared) { super(declared); } } diff --git a/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyYangVersionEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyYangVersionEffectiveStatement.java new file mode 100644 index 0000000000..c46826d328 --- /dev/null +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyYangVersionEffectiveStatement.java @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; + +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.common.YangVersion; +import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement; +import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; +import org.opendaylight.yangtools.yang.model.spi.stmt.impl.decl.EmptyYangVersionStatement; + +public final class EmptyYangVersionEffectiveStatement extends DefaultArgument + implements YangVersionEffectiveStatement { + public static final @NonNull EmptyYangVersionEffectiveStatement VERSION_1 = + new EmptyYangVersionEffectiveStatement(EmptyYangVersionStatement.VERSION_1); + public static final @NonNull EmptyYangVersionEffectiveStatement VERSION_1_1 = + new EmptyYangVersionEffectiveStatement(EmptyYangVersionStatement.VERSION_1_1); + + public EmptyYangVersionEffectiveStatement(final YangVersionStatement declared) { + super(declared); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yin_element/EmptyYinElementEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyYinElementEffectiveStatement.java similarity index 72% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yin_element/EmptyYinElementEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyYinElementEffectiveStatement.java index 010899c1b5..607a214e98 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yin_element/EmptyYinElementEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/EmptyYinElementEffectiveStatement.java @@ -5,15 +5,15 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.yin_element; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import org.opendaylight.yangtools.yang.model.api.stmt.YinElementEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; -final class EmptyYinElementEffectiveStatement extends DefaultArgument +public final class EmptyYinElementEffectiveStatement extends DefaultArgument implements YinElementEffectiveStatement { - EmptyYinElementEffectiveStatement(final YinElementStatement declared) { + public EmptyYinElementEffectiveStatement(final YinElementStatement declared) { super(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/RegularBelongsToEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularBelongsToEffectiveStatement.java similarity index 77% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/RegularBelongsToEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularBelongsToEffectiveStatement.java index 62df407a76..d5e826205d 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/RegularBelongsToEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularBelongsToEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.belongs_to; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -13,9 +13,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToEffectiveStatemen import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularBelongsToEffectiveStatement extends WithSubstatements +public final class RegularBelongsToEffectiveStatement extends WithSubstatements implements BelongsToEffectiveStatement { - RegularBelongsToEffectiveStatement(final BelongsToStatement declared, + public RegularBelongsToEffectiveStatement(final BelongsToStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/RegularErrorAppTagEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularErrorAppTagEffectiveStatement.java similarity index 77% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/RegularErrorAppTagEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularErrorAppTagEffectiveStatement.java index 0445ed918d..89d19d68b4 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_app_tag/RegularErrorAppTagEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularErrorAppTagEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_app_tag; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -13,9 +13,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagEffectiveStatem import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularErrorAppTagEffectiveStatement extends WithSubstatements +public final class RegularErrorAppTagEffectiveStatement extends WithSubstatements implements ErrorAppTagEffectiveStatement { - RegularErrorAppTagEffectiveStatement(final ErrorAppTagStatement declared, + public RegularErrorAppTagEffectiveStatement(final ErrorAppTagStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/RegularErrorMessageEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularErrorMessageEffectiveStatement.java similarity index 77% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/RegularErrorMessageEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularErrorMessageEffectiveStatement.java index c1264f0b75..51c1c7f062 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/RegularErrorMessageEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularErrorMessageEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.error_message; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -13,9 +13,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageEffectiveState import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularErrorMessageEffectiveStatement extends WithSubstatements +public final class RegularErrorMessageEffectiveStatement extends WithSubstatements implements ErrorMessageEffectiveStatement { - RegularErrorMessageEffectiveStatement(final ErrorMessageStatement declared, + public RegularErrorMessageEffectiveStatement(final ErrorMessageStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/fraction_digits/RegularFractionDigitsEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularFractionDigitsEffectiveStatement.java similarity index 76% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/fraction_digits/RegularFractionDigitsEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularFractionDigitsEffectiveStatement.java index e884e34379..3e6e52d3a0 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/fraction_digits/RegularFractionDigitsEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularFractionDigitsEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.fraction_digits; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -13,9 +13,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsEffectiveSta import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularFractionDigitsEffectiveStatement extends WithSubstatements +public final class RegularFractionDigitsEffectiveStatement extends WithSubstatements implements FractionDigitsEffectiveStatement { - RegularFractionDigitsEffectiveStatement(final FractionDigitsStatement declared, + public RegularFractionDigitsEffectiveStatement(final FractionDigitsStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/if_feature/RegularIfFeatureEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularIfFeatureEffectiveStatement.java similarity index 78% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/if_feature/RegularIfFeatureEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularIfFeatureEffectiveStatement.java index e15000f0b7..757ec702e3 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/if_feature/RegularIfFeatureEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularIfFeatureEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.if_feature; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -14,9 +14,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureExpr; import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularIfFeatureEffectiveStatement extends WithSubstatements +public final class RegularIfFeatureEffectiveStatement extends WithSubstatements implements IfFeatureEffectiveStatement { - RegularIfFeatureEffectiveStatement(final IfFeatureStatement declared, + public RegularIfFeatureEffectiveStatement(final IfFeatureStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/include/RegularIncludeEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularIncludeEffectiveStatement.java similarity index 78% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/include/RegularIncludeEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularIncludeEffectiveStatement.java index f91c1c69bf..f097d94633 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/include/RegularIncludeEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularIncludeEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.include; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -13,9 +13,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.IncludeEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.IncludeStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularIncludeEffectiveStatement extends WithSubstatements +public final class RegularIncludeEffectiveStatement extends WithSubstatements implements IncludeEffectiveStatement { - RegularIncludeEffectiveStatement(final IncludeStatement declared, + public RegularIncludeEffectiveStatement(final IncludeStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/mandatory/RegularMandatoryEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularMandatoryEffectiveStatement.java similarity index 77% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/mandatory/RegularMandatoryEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularMandatoryEffectiveStatement.java index be8e6013db..26dcfced93 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/mandatory/RegularMandatoryEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularMandatoryEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.mandatory; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -13,9 +13,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryEffectiveStatemen import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularMandatoryEffectiveStatement extends WithSubstatements +public final class RegularMandatoryEffectiveStatement extends WithSubstatements implements MandatoryEffectiveStatement { - RegularMandatoryEffectiveStatement(final MandatoryStatement declared, + public RegularMandatoryEffectiveStatement(final MandatoryStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/max_elements/RegularMaxElementsEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularMaxElementsEffectiveStatement.java similarity index 77% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/max_elements/RegularMaxElementsEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularMaxElementsEffectiveStatement.java index ff1f2ad833..df51d3148b 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/max_elements/RegularMaxElementsEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularMaxElementsEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.max_elements; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -13,9 +13,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsEffectiveStatem import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularMaxElementsEffectiveStatement extends WithSubstatements +public final class RegularMaxElementsEffectiveStatement extends WithSubstatements implements MaxElementsEffectiveStatement { - RegularMaxElementsEffectiveStatement(final MaxElementsStatement declared, + public RegularMaxElementsEffectiveStatement(final MaxElementsStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/min_elements/RegularMinElementsEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularMinElementsEffectiveStatement.java similarity index 77% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/min_elements/RegularMinElementsEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularMinElementsEffectiveStatement.java index 7b8fc1e3be..25fe2a9c6f 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/min_elements/RegularMinElementsEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularMinElementsEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.min_elements; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -13,9 +13,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsEffectiveStatem import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularMinElementsEffectiveStatement extends WithSubstatements +public final class RegularMinElementsEffectiveStatement extends WithSubstatements implements MinElementsEffectiveStatement { - RegularMinElementsEffectiveStatement(final MinElementsStatement declared, + public RegularMinElementsEffectiveStatement(final MinElementsStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/namespace/RegularNamespaceEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularNamespaceEffectiveStatement.java similarity index 78% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/namespace/RegularNamespaceEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularNamespaceEffectiveStatement.java index 04fc4cd501..cd5a864e8d 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/namespace/RegularNamespaceEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularNamespaceEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.namespace; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.common.XMLNamespace; @@ -14,9 +14,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceEffectiveStatemen import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularNamespaceEffectiveStatement extends WithSubstatements +public final class RegularNamespaceEffectiveStatement extends WithSubstatements implements NamespaceEffectiveStatement { - RegularNamespaceEffectiveStatement(final NamespaceStatement declared, + public RegularNamespaceEffectiveStatement(final NamespaceStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/RegularOrderedByEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularOrderedByEffectiveStatement.java similarity index 78% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/RegularOrderedByEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularOrderedByEffectiveStatement.java index 7f47a44842..c216c9ca8b 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/RegularOrderedByEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularOrderedByEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ordered_by; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.common.Ordering; @@ -14,9 +14,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByEffectiveStatemen import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularOrderedByEffectiveStatement extends WithSubstatements +public final class RegularOrderedByEffectiveStatement extends WithSubstatements implements OrderedByEffectiveStatement { - RegularOrderedByEffectiveStatement(final OrderedByStatement declared, + public RegularOrderedByEffectiveStatement(final OrderedByStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/organization/RegularOrganizationEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularOrganizationEffectiveStatement.java similarity index 77% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/organization/RegularOrganizationEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularOrganizationEffectiveStatement.java index da3bd36638..2506dbf847 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/organization/RegularOrganizationEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularOrganizationEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.organization; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -13,9 +13,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationEffectiveState import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularOrganizationEffectiveStatement extends WithSubstatements +public final class RegularOrganizationEffectiveStatement extends WithSubstatements implements OrganizationEffectiveStatement { - RegularOrganizationEffectiveStatement(final OrganizationStatement declared, + public RegularOrganizationEffectiveStatement(final OrganizationStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/path/RegularPathEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularPathEffectiveStatement.java similarity index 79% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/path/RegularPathEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularPathEffectiveStatement.java index d4a9cbe12d..5d34659493 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/path/RegularPathEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularPathEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.path; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.PathExpression; @@ -14,9 +14,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.PathEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.PathStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularPathEffectiveStatement extends WithSubstatements +public final class RegularPathEffectiveStatement extends WithSubstatements implements PathEffectiveStatement { - RegularPathEffectiveStatement(final PathStatement declared, + public RegularPathEffectiveStatement(final PathStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/position/RegularPositionEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularPositionEffectiveStatement.java similarity index 79% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/position/RegularPositionEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularPositionEffectiveStatement.java index 5bb1030d38..8d0044dd44 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/position/RegularPositionEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularPositionEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.position; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.common.Uint32; @@ -14,9 +14,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.PositionEffectiveStatement import org.opendaylight.yangtools.yang.model.api.stmt.PositionStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularPositionEffectiveStatement extends WithSubstatements +public final class RegularPositionEffectiveStatement extends WithSubstatements implements PositionEffectiveStatement { - RegularPositionEffectiveStatement(final PositionStatement declared, + public RegularPositionEffectiveStatement(final PositionStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/RegularReferenceEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularReferenceEffectiveStatement.java similarity index 77% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/RegularReferenceEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularReferenceEffectiveStatement.java index 5735d0285d..5a9b707131 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/RegularReferenceEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularReferenceEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.reference; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -13,9 +13,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatemen import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularReferenceEffectiveStatement extends WithSubstatements +public final class RegularReferenceEffectiveStatement extends WithSubstatements implements ReferenceEffectiveStatement { - RegularReferenceEffectiveStatement(final ReferenceStatement declared, + public RegularReferenceEffectiveStatement(final ReferenceStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/require_instance/RegularRequireInstanceEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularRequireInstanceEffectiveStatement.java similarity index 76% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/require_instance/RegularRequireInstanceEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularRequireInstanceEffectiveStatement.java index f7cb1e8254..031b810fcc 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/require_instance/RegularRequireInstanceEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularRequireInstanceEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.require_instance; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -13,9 +13,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceEffectiveSt import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularRequireInstanceEffectiveStatement extends WithSubstatements +public final class RegularRequireInstanceEffectiveStatement extends WithSubstatements implements RequireInstanceEffectiveStatement { - RegularRequireInstanceEffectiveStatement(final RequireInstanceStatement declared, + public RegularRequireInstanceEffectiveStatement(final RequireInstanceStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/status/RegularStatusEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularStatusEffectiveStatement.java similarity index 79% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/status/RegularStatusEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularStatusEffectiveStatement.java index f2132d442d..556657e09a 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/status/RegularStatusEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularStatusEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.status; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.Status; @@ -14,9 +14,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularStatusEffectiveStatement extends WithSubstatements +public final class RegularStatusEffectiveStatement extends WithSubstatements implements StatusEffectiveStatement { - RegularStatusEffectiveStatement(final StatusStatement declared, + public RegularStatusEffectiveStatement(final StatusStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/value/RegularValueEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularValueEffectiveStatement.java similarity index 78% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/value/RegularValueEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularValueEffectiveStatement.java index a5787e0131..1b9bb332e9 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/value/RegularValueEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularValueEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.value; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -13,9 +13,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.ValueEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ValueStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularValueEffectiveStatement extends WithSubstatements +public final class RegularValueEffectiveStatement extends WithSubstatements implements ValueEffectiveStatement { - RegularValueEffectiveStatement(final ValueStatement declared, + public RegularValueEffectiveStatement(final ValueStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yang_version/RegularYangVersionEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularYangVersionEffectiveStatement.java similarity index 78% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yang_version/RegularYangVersionEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularYangVersionEffectiveStatement.java index 9ff625de03..fb96add4fb 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yang_version/RegularYangVersionEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularYangVersionEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.yang_version; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.common.YangVersion; @@ -14,9 +14,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionEffectiveStatem import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularYangVersionEffectiveStatement extends WithSubstatements +public final class RegularYangVersionEffectiveStatement extends WithSubstatements implements YangVersionEffectiveStatement { - RegularYangVersionEffectiveStatement(final YangVersionStatement declared, + public RegularYangVersionEffectiveStatement(final YangVersionStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yin_element/RegularYinElementEffectiveStatement.java b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularYinElementEffectiveStatement.java similarity index 77% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yin_element/RegularYinElementEffectiveStatement.java rename to yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularYinElementEffectiveStatement.java index 699a239eef..2123174675 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yin_element/RegularYinElementEffectiveStatement.java +++ b/yang/yang-model-spi/src/main/java/org/opendaylight/yangtools/yang/model/spi/stmt/impl/eff/RegularYinElementEffectiveStatement.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.yin_element; +package org.opendaylight.yangtools.yang.model.spi.stmt.impl.eff; import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -13,9 +13,9 @@ import org.opendaylight.yangtools.yang.model.api.stmt.YinElementEffectiveStateme import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement; import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements; -final class RegularYinElementEffectiveStatement extends WithSubstatements +public final class RegularYinElementEffectiveStatement extends WithSubstatements implements YinElementEffectiveStatement { - RegularYinElementEffectiveStatement(final YinElementStatement declared, + public RegularYinElementEffectiveStatement(final YinElementStatement declared, final ImmutableList> substatements) { super(declared, substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/EffectiveStatementMixins.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/EffectiveStatementMixins.java index 166c197bfe..5d9358402e 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/EffectiveStatementMixins.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/EffectiveStatementMixins.java @@ -473,7 +473,7 @@ public final class EffectiveStatementMixins { */ public interface EffectiveStatementWithFlags> extends Mixin { /** - * Return flags assicated with this statements. Flags can be built using {@link FlagsBuilder}. + * Return flags associated with this statements. Flags can be built using {@link FlagsBuilder}. * * @return Flag field value (32 bits). */ diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/BelongsToStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/BelongsToStatementSupport.java index 1e498be71f..267e6858fd 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/BelongsToStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/belongs_to/BelongsToStatementSupport.java @@ -20,6 +20,7 @@ import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement; import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier; import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier; import org.opendaylight.yangtools.yang.model.spi.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.spi.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException; @@ -97,8 +98,7 @@ public final class BelongsToStatementSupport @Override protected BelongsToEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { - return substatements.isEmpty() ? new EmptyBelongsToEffectiveStatement(stmt.declared()) - : new RegularBelongsToEffectiveStatement(stmt.declared(), substatements); + return EffectiveStatements.createBelongsTo(stmt.declared(), substatements); } private static SourceIdentifier getSourceIdentifier(final StmtContext stmt, final ImmutableList> substatements) { - return substatements.isEmpty() ? new EmptyErrorAppTagEffectiveStatement(stmt.declared()) - : new RegularErrorAppTagEffectiveStatement(stmt.declared(), substatements); + return EffectiveStatements.createErrorAppTag(stmt.declared(), substatements); } } \ No newline at end of file diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/ErrorMessageStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/ErrorMessageStatementSupport.java index 25f7aa9963..1492d0ef64 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/ErrorMessageStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/error_message/ErrorMessageStatementSupport.java @@ -14,6 +14,7 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.spi.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @@ -52,7 +53,6 @@ public final class ErrorMessageStatementSupport @Override protected ErrorMessageEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { - return substatements.isEmpty() ? new EmptyErrorMessageEffectiveStatement(stmt.declared()) - : new RegularErrorMessageEffectiveStatement(stmt.declared(), substatements); + return EffectiveStatements.createErrorMessage(stmt.declared(), substatements); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/fraction_digits/FractionDigitsStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/fraction_digits/FractionDigitsStatementSupport.java index c35953b099..82954b5250 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/fraction_digits/FractionDigitsStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/fraction_digits/FractionDigitsStatementSupport.java @@ -7,8 +7,6 @@ */ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.fraction_digits; -import static com.google.common.base.Verify.verifyNotNull; - import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableMap.Builder; @@ -19,6 +17,7 @@ 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.FractionDigitsStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.spi.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @@ -31,22 +30,15 @@ public final class FractionDigitsStatementSupport SubstatementValidator.builder(YangStmtMapping.FRACTION_DIGITS).build(); private static final FractionDigitsStatementSupport INSTANCE = new FractionDigitsStatementSupport(); - private static final ImmutableMap EMPTY_DECLS; - private static final ImmutableMap EMPTY_EFF; + // FIXME: move this to yang-model-spi + private static final ImmutableMap EMPTY_EFF; static { - final Builder declBuilder = ImmutableMap.builder(); - final Builder effBuilder = - ImmutableMap.builder(); - + final Builder effBuilder = ImmutableMap.builder(); for (int i = 1; i <= 18; ++i) { - final Integer argument = i; - final FractionDigitsStatement decl = DeclaredStatements.createFractionDigits(argument); - declBuilder.put(argument, decl); - effBuilder.put(decl, new EmptyFractionDigitsEffectiveStatement(decl)); + final FractionDigitsStatement decl = DeclaredStatements.createFractionDigits(i); + effBuilder.put(decl, EffectiveStatements.createFractionDigits(decl)); } - - EMPTY_DECLS = declBuilder.build(); EMPTY_EFF = effBuilder.build(); } @@ -85,20 +77,19 @@ public final class FractionDigitsStatementSupport @Override protected FractionDigitsStatement createEmptyDeclared(final StmtContext ctx) { - final Integer argument = ctx.getArgument(); - return verifyNotNull(EMPTY_DECLS.get(argument), "No declared instance for %s", argument); + return DeclaredStatements.createFractionDigits(ctx.getArgument()); } @Override protected FractionDigitsEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { return substatements.isEmpty() ? createEmptyEffective(stmt.declared()) - : new RegularFractionDigitsEffectiveStatement(stmt.declared(), substatements); + : EffectiveStatements.createFractionDigits(stmt.declared(), substatements); } private static @NonNull FractionDigitsEffectiveStatement createEmptyEffective( final FractionDigitsStatement declared) { - final EmptyFractionDigitsEffectiveStatement shared = EMPTY_EFF.get(declared); - return shared != null ? shared : new EmptyFractionDigitsEffectiveStatement(declared); + final FractionDigitsEffectiveStatement shared = EMPTY_EFF.get(declared); + return shared != null ? shared : EffectiveStatements.createFractionDigits(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/if_feature/AbstractIfFeatureStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/if_feature/AbstractIfFeatureStatementSupport.java index 5a7a8e6865..3f056023ca 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/if_feature/AbstractIfFeatureStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/if_feature/AbstractIfFeatureStatementSupport.java @@ -23,6 +23,7 @@ import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureEffectiveStatemen import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureExpr; import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.spi.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.spi.FeatureNamespace; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; @@ -100,7 +101,6 @@ abstract class AbstractIfFeatureStatementSupport @Override protected final IfFeatureEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { - return substatements.isEmpty() ? new EmptyIfFeatureEffectiveStatement(stmt.declared()) - : new RegularIfFeatureEffectiveStatement(stmt.declared(), substatements); + return EffectiveStatements.createIfFeature(stmt.declared(), substatements); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/include/IncludeStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/include/IncludeStatementSupport.java index 21a4d5f531..4130794992 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/include/IncludeStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/include/IncludeStatementSupport.java @@ -25,6 +25,7 @@ import org.opendaylight.yangtools.yang.model.api.stmt.IncludeStatement; import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement; import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier; import org.opendaylight.yangtools.yang.model.spi.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.spi.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.spi.SubmoduleNamespace; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; @@ -128,7 +129,6 @@ public final class IncludeStatementSupport @Override protected IncludeEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { - return substatements.isEmpty() ? new EmptyIncludeEffectiveStatement(stmt.declared()) - : new RegularIncludeEffectiveStatement(stmt.declared(), substatements); + return EffectiveStatements.createInclude(stmt.declared(), substatements); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/mandatory/MandatoryStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/mandatory/MandatoryStatementSupport.java index ce248e1bf7..c001d3a035 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/mandatory/MandatoryStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/mandatory/MandatoryStatementSupport.java @@ -14,6 +14,7 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.spi.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractBooleanStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator; @@ -26,8 +27,8 @@ public final class MandatoryStatementSupport extends private MandatoryStatementSupport() { super(YangStmtMapping.MANDATORY, - new EmptyMandatoryEffectiveStatement(DeclaredStatements.createMandatory(Boolean.FALSE)), - new EmptyMandatoryEffectiveStatement(DeclaredStatements.createMandatory(Boolean.TRUE)), + EffectiveStatements.createMandatory(DeclaredStatements.createMandatory(Boolean.FALSE)), + EffectiveStatements.createMandatory(DeclaredStatements.createMandatory(Boolean.TRUE)), StatementPolicy.contextIndependent()); } @@ -49,11 +50,11 @@ public final class MandatoryStatementSupport extends @Override protected MandatoryEffectiveStatement createEffective(final MandatoryStatement declared, final ImmutableList> substatements) { - return new RegularMandatoryEffectiveStatement(declared, substatements); + return EffectiveStatements.createMandatory(declared, substatements); } @Override protected MandatoryEffectiveStatement createEmptyEffective(final MandatoryStatement declared) { - return new EmptyMandatoryEffectiveStatement(declared); + return EffectiveStatements.createMandatory(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/max_elements/MaxElementsStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/max_elements/MaxElementsStatementSupport.java index 6b44b6631a..9cad9a8457 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/max_elements/MaxElementsStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/max_elements/MaxElementsStatementSupport.java @@ -14,6 +14,7 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.spi.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStringStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @@ -58,7 +59,6 @@ public final class MaxElementsStatementSupport @Override protected MaxElementsEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { - return substatements.isEmpty() ? new EmptyMaxElementsEffectiveStatement(stmt.declared()) - : new RegularMaxElementsEffectiveStatement(stmt.declared(), substatements); + return EffectiveStatements.createMaxElements(stmt.declared(), substatements); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/min_elements/MinElementsStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/min_elements/MinElementsStatementSupport.java index 95567d8136..a39a866c7d 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/min_elements/MinElementsStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/min_elements/MinElementsStatementSupport.java @@ -14,6 +14,7 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.spi.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractInternedStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator; @@ -62,11 +63,11 @@ public final class MinElementsStatementSupport @Override protected MinElementsEffectiveStatement createEffective(final MinElementsStatement declared, final ImmutableList> substatements) { - return new RegularMinElementsEffectiveStatement(declared, substatements); + return EffectiveStatements.createMinElements(declared, substatements); } @Override protected MinElementsEffectiveStatement createEmptyEffective(final MinElementsStatement declared) { - return new EmptyMinElementsEffectiveStatement(declared); + return EffectiveStatements.createMinElements(declared); } } \ No newline at end of file diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/namespace/NamespaceStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/namespace/NamespaceStatementSupport.java index 6d3b995c0b..2aac1cb0d5 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/namespace/NamespaceStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/namespace/NamespaceStatementSupport.java @@ -16,6 +16,7 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.spi.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @@ -65,7 +66,6 @@ public final class NamespaceStatementSupport @Override protected NamespaceEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { - return substatements.isEmpty() ? new EmptyNamespaceEffectiveStatement(stmt.declared()) - : new RegularNamespaceEffectiveStatement(stmt.declared(), substatements); + return EffectiveStatements.createNamespace(stmt.declared(), substatements); } } \ No newline at end of file diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/OrderedByStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/OrderedByStatementSupport.java index 170c702270..7505318b0c 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/OrderedByStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/ordered_by/OrderedByStatementSupport.java @@ -16,6 +16,7 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.spi.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @@ -32,14 +33,15 @@ public final class OrderedByStatementSupport * Ordered-by has low argument cardinality, hence we can reuse them in case declaration does not have any * substatements (which is the usual case). */ + // FIXME: move this to yang-model-spi private static final @NonNull OrderedByStatement EMPTY_SYSTEM_DECL = DeclaredStatements.createOrderedBy(Ordering.SYSTEM); private static final @NonNull OrderedByStatement EMPTY_USER_DECL = DeclaredStatements.createOrderedBy(Ordering.USER); - private static final @NonNull EmptyOrderedByEffectiveStatement EMPTY_SYSTEM_EFF = - new EmptyOrderedByEffectiveStatement(EMPTY_SYSTEM_DECL); - private static final @NonNull EmptyOrderedByEffectiveStatement EMPTY_USER_EFF = - new EmptyOrderedByEffectiveStatement(EMPTY_USER_DECL); + private static final @NonNull OrderedByEffectiveStatement EMPTY_SYSTEM_EFF = + EffectiveStatements.createOrderedBy(EMPTY_SYSTEM_DECL); + private static final @NonNull OrderedByEffectiveStatement EMPTY_USER_EFF = + EffectiveStatements.createOrderedBy(EMPTY_USER_DECL); private OrderedByStatementSupport() { super(YangStmtMapping.ORDERED_BY, StatementPolicy.contextIndependent()); @@ -97,7 +99,7 @@ public final class OrderedByStatementSupport protected OrderedByEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { return substatements.isEmpty() ? createEmptyEffective(stmt.declared()) - : new RegularOrderedByEffectiveStatement(stmt.declared(), substatements); + : EffectiveStatements.createOrderedBy(stmt.declared(), substatements); } private static @NonNull OrderedByEffectiveStatement createEmptyEffective(final OrderedByStatement declared) { @@ -109,7 +111,7 @@ public final class OrderedByStatementSupport } else if (EMPTY_SYSTEM_DECL.equals(declared)) { return EMPTY_SYSTEM_EFF; } else { - return new EmptyOrderedByEffectiveStatement(declared); + return EffectiveStatements.createOrderedBy(declared); } } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/organization/OrganizationStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/organization/OrganizationStatementSupport.java index 01260e0fc1..621bfd25e5 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/organization/OrganizationStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/organization/OrganizationStatementSupport.java @@ -14,6 +14,7 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.spi.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractInternedStringStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator; @@ -51,11 +52,11 @@ public final class OrganizationStatementSupport @Override protected OrganizationEffectiveStatement createEffective(final OrganizationStatement declared, final ImmutableList> substatements) { - return new RegularOrganizationEffectiveStatement(declared, substatements); + return EffectiveStatements.createOrganization(declared, substatements); } @Override protected OrganizationEffectiveStatement createEmptyEffective(final OrganizationStatement declared) { - return new EmptyOrganizationEffectiveStatement(declared); + return EffectiveStatements.createOrganization(declared); } } \ No newline at end of file diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/path/PathStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/path/PathStatementSupport.java index 033a994294..4971c1a313 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/path/PathStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/path/PathStatementSupport.java @@ -17,6 +17,7 @@ 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.PathStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.spi.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @@ -71,7 +72,6 @@ public final class PathStatementSupport @Override protected PathEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { - return substatements.isEmpty() ? new EmptyPathEffectiveStatement(stmt.declared()) - : new RegularPathEffectiveStatement(stmt.declared(), substatements); + return EffectiveStatements.createPath(stmt.declared(), substatements); } } \ No newline at end of file diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/position/PositionStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/position/PositionStatementSupport.java index 395e571c40..e1eda6c603 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/position/PositionStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/position/PositionStatementSupport.java @@ -15,6 +15,7 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.PositionEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.PositionStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.spi.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractInternedStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator; @@ -62,11 +63,11 @@ public final class PositionStatementSupport @Override protected PositionEffectiveStatement createEffective(final PositionStatement declared, final ImmutableList> substatements) { - return new RegularPositionEffectiveStatement(declared, substatements); + return EffectiveStatements.createPosition(declared, substatements); } @Override protected PositionEffectiveStatement createEmptyEffective(final PositionStatement declared) { - return new EmptyPositionEffectiveStatement(declared); + return EffectiveStatements.createPosition(declared); } } \ No newline at end of file diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/ReferenceStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/ReferenceStatementSupport.java index 7fe3d4c35b..d299d1e987 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/ReferenceStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/reference/ReferenceStatementSupport.java @@ -14,6 +14,7 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.spi.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractInternedStringStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator; @@ -51,11 +52,11 @@ public final class ReferenceStatementSupport @Override protected ReferenceEffectiveStatement createEffective(final ReferenceStatement declared, final ImmutableList> substatements) { - return new RegularReferenceEffectiveStatement(declared, substatements); + return EffectiveStatements.createReference(declared, substatements); } @Override protected ReferenceEffectiveStatement createEmptyEffective(final ReferenceStatement declared) { - return new EmptyReferenceEffectiveStatement(declared); + return EffectiveStatements.createReference(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/require_instance/EmptyRequireInstanceEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/require_instance/EmptyRequireInstanceEffectiveStatement.java deleted file mode 100644 index 6890f17fe2..0000000000 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/require_instance/EmptyRequireInstanceEffectiveStatement.java +++ /dev/null @@ -1,19 +0,0 @@ -/* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.require_instance; - -import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceEffectiveStatement; -import org.opendaylight.yangtools.yang.model.api.stmt.RequireInstanceStatement; -import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; - -final class EmptyRequireInstanceEffectiveStatement extends DefaultArgument - implements RequireInstanceEffectiveStatement { - EmptyRequireInstanceEffectiveStatement(final RequireInstanceStatement declared) { - super(declared); - } -} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/require_instance/RequireInstanceStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/require_instance/RequireInstanceStatementSupport.java index 3dac1e1df9..027d5595f1 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/require_instance/RequireInstanceStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/require_instance/RequireInstanceStatementSupport.java @@ -14,6 +14,7 @@ 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.RequireInstanceStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.spi.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractBooleanStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator; @@ -26,8 +27,7 @@ public final class RequireInstanceStatementSupport private RequireInstanceStatementSupport() { super(YangStmtMapping.REQUIRE_INSTANCE, - new EmptyRequireInstanceEffectiveStatement(DeclaredStatements.createRequireInstance(Boolean.FALSE)), - new EmptyRequireInstanceEffectiveStatement(DeclaredStatements.createRequireInstance(Boolean.TRUE)), + EffectiveStatements.createRequireInstance(false), EffectiveStatements.createRequireInstance(true), StatementPolicy.contextIndependent()); } @@ -49,11 +49,11 @@ public final class RequireInstanceStatementSupport @Override protected RequireInstanceEffectiveStatement createEffective(final RequireInstanceStatement declared, final ImmutableList> substatements) { - return new RegularRequireInstanceEffectiveStatement(declared, substatements); + return EffectiveStatements.createRequireInstance(declared, substatements); } @Override - protected EmptyRequireInstanceEffectiveStatement createEmptyEffective(final RequireInstanceStatement declared) { - return new EmptyRequireInstanceEffectiveStatement(declared); + protected RequireInstanceEffectiveStatement createEmptyEffective(final RequireInstanceStatement declared) { + return EffectiveStatements.createRequireInstance(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/status/EmptyStatusEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/status/EmptyStatusEffectiveStatement.java deleted file mode 100644 index b0143853a4..0000000000 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/status/EmptyStatusEffectiveStatement.java +++ /dev/null @@ -1,20 +0,0 @@ -/* - * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.status; - -import org.opendaylight.yangtools.yang.model.api.Status; -import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement; -import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement; -import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; - -final class EmptyStatusEffectiveStatement extends DefaultArgument - implements StatusEffectiveStatement { - EmptyStatusEffectiveStatement(final StatusStatement declared) { - super(declared); - } -} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/status/StatusStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/status/StatusStatementSupport.java index 4d81ab9a29..13e1b24bce 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/status/StatusStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/status/StatusStatementSupport.java @@ -8,7 +8,6 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.status; import com.google.common.collect.ImmutableList; -import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.yangtools.yang.model.api.Status; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; @@ -16,6 +15,7 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.spi.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @@ -24,27 +24,10 @@ import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; public final class StatusStatementSupport extends AbstractStatementSupport { - private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping - .STATUS) - .build(); + private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = + SubstatementValidator.builder(YangStmtMapping.STATUS).build(); private static final StatusStatementSupport INSTANCE = new StatusStatementSupport(); - /* - * status has low argument cardinality, hence we can reuse them in case declaration does not have any - * substatements (which is the usual case). Yeah, we could consider an EnumMap, but this is not too bad, either. - */ - private static final @NonNull StatusStatement EMPTY_CURRENT_DECL = DeclaredStatements.createStatus(Status.CURRENT); - private static final @NonNull StatusStatement EMPTY_DEPRECATED_DECL = - DeclaredStatements.createStatus(Status.DEPRECATED); - private static final @NonNull StatusStatement EMPTY_OBSOLETE_DECL = - DeclaredStatements.createStatus(Status.OBSOLETE); - private static final @NonNull EmptyStatusEffectiveStatement EMPTY_CURRENT_EFF = - new EmptyStatusEffectiveStatement(EMPTY_CURRENT_DECL); - private static final @NonNull EmptyStatusEffectiveStatement EMPTY_DEPRECATED_EFF = - new EmptyStatusEffectiveStatement(EMPTY_DEPRECATED_DECL); - private static final @NonNull EmptyStatusEffectiveStatement EMPTY_OBSOLETE_EFF = - new EmptyStatusEffectiveStatement(EMPTY_OBSOLETE_DECL); - private StatusStatementSupport() { super(YangStmtMapping.STATUS, StatementPolicy.contextIndependent()); } @@ -94,40 +77,12 @@ public final class StatusStatementSupport @Override protected StatusStatement createEmptyDeclared(final StmtContext ctx) { - final Status argument = ctx.getArgument(); - switch (argument) { - case CURRENT: - return EMPTY_CURRENT_DECL; - case DEPRECATED: - return EMPTY_DEPRECATED_DECL; - case OBSOLETE: - return EMPTY_OBSOLETE_DECL; - default: - throw new IllegalStateException("Unhandled argument " + argument); - } + return DeclaredStatements.createStatus(ctx.getArgument()); } @Override protected StatusEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { - return substatements.isEmpty() ? createEmptyEffective(stmt.declared()) - : new RegularStatusEffectiveStatement(stmt.declared(), substatements); - } - - private static @NonNull StatusEffectiveStatement createEmptyEffective(final StatusStatement declared) { - // Aggressively reuse effective instances which are backed by the corresponding empty declared instance, as this - // is the case unless there is a weird extension in use. - if (EMPTY_DEPRECATED_DECL.equals(declared)) { - // Most likely to be seen (as current is the default) - return EMPTY_DEPRECATED_EFF; - } else if (EMPTY_OBSOLETE_DECL.equals(declared)) { - // less likely - return EMPTY_OBSOLETE_EFF; - } else if (EMPTY_CURRENT_DECL.equals(declared)) { - // ... okay, why is this there? :) - return EMPTY_CURRENT_EFF; - } else { - return new EmptyStatusEffectiveStatement(declared); - } + return EffectiveStatements.createStatus(stmt.declared(), substatements); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/value/ValueStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/value/ValueStatementSupport.java index a5f86d8e9c..7e42424f3a 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/value/ValueStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/value/ValueStatementSupport.java @@ -15,6 +15,7 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ValueEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ValueStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.spi.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractInternedStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator; @@ -63,11 +64,11 @@ public final class ValueStatementSupport @Override protected ValueEffectiveStatement createEffective(final ValueStatement declared, final ImmutableList> substatements) { - return new RegularValueEffectiveStatement(declared, substatements); + return EffectiveStatements.createValue(declared, substatements); } @Override protected ValueEffectiveStatement createEmptyEffective(@NonNull final ValueStatement declared) { - return new EmptyValueEffectiveStatement(declared); + return EffectiveStatements.createValue(declared); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yang_version/EmptyYangVersionEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yang_version/EmptyYangVersionEffectiveStatement.java deleted file mode 100644 index 8ce29f9c0f..0000000000 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yang_version/EmptyYangVersionEffectiveStatement.java +++ /dev/null @@ -1,20 +0,0 @@ -/* - * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.yang_version; - -import org.opendaylight.yangtools.yang.common.YangVersion; -import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionEffectiveStatement; -import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement; -import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument; - -final class EmptyYangVersionEffectiveStatement extends DefaultArgument - implements YangVersionEffectiveStatement { - EmptyYangVersionEffectiveStatement(final YangVersionStatement declared) { - super(declared); - } -} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yang_version/YangVersionStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yang_version/YangVersionStatementSupport.java index 0a4428cd2e..893dead40f 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yang_version/YangVersionStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yang_version/YangVersionStatementSupport.java @@ -8,7 +8,6 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.yang_version; import com.google.common.collect.ImmutableList; -import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.yangtools.yang.common.YangVersion; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; @@ -16,6 +15,7 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.spi.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @@ -25,20 +25,10 @@ import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; public final class YangVersionStatementSupport extends AbstractStatementSupport { - private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping - .YANG_VERSION) - .build(); + private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = + SubstatementValidator.builder(YangStmtMapping.YANG_VERSION).build(); private static final YangVersionStatementSupport INSTANCE = new YangVersionStatementSupport(); - private static final @NonNull YangVersionStatement EMPTY_VER1_DECL = - DeclaredStatements.createYangVersion(YangVersion.VERSION_1); - private static final @NonNull YangVersionStatement EMPTY_VER1_1_DECL = - DeclaredStatements.createYangVersion(YangVersion.VERSION_1_1); - private static final @NonNull EmptyYangVersionEffectiveStatement EMPTY_VER1_EFF = - new EmptyYangVersionEffectiveStatement(EMPTY_VER1_DECL); - private static final @NonNull EmptyYangVersionEffectiveStatement EMPTY_VER1_1_EFF = - new EmptyYangVersionEffectiveStatement(EMPTY_VER1_1_DECL); - private YangVersionStatementSupport() { super(YangStmtMapping.YANG_VERSION, StatementPolicy.reject()); } @@ -71,31 +61,12 @@ public final class YangVersionStatementSupport @Override protected YangVersionStatement createEmptyDeclared(final StmtContext ctx) { - final YangVersion argument = ctx.getArgument(); - switch (argument) { - case VERSION_1: - return EMPTY_VER1_DECL; - case VERSION_1_1: - return EMPTY_VER1_1_DECL; - default: - throw new IllegalStateException("Unhandled version " + argument); - } + return DeclaredStatements.createYangVersion(ctx.getArgument()); } @Override protected YangVersionEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { - return substatements.isEmpty() ? createEmptyEffective(stmt.declared()) - : new RegularYangVersionEffectiveStatement(stmt.declared(), substatements); - } - - private static @NonNull YangVersionEffectiveStatement createEmptyEffective(final YangVersionStatement declared) { - if (EMPTY_VER1_DECL.equals(declared)) { - return EMPTY_VER1_EFF; - } else if (EMPTY_VER1_1_DECL.equals(declared)) { - return EMPTY_VER1_1_EFF; - } else { - return new EmptyYangVersionEffectiveStatement(declared); - } + return EffectiveStatements.createYangVersion(stmt.declared(), substatements); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yin_element/YinElementStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yin_element/YinElementStatementSupport.java index 664a52af02..1af5c42c53 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yin_element/YinElementStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/yin_element/YinElementStatementSupport.java @@ -14,6 +14,7 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.YinElementEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement; import org.opendaylight.yangtools.yang.model.spi.stmt.DeclaredStatements; +import org.opendaylight.yangtools.yang.model.spi.stmt.EffectiveStatements; import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractBooleanStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator; @@ -26,8 +27,8 @@ public final class YinElementStatementSupport private YinElementStatementSupport() { super(YangStmtMapping.YIN_ELEMENT, - new EmptyYinElementEffectiveStatement(DeclaredStatements.createYinElement(Boolean.FALSE)), - new EmptyYinElementEffectiveStatement(DeclaredStatements.createYinElement(Boolean.TRUE)), + EffectiveStatements.createYinElement(DeclaredStatements.createYinElement(false)), + EffectiveStatements.createYinElement(DeclaredStatements.createYinElement(true)), StatementPolicy.reject()); } @@ -49,11 +50,11 @@ public final class YinElementStatementSupport @Override protected YinElementEffectiveStatement createEffective(final YinElementStatement declared, final ImmutableList> substatements) { - return new RegularYinElementEffectiveStatement(declared, substatements); + return EffectiveStatements.createYinElement(declared, substatements); } @Override protected YinElementEffectiveStatement createEmptyEffective(final YinElementStatement declared) { - return new EmptyYinElementEffectiveStatement(declared); + return EffectiveStatements.createYinElement(declared); } } -- 2.36.6