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%2FAbstractEffectiveModule.java;h=aab5cb9ac333835b953d68c5fee8a504e4a12408;hb=60aaa85b10b02b29f357fb53fed5723a498e1cef;hp=055188be4e45d478916d8e92689f99619d2fc2f8;hpb=6ba759ce6949dfa7ebbaf90a2a937674f3c52542;p=yangtools.git

diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveModule.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveModule.java
index 055188be4e..aab5cb9ac3 100644
--- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveModule.java
+++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveModule.java
@@ -7,24 +7,26 @@
  */
 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
 
+import static com.google.common.base.Verify.verifyNotNull;
 import static java.util.Objects.requireNonNull;
 
 import com.google.common.annotations.Beta;
 import com.google.common.base.MoreObjects;
+import com.google.common.collect.Collections2;
 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 java.net.URI;
-import java.util.ArrayList;
-import java.util.HashSet;
+import java.util.Collection;
 import java.util.LinkedHashSet;
-import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.concepts.SemVer;
 import org.opendaylight.yangtools.openconfig.model.api.OpenConfigVersionEffectiveStatement;
 import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
 import org.opendaylight.yangtools.yang.common.YangVersion;
 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
@@ -33,105 +35,68 @@ import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
 import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
 import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Module;
 import org.opendaylight.yangtools.yang.model.api.ModuleImport;
+import org.opendaylight.yangtools.yang.model.api.ModuleLike;
 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
 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.meta.IdentifierNamespace;
 import org.opendaylight.yangtools.yang.model.api.stmt.ContactEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeAwareEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ImportEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.PrefixEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeAwareEffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionEffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.compat.NotificationNodeContainerCompat;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultWithDataTree.WithSubstatements;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.DocumentedNodeMixin;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
+import org.opendaylight.yangtools.yang.parser.spi.source.ImportPrefixToModuleCtx;
 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
 
 @Beta
