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=5d35db7723bb19c00955c580b21df9552de9fea0;hp=8de6d290a63c8c20c64466efdd7e216d0b27e506;hpb=3fb52b5ee8449944f233e8c277b2f689da6c433d;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 8de6d290a6..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
@@ -12,15 +12,13 @@ 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.Collection;
 import java.util.LinkedHashSet;
-import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
@@ -28,7 +26,7 @@ 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;
@@ -37,8 +35,8 @@ 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;
@@ -58,40 +56,29 @@ import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStateme
 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>,
-        E extends DataTreeAwareEffectiveStatement<String, D>> extends
-        AbstractSchemaEffectiveDocumentedNode<String, D> implements Module,
-        NotificationNodeContainerCompat<String, D, E> {
-    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
@@ -103,59 +90,13 @@ public abstract class AbstractEffectiveModule<D extends DeclaredStatement<String
         // 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 LinkedHashSet<>();
-        final Set<NotificationDefinition> notificationsInit = new LinkedHashSet<>();
-        final Set<RpcDefinition> rpcsInit = new LinkedHashSet<>();
-        final Set<Deviation> deviationsInit = new LinkedHashSet<>();
-        final Set<IdentitySchemaNode> identitiesInit = new LinkedHashSet<>();
-        final Set<FeatureDefinition> featuresInit = new LinkedHashSet<>();
-        final List<ExtensionDefinition> extensionNodesInit = new ArrayList<>();
 
         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);
             }
@@ -171,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
@@ -208,57 +134,58 @@ 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 Collection<? extends ModuleImport> getImports() {
-        return imports;
+    public Collection<? extends @NonNull ModuleImport> getImports() {
+        return filterSubstatements(ModuleImport.class);
     }
 
     @Override
-    public Collection<? extends FeatureDefinition> getFeatures() {
-        return features;
+    public Collection<? extends @NonNull FeatureDefinition> getFeatures() {
+        return filterSubstatements(FeatureDefinition.class);
     }
 
     @Override
-    public Collection<? extends NotificationDefinition> getNotifications() {
-        return notifications;
+    public Collection<? extends @NonNull NotificationDefinition> getNotifications() {
+        return filterSubstatements(NotificationDefinition.class);
     }
 
     @Override
-    public Collection<? extends AugmentationSchemaNode> getAugmentations() {
-        return augmentations;
+    public Collection<? extends @NonNull AugmentationSchemaNode> getAugmentations() {
+        return filterSubstatements(AugmentationSchemaNode.class);
     }
 
     @Override
-    public Collection<? extends RpcDefinition> getRpcs() {
-        return rpcs;
+    public Collection<? extends @NonNull RpcDefinition> getRpcs() {
+        return filterSubstatements(RpcDefinition.class);
     }
 
     @Override
-    public Collection<? extends Deviation> getDeviations() {
-        return deviations;
+    public Collection<? extends @NonNull Deviation> getDeviations() {
+        return filterSubstatements(Deviation.class);
     }
 
     @Override
-    public Collection<? extends ExtensionDefinition> getExtensionSchemaNodes() {
-        return extensionNodes;
+    public Collection<? extends @NonNull ExtensionDefinition> getExtensionSchemaNodes() {
+        return filterSubstatements(ExtensionDefinition.class);
     }
 
     @Override
-    public Collection<? extends IdentitySchemaNode> getIdentities() {
-        return identities;
+    public Collection<? extends @NonNull IdentitySchemaNode> getIdentities() {
+        return filterSubstatements(IdentitySchemaNode.class);
     }
 
     @Override
@@ -268,7 +195,7 @@ public abstract class AbstractEffectiveModule<D extends DeclaredStatement<String
 
     @Override
     public final Collection<? extends DataSchemaNode> getChildNodes() {
-        return publicChildNodes;
+        return filterSubstatements(DataSchemaNode.class);
     }
 
     @Override
@@ -290,7 +217,7 @@ public abstract class AbstractEffectiveModule<D extends DeclaredStatement<String
 
     @Override
     public Optional<SemVer> getSemanticVersion() {
-        return Optional.ofNullable(semanticVersion);
+        return findFirstEffectiveSubstatementArgument(OpenConfigVersionEffectiveStatement.class);
     }
 
     @Override
@@ -306,11 +233,11 @@ public abstract class AbstractEffectiveModule<D extends DeclaredStatement<String
     @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();
     }
 
@@ -333,4 +260,9 @@ public abstract class AbstractEffectiveModule<D extends DeclaredStatement<String
                 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);
+    }
 }