import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
-import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
private static boolean isAnyDefaultValueMarkedWithIfFeature(final TypeEffectiveStatement<?> typeStmt,
final Set<String> defaultValues) {
- final Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements = typeStmt.effectiveSubstatements();
- for (final EffectiveStatement<?, ?> effectiveSubstatement : effectiveSubstatements) {
+ for (final EffectiveStatement<?, ?> effectiveSubstatement : typeStmt.effectiveSubstatements()) {
if (YangStmtMapping.BIT.equals(effectiveSubstatement.statementDefinition())) {
final QName bitQName = (QName) effectiveSubstatement.argument();
if (defaultValues.remove(bitQName.getLocalName()) && containsIfFeature(effectiveSubstatement)) {
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
-import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
final StmtContext<A, D, ?> ctx) {
super(ctx);
- Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements = effectiveSubstatements();
-
Map<QName, DataSchemaNode> mutableChildNodes = new LinkedHashMap<>();
Set<GroupingDefinition> mutableGroupings = new HashSet<>();
Set<UsesNode> mutableUses = new HashSet<>();
Set<TypeDefinition<?>> mutableTypeDefinitions = new LinkedHashSet<>();
Set<DataSchemaNode> mutablePublicChildNodes = new LinkedHashSet<>();
- for (EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements) {
- if (effectiveStatement instanceof DataSchemaNode) {
- final DataSchemaNode dataSchemaNode = (DataSchemaNode) effectiveStatement;
+ for (EffectiveStatement<?, ?> stmt : effectiveSubstatements()) {
+ if (stmt instanceof DataSchemaNode) {
+ final DataSchemaNode dataSchemaNode = (DataSchemaNode) stmt;
if (!mutableChildNodes.containsKey(dataSchemaNode.getQName())) {
/**
* Add case short hand when augmenting choice with short hand
**/
- if (this instanceof AugmentationSchema && !(effectiveStatement instanceof ChoiceCaseNode ||
- effectiveStatement instanceof ChoiceSchemaNode) &&
- (YangValidationBundles.SUPPORTED_CASE_SHORTHANDS.contains(effectiveStatement.statementDefinition())) &&
- Boolean.TRUE.equals(ctx.getFromNamespace(AugmentToChoiceNamespace.class, ctx))) {
+ if (this instanceof AugmentationSchema
+ && !(stmt instanceof ChoiceCaseNode || stmt instanceof ChoiceSchemaNode)
+ && YangValidationBundles.SUPPORTED_CASE_SHORTHANDS.contains(stmt.statementDefinition())
+ && Boolean.TRUE.equals(ctx.getFromNamespace(AugmentToChoiceNamespace.class, ctx))) {
final CaseShorthandImpl caseShorthand = new CaseShorthandImpl(dataSchemaNode);
mutableChildNodes.put(caseShorthand.getQName(), caseShorthand);
mutablePublicChildNodes.add(caseShorthand);
mutablePublicChildNodes.add(dataSchemaNode);
}
} else {
- throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, effectiveStatement);
+ throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, stmt);
}
}
- if (effectiveStatement instanceof UsesNode) {
- UsesNode usesNode = (UsesNode) effectiveStatement;
+ if (stmt instanceof UsesNode) {
+ UsesNode usesNode = (UsesNode) stmt;
if (!mutableUses.contains(usesNode)) {
mutableUses.add(usesNode);
} else {
- throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, effectiveStatement);
+ throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, stmt);
}
}
- if (effectiveStatement instanceof TypeDefEffectiveStatementImpl) {
- TypeDefEffectiveStatementImpl typeDef = (TypeDefEffectiveStatementImpl) effectiveStatement;
+ if (stmt instanceof TypeDefEffectiveStatementImpl) {
+ TypeDefEffectiveStatementImpl typeDef = (TypeDefEffectiveStatementImpl) stmt;
TypeDefinition<?> type = typeDef.getTypeDefinition();
if (!mutableTypeDefinitions.contains(type)) {
mutableTypeDefinitions.add(type);
} else {
- throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, effectiveStatement);
+ throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, stmt);
}
}
- if (effectiveStatement instanceof GroupingDefinition) {
- GroupingDefinition grp = (GroupingDefinition) effectiveStatement;
+ if (stmt instanceof GroupingDefinition) {
+ GroupingDefinition grp = (GroupingDefinition) stmt;
if (!mutableGroupings.contains(grp)) {
mutableGroupings.add(grp);
} else {
- throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, effectiveStatement);
+ throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, stmt);
}
}
}
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.net.URI;
-import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
this.copyOf = ctx.getOriginalCtx() == null ? null : (AugmentationSchema) ctx.getOriginalCtx().buildEffective();
final WhenEffectiveStatementImpl whenStmt = firstEffective(WhenEffectiveStatementImpl.class);
- this.whenCondition = (whenStmt == null) ? null : whenStmt.argument();
+ this.whenCondition = whenStmt == null ? null : whenStmt.argument();
// initSubstatementCollections
- final Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements = effectiveSubstatements();
final ImmutableSet.Builder<ActionDefinition> actionsBuilder = ImmutableSet.builder();
final ImmutableSet.Builder<NotificationDefinition> notificationsBuilder = ImmutableSet.builder();
final ImmutableList.Builder<UnknownSchemaNode> listBuilder = new ImmutableList.Builder<>();
- for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements) {
+ for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
if (effectiveStatement instanceof ActionDefinition) {
actionsBuilder.add((ActionDefinition) effectiveStatement);
} else if (effectiveStatement instanceof NotificationDefinition) {
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableSet;
-import java.util.Collection;
import java.util.Comparator;
import java.util.LinkedHashSet;
import java.util.Objects;
this.original = ctx.getOriginalCtx() == null ? null : (ChoiceSchemaNode) ctx.getOriginalCtx().buildEffective();
final DefaultEffectiveStatementImpl defaultStmt = firstEffective(DefaultEffectiveStatementImpl.class);
- this.defaultCase = (defaultStmt == null) ? null : defaultStmt.argument();
+ this.defaultCase = defaultStmt == null ? null : defaultStmt.argument();
// initSubstatementCollectionsAndFields
- final Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements = effectiveSubstatements();
final Set<AugmentationSchema> augmentationsInit = new LinkedHashSet<>();
final SortedSet<ChoiceCaseNode> casesInit = new TreeSet<>(SCHEMA_NODE_COMP);
- for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements) {
+ for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
if (effectiveStatement instanceof AugmentationSchema) {
final AugmentationSchema augmentationSchema = (AugmentationSchema) effectiveStatement;
augmentationsInit.add(augmentationSchema);
Preconditions.checkArgument(name != null, "Choice Case string Name cannot be NULL!");
for (final ChoiceCaseNode caseNode : cases) {
- if (caseNode != null && (caseNode.getQName() != null) && name.equals(caseNode.getQName().getLocalName())) {
+ if (caseNode != null && caseNode.getQName() != null && name.equals(caseNode.getQName().getLocalName())) {
return caseNode;
}
}
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
-import java.util.Collection;
+import java.util.ArrayList;
import java.util.LinkedHashSet;
-import java.util.LinkedList;
import java.util.List;
import java.util.Objects;
import java.util.Set;
this.constraints = EffectiveConstraintDefinitionImpl.forParent(this);
// initSubstatementCollections
- Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements = effectiveSubstatements();
- List<UnknownSchemaNode> unknownNodesInit = new LinkedList<>();
+ List<UnknownSchemaNode> unknownNodesInit = new ArrayList<>();
Set<AugmentationSchema> augmentationsInit = new LinkedHashSet<>();
- for (EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements) {
+ for (EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
if (effectiveStatement instanceof UnknownSchemaNode) {
UnknownSchemaNode unknownNode = (UnknownSchemaNode) effectiveStatement;
unknownNodesInit.add(unknownNode);
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
import com.google.common.collect.ImmutableList;
-import java.util.Collection;
-import java.util.LinkedList;
import java.util.List;
+import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RefineStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
refineTargetNode = (SchemaNode) ctx.getEffectOfStatement().iterator().next().buildEffective();
// initSubstatementCollectionsAndFields
- Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements = effectiveSubstatements();
- List<UnknownSchemaNode> unknownNodesInit = new LinkedList<>();
- for (EffectiveStatement<?, ?> effectiveSubstatement : effectiveSubstatements) {
- if (effectiveSubstatement instanceof UnknownSchemaNode) {
- UnknownSchemaNode unknownNode = (UnknownSchemaNode) effectiveSubstatement;
- unknownNodesInit.add(unknownNode);
- }
- }
- this.unknownNodes = ImmutableList.copyOf(unknownNodesInit);
+ this.unknownNodes = ImmutableList.copyOf(effectiveSubstatements().stream()
+ .filter(UnknownSchemaNode.class::isInstance)
+ .map(UnknownSchemaNode.class::cast)
+ .collect(Collectors.toList()));
}
public SchemaNode getRefineTargetNode() {
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective;
import com.google.common.collect.ImmutableSet;
-import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Objects;
this.output = firstEffective(OutputEffectiveStatementImpl.class);
// initSubstatements
- Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements = effectiveSubstatements();
Set<GroupingDefinition> groupingsInit = new HashSet<>();
Set<TypeDefinition<?>> mutableTypeDefinitions = new LinkedHashSet<>();
- for (EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements) {
+ for (EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
if (effectiveStatement instanceof GroupingDefinition) {
GroupingDefinition groupingDefinition = (GroupingDefinition) effectiveStatement;
groupingsInit.add(groupingDefinition);
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
-import java.util.Collection;
+import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashSet;
-import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
import org.opendaylight.yangtools.yang.parser.spi.GroupingNamespace;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
public final class UsesEffectiveStatementImpl extends AbstractEffectiveDocumentedNode<QName, UsesStatement> implements UsesNode {
private final SchemaPath groupingPath;
addedByUses = ctx.getCopyHistory().contains(CopyType.ADDED_BY_USES);
// initSubstatementCollections
- final Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements = effectiveSubstatements();
- final List<UnknownSchemaNode> unknownNodesInit = new LinkedList<>();
+ final List<UnknownSchemaNode> unknownNodesInit = new ArrayList<>();
final Set<AugmentationSchema> augmentationsInit = new LinkedHashSet<>();
final Map<SchemaPath, SchemaNode> refinesInit = new HashMap<>();
- for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements) {
+ for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
if (effectiveStatement instanceof UnknownSchemaNode) {
final UnknownSchemaNode unknownNode = (UnknownSchemaNode) effectiveStatement;
unknownNodesInit.add(unknownNode);
this.refines = ImmutableMap.copyOf(refinesInit);
final WhenEffectiveStatementImpl whenStmt = firstEffective(WhenEffectiveStatementImpl.class);
- this.whenCondition = (whenStmt == null) ? null : whenStmt.argument();
+ this.whenCondition = whenStmt == null ? null : whenStmt.argument();
}
@Nonnull
import com.google.common.base.MoreObjects;
import com.google.common.collect.ImmutableSet;
-import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Objects;
this.output = firstEffective(OutputEffectiveStatementImpl.class);
// initSubstatements
- Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements = effectiveSubstatements();
Set<GroupingDefinition> groupingsInit = new HashSet<>();
Set<TypeDefinition<?>> mutableTypeDefinitions = new LinkedHashSet<>();
- for (EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements) {
+ for (EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
if (effectiveStatement instanceof GroupingDefinition) {
GroupingDefinition groupingDefinition = (GroupingDefinition) effectiveStatement;
groupingsInit.add(groupingDefinition);
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import java.util.Collection;
import java.util.Date;
import org.junit.Ignore;
import org.junit.Test;
final LeafSchemaNode leaf = (LeafSchemaNode) cont.getDataChildByName(leafQName);
assertNotNull(leaf);
- final Collection<? extends EffectiveStatement<?, ?>> effectiveSubstatements =
- ((LeafEffectiveStatementImpl) leaf).effectiveSubstatements();
-
- for (EffectiveStatement<?, ?> effStmt : effectiveSubstatements) {
+ for (EffectiveStatement<?, ?> effStmt : ((LeafEffectiveStatementImpl) leaf).effectiveSubstatements()) {
if (effStmt instanceof UnitsEffectiveStatementImpl) {
units = (UnitsEffectiveStatementImpl) effStmt;
break;