-public abstract class AbstractEffectiveModule<D extends DeclaredStatement<String>> extends
-        AbstractSchemaEffectiveDocumentedNode<String, D> implements Module,
-        NotificationNodeContainerCompat<String, D> {
-    private final String name;
+public abstract class AbstractEffectiveModule<D extends DeclaredStatement<UnqualifiedQName>,
+        E extends DataTreeAwareEffectiveStatement<UnqualifiedQName, D>>
+        extends WithSubstatements<UnqualifiedQName, D, E>
+        implements ModuleLike, DocumentedNodeMixin<UnqualifiedQName, D>,
+            NotificationNodeContainerCompat<UnqualifiedQName, D, E> {
     private final String prefix;
-    private final YangVersion yangVersion;
-    private final String organization;
-    private final String contact;
-    private final ImmutableSet<ModuleImport> imports;
-    private final ImmutableSet<FeatureDefinition> features;
-    private final @NonNull ImmutableSet<NotificationDefinition> notifications;
-    private final ImmutableSet<AugmentationSchemaNode> augmentations;
-    private final ImmutableSet<RpcDefinition> rpcs;
-    private final ImmutableSet<Deviation> deviations;
-    private final ImmutableList<ExtensionDefinition> extensionNodes;
-    private final ImmutableSet<IdentitySchemaNode> identities;
     private final ImmutableSet<GroupingDefinition> groupings;
     private final ImmutableSet<UsesNode> uses;
     private final ImmutableSet<TypeDefinition<?>> typeDefinitions;
-    private final ImmutableSet<DataSchemaNode> publicChildNodes;
-    private final SemVer semanticVersion;
+    private final ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace;
 
-    protected AbstractEffectiveModule(
-            final @NonNull StmtContext<String, D, ? extends EffectiveStatement<String, ?>> ctx,
-            final @NonNull String prefix) {
-        super(ctx);
+    protected AbstractEffectiveModule(final D declared,
+            final StmtContext<UnqualifiedQName, D, ? extends EffectiveStatement<UnqualifiedQName, ?>> ctx,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final String prefix) {
+        super(declared, ctx, substatements);
+
+        // This check is rather weird, but comes from our desire to lower memory footprint while providing both
+        // EffectiveStatements and SchemaNode interfaces -- which do not overlap completely where child lookups are
+        // concerned. This ensures that we have SchemaTree index available for use with child lookups.
+        final Map<QName, SchemaTreeEffectiveStatement<?>> schemaTree =
+                createSchemaTreeNamespace(ctx.getStatementSourceReference(), effectiveSubstatements());
+        schemaTreeNamespace = ImmutableMap.copyOf(schemaTree);
+
+        // Data tree check, not currently used
+        createDataTreeNamespace(ctx.getStatementSourceReference(), schemaTree.values(), schemaTreeNamespace);
 
-        this.name = argument();
         this.prefix = requireNonNull(prefix);
-        this.yangVersion = findFirstEffectiveSubstatementArgument(YangVersionEffectiveStatement.class)
-                .orElse(YangVersion.VERSION_1);
-        this.semanticVersion = findFirstEffectiveSubstatementArgument(OpenConfigVersionEffectiveStatement.class)
-                .orElse(null);
-        this.organization = findFirstEffectiveSubstatementArgument(OrganizationEffectiveStatement.class)
-                .orElse(null);
-        this.contact = findFirstEffectiveSubstatementArgument(ContactEffectiveStatement.class)
-                .orElse(null);
-
-        final Set<AugmentationSchemaNode> augmentationsInit = new LinkedHashSet<>();
-        final Set<ModuleImport> importsInit = new HashSet<>();
-        final Set<NotificationDefinition> notificationsInit = new HashSet<>();
-        final Set<RpcDefinition> rpcsInit = new HashSet<>();
-        final Set<Deviation> deviationsInit = new HashSet<>();
-        final Set<IdentitySchemaNode> identitiesInit = new HashSet<>();
-        final Set<FeatureDefinition> featuresInit = new HashSet<>();
-        final List<ExtensionDefinition> extensionNodesInit = new ArrayList<>();
-
-        final Set<GroupingDefinition> mutableGroupings = new HashSet<>();
-        final Set<UsesNode> mutableUses = new HashSet<>();
+
+        final Set<GroupingDefinition> mutableGroupings = new LinkedHashSet<>();
+        final Set<UsesNode> mutableUses = new LinkedHashSet<>();
         final Set<TypeDefinition<?>> mutableTypeDefinitions = new LinkedHashSet<>();
-        final Set<DataSchemaNode> mutablePublicChildNodes = new LinkedHashSet<>();
 
         for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
-            if (effectiveStatement instanceof AugmentationSchemaNode) {
-                augmentationsInit.add((AugmentationSchemaNode) effectiveStatement);
-            }
-            if (effectiveStatement instanceof ModuleImport) {
-                importsInit.add((ModuleImport) effectiveStatement);
-            }
-            if (effectiveStatement instanceof NotificationDefinition) {
-                notificationsInit.add((NotificationDefinition) effectiveStatement);
-            }
-            if (effectiveStatement instanceof RpcDefinition) {
-                rpcsInit.add((RpcDefinition) effectiveStatement);
-            }
-            if (effectiveStatement instanceof Deviation) {
-                deviationsInit.add((Deviation) effectiveStatement);
-            }
-            if (effectiveStatement instanceof IdentitySchemaNode) {
-                identitiesInit.add((IdentitySchemaNode) effectiveStatement);
-            }
-            if (effectiveStatement instanceof FeatureDefinition) {
-                featuresInit.add((FeatureDefinition) effectiveStatement);
-            }
-            if (effectiveStatement instanceof ExtensionDefinition) {
-                extensionNodesInit.add((ExtensionDefinition) effectiveStatement);
-            }
-            if (effectiveStatement instanceof DataSchemaNode) {
-                mutablePublicChildNodes.add((DataSchemaNode) effectiveStatement);
-            }
             if (effectiveStatement instanceof UsesNode && !mutableUses.add((UsesNode) effectiveStatement)) {
                 throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, effectiveStatement);
             }
@@ -147,34 +112,19 @@ public abstract class AbstractEffectiveModule<D extends DeclaredStatement<String
             }
         }
 
-        this.augmentations = ImmutableSet.copyOf(augmentationsInit);
-        this.imports = ImmutableSet.copyOf(importsInit);
-        this.notifications = ImmutableSet.copyOf(notificationsInit);
-        this.rpcs = ImmutableSet.copyOf(rpcsInit);
-        this.deviations = ImmutableSet.copyOf(deviationsInit);
-        this.identities = ImmutableSet.copyOf(identitiesInit);
-        this.features = ImmutableSet.copyOf(featuresInit);
-        this.extensionNodes = ImmutableList.copyOf(extensionNodesInit);
-
         this.groupings = ImmutableSet.copyOf(mutableGroupings);
-        this.publicChildNodes = ImmutableSet.copyOf(mutablePublicChildNodes);
         this.typeDefinitions = ImmutableSet.copyOf(mutableTypeDefinitions);
         this.uses = ImmutableSet.copyOf(mutableUses);
     }
 
     @Override
