Bug 6867: Extend yang statement parser to support different yang versions

[yangtools.git] / yang / yang-parser-impl / src / main / java / org / opendaylight / yangtools / yang / parser / stmt / rfc6020 / effective / AbstractEffectiveModule.java

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveModule.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveModule.java
index ff01174c5506801ad42e942b8812fcde05f2c65a..7ae2adc5528caf70ae20e5f74c589ff8d31bde54 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveModule.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/effective/AbstractEffectiveModule.java
@@ -11,19 +11,22 @@ import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import java.net.URI;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Date;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
-import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import javax.annotation.Nonnull;
 import org.opendaylight.yangtools.concepts.Immutable;
+import org.opendaylight.yangtools.concepts.SemVer;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.common.QNameModule;
 import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
+import org.opendaylight.yangtools.yang.common.YangVersion;
 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.Deviation;
@@ -42,8 +45,6 @@ import org.opendaylight.yangtools.yang.model.api.UsesNode;
 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
-import org.opendaylight.yangtools.yang.model.util.ExtendedType;
-import org.opendaylight.yangtools.yang.model.util.ModuleImportImpl;
 import org.opendaylight.yangtools.yang.parser.spi.SubmoduleNamespace;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
@@ -57,7 +58,7 @@ abstract class AbstractEffectiveModule<D extends DeclaredStatement<String>> exte
     private final String name;
     private final String sourcePath;
     private final String prefix;
-    private final String yangVersion;
+    private final YangVersion yangVersion;
     private final String organization;
     private final String contact;
     private final Set<ModuleImport> imports;
@@ -75,6 +76,7 @@ abstract class AbstractEffectiveModule<D extends DeclaredStatement<String>> exte
     private final Set<UsesNode> uses;
     private final Set<TypeDefinition<?>> typeDefinitions;
     private final Set<DataSchemaNode> publicChildNodes;
