X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Fstmt%2Freactor%2FRootStatementContext.java;h=7c8b2d5877d44e16bba09744e3fbe44dd4568467;hb=fa1ed213acc06358d9b759fa871e2b360605734e;hp=b1bf364e0c387792d4b156d333ce25aa1dd387a0;hpb=ea2f209fe116f2d90e48238906a2f3b24ed455c4;p=yangtools.git diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/RootStatementContext.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/RootStatementContext.java index b1bf364e0c..7c8b2d5877 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/RootStatementContext.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/RootStatementContext.java @@ -7,74 +7,81 @@ */ package org.opendaylight.yangtools.yang.parser.stmt.reactor; +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; +import com.google.common.base.Verify; +import com.google.common.collect.ImmutableList; +import java.util.ArrayList; import java.util.Collection; -import java.util.LinkedList; -import java.util.List; +import java.util.Map; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; import org.opendaylight.yangtools.yang.common.QNameModule; +import org.opendaylight.yangtools.yang.common.YangVersion; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; 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.parser.spi.meta.CopyType; import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.NamespaceStorageNode; import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.Registry; import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour.StorageNodeType; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; -import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils; +import org.opendaylight.yangtools.yang.parser.spi.source.IncludedModuleContext; /** - * root statement class for a Yang source + * Root statement class for a YANG source. All statements defined in that YANG source are mapped underneath an instance + * of this class, hence recursive lookups from them cross this class. */ public class RootStatementContext, E extends EffectiveStatement> extends StatementContextBase { + public static final YangVersion DEFAULT_VERSION = YangVersion.VERSION_1; + private final SourceSpecificContext sourceContext; private final A argument; - RootStatementContext(ContextBuilder builder, SourceSpecificContext sourceContext) throws SourceException { + private YangVersion version; + + /** + * References to RootStatementContext of submodules which are included in this source. + */ + private Collection> includedContexts = ImmutableList.of(); + + RootStatementContext(final ContextBuilder builder, final SourceSpecificContext sourceContext) { super(builder); - this.sourceContext = sourceContext; + this.sourceContext = Preconditions.checkNotNull(sourceContext); this.argument = builder.getDefinition().parseArgumentValue(this, builder.getRawArgument()); } - RootStatementContext(RootStatementContext original, QNameModule newQNameModule, TypeOfCopy typeOfCopy) - throws SourceException { + RootStatementContext(final ContextBuilder builder, final SourceSpecificContext sourceContext, + final YangVersion version) { + this(builder, sourceContext); + this.setRootVersion(version); + } + + RootStatementContext(final RootStatementContext original, final QNameModule newQNameModule, + final CopyType typeOfCopy) { super(original); - sourceContext = original.sourceContext; + sourceContext = Preconditions.checkNotNull(original.sourceContext); this.argument = original.argument; - copyDeclaredStmts(original, newQNameModule, typeOfCopy); + final Collection> declared = original.declaredSubstatements(); + final Collection> effective = original.effectiveSubstatements(); + final Collection> buffer = new ArrayList<>(declared.size() + effective.size()); - copyEffectiveStmts(original, newQNameModule, typeOfCopy); - - } - - /** - * copies declared statements from original to this' substatements - * - * @param typeOfCopy - * determines whether copy is used by augmentation or uses - * @throws SourceException - */ - private void copyDeclaredStmts(RootStatementContext original, QNameModule newQNameModule, - TypeOfCopy typeOfCopy) throws SourceException { - Collection> originalDeclaredSubstatements = original.declaredSubstatements(); - for (StmtContext stmtContext : originalDeclaredSubstatements) { - this.addEffectiveSubstatement(stmtContext.createCopy(newQNameModule, this, typeOfCopy)); + for (final StatementContextBase stmtContext : declared) { + if (StmtContextUtils.areFeaturesSupported(stmtContext)) { + buffer.add(stmtContext.createCopy(newQNameModule, this, typeOfCopy)); + } } - } - - /** - * copies effective statements from original to this' substatements - * - * @param typeOfCopy - * determines whether copy is used by augmentation or uses - * @throws SourceException - */ - private void copyEffectiveStmts(RootStatementContext original, QNameModule newQNameModule, - TypeOfCopy typeOfCopy) throws SourceException { - Collection> originalEffectiveSubstatements = original.effectiveSubstatements(); - for (StmtContext stmtContext : originalEffectiveSubstatements) { - this.addEffectiveSubstatement(stmtContext.createCopy(newQNameModule, this, typeOfCopy)); + for (final StmtContext stmtContext : effective) { + buffer.add(stmtContext.createCopy(newQNameModule, this, typeOfCopy)); } + + addEffectiveSubstatements(buffer); } /** @@ -108,6 +115,7 @@ public class RootStatementContext, E extends E /** * @return this as its own root */ + @Nonnull @Override public RootStatementContext getRoot() { return this; @@ -123,30 +131,29 @@ public class RootStatementContext, E extends E } /** - * @return copy of this considering {@link TypeOfCopy} (augment, uses) + * @return copy of this considering {@link CopyType} (augment, uses) * - * @throws SourceException instance of SourceException + * @throws org.opendaylight.yangtools.yang.parser.spi.source.SourceException instance of SourceException */ @Override - public StatementContextBase createCopy(StatementContextBase newParent, TypeOfCopy typeOfCopy) - throws SourceException { + public StatementContextBase createCopy(final StatementContextBase newParent, + final CopyType typeOfCopy) { return createCopy(null, newParent, typeOfCopy); } /** - * @return copy of this considering {@link TypeOfCopy} (augment, uses) + * @return copy of this considering {@link CopyType} (augment, uses) * - * @throws SourceException instance of SourceException + * @throws org.opendaylight.yangtools.yang.parser.spi.source.SourceException instance of SourceException */ @Override - public StatementContextBase createCopy(QNameModule newQNameModule, - StatementContextBase newParent, TypeOfCopy typeOfCopy) throws SourceException { - RootStatementContext copy = new RootStatementContext<>(this, newQNameModule, typeOfCopy); + public StatementContextBase createCopy(final QNameModule newQNameModule, + final StatementContextBase newParent, final CopyType typeOfCopy) { + final RootStatementContext copy = new RootStatementContext<>(this, newQNameModule, typeOfCopy); - copy.addAllToCopyHistory(this.getCopyHistory()); - copy.addToCopyHistory(typeOfCopy); + copy.appendCopyHistory(typeOfCopy, this.getCopyHistory()); - if(this.getOriginalCtx() != null) { + if (this.getOriginalCtx() != null) { copy.setOriginalCtx(this.getOriginalCtx()); } else { copy.setOriginalCtx(this); @@ -155,32 +162,85 @@ public class RootStatementContext, E extends E return copy; } - /** - * @return this' argument as it is the only from root (this) - */ + @Nonnull @Override - public List getArgumentsFromRoot() { - List argumentList = new LinkedList<>(); - argumentList.add(argument); - return argumentList; + public Optional getSchemaPath() { + return Optional.of(SchemaPath.ROOT); } /** - * @return this as it is the only\context from root (this) + * @return true */ @Override - public List> getStmtContextsFromRoot() { - List> stmtContextsList = new LinkedList<>(); - stmtContextsList.add(this); - return stmtContextsList; + public boolean isRootContext() { + return true; } - /** - * @return true - */ @Override - public boolean isRootContext() { + public boolean isConfiguration() { return true; } + @Override + public boolean isEnabledSemanticVersioning() { + return sourceContext.isEnabledSemanticVersioning(); + } + + @Override + public > void addToLocalStorage(final Class type, final K key, + final V value) { + if (IncludedModuleContext.class.isAssignableFrom(type)) { + if (includedContexts.isEmpty()) { + includedContexts = new ArrayList<>(1); + } + Verify.verify(value instanceof RootStatementContext); + includedContexts.add((RootStatementContext) value); + } + super.addToLocalStorage(type, key, value); + } + + @Override + public > V getFromLocalStorage(final Class type, final K key) { + final V potentialLocal = super.getFromLocalStorage(type, key); + if (potentialLocal != null) { + return potentialLocal; + } + for (final NamespaceStorageNode includedSource : includedContexts) { + final V potential = includedSource.getFromLocalStorage(type, key); + if (potential != null) { + return potential; + } + } + return null; + } + + @Nullable + @Override + public > Map getAllFromLocalStorage(final Class type) { + final Map potentialLocal = super.getAllFromLocalStorage(type); + if (potentialLocal != null) { + return potentialLocal; + } + for (final NamespaceStorageNode includedSource : includedContexts) { + final Map potential = includedSource.getAllFromLocalStorage(type); + if (potential != null) { + return potential; + } + } + return null; + } + + @Override + public YangVersion getRootVersion() { + return version == null ? DEFAULT_VERSION : version; + } + + @Override + public void setRootVersion(final YangVersion version) { + Preconditions.checkArgument(sourceContext.getSupportedVersions().contains(version), + "Unsupported yang version %s in %s", version, getStatementSourceReference()); + Preconditions.checkState(this.version == null, "Version of root %s has been already set to %s", argument, + this.version); + this.version = Preconditions.checkNotNull(version); + } }