import java.util.ArrayDeque;
import java.util.Collection;
import java.util.Deque;
-import java.util.HashSet;
import java.util.Optional;
import org.opendaylight.yangtools.odlext.model.api.YangModeledAnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.common.QName;
checkArgument(parent instanceof DataNodeContainer, "Augmentation allowed only in DataNodeContainer", parent);
final AugmentationSchemaNode schema = SchemaUtils.findSchemaForAugment((AugmentationTarget) parent,
identifier.getPossibleChildNames());
- final HashSet<DataSchemaNode> realChildSchemas = new HashSet<>();
- for (final DataSchemaNode child : schema.getChildNodes()) {
- realChildSchemas.add(((DataNodeContainer) parent).getDataChildByName(child.getQName()));
- }
- final AugmentationSchemaNode resolvedSchema = new EffectiveAugmentationSchema(schema, realChildSchemas);
+ final AugmentationSchemaNode resolvedSchema = EffectiveAugmentationSchema.create(schema,
+ (DataNodeContainer) parent);
schemaStack.push(resolvedSchema);
return resolvedSchema;
}
import com.google.common.collect.Iterables;
import java.util.Collection;
import java.util.Collections;
-import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
-import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.ModifyAction;
return new AugmentationIdentifier(potentialChildren.build());
}
- private static DataNodeContainer augmentationProxy(final AugmentationSchemaNode augmentation,
- final DataNodeContainer schema) {
- final Set<DataSchemaNode> children = new HashSet<>();
- for (final DataSchemaNode augNode : augmentation.getChildNodes()) {
- children.add(schema.getDataChildByName(augNode.getQName()));
- }
- return new EffectiveAugmentationSchema(augmentation, children);
- }
-
@Override
@SuppressWarnings("unchecked")
public final NormalizedNode<?, ?> create(final YangInstanceIdentifier instanceId,
static final class AugmentationNormalization extends DataContainerNormalizationOperation<AugmentationIdentifier> {
AugmentationNormalization(final AugmentationSchemaNode augmentation, final DataNodeContainer schema) {
- super(augmentationIdentifierFrom(augmentation), augmentationProxy(augmentation, schema));
+ super(augmentationIdentifierFrom(augmentation), EffectiveAugmentationSchema.create(augmentation, schema));
}
@Override
import static com.google.common.base.Preconditions.checkArgument;
-import java.util.HashSet;
-import java.util.Set;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeConfiguration;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableAugmentationNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.util.EffectiveAugmentationSchema;
final class AugmentationModificationStrategy
extends AbstractDataNodeContainerModificationStrategy<AugmentationSchemaNode> {
AugmentationModificationStrategy(final AugmentationSchemaNode schema, final DataNodeContainer resolved,
final DataTreeConfiguration treeConfig) {
- super(createAugmentProxy(schema,resolved), AugmentationNode.class, treeConfig);
+ super(EffectiveAugmentationSchema.create(schema, resolved), AugmentationNode.class, treeConfig);
}
@Override
return ImmutableAugmentationNodeBuilder.create()
.withNodeIdentifier(((AugmentationNode) original).getIdentifier()).build();
}
-
- private static AugmentationSchemaNode createAugmentProxy(final AugmentationSchemaNode schema,
- final DataNodeContainer resolved) {
- final Set<DataSchemaNode> realChildSchemas = new HashSet<>();
- for (final DataSchemaNode augChild : schema.getChildNodes()) {
- realChildSchemas.add(resolved.getDataChildByName(augChild.getQName()));
- }
- return new EffectiveAugmentationSchema(schema, realChildSchemas);
- }
-}
\ No newline at end of file
+}
import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.util.EffectiveAugmentationSchema;
-final class AugmentationContextNode extends
- DataContainerContextNode<AugmentationIdentifier> {
-
+final class AugmentationContextNode extends DataContainerContextNode<AugmentationIdentifier> {
AugmentationContextNode(final AugmentationSchemaNode augmentation, final DataNodeContainer schema) {
- super(augmentationIdentifierFrom(augmentation), augmentationProxy(augmentation, schema), null);
+ super(augmentationIdentifierFrom(augmentation), EffectiveAugmentationSchema.create(augmentation, schema), null);
}
@Override
@Override
protected DataSchemaContextNode<?> fromLocalSchemaAndQName(final DataNodeContainer schema, final QName child) {
- DataSchemaNode result = findChildSchemaNode(schema, child);
+ final DataSchemaNode result = findChildSchemaNode(schema, child);
// We try to look up if this node was added by augmentation
- if ((schema instanceof DataSchemaNode) && result.isAugmenting()) {
+ if (schema instanceof DataSchemaNode && result.isAugmenting()) {
return fromAugmentation(schema, (AugmentationTarget) schema, result);
}
return fromDataSchemaNode(result);
protected Set<QName> getQNameIdentifiers() {
return getIdentifier().getPossibleChildNames();
}
-
}
import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableSet;
-import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
* Find a child node identifier by its {@link PathArgument}.
*
* @param child Child path argument
- * @return
+ * @return A child node, or null if not found
*/
@Nullable public abstract DataSchemaContextNode<?> getChild(PathArgument child);
return new AugmentationIdentifier(potentialChildren.build());
}
- static DataNodeContainer augmentationProxy(final AugmentationSchemaNode augmentation,
- final DataNodeContainer schema) {
- Set<DataSchemaNode> children = new HashSet<>();
- for (DataSchemaNode augNode : augmentation.getChildNodes()) {
- children.add(schema.getDataChildByName(augNode.getQName()));
- }
- return new EffectiveAugmentationSchema(augmentation, children);
+ /**
+ * Returns an AugmentationSchemaNode as effective in a parent node.
+ *
+ * @param schema Augmentation schema
+ * @param parent Parent schema
+ * @return Adjusted Augmentation schema
+ * @throws NullPointerException if any of the arguments is null
+ * @deprecated Use {@link EffectiveAugmentationSchema#create(AugmentationSchemaNode, DataNodeContainer)} instead.
+ */
+ @Deprecated
+ public static AugmentationSchemaNode augmentationProxy(final AugmentationSchemaNode schema,
+ final DataNodeContainer parent) {
+ return EffectiveAugmentationSchema.create(schema, parent);
}
/**
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
this.mappedChildSchemas = ImmutableMap.copyOf(m);
}
+ /**
+ * Returns an AugmentationSchemaNode as effective in a parent node.
+ *
+ * @param schema Augmentation schema
+ * @param parent Parent schema
+ * @return Adjusted Augmentation schema
+ * @throws NullPointerException if any of the arguments is null
+ */
+ public static AugmentationSchemaNode create(final AugmentationSchemaNode schema, final DataNodeContainer parent) {
+ Set<DataSchemaNode> children = new HashSet<>();
+ for (DataSchemaNode augNode : schema.getChildNodes()) {
+ children.add(parent.getDataChildByName(augNode.getQName()));
+ }
+ return new EffectiveAugmentationSchema(schema, children);
+ }
+
@Override
public Optional<RevisionAwareXPath> getWhenCondition() {
return delegate.getWhenCondition();