+    private final SemVer semanticVersion;
 
     AbstractEffectiveModule(final StmtContext<String, D, ? extends EffectiveStatement<String, ?>> ctx) {
         super(ctx);
@@ -85,7 +87,10 @@ abstract class AbstractEffectiveModule<D extends DeclaredStatement<String>> exte
         this.prefix = (prefixStmt == null) ? null : prefixStmt.argument();
 
         YangVersionEffectiveStatementImpl yangVersionStmt = firstEffective(YangVersionEffectiveStatementImpl.class);
-        this.yangVersion = (yangVersionStmt == null) ? "1" : yangVersionStmt.argument();
+        this.yangVersion = (yangVersionStmt == null) ? YangVersion.VERSION_1 : yangVersionStmt.argument();
+
+        SemanticVersionEffectiveStatementImpl semanticVersionStmt = firstEffective(SemanticVersionEffectiveStatementImpl.class);
+        this.semanticVersion = (semanticVersionStmt == null) ? DEFAULT_SEMANTIC_VERSION : semanticVersionStmt.argument();
 
         OrganizationEffectiveStatementImpl organizationStmt = firstEffective(OrganizationEffectiveStatementImpl.class);
         this.organization = (organizationStmt == null) ? null : organizationStmt.argument();
@@ -110,11 +115,12 @@ abstract class AbstractEffectiveModule<D extends DeclaredStatement<String>> exte
         } else {
             Collection<ModuleIdentifier> includedSubmodules = includedSubmodulesMap.values();
             Set<Module> submodulesInit = new HashSet<>();
-            List<EffectiveStatement<?, ?>> substatementsOfSubmodulesInit = new LinkedList<>();
+            List<EffectiveStatement<?, ?>> substatementsOfSubmodulesInit = new ArrayList<>();
             for (ModuleIdentifier submoduleIdentifier : includedSubmodules) {
                 @SuppressWarnings("unchecked")
-                Mutable<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> submoduleCtx = (Mutable<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>>) ctx
-                        .getFromNamespace(SubmoduleNamespace.class, submoduleIdentifier);
+                Mutable<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>> submoduleCtx =
+                    (Mutable<String, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>>)
+                        ctx.getFromNamespace(SubmoduleNamespace.class, submoduleIdentifier);
                 SubmoduleEffectiveStatementImpl submodule = (SubmoduleEffectiveStatementImpl) submoduleCtx
                         .buildEffective();
                 submodulesInit.add(submodule);
@@ -126,20 +132,19 @@ abstract class AbstractEffectiveModule<D extends DeclaredStatement<String>> exte
         }
 
         // init substatements collections
-        List<EffectiveStatement<?, ?>> effectiveSubstatements = new LinkedList<>();
-
+        List<EffectiveStatement<?, ?>> effectiveSubstatements = new ArrayList<>();
         effectiveSubstatements.addAll(effectiveSubstatements());
         effectiveSubstatements.addAll(substatementsOfSubmodules);
 
-        List<UnknownSchemaNode> unknownNodesInit = new LinkedList<>();
-        Set<AugmentationSchema> augmentationsInit = new HashSet<>();
+        List<UnknownSchemaNode> unknownNodesInit = new ArrayList<>();
+        Set<AugmentationSchema> augmentationsInit = new LinkedHashSet<>();
         Set<ModuleImport> importsInit = new HashSet<>();
         Set<NotificationDefinition> notificationsInit = new HashSet<>();
         Set<RpcDefinition> rpcsInit = new HashSet<>();
         Set<Deviation> deviationsInit = new HashSet<>();
         Set<IdentitySchemaNode> identitiesInit = new HashSet<>();
         Set<FeatureDefinition> featuresInit = new HashSet<>();
-        List<ExtensionDefinition> extensionNodesInit = new LinkedList<>();
+        List<ExtensionDefinition> extensionNodesInit = new ArrayList<>();
 
         Map<QName, DataSchemaNode> mutableChildNodes = new LinkedHashMap<>();
         Set<GroupingDefinition> mutableGroupings = new HashSet<>();
@@ -172,8 +177,8 @@ abstract class AbstractEffectiveModule<D extends DeclaredStatement<String>> exte
             if (effectiveStatement instanceof FeatureDefinition) {
                 featuresInit.add((FeatureDefinition) effectiveStatement);
             }
-            if (effectiveStatement instanceof ExtensionDefinition) {
-                extensionNodesInit.add((ExtensionDefinition) effectiveStatement);
+            if (effectiveStatement instanceof ExtensionEffectiveStatementImpl) {
+                extensionNodesInit.add((ExtensionEffectiveStatementImpl) effectiveStatement);
             }
             if (effectiveStatement instanceof DataSchemaNode) {
                 DataSchemaNode dataSchemaNode = (DataSchemaNode) effectiveStatement;
@@ -194,9 +199,9 @@ abstract class AbstractEffectiveModule<D extends DeclaredStatement<String>> exte
             }
             if (effectiveStatement instanceof TypeDefEffectiveStatementImpl) {
                 TypeDefEffectiveStatementImpl typeDef = (TypeDefEffectiveStatementImpl) effectiveStatement;
-                ExtendedType extendedType = typeDef.buildType();
-                if (!mutableTypeDefinitions.contains(extendedType)) {
-                    mutableTypeDefinitions.add(extendedType);
+                TypeDefinition<?> type = typeDef.getTypeDefinition();
+                if (!mutableTypeDefinitions.contains(type)) {
+                    mutableTypeDefinitions.add(type);
                 } else {
                     throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, effectiveStatement);
                 }
@@ -213,7 +218,11 @@ abstract class AbstractEffectiveModule<D extends DeclaredStatement<String>> exte
 
         this.unknownNodes = ImmutableList.copyOf(unknownNodesInit);
         this.augmentations = ImmutableSet.copyOf(augmentationsInit);
-        this.imports = ImmutableSet.copyOf(resolveModuleImports(importsInit, ctx));
+        if (ctx.isEnabledSemanticVersioning()) {
+            this.imports = ImmutableSet.copyOf(importsInit);
+        } else {
+            this.imports = ImmutableSet.copyOf(resolveModuleImports(importsInit, ctx));
+        }
         this.notifications = ImmutableSet.copyOf(notificationsInit);
         this.rpcs = ImmutableSet.copyOf(rpcsInit);
         this.deviations = ImmutableSet.copyOf(deviationsInit);
@@ -231,15 +240,13 @@ abstract class AbstractEffectiveModule<D extends DeclaredStatement<String>> exte
 
     private static Set<ModuleImport> resolveModuleImports(final Set<ModuleImport> importsInit,
             final StmtContext<String, ? extends DeclaredStatement<String>, ? extends EffectiveStatement<String, ?>> ctx) {
-        Set<ModuleImport> resolvedModuleImports = new LinkedHashSet<>();
+        final Set<ModuleImport> resolvedModuleImports = new LinkedHashSet<>();
         for (ModuleImport moduleImport : importsInit) {
             if (moduleImport.getRevision().equals(SimpleDateFormatUtil.DEFAULT_DATE_IMP)) {
-                QNameModule impModuleQName = Utils.getModuleQNameByPrefix(ctx, moduleImport.getPrefix());
-                if (!impModuleQName.getRevision().equals(SimpleDateFormatUtil.DEFAULT_DATE_REV)) {
-                    ModuleImport resolvedModuleImport = new ModuleImportImpl(moduleImport.getModuleName(),
-                            impModuleQName.getRevision(), moduleImport.getPrefix());
-                    resolvedModuleImports.add(resolvedModuleImport);
-                }
+                final QNameModule impModuleQName = Utils.getModuleQNameByPrefix(ctx, moduleImport.getPrefix());
+                final ModuleImport resolvedModuleImport = new ModuleImportImpl(moduleImport.getModuleName(),
+                        impModuleQName.getRevision(), moduleImport.getPrefix());
+                resolvedModuleImports.add(resolvedModuleImport);
             } else {
                 resolvedModuleImports.add(moduleImport);
             }
@@ -279,7 +286,7 @@ abstract class AbstractEffectiveModule<D extends DeclaredStatement<String>> exte
 
     @Override
     public String getYangVersion() {
-        return yangVersion;
+        return yangVersion.toCanonicalString();
     }
 
     @Override
@@ -337,6 +344,7 @@ abstract class AbstractEffectiveModule<D extends DeclaredStatement<String>> exte
         return identities;
     }
 
+    @Nonnull
     @Override
     public List<UnknownSchemaNode> getUnknownSchemaNodes() {
         return unknownNodes;
@@ -365,31 +373,24 @@ abstract class AbstractEffectiveModule<D extends DeclaredStatement<String>> exte
     }
 
     @Override
-    public final DataSchemaNode getDataChildByName(final String name) {
-        for (DataSchemaNode node : childNodes.values()) {
-            if (node.getQName().getLocalName().equals(name)) {
-                return node;
-            }
-        }
-        return null;
+    public Set<UsesNode> getUses() {
+        return uses;
     }
 
     @Override
-    public Set<UsesNode> getUses() {
-        return uses;
+    public SemVer getSemanticVersion() {
+        return semanticVersion;
     }
 
     @Override
     public String toString() {
-        StringBuilder sb = new StringBuilder(this.getClass().getSimpleName());
-        sb.append("[");
-        sb.append("name=").append(name);
-        sb.append(", namespace=").append(getNamespace());
-        sb.append(", revision=").append(getRevision());
-        sb.append(", prefix=").append(prefix);
-        sb.append(", yangVersion=").append(yangVersion);
-        sb.append("]");
-        return sb.toString();
+        return this.getClass().getSimpleName() + "[" +
+                "name=" + name +
+                ", namespace=" + getNamespace() +
+                ", revision=" + getRevision() +
+                ", prefix=" + prefix +
+                ", yangVersion=" + yangVersion +
+                "]";
     }
 
 }