import java.util.Objects;
import java.util.Optional;
import java.util.Set;
-import javax.annotation.Nullable;
import org.antlr.v4.runtime.ParserRuleContext;
-import org.opendaylight.yangtools.antlrv4.code.gen.YangStatementParser.StatementContext;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigStatements;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.yang.parser.antlr.YangStatementParser.ArgumentContext;
+import org.opendaylight.yangtools.yang.parser.antlr.YangStatementParser.StatementContext;
import org.opendaylight.yangtools.yang.parser.spi.source.DeclarationInTextSource;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
* @return {@link YangModelDependencyInfo}
* @throws YangSyntaxErrorException If the AST is not a valid YANG module/submodule
*/
- static YangModelDependencyInfo fromAST(final SourceIdentifier source, final ParserRuleContext tree)
+ static @NonNull YangModelDependencyInfo fromAST(final SourceIdentifier source, final ParserRuleContext tree)
throws YangSyntaxErrorException {
if (tree instanceof StatementContext) {
throw new YangSyntaxErrorException(source, 0, 0, "Unknown YANG text type");
}
- private static YangModelDependencyInfo parseAST(final StatementContext rootStatement,
+ private static @NonNull YangModelDependencyInfo parseAST(final StatementContext rootStatement,
final SourceIdentifier source) {
final String keyWordText = rootStatement.keyword().getText();
if (MODULE.equals(keyWordText)) {
return parseAST((StatementContext) ast, source.getIdentifier());
}
- private static YangModelDependencyInfo parseModuleContext(final StatementContext module,
+ private static @NonNull YangModelDependencyInfo parseModuleContext(final StatementContext module,
final SourceIdentifier source) {
- final String name = ArgumentContextUtils.stringFromStringContext(module.argument(), getReference(source,
- module));
+ final String name = safeStringArgument(source, module, "module name");
final String latestRevision = getLatestRevision(module, source);
final Optional<SemVer> semVer = Optional.ofNullable(findSemanticVersion(module, source));
final ImmutableSet<ModuleImport> imports = parseImports(module, source);
final Set<ModuleImport> result = new HashSet<>();
for (final StatementContext subStatementContext : module.statement()) {
if (IMPORT.equals(subStatementContext.keyword().getText())) {
+ final String importedModuleName = safeStringArgument(source, subStatementContext,
+ "imported module name");
final String revisionDateStr = getRevisionDateString(subStatementContext, source);
- final String importedModuleName = ArgumentContextUtils.stringFromStringContext(
- subStatementContext.argument(), getReference(source, subStatementContext));
final Revision revisionDate = Revision.ofNullable(revisionDateStr).orElse(null);
final SemVer importSemVer = findSemanticVersion(subStatementContext, source);
result.add(new ModuleImportImpl(importedModuleName, revisionDate, importSemVer));
for (final StatementContext subStatement : statement.statement()) {
final String subStatementName = trimPrefix(subStatement.keyword().getText());
if (OPENCONFIG_VERSION.equals(subStatementName)) {
- semVerString = ArgumentContextUtils.stringFromStringContext(subStatement.argument(),
- getReference(source, subStatement));
+ semVerString = safeStringArgument(source, subStatement, "version string");
break;
}
}
for (final StatementContext subStatementContext : module.statement()) {
if (INCLUDE.equals(subStatementContext.keyword().getText())) {
final String revisionDateStr = getRevisionDateString(subStatementContext, source);
- final String IncludeModuleName = ArgumentContextUtils.stringFromStringContext(
- subStatementContext.argument(), getReference(source, subStatementContext));
+ final String IncludeModuleName = safeStringArgument(source, subStatementContext,
+ "included submodule name");
final Revision revisionDate = Revision.ofNullable(revisionDateStr).orElse(null);
result.add(new ModuleImportImpl(IncludeModuleName, revisionDate));
}
String revisionDateStr = null;
for (final StatementContext importSubStatement : importStatement.statement()) {
if (REVISION_DATE.equals(importSubStatement.keyword().getText())) {
- revisionDateStr = ArgumentContextUtils.stringFromStringContext(importSubStatement.argument(),
- getReference(source, importSubStatement));
+ revisionDateStr = safeStringArgument(source, importSubStatement, "imported module revision-date");
}
}
return revisionDateStr;
String latestRevision = null;
for (final StatementContext subStatementContext : module.statement()) {
if (REVISION.equals(subStatementContext.keyword().getText())) {
- final String currentRevision = ArgumentContextUtils.stringFromStringContext(
- subStatementContext.argument(), getReference(source, subStatementContext));
+ final String currentRevision = safeStringArgument(source, subStatementContext, "revision date");
if (latestRevision == null || latestRevision.compareTo(currentRevision) < 0) {
latestRevision = currentRevision;
}
return latestRevision;
}
- private static YangModelDependencyInfo parseSubmoduleContext(final StatementContext submodule,
+ private static @NonNull YangModelDependencyInfo parseSubmoduleContext(final StatementContext submodule,
final SourceIdentifier source) {
- final String name = ArgumentContextUtils.stringFromStringContext(submodule.argument(),
- getReference(source, submodule));
+ final String name = safeStringArgument(source, submodule, "submodule name");
final String belongsTo = parseBelongsTo(submodule, source);
final String latestRevision = getLatestRevision(submodule, source);
private static String parseBelongsTo(final StatementContext submodule, final SourceIdentifier source) {
for (final StatementContext subStatementContext : submodule.statement()) {
if (BELONGS_TO.equals(subStatementContext.keyword().getText())) {
- return ArgumentContextUtils.stringFromStringContext(subStatementContext.argument(),
- getReference(source, subStatementContext));
+ return safeStringArgument(source, subStatementContext, "belongs-to module name");
}
}
return null;
}
+ private static String safeStringArgument(final SourceIdentifier source, final StatementContext stmt,
+ final String desc) {
+ final StatementSourceReference ref = getReference(source, stmt);
+ final ArgumentContext arg = stmt.argument();
+ checkArgument(arg != null, "Missing %s at %s", desc, ref);
+ return ArgumentContextUtils.stringFromStringContext(arg, YangVersion.VERSION_1, ref);
+ }
+
private static StatementSourceReference getReference(final SourceIdentifier source,
final StatementContext context) {
return DeclarationInTextSource.atPosition(source.getName(), context.getStart().getLine(),
* Dependency information for YANG module.
*/
public static final class ModuleDependencyInfo extends YangModelDependencyInfo {
- private ModuleDependencyInfo(final String name, final String latestRevision,
- final ImmutableSet<ModuleImport> imports, final ImmutableSet<ModuleImport> includes) {
- super(name, latestRevision, imports, includes);
- }
-
- private ModuleDependencyInfo(final String name, final String latestRevision,
- final ImmutableSet<ModuleImport> imports,
- final ImmutableSet<ModuleImport> includes,
- final Optional<SemVer> semVer) {
+ ModuleDependencyInfo(final String name, final String latestRevision, final ImmutableSet<ModuleImport> imports,
+ final ImmutableSet<ModuleImport> includes, final Optional<SemVer> semVer) {
super(name, latestRevision, imports, includes, semVer);
}
private final SemVer semVer;
private final String name;
- ModuleImportImpl(final String moduleName, final Revision revision) {
+ ModuleImportImpl(final @NonNull String moduleName, final @Nullable Revision revision) {
this(moduleName, revision, null);
}
- ModuleImportImpl(final String moduleName, @Nullable final Revision revision, @Nullable final SemVer semVer) {
+ ModuleImportImpl(final @NonNull String moduleName, final @Nullable Revision revision,
+ final @Nullable SemVer semVer) {
this.name = requireNonNull(moduleName, "Module name must not be null.");
this.revision = revision;
this.semVer = semVer;
if (this == obj) {
return true;
}
- if (obj == null) {
- return false;
- }
- if (getClass() != obj.getClass()) {
+ if (!(obj instanceof ModuleImportImpl)) {
return false;
}
final ModuleImportImpl other = (ModuleImportImpl) obj;
- if (name == null) {
- if (other.name != null) {
- return false;
- }
- } else if (!name.equals(other.name)) {
- return false;
- }
- if (revision == null) {
- if (other.revision != null) {
- return false;
- }
- } else if (!revision.equals(other.revision)) {
- return false;
- }
-
- if (!Objects.equals(getSemanticVersion(), other.getSemanticVersion())) {
- return false;
- }
- return true;
+ return name.equals(other.name) && Objects.equals(revision, other.revision)
+ && Objects.equals(getSemanticVersion(), other.getSemanticVersion());
}
@Override
Code Review / yangtools.git / blobdiff