*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.SOURCE_LINKAGE;
import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.SOURCE_PRE_LINKAGE;
+import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.findFirstDeclaredSubstatement;
import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
+import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.common.base.Verify;
import java.net.URI;
import java.util.Collection;
-import java.util.Date;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.NavigableMap;
import java.util.Optional;
import org.opendaylight.yangtools.concepts.SemVer;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
-import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ImportStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
+import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
+import org.opendaylight.yangtools.yang.model.repo.api.SemVerSourceIdentifier;
+import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.util.ModuleIdentifierImpl;
import org.opendaylight.yangtools.yang.parser.spi.ModuleNamespace;
import org.opendaylight.yangtools.yang.parser.spi.PreLinkageModuleNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
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.NamespaceKeyCriterion;
import org.opendaylight.yangtools.yang.parser.spi.meta.SemanticVersionModuleNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.SemanticVersionNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
-import org.opendaylight.yangtools.yang.parser.spi.source.ImpPrefixToModuleIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.ImpPrefixToNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.source.ImpPrefixToSemVerModuleIdentifier;
+import org.opendaylight.yangtools.yang.parser.spi.source.ImportPrefixToModuleCtx;
+import org.opendaylight.yangtools.yang.parser.spi.source.ImportPrefixToSemVerSourceIdentifier;
import org.opendaylight.yangtools.yang.parser.spi.source.ImportedModuleContext;
import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleIdentifier;
import org.opendaylight.yangtools.yang.parser.spi.source.ModuleNameToNamespace;
}
@Override
- public void onPreLinkageDeclared(final Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> stmt) {
+ public void onPreLinkageDeclared(final Mutable<String, ImportStatement,
+ EffectiveStatement<String, ImportStatement>> stmt) {
/*
* Add ModuleIdentifier of a module which is required by this module.
* Based on this information, required modules are searched from library
* sources.
*/
- stmt.addRequiredModule(RevisionImport.getImportedModuleIdentifier(stmt));
+ stmt.addRequiredSource(RevisionImport.getImportedSourceIdentifier(stmt));
final String moduleName = stmt.getStatementArgument();
final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_PRE_LINKAGE);
private static void onLinkageDeclared(
final Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> stmt) {
- final ModuleIdentifier impIdentifier = getImportedModuleIdentifier(stmt);
final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_LINKAGE);
- final Prerequisite<StmtContext<?, ?, ?>> imported = importAction.requiresCtx(stmt, ModuleNamespace.class,
- impIdentifier, SOURCE_LINKAGE);
- final Prerequisite<Mutable<?, ?, ?>> linkageTarget = importAction
- .mutatesCtx(stmt.getRoot(), SOURCE_LINKAGE);
+ final Prerequisite<StmtContext<?, ?, ?>> imported;
+ final String moduleName = stmt.getStatementArgument();
+ final Revision revision = firstAttributeOf(stmt.declaredSubstatements(), RevisionDateStatement.class);
+ if (revision == null) {
+ imported = importAction.requiresCtx(stmt, ModuleNamespace.class,
+ NamespaceKeyCriterion.latestRevisionModule(moduleName), SOURCE_LINKAGE);
+ } else {
+ imported = importAction.requiresCtx(stmt, ModuleNamespace.class,
+ ModuleIdentifierImpl.create(moduleName, Optional.of(revision)), SOURCE_LINKAGE);
+ }
+
+ final Prerequisite<Mutable<?, ?, ?>> linkageTarget = importAction.mutatesCtx(stmt.getRoot(),
+ SOURCE_LINKAGE);
importAction.apply(new InferenceAction() {
@Override
public void apply(final InferenceContext ctx) {
- StmtContext<?, ?, ?> importedModule = null;
- ModuleIdentifier importedModuleIdentifier = null;
- if (impIdentifier.getRevision() == SimpleDateFormatUtil.DEFAULT_DATE_IMP) {
- final Entry<ModuleIdentifier, StmtContext<?, ModuleStatement, EffectiveStatement<String, ModuleStatement>>> recentModuleEntry = findRecentModule(
- impIdentifier, stmt.getAllFromNamespace(ModuleNamespace.class));
- if (recentModuleEntry != null) {
- importedModuleIdentifier = recentModuleEntry.getKey();
- importedModule = recentModuleEntry.getValue();
- }
- }
+ final StmtContext<?, ?, ?> importedModule = imported.resolve(ctx);
- if (importedModule == null || importedModuleIdentifier == null) {
- importedModule = imported.resolve(ctx);
- importedModuleIdentifier = impIdentifier;
- }
-
- linkageTarget.resolve(ctx).addToNs(ImportedModuleContext.class, importedModuleIdentifier, importedModule);
+ linkageTarget.resolve(ctx).addToNs(ImportedModuleContext.class,
+ stmt.getFromNamespace(ModuleCtxToModuleIdentifier.class, importedModule), importedModule);
final String impPrefix = firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class);
- stmt.addToNs(ImpPrefixToModuleIdentifier.class, impPrefix, importedModuleIdentifier);
-
- final URI modNs = firstAttributeOf(importedModule.declaredSubstatements(), NamespaceStatement.class);
+ final URI modNs = firstAttributeOf(importedModule.declaredSubstatements(),
+ NamespaceStatement.class);
+ stmt.addToNs(ImportPrefixToModuleCtx.class, impPrefix, importedModule);
stmt.addToNs(URIStringToImpPrefix.class, modNs.toString(), impPrefix);
}
public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
if (failed.contains(imported)) {
throw new InferenceException(stmt.getStatementSourceReference(),
- "Imported module [%s] was not found.", impIdentifier);
+ "Imported module [%s] was not found.", moduleName);
}
}
});
+ }
+ static SourceIdentifier getImportedSourceIdentifier(final StmtContext<String, ImportStatement, ?> stmt) {
+ final StmtContext<Revision, ?, ?> revision = findFirstDeclaredSubstatement(stmt,
+ RevisionDateStatement.class);
+ return revision == null ? RevisionSourceIdentifier.create(stmt.getStatementArgument())
+ : RevisionSourceIdentifier.create(stmt.getStatementArgument(), revision.rawStatementArgument());
}
+ }
- private static Entry<ModuleIdentifier, StmtContext<?, ModuleStatement, EffectiveStatement<String, ModuleStatement>>> findRecentModule(
- final ModuleIdentifier impIdentifier,
- final Map<ModuleIdentifier, StmtContext<?, ModuleStatement, EffectiveStatement<String, ModuleStatement>>> allModules) {
+ private static class SemanticVersionImport {
- ModuleIdentifier recentModuleIdentifier = impIdentifier;
- Entry<ModuleIdentifier, StmtContext<?, ModuleStatement, EffectiveStatement<String, ModuleStatement>>> recentModuleEntry = null;
+ private abstract static class CompatibleCriterion extends NamespaceKeyCriterion<SemVerSourceIdentifier> {
+ private final String moduleName;
- for (final Entry<ModuleIdentifier, StmtContext<?, ModuleStatement, EffectiveStatement<String, ModuleStatement>>> moduleEntry : allModules
- .entrySet()) {
- final ModuleIdentifier id = moduleEntry.getKey();
+ CompatibleCriterion(final String moduleName) {
+ this.moduleName = requireNonNull(moduleName);
+ }
- if (id.getName().equals(impIdentifier.getName())
- && id.getRevision().compareTo(recentModuleIdentifier.getRevision()) > 0) {
- recentModuleIdentifier = id;
- recentModuleEntry = moduleEntry;
- }
+ @Override
+ public boolean match(final SemVerSourceIdentifier key) {
+ return moduleName.equals(key.getName());
}
- return recentModuleEntry;
+ @Override
+ protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
+ return toStringHelper.add("moduleName", moduleName);
+ }
}
- private static ModuleIdentifier getImportedModuleIdentifier(final StmtContext<String, ImportStatement, ?> stmt) {
- Date revision = firstAttributeOf(stmt.declaredSubstatements(), RevisionDateStatement.class);
- if (revision == null) {
- revision = SimpleDateFormatUtil.DEFAULT_DATE_IMP;
+ private static final class NoVerCompatibleCriterion extends CompatibleCriterion {
+ NoVerCompatibleCriterion(final String moduleName) {
+ super(moduleName);
}
- return ModuleIdentifierImpl.create(stmt.getStatementArgument(), Optional.empty(), Optional.of(revision));
+ @Override
+ public SemVerSourceIdentifier select(final SemVerSourceIdentifier first,
+ final SemVerSourceIdentifier second) {
+ // TODO Auto-generated method stub
+ return null;
+ }
}
- }
- private static class SemanticVersionImport {
+ private static final class SemVerCompatibleCriterion extends CompatibleCriterion {
+ private final SemVer semVer;
+
+ SemVerCompatibleCriterion(final String moduleName, final SemVer semVer) {
+ super(moduleName);
+ this.semVer = requireNonNull(semVer);
+ }
+
+ @Override
+ public boolean match(final SemVerSourceIdentifier key) {
+ if (!super.match(key)) {
+ return false;
+ }
+ final Optional<SemVer> optKeyVer = key.getSemanticVersion();
+ if (!optKeyVer.isPresent()) {
+ return false;
+ }
+
+ final SemVer keyVer = optKeyVer.get();
+ if (semVer.getMajor() != keyVer.getMajor()) {
+ return false;
+ }
+ if (semVer.getMinor() > keyVer.getMinor()) {
+ return false;
+ }
+ return semVer.getMinor() < keyVer.getMinor() || semVer.getPatch() <= keyVer.getPatch();
+ }
+
+ @Override
+ public SemVerSourceIdentifier select(final SemVerSourceIdentifier first,
+ final SemVerSourceIdentifier second) {
+ return first.getSemanticVersion().get().compareTo(second.getSemanticVersion().get()) >= 0 ? first
+ : second;
+ }
+
+ @Override
+ protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
+ return super.addToStringAttributes(toStringHelper).add("version", semVer);
+ }
+ }
+
+
private SemanticVersionImport() {
throw new UnsupportedOperationException("Utility class");
}
private static void onLinkageDeclared(
final Mutable<String, ImportStatement, EffectiveStatement<String, ImportStatement>> stmt) {
- final ModuleIdentifier impIdentifier = getImportedModuleIdentifier(stmt);
final ModelActionBuilder importAction = stmt.newInferenceAction(SOURCE_LINKAGE);
- final Prerequisite<StmtContext<?, ?, ?>> imported = importAction.requiresCtx(stmt, ModuleNamespace.class,
- impIdentifier, SOURCE_LINKAGE);
- final Prerequisite<Mutable<?, ?, ?>> linkageTarget = importAction
- .mutatesCtx(stmt.getRoot(), SOURCE_LINKAGE);
+ final String moduleName = stmt.getStatementArgument();
+ final SemVer semanticVersion = stmt.getFromNamespace(SemanticVersionNamespace.class, stmt);
+ final CompatibleCriterion criterion = semanticVersion == null ? new NoVerCompatibleCriterion(moduleName)
+ : new SemVerCompatibleCriterion(moduleName, semanticVersion);
+
+ final Prerequisite<StmtContext<?, ?, ?>> imported = importAction.requiresCtx(stmt,
+ SemanticVersionModuleNamespace.class, criterion, SOURCE_LINKAGE);
+ final Prerequisite<Mutable<?, ?, ?>> linkageTarget = importAction.mutatesCtx(stmt.getRoot(),
+ SOURCE_LINKAGE);
importAction.apply(new InferenceAction() {
@Override
public void apply(final InferenceContext ctx) {
- final Entry<SemVer, StmtContext<?, ?, ?>> importedModuleEntry= findRecentCompatibleModuleEntry(
- impIdentifier.getName(), stmt);
-
- StmtContext<?, ?, ?> importedModule = null;
- ModuleIdentifier importedModuleIdentifier = null;
- ModuleIdentifier semVerModuleIdentifier = null;
- if (importedModuleEntry != null) {
- importedModule = importedModuleEntry.getValue();
- importedModuleIdentifier = importedModule.getFromNamespace(ModuleCtxToModuleIdentifier.class, importedModule);
- semVerModuleIdentifier = createSemVerModuleIdentifier(importedModuleIdentifier, importedModuleEntry.getKey());
- } else {
- throw new InferenceException(stmt.getStatementSourceReference(),
- "Unable to find module compatible with requested import [%s(%s)].", impIdentifier
- .getName(), getRequestedImportVersion(stmt));
- }
-
- linkageTarget.resolve(ctx).addToNs(ImportedModuleContext.class, importedModuleIdentifier, importedModule);
+ final StmtContext<?, ?, ?> importedModule = imported.resolve(ctx);
+ final SemVer importedVersion = stmt.getFromNamespace(SemanticVersionNamespace.class, stmt);
+ final ModuleIdentifier importedModuleIdentifier = importedModule.getFromNamespace(
+ ModuleCtxToModuleIdentifier.class, importedModule);
+ final SemVerSourceIdentifier semVerModuleIdentifier = createSemVerModuleIdentifier(
+ importedModuleIdentifier, importedVersion);
+
+ linkageTarget.resolve(ctx).addToNs(ImportedModuleContext.class, importedModuleIdentifier,
+ importedModule);
final String impPrefix = firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class);
- stmt.addToNs(ImpPrefixToModuleIdentifier.class, impPrefix, importedModuleIdentifier);
- stmt.addToNs(ImpPrefixToSemVerModuleIdentifier.class, impPrefix, semVerModuleIdentifier);
+ stmt.addToNs(ImportPrefixToModuleCtx.class, impPrefix, importedModule);
+ stmt.addToNs(ImportPrefixToSemVerSourceIdentifier.class, impPrefix, semVerModuleIdentifier);
- final URI modNs = firstAttributeOf(importedModule.declaredSubstatements(), NamespaceStatement.class);
+ final URI modNs = firstAttributeOf(importedModule.declaredSubstatements(),
+ NamespaceStatement.class);
stmt.addToNs(URIStringToImpPrefix.class, modNs.toString(), impPrefix);
}
public void prerequisiteFailed(final Collection<? extends Prerequisite<?>> failed) {
if (failed.contains(imported)) {
throw new InferenceException(stmt.getStatementSourceReference(),
- "Unable to find module compatible with requested import [%s(%s)].", impIdentifier
- .getName(), getRequestedImportVersion(stmt));
+ "Unable to find module compatible with requested import [%s(%s)].", moduleName,
+ getRequestedImportVersionString(stmt));
}
}
});
}
- private static SemVer getRequestedImportVersion(final StmtContext<?, ?, ?> impStmt) {
- SemVer requestedImportVersion = impStmt.getFromNamespace(SemanticVersionNamespace.class, impStmt);
- if (requestedImportVersion == null) {
- requestedImportVersion = Module.DEFAULT_SEMANTIC_VERSION;
- }
- return requestedImportVersion;
- }
-
- private static Entry<SemVer, StmtContext<?, ?, ?>> findRecentCompatibleModuleEntry(final String moduleName,
- final StmtContext<String, ImportStatement, EffectiveStatement<String, ImportStatement>> impStmt) {
- NavigableMap<SemVer, StmtContext<?, ?, ?>> allRelevantModulesMap = impStmt.getFromNamespace(
- SemanticVersionModuleNamespace.class, moduleName);
- if (allRelevantModulesMap == null) {
- return null;
- }
-
- final SemVer requestedImportVersion = getRequestedImportVersion(impStmt);
- allRelevantModulesMap = allRelevantModulesMap.subMap(requestedImportVersion, true,
- SemVer.create(requestedImportVersion.getMajor() + 1), false);
- if (!allRelevantModulesMap.isEmpty()) {
- return allRelevantModulesMap.lastEntry();
- }
-
- return null;
+ private static Optional<SemVer> getRequestedImportVersion(final StmtContext<?, ?, ?> stmt) {
+ return Optional.ofNullable(stmt.getFromNamespace(SemanticVersionNamespace.class, stmt));
}
- private static ModuleIdentifier getImportedModuleIdentifier(final StmtContext<String, ImportStatement, ?> impStmt) {
- return ModuleIdentifierImpl.create(impStmt.getStatementArgument(), Optional.empty(),
- Optional.of(SimpleDateFormatUtil.DEFAULT_DATE_IMP));
+ private static String getRequestedImportVersionString(final StmtContext<?, ?, ?> stmt) {
+ return getRequestedImportVersion(stmt).map(SemVer::toString).orElse("<any>");
}
- private static ModuleIdentifier createSemVerModuleIdentifier(final ModuleIdentifier importedModuleIdentifier,
- final SemVer semVer) {
- return ModuleIdentifierImpl.create(importedModuleIdentifier.getName(),
- Optional.ofNullable(importedModuleIdentifier.getNamespace()),
- Optional.of(importedModuleIdentifier.getRevision()), semVer);
+ private static SemVerSourceIdentifier createSemVerModuleIdentifier(
+ final ModuleIdentifier importedModuleIdentifier, final SemVer semVer) {
+ final String formattedRevision = importedModuleIdentifier.getRevision().map(Revision::toString)
+ .orElse(null);
+ return SemVerSourceIdentifier.create(importedModuleIdentifier.getName(), formattedRevision, semVer);
}
}
}
Code Review / yangtools.git / blobdiff