-    public URI getNamespace() {
-        return getQNameModule().getNamespace();
+    public UnqualifiedQName argument() {
+        return getDeclared().argument();
     }
 
     @Override
     public String getName() {
-        return name;
-    }
-
-    @Override
-    public Optional<Revision> getRevision() {
-        return getQNameModule().getRevision();
+        return argument().getLocalName();
     }
 
     @Override
@@ -184,98 +134,110 @@ public abstract class AbstractEffectiveModule<D extends DeclaredStatement<String
 
     @Override
     public YangVersion getYangVersion() {
-        return yangVersion;
+        return findFirstEffectiveSubstatementArgument(YangVersionEffectiveStatement.class)
+                .orElse(YangVersion.VERSION_1);
     }
 
     @Override
     public Optional<String> getOrganization() {
-        return Optional.ofNullable(organization);
+        return findFirstEffectiveSubstatementArgument(OrganizationEffectiveStatement.class);
     }
 
     @Override
     public Optional<String> getContact() {
-        return Optional.ofNullable(contact);
+        return findFirstEffectiveSubstatementArgument(ContactEffectiveStatement.class);
     }
 
     @Override
-    public Set<ModuleImport> getImports() {
-        return imports;
+    public Collection<? extends @NonNull ModuleImport> getImports() {
+        return filterSubstatements(ModuleImport.class);
     }
 
     @Override
-    public Set<FeatureDefinition> getFeatures() {
-        return features;
+    public Collection<? extends @NonNull FeatureDefinition> getFeatures() {
+        return filterSubstatements(FeatureDefinition.class);
     }
 
     @Override
-    public Set<NotificationDefinition> getNotifications() {
-        return notifications;
+    public Collection<? extends @NonNull NotificationDefinition> getNotifications() {
+        return filterSubstatements(NotificationDefinition.class);
     }
 
     @Override
-    public Set<AugmentationSchemaNode> getAugmentations() {
-        return augmentations;
+    public Collection<? extends @NonNull AugmentationSchemaNode> getAugmentations() {
+        return filterSubstatements(AugmentationSchemaNode.class);
     }
 
     @Override
-    public Set<RpcDefinition> getRpcs() {
-        return rpcs;
+    public Collection<? extends @NonNull RpcDefinition> getRpcs() {
+        return filterSubstatements(RpcDefinition.class);
     }
 
     @Override
-    public Set<Deviation> getDeviations() {
-        return deviations;
+    public Collection<? extends @NonNull Deviation> getDeviations() {
+        return filterSubstatements(Deviation.class);
     }
 
     @Override
-    public List<ExtensionDefinition> getExtensionSchemaNodes() {
-        return extensionNodes;
+    public Collection<? extends @NonNull ExtensionDefinition> getExtensionSchemaNodes() {
+        return filterSubstatements(ExtensionDefinition.class);
     }
 
     @Override
-    public Set<IdentitySchemaNode> getIdentities() {
-        return identities;
+    public Collection<? extends @NonNull IdentitySchemaNode> getIdentities() {
+        return filterSubstatements(IdentitySchemaNode.class);
     }
 
     @Override
-    public final Set<TypeDefinition<?>> getTypeDefinitions() {
+    public final Collection<? extends TypeDefinition<?>> getTypeDefinitions() {
         return typeDefinitions;
     }
 
     @Override
-    public final Set<DataSchemaNode> getChildNodes() {
-        return publicChildNodes;
+    public final Collection<? extends DataSchemaNode> getChildNodes() {
+        return filterSubstatements(DataSchemaNode.class);
     }
 
     @Override
-    public final Set<GroupingDefinition> getGroupings() {
+    public final Collection<? extends GroupingDefinition> getGroupings() {
         return groupings;
     }
 
     @Override
     @SuppressWarnings("checkstyle:hiddenField")
     public final Optional<DataSchemaNode> findDataChildByName(final QName name) {
-        return findDataSchemaNode(name);
+        final SchemaTreeEffectiveStatement<?> child = schemaTreeNamespace.get(requireNonNull(name));
+        return child instanceof DataSchemaNode ? Optional.of((DataSchemaNode) child) : Optional.empty();
     }
 
     @Override
-    public Set<UsesNode> getUses() {
+    public Collection<? extends UsesNode> getUses() {
         return uses;
     }
 
     @Override
     public Optional<SemVer> getSemanticVersion() {
-        return Optional.ofNullable(semanticVersion);
+        return findFirstEffectiveSubstatementArgument(OpenConfigVersionEffectiveStatement.class);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    protected <K, V, N extends IdentifierNamespace<K, V>> Optional<? extends Map<K, V>> getNamespaceContents(
+            final Class<N> namespace) {
+        if (SchemaTreeAwareEffectiveStatement.Namespace.class.equals(namespace)) {
+            return Optional.of((Map<K, V>) schemaTreeNamespace);
+        }
+        return super.getNamespaceContents(namespace);
     }
 
     @Override
     public String toString() {
         return MoreObjects.toStringHelper(this).omitNullValues()
-                .add("name", name)
+                .add("name", getName())
                 .add("namespace", getNamespace())
                 .add("revision", getRevision().orElse(null))
                 .add("prefix", prefix)
-                .add("yangVersion", yangVersion)
+                .add("yangVersion", getYangVersion())
                 .toString();
     }
 
@@ -285,4 +247,22 @@ public abstract class AbstractEffectiveModule<D extends DeclaredStatement<String
             StmtContextUtils.firstAttributeOf(ctx.declaredSubstatements(), PrefixStatement.class),
             ctx.getStatementSourceReference(), "Unable to resolve prefix for %s %s.", type, name);
     }
+
+    // Alright. this is quite ugly
+    protected final void appendPrefixes(final StmtContext<?, ?, ?> ctx,
+            final Builder<String, ModuleEffectiveStatement> builder) {
+        streamEffectiveSubstatements(ImportEffectiveStatement.class)
+            .map(imp -> imp.findFirstEffectiveSubstatementArgument(PrefixEffectiveStatement.class).get())
+            .forEach(pfx -> {
+                final StmtContext<?, ?, ?> importedCtx =
+                        verifyNotNull(ctx.getFromNamespace(ImportPrefixToModuleCtx.class, pfx),
+                            "Failed to resolve prefix %s", pfx);
+                builder.put(pfx, (ModuleEffectiveStatement) importedCtx.buildEffective());
+            });
+    }
+
+    @SuppressWarnings("unchecked")
+    private <T> @NonNull Collection<? extends T> filterSubstatements(final Class<T> type) {
+        return (Collection<? extends T>) Collections2.filter(effectiveSubstatements(), type::isInstance);
+    }
 }