X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-rfc7950%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Frfc7950%2Fstmt%2Fsubmodule%2FSubmoduleEffectiveStatementImpl.java;h=dfe3f8eb21fbd399f7c39180de839ae2c4b94485;hb=5d35db7723bb19c00955c580b21df9552de9fea0;hp=90edc788679f0b4922332fcf3193b458723d0b6f;hpb=32b112dc64848d9c1cf0ea227109ca9a1265e2e7;p=yangtools.git

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/submodule/SubmoduleEffectiveStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/submodule/SubmoduleEffectiveStatementImpl.java
index 90edc78867..dfe3f8eb21 100644
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/submodule/SubmoduleEffectiveStatementImpl.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/submodule/SubmoduleEffectiveStatementImpl.java
@@ -10,19 +10,29 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.submodule;
 import static com.google.common.base.Preconditions.checkState;
 import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
 
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMap.Builder;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
+import com.google.common.collect.Maps;
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.Map;
-import java.util.Objects;
+import java.util.Map.Entry;
 import java.util.Optional;
 import java.util.Set;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.common.QNameModule;
 import org.opendaylight.yangtools.yang.common.Revision;
-import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.model.api.Submodule;
 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
 import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement.PrefixToEffectiveModuleNamespace;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement.QNameModuleToPrefixNamespace;
 import org.opendaylight.yangtools.yang.model.api.stmt.RevisionEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
@@ -35,22 +45,36 @@ import org.opendaylight.yangtools.yang.parser.spi.source.IncludedSubmoduleNameTo
 import org.opendaylight.yangtools.yang.parser.spi.source.ModuleNameToModuleQName;
 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
 
