2 * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
10 import static com.google.common.base.Preconditions.checkState;
11 import static java.util.Objects.requireNonNull;
13 import com.google.common.annotations.Beta;
14 import com.google.common.base.MoreObjects;
15 import com.google.common.base.Verify;
16 import com.google.common.collect.ImmutableList;
17 import com.google.common.collect.ImmutableMap;
18 import com.google.common.collect.ImmutableSet;
19 import com.google.common.collect.Iterables;
21 import java.util.ArrayList;
22 import java.util.HashSet;
23 import java.util.LinkedHashMap;
24 import java.util.LinkedHashSet;
25 import java.util.List;
27 import java.util.Optional;
29 import java.util.stream.Collectors;
30 import javax.annotation.Nonnull;
31 import org.eclipse.jdt.annotation.NonNull;
32 import org.opendaylight.yangtools.concepts.SemVer;
33 import org.opendaylight.yangtools.yang.common.QName;
34 import org.opendaylight.yangtools.yang.common.Revision;
35 import org.opendaylight.yangtools.yang.common.YangVersion;
36 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
37 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
38 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
39 import org.opendaylight.yangtools.yang.model.api.Deviation;
40 import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
41 import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
42 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
43 import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
44 import org.opendaylight.yangtools.yang.model.api.Module;
45 import org.opendaylight.yangtools.yang.model.api.ModuleImport;
46 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
47 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
48 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
49 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
50 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
51 import org.opendaylight.yangtools.yang.model.api.UsesNode;
52 import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
53 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
54 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
55 import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToEffectiveStatement;
56 import org.opendaylight.yangtools.yang.model.api.stmt.ContactEffectiveStatement;
57 import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationEffectiveStatement;
58 import org.opendaylight.yangtools.yang.model.api.stmt.PrefixEffectiveStatement;
59 import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleEffectiveStatement;
60 import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
61 import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
62 import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionEffectiveStatement;
63 import org.opendaylight.yangtools.yang.parser.spi.meta.MutableStatement;
64 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
65 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
66 import org.opendaylight.yangtools.yang.parser.spi.source.IncludedSubmoduleNameToModuleCtx;
67 import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
68 import org.opendaylight.yangtools.yang.parser.stmt.openconfig.OpenconfigVersionEffectiveStatement;
71 public abstract class AbstractEffectiveModule<D extends DeclaredStatement<String>> extends
72 AbstractEffectiveDocumentedNode<String, D> implements Module, MutableStatement {
73 private final String name;
74 private final String prefix;
75 private final YangVersion yangVersion;
76 private final String organization;
77 private final String contact;
78 private final Set<ModuleImport> imports;
79 private final Set<FeatureDefinition> features;
80 private final Set<NotificationDefinition> notifications;
81 private final Set<AugmentationSchemaNode> augmentations;
82 private final Set<RpcDefinition> rpcs;
83 private final Set<Deviation> deviations;
84 private final List<ExtensionDefinition> extensionNodes;
85 private final Set<IdentitySchemaNode> identities;
86 private final List<UnknownSchemaNode> unknownNodes;
87 private final Map<QName, DataSchemaNode> childNodes;
88 private final Set<GroupingDefinition> groupings;
89 private final Set<UsesNode> uses;
90 private final Set<TypeDefinition<?>> typeDefinitions;
91 private final Set<DataSchemaNode> publicChildNodes;
92 private final SemVer semanticVersion;
94 private Set<StmtContext<?, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>>>
95 submoduleContextsToBuild;
96 private Set<Module> submodules;
97 private boolean sealed;
99 protected AbstractEffectiveModule(final StmtContext<String, D, ? extends EffectiveStatement<String, ?>> ctx) {
102 this.name = argument();
104 final EffectiveStatement<?, ?> parentOfPrefix;
105 if (ctx.getPublicDefinition() == YangStmtMapping.SUBMODULE) {
106 final Optional<BelongsToEffectiveStatement> optParent =
107 findFirstEffectiveSubstatement(BelongsToEffectiveStatement.class);
108 SourceException.throwIf(!optParent.isPresent(), ctx.getStatementSourceReference(),
109 "Unable to find belongs-to statement in submodule %s.", ctx.getStatementArgument());
110 parentOfPrefix = optParent.get();
112 parentOfPrefix = this;
115 final Optional<@NonNull PrefixEffectiveStatement> prefixStmt = parentOfPrefix.findFirstEffectiveSubstatement(
116 PrefixEffectiveStatement.class);
117 SourceException.throwIf(!prefixStmt.isPresent(), ctx.getStatementSourceReference(),
118 "Unable to resolve prefix for module or submodule %s.", ctx.getStatementArgument());
119 this.prefix = prefixStmt.get().argument();
120 this.yangVersion = findFirstEffectiveSubstatementArgument(YangVersionEffectiveStatement.class)
121 .orElse(YangVersion.VERSION_1);
122 this.semanticVersion = findFirstEffectiveSubstatementArgument(OpenconfigVersionEffectiveStatement.class)
124 this.organization = findFirstEffectiveSubstatementArgument(OrganizationEffectiveStatement.class)
126 this.contact = findFirstEffectiveSubstatementArgument(ContactEffectiveStatement.class)
129 // init submodules and substatements of submodules
130 final List<EffectiveStatement<?, ?>> substatementsOfSubmodules;
131 final Map<String, StmtContext<?, ?, ?>> includedSubmodulesMap = ctx
132 .getAllFromCurrentStmtCtxNamespace(IncludedSubmoduleNameToModuleCtx.class);
134 if (includedSubmodulesMap == null || includedSubmodulesMap.isEmpty()) {
135 this.submodules = ImmutableSet.of();
136 this.submoduleContextsToBuild = ImmutableSet.of();
137 substatementsOfSubmodules = ImmutableList.of();
138 } else if (YangStmtMapping.MODULE.equals(ctx.getPublicDefinition())) {
140 * Aggregation of substatements from submodules should be done only
141 * for modules. In case of submodules it does not make sense because
142 * of possible circular chains of includes between submodules.
144 final Set<Module> submodulesInit = new HashSet<>();
145 final List<EffectiveStatement<?, ?>> substatementsOfSubmodulesInit = new ArrayList<>();
146 for (final StmtContext<?, ?, ?> submoduleCtx : includedSubmodulesMap.values()) {
147 final EffectiveStatement<?, ?> submodule = submoduleCtx.buildEffective();
148 Verify.verify(submodule instanceof SubmoduleEffectiveStatement);
149 Verify.verify(submodule instanceof Module, "Submodule statement %s is not a Module", submodule);
150 submodulesInit.add((Module) submodule);
151 substatementsOfSubmodulesInit.addAll(submodule.effectiveSubstatements().stream()
152 .filter(sub -> sub instanceof SchemaNode || sub instanceof DataNodeContainer)
153 .collect(Collectors.toList()));
156 this.submodules = ImmutableSet.copyOf(submodulesInit);
157 this.submoduleContextsToBuild = ImmutableSet.of();
158 substatementsOfSubmodules = ImmutableList.copyOf(substatementsOfSubmodulesInit);
161 * Because of possible circular chains of includes between submodules we can
162 * collect only submodule contexts here and then build them during
163 * sealing of this statement.
165 final Set<StmtContext<?, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>>>
166 submoduleContextsInit = new HashSet<>();
167 for (final StmtContext<?, ?, ?> submoduleCtx : includedSubmodulesMap.values()) {
168 submoduleContextsInit.add(
169 (StmtContext<?, SubmoduleStatement, EffectiveStatement<String, SubmoduleStatement>>)submoduleCtx);
172 this.submoduleContextsToBuild = ImmutableSet.copyOf(submoduleContextsInit);
173 substatementsOfSubmodules = ImmutableList.of();
176 if (!submoduleContextsToBuild.isEmpty()) {
177 ((Mutable<?, ?, ?>) ctx).addMutableStmtToSeal(this);
183 // init substatements collections
184 final List<EffectiveStatement<?, ?>> effectiveSubstatements = new ArrayList<>();
185 effectiveSubstatements.addAll(effectiveSubstatements());
186 effectiveSubstatements.addAll(substatementsOfSubmodules);
188 final List<UnknownSchemaNode> unknownNodesInit = new ArrayList<>();
189 final Set<AugmentationSchemaNode> augmentationsInit = new LinkedHashSet<>();
190 final Set<ModuleImport> importsInit = new HashSet<>();
191 final Set<NotificationDefinition> notificationsInit = new HashSet<>();
192 final Set<RpcDefinition> rpcsInit = new HashSet<>();
193 final Set<Deviation> deviationsInit = new HashSet<>();
194 final Set<IdentitySchemaNode> identitiesInit = new HashSet<>();
195 final Set<FeatureDefinition> featuresInit = new HashSet<>();
196 final List<ExtensionDefinition> extensionNodesInit = new ArrayList<>();
198 final Map<QName, DataSchemaNode> mutableChildNodes = new LinkedHashMap<>();
199 final Set<GroupingDefinition> mutableGroupings = new HashSet<>();
200 final Set<UsesNode> mutableUses = new HashSet<>();
201 final Set<TypeDefinition<?>> mutableTypeDefinitions = new LinkedHashSet<>();
202 final Set<DataSchemaNode> mutablePublicChildNodes = new LinkedHashSet<>();
204 for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements) {
205 if (effectiveStatement instanceof UnknownSchemaNode) {
206 unknownNodesInit.add((UnknownSchemaNode) effectiveStatement);
208 if (effectiveStatement instanceof AugmentationSchemaNode) {
209 augmentationsInit.add((AugmentationSchemaNode) effectiveStatement);
211 if (effectiveStatement instanceof ModuleImport) {
212 importsInit.add((ModuleImport) effectiveStatement);
214 if (effectiveStatement instanceof NotificationDefinition) {
215 notificationsInit.add((NotificationDefinition) effectiveStatement);
217 if (effectiveStatement instanceof RpcDefinition) {
218 rpcsInit.add((RpcDefinition) effectiveStatement);
220 if (effectiveStatement instanceof Deviation) {
221 deviationsInit.add((Deviation) effectiveStatement);
223 if (effectiveStatement instanceof IdentitySchemaNode) {
224 identitiesInit.add((IdentitySchemaNode) effectiveStatement);
226 if (effectiveStatement instanceof FeatureDefinition) {
227 featuresInit.add((FeatureDefinition) effectiveStatement);
229 if (effectiveStatement instanceof ExtensionDefinition) {
230 extensionNodesInit.add((ExtensionDefinition) effectiveStatement);
232 if (effectiveStatement instanceof DataSchemaNode) {
233 final DataSchemaNode dataSchemaNode = (DataSchemaNode) effectiveStatement;
234 if (!mutableChildNodes.containsKey(dataSchemaNode.getQName())) {
235 mutableChildNodes.put(dataSchemaNode.getQName(), dataSchemaNode);
236 mutablePublicChildNodes.add(dataSchemaNode);
238 throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, effectiveStatement);
241 if (effectiveStatement instanceof UsesNode) {
242 final UsesNode usesNode = (UsesNode) effectiveStatement;
243 if (!mutableUses.contains(usesNode)) {
244 mutableUses.add(usesNode);
246 throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, effectiveStatement);
249 if (effectiveStatement instanceof TypedefEffectiveStatement) {
250 final TypedefEffectiveStatement typeDef = (TypedefEffectiveStatement) effectiveStatement;
251 final TypeDefinition<?> type = typeDef.getTypeDefinition();
252 if (!mutableTypeDefinitions.contains(type)) {
253 mutableTypeDefinitions.add(type);
255 throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, effectiveStatement);
258 if (effectiveStatement instanceof GroupingDefinition) {
259 final GroupingDefinition grp = (GroupingDefinition) effectiveStatement;
260 if (!mutableGroupings.contains(grp)) {
261 mutableGroupings.add(grp);
263 throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, effectiveStatement);
268 this.unknownNodes = ImmutableList.copyOf(unknownNodesInit);
269 this.augmentations = ImmutableSet.copyOf(augmentationsInit);
270 this.imports = ImmutableSet.copyOf(importsInit);
271 this.notifications = ImmutableSet.copyOf(notificationsInit);
272 this.rpcs = ImmutableSet.copyOf(rpcsInit);
273 this.deviations = ImmutableSet.copyOf(deviationsInit);
274 this.identities = ImmutableSet.copyOf(identitiesInit);
275 this.features = ImmutableSet.copyOf(featuresInit);
276 this.extensionNodes = ImmutableList.copyOf(extensionNodesInit);
278 this.childNodes = ImmutableMap.copyOf(mutableChildNodes);
279 this.groupings = ImmutableSet.copyOf(mutableGroupings);
280 this.publicChildNodes = ImmutableSet.copyOf(mutablePublicChildNodes);
281 this.typeDefinitions = ImmutableSet.copyOf(mutableTypeDefinitions);
282 this.uses = ImmutableSet.copyOf(mutableUses);
287 public URI getNamespace() {
288 return getQNameModule().getNamespace();
292 public String getName() {
297 public Optional<Revision> getRevision() {
298 return getQNameModule().getRevision();
302 public String getPrefix() {
307 public YangVersion getYangVersion() {
312 public Optional<String> getOrganization() {
313 return Optional.ofNullable(organization);
317 public Optional<String> getContact() {
318 return Optional.ofNullable(contact);
322 public Set<ModuleImport> getImports() {
327 public Set<Module> getSubmodules() {
328 checkState(sealed, "Attempt to get base submodules from unsealed submodule effective statement %s",
334 public Set<FeatureDefinition> getFeatures() {
339 public Set<NotificationDefinition> getNotifications() {
340 return notifications;
344 public Set<AugmentationSchemaNode> getAugmentations() {
345 return augmentations;
349 public Set<RpcDefinition> getRpcs() {
354 public Set<Deviation> getDeviations() {
359 public List<ExtensionDefinition> getExtensionSchemaNodes() {
360 return extensionNodes;
364 public Set<IdentitySchemaNode> getIdentities() {
370 public List<UnknownSchemaNode> getUnknownSchemaNodes() {
375 public final Set<TypeDefinition<?>> getTypeDefinitions() {
376 return typeDefinitions;
380 public final Set<DataSchemaNode> getChildNodes() {
381 return publicChildNodes;
385 public final Set<GroupingDefinition> getGroupings() {
390 public final Optional<DataSchemaNode> findDataChildByName(final QName name) {
391 // Child nodes are keyed by their container name, so we can do a direct lookup
392 return Optional.ofNullable(childNodes.get(requireNonNull(name)));
396 public Set<UsesNode> getUses() {
401 public Optional<SemVer> getSemanticVersion() {
402 return Optional.ofNullable(semanticVersion);
406 public String toString() {
407 return MoreObjects.toStringHelper(this).omitNullValues()
409 .add("namespace", getNamespace())
410 .add("revision", getRevision().orElse(null))
411 .add("prefix", prefix)
412 .add("yangVersion", yangVersion)
419 submodules = ImmutableSet.copyOf(Iterables.transform(submoduleContextsToBuild,
420 ctx -> (Module) ctx.buildEffective()));
421 submoduleContextsToBuild = ImmutableSet.of();