X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-spi%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Fspi%2Fmeta%2FStmtContextUtils.java;h=951275b30c3a7d95406a258757ecc5db7ec9d8fd;hb=a36fd793d86133286a46bf277f90c9a52f74b992;hp=69894692853ba984b78425148607ed155e58d4ac;hpb=af5b2323bb4ed819689f224c8684131373a9677e;p=yangtools.git diff --git a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContextUtils.java b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContextUtils.java index 6989469285..951275b30c 100644 --- a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContextUtils.java +++ b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContextUtils.java @@ -11,9 +11,11 @@ import static com.google.common.base.Preconditions.checkArgument; import static java.util.Objects.requireNonNull; import com.google.common.base.Strings; +import com.google.common.base.VerifyException; import com.google.common.collect.ImmutableList; -import com.google.common.collect.Iterables; +import java.util.ArrayList; import java.util.Collection; +import java.util.List; import java.util.Optional; import java.util.Set; import java.util.function.Predicate; @@ -25,19 +27,21 @@ import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.KeyEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement; import org.opendaylight.yangtools.yang.model.api.stmt.LeafStatement; import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement; import org.opendaylight.yangtools.yang.model.api.stmt.MinElementsStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement; -import org.opendaylight.yangtools.yang.model.api.stmt.PresenceStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.PresenceEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.RevisionStatement; -import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier; import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement; import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement; import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement; -import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier; -import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier; +import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction; +import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceContext; +import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable; import org.opendaylight.yangtools.yang.parser.spi.source.BelongsToPrefixToModuleName; import org.opendaylight.yangtools.yang.parser.spi.source.ImportPrefixToModuleCtx; import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName; @@ -53,8 +57,8 @@ public final class StmtContextUtils { public static > A firstAttributeOf( final Iterable> contexts, final Class declaredType) { for (final StmtContext ctx : contexts) { - if (producesDeclared(ctx, declaredType)) { - return (A) ctx.getStatementArgument(); + if (ctx.producesDeclared(declaredType)) { + return (A) ctx.argument(); } } return null; @@ -63,7 +67,7 @@ public final class StmtContextUtils { @SuppressWarnings("unchecked") public static > A firstAttributeOf(final StmtContext ctx, final Class declaredType) { - return producesDeclared(ctx, declaredType) ? (A) ctx.getStatementArgument() : null; + return ctx.producesDeclared(declaredType) ? (A) ctx.argument() : null; } public static > A firstSubstatementAttributeOf( @@ -75,7 +79,7 @@ public final class StmtContextUtils { public static > StmtContext findFirstDeclaredSubstatement( final StmtContext stmtContext, final Class declaredType) { for (final StmtContext subStmtContext : stmtContext.declaredSubstatements()) { - if (producesDeclared(subStmtContext, declaredType)) { + if (subStmtContext.producesDeclared(declaredType)) { return (StmtContext) subStmtContext; } } @@ -83,6 +87,7 @@ public final class StmtContextUtils { } @SafeVarargs + @SuppressWarnings({ "rawtypes", "unchecked" }) public static StmtContext findFirstDeclaredSubstatement(final StmtContext stmtContext, int startIndex, final Class>... types) { if (startIndex >= types.length) { @@ -90,7 +95,7 @@ public final class StmtContextUtils { } for (final StmtContext subStmtContext : stmtContext.declaredSubstatements()) { - if (producesDeclared(subStmtContext, types[startIndex])) { + if (subStmtContext.producesDeclared((Class) types[startIndex])) { return startIndex + 1 == types.length ? subStmtContext : findFirstDeclaredSubstatement(subStmtContext, ++startIndex, types); } @@ -103,7 +108,7 @@ public final class StmtContextUtils { final StmtContext stmtContext, final Class declaredType) { final ImmutableList.Builder> listBuilder = ImmutableList.builder(); for (final StmtContext subStmtContext : stmtContext.declaredSubstatements()) { - if (producesDeclared(subStmtContext, declaredType)) { + if (subStmtContext.producesDeclared(declaredType)) { listBuilder.add((StmtContext) subStmtContext); } } @@ -115,7 +120,7 @@ public final class StmtContextUtils { final StmtContext stmtContext, final Class type) { final ImmutableList.Builder> listBuilder = ImmutableList.builder(); for (final StmtContext subStmtContext : stmtContext.effectiveSubstatements()) { - if (producesDeclared(subStmtContext, type)) { + if (subStmtContext.producesDeclared(type)) { listBuilder.add((StmtContext) subStmtContext); } } @@ -134,7 +139,7 @@ public final class StmtContextUtils { public static > StmtContext findFirstEffectiveSubstatement( final StmtContext stmtContext, final Class declaredType) { for (final StmtContext subStmtContext : stmtContext.effectiveSubstatements()) { - if (producesDeclared(subStmtContext, declaredType)) { + if (subStmtContext.producesDeclared(declaredType)) { return (StmtContext) subStmtContext; } } @@ -152,7 +157,9 @@ public final class StmtContextUtils { * @param statement argument type * @param declared statement type * @return statement context that was searched for or null if was not found + * @deprecated Use {@link BoundStmtCtx#findSubstatementArgument(Class)} instead. */ + @Deprecated(forRemoval = true) public static > StmtContext findFirstSubstatement( final StmtContext stmtContext, final Class declaredType) { final StmtContext effectiveSubstatement = findFirstEffectiveSubstatement(stmtContext, declaredType); @@ -161,9 +168,9 @@ public final class StmtContextUtils { } public static > StmtContext findFirstDeclaredSubstatementOnSublevel( - final StmtContext stmtContext, final Class declaredType, int sublevel) { + final StmtContext stmtContext, final Class declaredType, int sublevel) { for (final StmtContext subStmtContext : stmtContext.declaredSubstatements()) { - if (sublevel == 1 && producesDeclared(subStmtContext, declaredType)) { + if (sublevel == 1 && subStmtContext.producesDeclared(declaredType)) { return subStmtContext; } if (sublevel > 1) { @@ -179,9 +186,9 @@ public final class StmtContextUtils { } public static > StmtContext findDeepFirstDeclaredSubstatement( - final StmtContext stmtContext, final Class declaredType) { + final StmtContext stmtContext, final Class declaredType) { for (final StmtContext subStmtContext : stmtContext.declaredSubstatements()) { - if (producesDeclared(subStmtContext, declaredType)) { + if (subStmtContext.producesDeclared(declaredType)) { return subStmtContext; } @@ -194,21 +201,19 @@ public final class StmtContextUtils { return null; } - public static boolean producesDeclared(final StmtContext ctx, - final Class> type) { - return type.isAssignableFrom(ctx.getPublicDefinition().getDeclaredRepresentationClass()); - } - public static boolean isInExtensionBody(final StmtContext stmtCtx) { StmtContext current = stmtCtx; - while (current.coerceParentContext().getParentContext() != null) { - current = current.getParentContext(); - if (isUnknownStatement(current)) { + + while (true) { + final StmtContext parent = current.coerceParentContext(); + if (parent.getParentContext() == null) { + return false; + } + if (isUnknownStatement(parent)) { return true; } + current = parent; } - - return false; } /** @@ -223,8 +228,7 @@ public final class StmtContextUtils { * if supplied statement context is null */ public static boolean isUnknownStatement(final StmtContext stmtCtx) { - return UnknownStatement.class - .isAssignableFrom(stmtCtx.getPublicDefinition().getDeclaredRepresentationClass()); + return UnknownStatement.class.isAssignableFrom(stmtCtx.publicDefinition().getDeclaredRepresentationClass()); } /** @@ -239,8 +243,7 @@ public final class StmtContextUtils { * if supplied statement context is null */ public static boolean isUnrecognizedStatement(final StmtContext stmtCtx) { - return UnrecognizedStatement.class - .isAssignableFrom(stmtCtx.getPublicDefinition().getDeclaredRepresentationClass()); + return stmtCtx.producesDeclared(UnrecognizedStatement.class); } public static boolean checkFeatureSupport(final StmtContext stmtContext, @@ -248,10 +251,10 @@ public final class StmtContextUtils { boolean isSupported = false; boolean containsIfFeature = false; for (final StmtContext stmt : stmtContext.declaredSubstatements()) { - if (YangStmtMapping.IF_FEATURE.equals(stmt.getPublicDefinition())) { + if (YangStmtMapping.IF_FEATURE.equals(stmt.publicDefinition())) { containsIfFeature = true; @SuppressWarnings("unchecked") - final Predicate> argument = (Predicate>) stmt.coerceStatementArgument(); + final Predicate> argument = (Predicate>) stmt.getArgument(); if (argument.test(supportedFeatures)) { isSupported = true; } else { @@ -272,7 +275,7 @@ public final class StmtContextUtils { * @return true if it is a presence container */ public static boolean isPresenceContainer(final StmtContext stmtCtx) { - return stmtCtx.getPublicDefinition() == YangStmtMapping.CONTAINER && containsPresenceSubStmt(stmtCtx); + return stmtCtx.publicDefinition() == YangStmtMapping.CONTAINER && containsPresenceSubStmt(stmtCtx); } /** @@ -283,11 +286,11 @@ public final class StmtContextUtils { * @return true if it is a non-presence container */ public static boolean isNonPresenceContainer(final StmtContext stmtCtx) { - return stmtCtx.getPublicDefinition() == YangStmtMapping.CONTAINER && !containsPresenceSubStmt(stmtCtx); + return stmtCtx.publicDefinition() == YangStmtMapping.CONTAINER && !containsPresenceSubStmt(stmtCtx); } private static boolean containsPresenceSubStmt(final StmtContext stmtCtx) { - return findFirstSubstatement(stmtCtx, PresenceStatement.class) != null; + return stmtCtx.hasSubstatement(PresenceEffectiveStatement.class); } /** @@ -300,10 +303,10 @@ public final class StmtContextUtils { * according to RFC6020. */ public static boolean isMandatoryNode(final StmtContext stmtCtx) { - if (!(stmtCtx.getPublicDefinition() instanceof YangStmtMapping)) { + if (!(stmtCtx.publicDefinition() instanceof YangStmtMapping)) { return false; } - switch ((YangStmtMapping) stmtCtx.getPublicDefinition()) { + switch ((YangStmtMapping) stmtCtx.publicDefinition()) { case LEAF: case CHOICE: case ANYXML: @@ -332,26 +335,24 @@ public final class StmtContextUtils { */ public static boolean isNotMandatoryNodeOfType(final StmtContext stmtCtx, final StatementDefinition stmtDef) { - return stmtCtx.getPublicDefinition().equals(stmtDef) && !isMandatoryNode(stmtCtx); + return stmtCtx.publicDefinition().equals(stmtDef) && !isMandatoryNode(stmtCtx); } /** * Checks whether at least one ancestor of a StatementContext matches one from a collection of statement * definitions. * - * @param ctx - * StatementContext to be checked - * @param ancestorTypes - * collection of statement definitions + * @param stmt Statement context to be checked + * @param ancestorTypes collection of statement definitions * @return true if at least one ancestor of a StatementContext matches one * from collection of statement definitions, otherwise false. */ - public static boolean hasAncestorOfType(final StmtContext ctx, + public static boolean hasAncestorOfType(final StmtContext stmt, final Collection ancestorTypes) { requireNonNull(ancestorTypes); - StmtContext current = ctx.getParentContext(); + StmtContext current = stmt.getParentContext(); while (current != null) { - if (ancestorTypes.contains(current.getPublicDefinition())) { + if (ancestorTypes.contains(current.publicDefinition())) { return true; } current = current.getParentContext(); @@ -360,51 +361,69 @@ public final class StmtContextUtils { } /** - * Checks whether all of StmtContext's ancestors of specified type have a child of specified type. + * Check whether all of StmtContext's {@code list} ancestors have a {@code key}. * - * @param ctx StmtContext to be checked - * @param ancestorType type of ancestor to search for - * @param ancestorChildType type of child to search for in the specified ancestor type - * @return true if all of StmtContext's ancestors of specified type have a child of specified type, otherwise false + * @param stmt EffectiveStmtCtx to be checked + * @param name Human-friendly statement name + * @throws SourceException if there is any keyless list ancestor */ - public static > boolean hasAncestorOfTypeWithChildOfType( - final StmtContext ctx, final StatementDefinition ancestorType, - final StatementDefinition ancestorChildType) { - requireNonNull(ctx); - requireNonNull(ancestorType); - requireNonNull(ancestorChildType); - - StmtContext current = ctx.coerceParentContext(); - StmtContext parent = current.getParentContext(); + public static void validateNoKeylessListAncestorOf(final Mutable stmt, final String name) { + requireNonNull(stmt); + + // We do not expect this to by typically populated + final List> incomplete = new ArrayList<>(0); + + Mutable current = stmt.coerceParentContext(); + Mutable parent = current.getParentContext(); while (parent != null) { - if (ancestorType.equals(current.getPublicDefinition())) { - @SuppressWarnings("unchecked") - final Class ancestorChildTypeClass = (Class) ancestorChildType.getDeclaredRepresentationClass(); - if (findFirstSubstatement(current, ancestorChildTypeClass) == null) { - return false; + if (YangStmtMapping.LIST == current.publicDefinition() + && !current.hasSubstatement(KeyEffectiveStatement.class)) { + if (ModelProcessingPhase.FULL_DECLARATION.isCompletedBy(current.getCompletedPhase())) { + throw new SourceException(stmt, "%s %s is defined within a list that has no key statement", name, + stmt.argument()); } + + // Ancestor has not completed full declaration yet missing 'key' statement may materialize later + incomplete.add(current); } current = parent; parent = current.getParentContext(); } - return true; + // Deal with whatever incomplete ancestors we encountered + for (Mutable ancestor : incomplete) { + // This check must complete during the ancestor's FULL_DECLARATION phase, i.e. the ancestor must not reach + // EFFECTIVE_MODEL until it is done. + final ModelActionBuilder action = ancestor.newInferenceAction(ModelProcessingPhase.FULL_DECLARATION); + action.apply(new InferenceAction() { + @Override + public void apply(final InferenceContext ctx) { + if (!ancestor.hasSubstatement(KeyEffectiveStatement.class)) { + throw new SourceException(stmt, "%s %s is defined within a list that has no key statement", + name, stmt.argument()); + } + } + + @Override + public void prerequisiteFailed(final Collection> failed) { + throw new VerifyException("Should never happen"); + } + }); + } } /** * Checks whether the parent of StmtContext is of specified type. * - * @param ctx - * StmtContext to be checked - * @param parentType - * type of parent to check + * @param ctx StmtContext to be checked + * @param parentType type of parent to check * @return true if the parent of StmtContext is of specified type, otherwise false */ public static boolean hasParentOfType(final StmtContext ctx, final StatementDefinition parentType) { requireNonNull(parentType); final StmtContext parentContext = ctx.getParentContext(); - return parentContext != null && parentType.equals(parentContext.getPublicDefinition()); + return parentContext != null && parentType.equals(parentContext.publicDefinition()); } /** @@ -422,15 +441,14 @@ public final class StmtContextUtils { return; } - final StmtContext listStmtCtx = ctx.getParentContext(); - final StmtContext, ?, ?> keyStmtCtx = findFirstDeclaredSubstatement( - listStmtCtx, KeyStatement.class); + final StmtContext listStmtCtx = ctx.coerceParentContext(); + final StmtContext, ?, ?> keyStmtCtx = findFirstDeclaredSubstatement(listStmtCtx, KeyStatement.class); - if (YangStmtMapping.LEAF.equals(ctx.getPublicDefinition())) { + if (YangStmtMapping.LEAF.equals(ctx.publicDefinition())) { if (isListKey(ctx, keyStmtCtx)) { disallowIfFeatureAndWhenOnListKeys(ctx); } - } else if (YangStmtMapping.USES.equals(ctx.getPublicDefinition())) { + } else if (YangStmtMapping.USES.equals(ctx.publicDefinition())) { findAllEffectiveSubstatements(listStmtCtx, LeafStatement.class).forEach(leafStmtCtx -> { if (isListKey(leafStmtCtx, keyStmtCtx)) { disallowIfFeatureAndWhenOnListKeys(leafStmtCtx); @@ -440,34 +458,28 @@ public final class StmtContextUtils { } private static boolean isRelevantForIfFeatureAndWhenOnListKeysCheck(final StmtContext ctx) { - return YangVersion.VERSION_1_1.equals(ctx.getRootVersion()) && hasParentOfType(ctx, YangStmtMapping.LIST) + return YangVersion.VERSION_1_1.equals(ctx.yangVersion()) && hasParentOfType(ctx, YangStmtMapping.LIST) && findFirstDeclaredSubstatement(ctx.coerceParentContext(), KeyStatement.class) != null; } private static boolean isListKey(final StmtContext leafStmtCtx, - final StmtContext, ?, ?> keyStmtCtx) { - for (final SchemaNodeIdentifier keyIdentifier : keyStmtCtx.coerceStatementArgument()) { - if (leafStmtCtx.getStatementArgument().equals(Iterables.getLast(keyIdentifier.getNodeIdentifiers()))) { - return true; - } - } - - return false; + final StmtContext, ?, ?> keyStmtCtx) { + return keyStmtCtx.getArgument().contains(leafStmtCtx.argument()); } private static void disallowIfFeatureAndWhenOnListKeys(final StmtContext leafStmtCtx) { leafStmtCtx.allSubstatements().forEach(leafSubstmtCtx -> { - final StatementDefinition statementDef = leafSubstmtCtx.getPublicDefinition(); + final StatementDefinition statementDef = leafSubstmtCtx.publicDefinition(); SourceException.throwIf(YangStmtMapping.IF_FEATURE.equals(statementDef) - || YangStmtMapping.WHEN.equals(statementDef), leafStmtCtx.getStatementSourceReference(), + || YangStmtMapping.WHEN.equals(statementDef), leafStmtCtx, "%s statement is not allowed in %s leaf statement which is specified as a list key.", - statementDef.getStatementName(), leafStmtCtx.getStatementArgument()); + statementDef.getStatementName(), leafStmtCtx.argument()); }); } public static QName qnameFromArgument(StmtContext ctx, final String value) { if (Strings.isNullOrEmpty(value)) { - return ctx.getPublicDefinition().getStatementName(); + return ctx.publicDefinition().getStatementName(); } String prefix; @@ -489,14 +501,13 @@ public final class StmtContextUtils { localName = value; qnameModule = getRootModuleQName(ctx); } - if (qnameModule == null && ctx.getCopyHistory().getLastOperation() == CopyType.ADDED_BY_AUGMENTATION) { + if (qnameModule == null && ctx.history().getLastOperation() == CopyType.ADDED_BY_AUGMENTATION) { ctx = ctx.getOriginalCtx().orElse(null); qnameModule = getModuleQNameByPrefix(ctx, prefix); } } - return internedQName(ctx, - InferenceException.throwIfNull(qnameModule, ctx.getStatementSourceReference(), + return internedQName(ctx, InferenceException.throwIfNull(qnameModule, ctx, "Cannot resolve QNameModule for '%s'", value), localName); } @@ -510,30 +521,16 @@ public final class StmtContextUtils { * @throws SourceException if the string is not a valid YANG identifier */ public static QName parseIdentifier(final StmtContext ctx, final String str) { - SourceException.throwIf(str.isEmpty(), ctx.getStatementSourceReference(), - "Identifier may not be an empty string"); + SourceException.throwIf(str.isEmpty(), ctx, "Identifier may not be an empty string"); return internedQName(ctx, str); } - public static QName parseNodeIdentifier(StmtContext ctx, final String prefix, + public static QName parseNodeIdentifier(final StmtContext ctx, final String prefix, final String localName) { - final QNameModule module = getModuleQNameByPrefix(ctx, prefix); - if (module != null) { - return internedQName(ctx, module, localName); - } - - if (ctx.getCopyHistory().getLastOperation() == CopyType.ADDED_BY_AUGMENTATION) { - final Optional> optOrigCtx = ctx.getOriginalCtx(); - if (optOrigCtx.isPresent()) { - ctx = optOrigCtx.get(); - final QNameModule origModule = getModuleQNameByPrefix(ctx, prefix); - if (origModule != null) { - return internedQName(ctx, origModule, localName); - } - } - } - - throw new InferenceException(ctx.getStatementSourceReference(), "Cannot resolve QNameModule for '%s'", prefix); + return internedQName(ctx, + InferenceException.throwIfNull(getModuleQNameByPrefix(ctx, prefix), ctx, + "Cannot resolve QNameModule for '%s'", prefix), + localName); } /** @@ -546,8 +543,7 @@ public final class StmtContextUtils { * @throws SourceException if the string is not a valid YANG node identifier */ public static QName parseNodeIdentifier(final StmtContext ctx, final String str) { - SourceException.throwIf(str.isEmpty(), ctx.getStatementSourceReference(), - "Node identifier may not be an empty string"); + SourceException.throwIf(str.isEmpty(), ctx, "Node identifier may not be an empty string"); final int colon = str.indexOf(':'); if (colon == -1) { @@ -555,11 +551,9 @@ public final class StmtContextUtils { } final String prefix = str.substring(0, colon); - SourceException.throwIf(prefix.isEmpty(), ctx.getStatementSourceReference(), - "String '%s' has an empty prefix", str); + SourceException.throwIf(prefix.isEmpty(), ctx, "String '%s' has an empty prefix", str); final String localName = str.substring(colon + 1); - SourceException.throwIf(localName.isEmpty(), ctx.getStatementSourceReference(), - "String '%s' has an empty identifier", str); + SourceException.throwIf(localName.isEmpty(), ctx, "String '%s' has an empty identifier", str); return parseNodeIdentifier(ctx, prefix, localName); } @@ -568,13 +562,13 @@ public final class StmtContextUtils { return internedQName(ctx, getRootModuleQName(ctx), localName); } - private static QName internedQName(final StmtContext ctx, final QNameModule module, + private static QName internedQName(final CommonStmtCtx ctx, final QNameModule module, final String localName) { final QName template; try { template = QName.create(module, localName); } catch (IllegalArgumentException e) { - throw new SourceException(ctx.getStatementSourceReference(), e, "Invalid identifier '%s'", localName); + throw new SourceException(ctx, e, "Invalid identifier '%s'", localName); } return template.intern(); } @@ -587,9 +581,9 @@ public final class StmtContextUtils { final StmtContext rootCtx = ctx.getRoot(); final QNameModule qnameModule; - if (producesDeclared(rootCtx, ModuleStatement.class)) { + if (rootCtx.producesDeclared(ModuleStatement.class)) { qnameModule = rootCtx.getFromNamespace(ModuleCtxToModuleQName.class, rootCtx); - } else if (producesDeclared(rootCtx, SubmoduleStatement.class)) { + } else if (rootCtx.producesDeclared(SubmoduleStatement.class)) { final String belongsToModuleName = firstAttributeOf(rootCtx.declaredSubstatements(), BelongsToStatement.class); qnameModule = rootCtx.getFromNamespace(ModuleNameToModuleQName.class, belongsToModuleName); @@ -602,42 +596,29 @@ public final class StmtContextUtils { } public static QNameModule getModuleQNameByPrefix(final StmtContext ctx, final String prefix) { - final StmtContext importedModule = ctx.getRoot().getFromNamespace(ImportPrefixToModuleCtx.class, - prefix); + final StmtContext root = ctx.getRoot(); + final StmtContext importedModule = root.getFromNamespace(ImportPrefixToModuleCtx.class, prefix); final QNameModule qnameModule = ctx.getFromNamespace(ModuleCtxToModuleQName.class, importedModule); if (qnameModule != null) { return qnameModule; } - if (producesDeclared(ctx.getRoot(), SubmoduleStatement.class)) { - final String moduleName = ctx.getRoot().getFromNamespace(BelongsToPrefixToModuleName.class, prefix); + if (root.producesDeclared(SubmoduleStatement.class)) { + final String moduleName = root.getFromNamespace(BelongsToPrefixToModuleName.class, prefix); return ctx.getFromNamespace(ModuleNameToModuleQName.class, moduleName); } return null; } - public static SourceIdentifier createSourceIdentifier(final StmtContext root) { - final QNameModule qNameModule = root.getFromNamespace(ModuleCtxToModuleQName.class, root); - if (qNameModule != null) { - // creates SourceIdentifier for a module - return RevisionSourceIdentifier.create((String) root.getStatementArgument(), qNameModule.getRevision()); - } - - // creates SourceIdentifier for a submodule - final Optional revision = getLatestRevision(root.declaredSubstatements()); - return RevisionSourceIdentifier.create((String) root.getStatementArgument(), revision); - } - public static Optional getLatestRevision(final Iterable> subStmts) { Revision revision = null; for (final StmtContext subStmt : subStmts) { - if (subStmt.getPublicDefinition().getDeclaredRepresentationClass().isAssignableFrom( - RevisionStatement.class)) { - if (revision == null && subStmt.getStatementArgument() != null) { - revision = (Revision) subStmt.getStatementArgument(); + if (subStmt.producesDeclared(RevisionStatement.class)) { + if (revision == null && subStmt.argument() != null) { + revision = (Revision) subStmt.argument(); } else { - final Revision subArg = (Revision) subStmt.getStatementArgument(); + final Revision subArg = (Revision) subStmt.argument(); if (subArg != null && subArg.compareTo(revision) > 0) { revision = subArg; }