*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import com.google.common.base.Preconditions;
+import com.google.common.base.Verify;
import com.google.common.collect.ImmutableList.Builder;
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.Set;
-import java.util.regex.Pattern;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MandatoryStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.TypeOfCopy;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace;
import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace.ValidationBundleType;
+import org.opendaylight.yangtools.yang.parser.stmt.reactor.RootStatementContext;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
// FIXME: Move this to the AugmentStatementDefinition#ApplyAction
private static void copyDeclaredStmts(final StatementContextBase<?, ?, ?> sourceCtx,
final StatementContextBase<?, ?, ?> targetCtx) throws SourceException {
- final List<StatementContextBase<?, ?, ?>> subStatements = new Builder<StatementContextBase<?, ?, ?>>()
- .addAll(targetCtx.declaredSubstatements()).addAll(targetCtx.effectiveSubstatements()).build();
- boolean sourceAndTargetInSameModule = Utils.getRootModuleQName(sourceCtx).equals(
- Utils.getRootModuleQName(targetCtx));
-
- TypeOfCopy typeOfCopy = sourceCtx.getParentContext().getPublicDefinition().getDeclaredRepresentationClass()
+ final TypeOfCopy typeOfCopy = sourceCtx.getParentContext().getPublicDefinition().getDeclaredRepresentationClass()
.equals(UsesStatement.class) ? TypeOfCopy.ADDED_BY_USES_AUGMENTATION : TypeOfCopy.ADDED_BY_AUGMENTATION;
for (StatementContextBase<?, ?, ?> originalStmtCtx : sourceCtx.declaredSubstatements()) {
if (needToCopyByAugment(originalStmtCtx)) {
- validateNodeCanBeCopiedByAugment(originalStmtCtx, subStatements, sourceAndTargetInSameModule);
+ validateNodeCanBeCopiedByAugment(originalStmtCtx, targetCtx, typeOfCopy);
StatementContextBase<?, ?, ?> copy = originalStmtCtx.createCopy(targetCtx, typeOfCopy);
targetCtx.addEffectiveSubstatement(copy);
private static void copyEffectiveStmts(final StatementContextBase<?, ?, ?> sourceCtx,
final StatementContextBase<?, ?, ?> targetCtx) throws SourceException {
-
- final List<StatementContextBase<?, ?, ?>> subStatements = new Builder<StatementContextBase<?, ?, ?>>()
- .addAll(targetCtx.declaredSubstatements()).addAll(targetCtx.effectiveSubstatements()).build();
- boolean sourceAndTargetInSameModule = Utils.getRootModuleQName(sourceCtx).equals(
- Utils.getRootModuleQName(targetCtx));
-
- TypeOfCopy typeOfCopy = sourceCtx.getParentContext().getPublicDefinition().getDeclaredRepresentationClass()
+ final TypeOfCopy typeOfCopy = sourceCtx.getParentContext().getPublicDefinition().getDeclaredRepresentationClass()
.equals(UsesStatement.class) ? TypeOfCopy.ADDED_BY_USES_AUGMENTATION : TypeOfCopy.ADDED_BY_AUGMENTATION;
for (StatementContextBase<?, ?, ?> originalStmtCtx : sourceCtx.effectiveSubstatements()) {
if (needToCopyByAugment(originalStmtCtx)) {
- validateNodeCanBeCopiedByAugment(originalStmtCtx, subStatements, sourceAndTargetInSameModule);
+ validateNodeCanBeCopiedByAugment(originalStmtCtx, targetCtx, typeOfCopy);
StatementContextBase<?, ?, ?> copy = originalStmtCtx.createCopy(targetCtx, typeOfCopy);
targetCtx.addEffectiveSubstatement(copy);
}
private static void validateNodeCanBeCopiedByAugment(final StatementContextBase<?, ?, ?> sourceCtx,
- final List<StatementContextBase<?, ?, ?>> targetSubStatements, final boolean sourceAndTargetInSameModule) {
+ final StatementContextBase<?, ?, ?> targetCtx, final TypeOfCopy typeOfCopy) {
if (sourceCtx.getPublicDefinition().getDeclaredRepresentationClass().equals(WhenStatement.class)) {
return;
}
- if (!sourceAndTargetInSameModule) {
+ if (typeOfCopy == TypeOfCopy.ADDED_BY_AUGMENTATION && reguiredCheckOfMandatoryNodes(sourceCtx, targetCtx)) {
final List<StatementContextBase<?, ?, ?>> sourceSubStatements = new Builder<StatementContextBase<?, ?, ?>>()
.addAll(sourceCtx.declaredSubstatements()).addAll(sourceCtx.effectiveSubstatements()).build();
for (final StatementContextBase<?, ?, ?> sourceSubStatement : sourceSubStatements) {
- if (sourceSubStatement.getPublicDefinition().getDeclaredRepresentationClass()
- .equals(MandatoryStatement.class)) {
- throw new IllegalArgumentException(
- String.format(
- "An augment cannot add node '%s' because it is mandatory and in module different from target",
- sourceCtx.rawStatementArgument()));
- }
+ InferenceException.throwIf(MandatoryStatement.class.equals(sourceSubStatement.getPublicDefinition()
+ .getDeclaredRepresentationClass()), sourceCtx.getStatementSourceReference(),
+ "An augment cannot add node '%s' because it is mandatory and in module different from target",
+ sourceCtx.rawStatementArgument());
}
}
+ final List<StatementContextBase<?, ?, ?>> targetSubStatements = new Builder<StatementContextBase<?, ?, ?>>()
+ .addAll(targetCtx.declaredSubstatements()).addAll(targetCtx.effectiveSubstatements()).build();
+
for (final StatementContextBase<?, ?, ?> subStatement : targetSubStatements) {
final boolean sourceIsDataNode = DataDefinitionStatement.class.isAssignableFrom(sourceCtx
boolean qNamesEqual = sourceIsDataNode && targetIsDataNode
&& Objects.equals(sourceCtx.getStatementArgument(), subStatement.getStatementArgument());
- if (qNamesEqual) {
- throw new IllegalStateException(String.format(
- "An augment cannot add node named '%s' because this name is already used in target",
- sourceCtx.rawStatementArgument()));
- }
+ InferenceException.throwIf(qNamesEqual, sourceCtx.getStatementSourceReference(),
+ "An augment cannot add node named '%s' because this name is already used in target",
+ sourceCtx.rawStatementArgument());
}
}
- private static final Set<Rfc6020Mapping> NOCOPY_DEV_SET = ImmutableSet.of(Rfc6020Mapping.USES);
+ private static boolean reguiredCheckOfMandatoryNodes(final StatementContextBase<?, ?, ?> sourceCtx,
+ StatementContextBase<?, ?, ?> targetCtx) {
+ /*
+ * If the statement argument is not QName, it cannot be mandatory statement,
+ * therefore return false and skip mandatory nodes validation
+ */
+ if(!(sourceCtx.getStatementArgument() instanceof QName)) {
+ return false;
+ }
+ QName sourceStmtQName = (QName) sourceCtx.getStatementArgument();
+
+ RootStatementContext<?, ?, ?> root = targetCtx.getRoot();
+ do {
+ Verify.verify(targetCtx.getStatementArgument() instanceof QName,
+ "Argument of augment target statement must be QName.");
+ QName targetStmtQName = (QName) targetCtx.getStatementArgument();
+ /*
+ * If target is from another module, return true and perform
+ * mandatory nodes validation
+ */
+ if (!Utils.belongsToTheSameModule(targetStmtQName, sourceStmtQName)) {
+ return true;
+ } else {
+ /*
+ * If target or one of its parent is a presence container from
+ * the same module, return false and skip mandatory nodes
+ * validation
+ */
+ if (Utils.isPresenceContainer(targetCtx)) {
+ return false;
+ }
+ }
+ } while ((targetCtx = targetCtx.getParentContext()) != root);
+
+ /*
+ * All target node's parents belong to the same module as source node,
+ * therefore return false and skip mandatory nodes validation.
+ */
+ return false;
+ }
+
+ private static final Set<Rfc6020Mapping> NOCOPY_DEF_SET = ImmutableSet.of(Rfc6020Mapping.USES, Rfc6020Mapping.WHEN,
+ Rfc6020Mapping.DESCRIPTION, Rfc6020Mapping.REFERENCE, Rfc6020Mapping.STATUS);
public static boolean needToCopyByAugment(final StmtContext<?, ?, ?> stmtContext) {
- return !NOCOPY_DEV_SET.contains(stmtContext.getPublicDefinition());
+ return !NOCOPY_DEF_SET.contains(stmtContext.getPublicDefinition());
}
private static final Set<Rfc6020Mapping> REUSED_DEF_SET = ImmutableSet.of(Rfc6020Mapping.TYPEDEF);
static boolean isSupportedAugmentTarget(final StatementContextBase<?, ?, ?> substatementCtx) {
/*
- * :TODO Substatement must be allowed augment target type e.g. Container, etc... and must be not for example
+ * :TODO Substatement must be allowed augment target type e.g. Container, etc... and must not be for example
* grouping, identity etc. It is problem in case when more than one substatements have the same QName, for
* example Grouping and Container are siblings and they have the same QName. We must find the Container and the
* Grouping must be ignored as disallowed augment target.
Code Review / yangtools.git / blobdiff