-final class SubmoduleEffectiveStatementImpl extends AbstractEffectiveModule<SubmoduleStatement>
-        implements SubmoduleEffectiveStatement, MutableStatement {
-
+final class SubmoduleEffectiveStatementImpl
+        extends AbstractEffectiveModule<SubmoduleStatement, SubmoduleEffectiveStatement>
+        implements Submodule, SubmoduleEffectiveStatement, MutableStatement {
+    private final ImmutableMap<String, ModuleEffectiveStatement> prefixToModule;
+    private final ImmutableMap<QNameModule, String> namespaceToPrefix;
     private final QNameModule qnameModule;
 
-    private Set<StmtContext<?, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>>> submoduleContexts;
-    private ImmutableSet<Module> submodules;
+    private Set<StmtContext<?, SubmoduleStatement, SubmoduleEffectiveStatement>> submoduleContexts;
+    private ImmutableSet<Submodule> submodules;
     private boolean sealed;
 
-    SubmoduleEffectiveStatementImpl(final StmtContext<String, SubmoduleStatement, SubmoduleEffectiveStatement> ctx) {
-        super(ctx, findSubmodulePrefix(ctx));
+    SubmoduleEffectiveStatementImpl(
+        final StmtContext<UnqualifiedQName, SubmoduleStatement, SubmoduleEffectiveStatement> ctx,
+            final SubmoduleStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+        super(declared, ctx, substatements, findSubmodulePrefix(ctx));
 
         final String belongsToModuleName = firstAttributeOf(ctx.declaredSubstatements(), BelongsToStatement.class);
         final QNameModule belongsToModuleQName = ctx.getFromNamespace(ModuleNameToModuleQName.class,
                 belongsToModuleName);
 
+        final Builder<String, ModuleEffectiveStatement> prefixToModuleBuilder = ImmutableMap.builder();
+        appendPrefixes(ctx, prefixToModuleBuilder);
+        prefixToModule = prefixToModuleBuilder.build();
+
+        final Map<QNameModule, String> tmp = Maps.newLinkedHashMapWithExpectedSize(prefixToModule.size());
+        for (Entry<String, ModuleEffectiveStatement> e : prefixToModule.entrySet()) {
+            tmp.putIfAbsent(e.getValue().localQNameModule(), e.getKey());
+        }
+        namespaceToPrefix = ImmutableMap.copyOf(tmp);
+
         final Optional<Revision> submoduleRevision = findFirstEffectiveSubstatementArgument(
             RevisionEffectiveStatement.class);
         this.qnameModule = QNameModule.create(belongsToModuleQName.getNamespace(), submoduleRevision).intern();
@@ -63,11 +87,11 @@ final class SubmoduleEffectiveStatementImpl extends AbstractEffectiveModule<Subm
         final Map<String, StmtContext<?, ?, ?>> includedSubmodulesMap = ctx.getAllFromCurrentStmtCtxNamespace(
             IncludedSubmoduleNameToModuleCtx.class);
         if (includedSubmodulesMap != null) {
-            final Set<StmtContext<?, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>>>
-                submoduleContextsInit = new HashSet<>();
+            final Set<StmtContext<?, SubmoduleStatement, SubmoduleEffectiveStatement>> submoduleContextsInit =
+                new HashSet<>();
             for (final StmtContext<?, ?, ?> submoduleCtx : includedSubmodulesMap.values()) {
                 submoduleContextsInit.add(
-                    (StmtContext<?, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>>)submoduleCtx);
+                    (StmtContext<?, SubmoduleStatement, SubmoduleEffectiveStatement>)submoduleCtx);
             }
             submoduleContexts = ImmutableSet.copyOf(submoduleContextsInit);
         } else {
@@ -89,42 +113,42 @@ final class SubmoduleEffectiveStatementImpl extends AbstractEffectiveModule<Subm
     }
 
     @Override
-    public Set<Module> getSubmodules() {
-        checkState(sealed, "Attempt to get base submodules from unsealed submodule effective statement %s",
-            qnameModule);
-        return submodules;
+    @SuppressWarnings("unchecked")
+    public <K, V, N extends IdentifierNamespace<K, V>> Optional<? extends Map<K, V>> getNamespaceContents(
+            final @NonNull Class<N> namespace) {
+        if (PrefixToEffectiveModuleNamespace.class.equals(namespace)) {
+            return Optional.of((Map<K, V>) prefixToModule);
+        }
+        if (QNameModuleToPrefixNamespace.class.equals(namespace)) {
+            return Optional.of((Map<K, V>) namespaceToPrefix);
+        }
+        return super.getNamespaceContents(namespace);
     }
 
     @Override
-    public int hashCode() {
-        return Objects.hash(getName(), getYangVersion(), qnameModule);
+    public Collection<? extends @NonNull Submodule> getSubmodules() {
+        checkState(sealed, "Attempt to get base submodules from unsealed submodule effective statement %s",
+            qnameModule);
+        return submodules;
     }
 
     @Override
-    public boolean equals(final Object obj) {
-        if (this == obj) {
-            return true;
-        }
-        if (!(obj instanceof SubmoduleEffectiveStatementImpl)) {
-            return false;
-        }
-        final SubmoduleEffectiveStatementImpl other = (SubmoduleEffectiveStatementImpl) obj;
-        return Objects.equals(getName(), other.getName()) && qnameModule.equals(other.qnameModule)
-                && Objects.equals(getYangVersion(), other.getYangVersion());
+    public SubmoduleEffectiveStatement asEffectiveStatement() {
+        return this;
     }
 
     @Override
     public void seal() {
         if (!sealed) {
             submodules = ImmutableSet.copyOf(Iterables.transform(submoduleContexts,
-                ctx -> (Module) ctx.buildEffective()));
+                ctx -> (Submodule) ctx.buildEffective()));
             submoduleContexts = ImmutableSet.of();
             sealed = true;
         }
     }
 
-    private static @NonNull String findSubmodulePrefix(final StmtContext<String, ?, ?> ctx) {
-        final String name = ctx.getStatementArgument();
+    private static @NonNull String findSubmodulePrefix(final StmtContext<UnqualifiedQName, ?, ?> ctx) {
+        final String name = ctx.coerceRawStatementArgument();
         final StmtContext<?, ?, ?> belongsTo = SourceException.throwIfNull(
                 StmtContextUtils.findFirstDeclaredSubstatement(ctx, BelongsToStatement.class),
                 ctx.getStatementSourceReference(), "Unable to find belongs-to statement in submodule %s.", name);