*/
package org.opendaylight.controller.md.sal.common.impl.util.compat;
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
-
-import javax.xml.transform.dom.DOMSource;
+import org.eclipse.jdt.annotation.Nullable;
+import org.gaul.modernizer_maven_annotations.SuppressModernizer;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.CompositeNode;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.api.Node;
-import org.opendaylight.yangtools.yang.data.api.SimpleNode;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
-import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
+import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
-import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
+import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
+import org.opendaylight.yangtools.yang.model.util.EffectiveAugmentationSchema;
-import com.google.common.base.Optional;
-import com.google.common.collect.FluentIterable;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-
-/**
- * @deprecated This class provides compatibility between {@link CompositeNode} and {@link NormalizedNode}.
- * Users of this class should use {@link NormalizedNode}s directly.
- */
@Deprecated
public abstract class DataNormalizationOperation<T extends PathArgument> implements Identifiable<T> {
private final T identifier;
- private final Optional<DataSchemaNode> dataSchemaNode;
+ private final DataSchemaNode dataSchemaNode;
@Override
public T getIdentifier() {
return identifier;
- };
+ }
protected DataNormalizationOperation(final T identifier, final SchemaNode schema) {
- super();
this.identifier = identifier;
- if(schema instanceof DataSchemaNode) {
- this.dataSchemaNode = Optional.of((DataSchemaNode) schema);
- } else {
- this.dataSchemaNode = Optional.absent();
- }
+ dataSchemaNode = schema instanceof DataSchemaNode ? (DataSchemaNode)schema : null;
}
public boolean isMixin() {
return Collections.singleton(identifier.getNodeType());
}
- public abstract DataNormalizationOperation<?> getChild(final PathArgument child) throws DataNormalizationException;
+ public abstract DataNormalizationOperation<?> getChild(PathArgument child) throws DataNormalizationException;
public abstract DataNormalizationOperation<?> getChild(QName child) throws DataNormalizationException;
- public abstract NormalizedNode<?, ?> normalize(Node<?> legacyData);
-
public abstract boolean isLeaf();
+ @SuppressModernizer
public Optional<DataSchemaNode> getDataSchemaNode() {
- // FIXME
- return dataSchemaNode;
+ return Optional.fromNullable(dataSchemaNode);
}
- private static abstract class SimpleTypeNormalization<T extends PathArgument> extends DataNormalizationOperation<T> {
-
- protected SimpleTypeNormalization(final T identifier, final DataSchemaNode potential) {
+ private abstract static class SimpleTypeNormalization<T extends PathArgument>
+ extends DataNormalizationOperation<T> {
+ SimpleTypeNormalization(final T identifier, final DataSchemaNode potential) {
super(identifier,potential);
}
- @Override
- public NormalizedNode<?, ?> normalize(final Node<?> legacyData) {
- checkArgument(legacyData != null);
- checkArgument(legacyData instanceof SimpleNode<?>);
- return normalizeImpl((SimpleNode<?>) legacyData);
- }
-
- protected abstract NormalizedNode<?, ?> normalizeImpl(SimpleNode<?> node);
-
@Override
public DataNormalizationOperation<?> getChild(final PathArgument child) {
return null;
public boolean isLeaf() {
return true;
}
-
}
private static final class LeafNormalization extends SimpleTypeNormalization<NodeIdentifier> {
-
- protected LeafNormalization(final LeafSchemaNode potential) {
+ LeafNormalization(final LeafSchemaNode potential) {
super(new NodeIdentifier(potential.getQName()),potential);
}
-
- @Override
- protected NormalizedNode<?, ?> normalizeImpl(final SimpleNode<?> node) {
- return ImmutableNodes.leafNode(node.getNodeType(), node.getValue());
- }
-
}
private static final class LeafListEntryNormalization extends SimpleTypeNormalization<NodeWithValue> {
-
- public LeafListEntryNormalization(final LeafListSchemaNode potential) {
+ LeafListEntryNormalization(final LeafListSchemaNode potential) {
super(new NodeWithValue(potential.getQName(), null),potential);
}
- @Override
- protected NormalizedNode<?, ?> normalizeImpl(final SimpleNode<?> node) {
- NodeWithValue nodeId = new NodeWithValue(node.getNodeType(), node.getValue());
- return Builders.leafSetEntryBuilder().withNodeIdentifier(nodeId).withValue(node.getValue()).build();
- }
-
-
@Override
public boolean isKeyedEntry() {
return true;
}
}
- private static abstract class CompositeNodeNormalizationOperation<T extends PathArgument> extends
- DataNormalizationOperation<T> {
-
- protected CompositeNodeNormalizationOperation(final T identifier, final DataSchemaNode schema) {
+ private abstract static class CompositeNodeNormalizationOperation<T extends PathArgument>
+ extends DataNormalizationOperation<T> {
+ CompositeNodeNormalizationOperation(final T identifier, final DataSchemaNode schema) {
super(identifier,schema);
}
- @SuppressWarnings({ "rawtypes", "unchecked" })
- @Override
- public final NormalizedNode<?, ?> normalize(final Node<?> legacyData) {
- checkArgument(legacyData != null);
- if (!isMixin() && getIdentifier().getNodeType() != null) {
- checkArgument(getIdentifier().getNodeType().equals(legacyData.getNodeType()),
- "Node QName must be %s was %s", getIdentifier().getNodeType(), legacyData.getNodeType());
- }
- checkArgument(legacyData instanceof CompositeNode, "Node %s should be composite", legacyData);
- CompositeNode compositeNode = (CompositeNode) legacyData;
- NormalizedNodeContainerBuilder builder = createBuilder(compositeNode);
-
- Set<DataNormalizationOperation<?>> usedMixins = new HashSet<>();
- for (Node<?> childLegacy : compositeNode.getValue()) {
- final DataNormalizationOperation childOp;
-
- try {
- childOp = getChild(childLegacy.getNodeType());
- } catch (DataNormalizationException e) {
- throw new IllegalArgumentException(String.format("Failed to normalize data %s", compositeNode.getValue()), e);
- }
-
- // We skip unknown nodes if this node is mixin since
- // it's nodes and parent nodes are interleaved
- if (childOp == null && isMixin()) {
- continue;
- }
-
- checkArgument(childOp != null, "Node %s is not allowed inside %s", childLegacy.getNodeType(),
- getIdentifier());
- if (childOp.isMixin()) {
- if (usedMixins.contains(childOp)) {
- // We already run / processed that mixin, so to avoid
- // duplicity we are skipping next nodes.
- continue;
- }
- builder.addChild(childOp.normalize(compositeNode));
- usedMixins.add(childOp);
- } else {
- builder.addChild(childOp.normalize(childLegacy));
- }
- }
- return builder.build();
- }
-
@Override
public boolean isLeaf() {
return false;
}
-
- @SuppressWarnings("rawtypes")
- protected abstract NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode);
-
}
- private static abstract class DataContainerNormalizationOperation<T extends PathArgument> extends
- CompositeNodeNormalizationOperation<T> {
-
+ private abstract static class DataContainerNormalizationOperation<T extends PathArgument>
+ extends CompositeNodeNormalizationOperation<T> {
private final DataNodeContainer schema;
private final Map<QName, DataNormalizationOperation<?>> byQName;
private final Map<PathArgument, DataNormalizationOperation<?>> byArg;
- protected DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema, final DataSchemaNode node) {
+ DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema,
+ final DataSchemaNode node) {
super(identifier,node);
this.schema = schema;
this.byArg = new ConcurrentHashMap<>();
return register(potential);
}
- private DataNormalizationOperation<?> fromLocalSchema(final PathArgument child) throws DataNormalizationException {
- if (child instanceof AugmentationIdentifier) {
- return fromSchemaAndQNameChecked(schema, ((AugmentationIdentifier) child).getPossibleChildNames()
- .iterator().next());
- }
- return fromSchemaAndQNameChecked(schema, child.getNodeType());
- }
-
@Override
public DataNormalizationOperation<?> getChild(final QName child) throws DataNormalizationException {
DataNormalizationOperation<?> potential = byQName.get(child);
return register(potential);
}
- protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema2, final QName child) throws DataNormalizationException {
+ private DataNormalizationOperation<?> fromLocalSchema(final PathArgument child)
+ throws DataNormalizationException {
+ if (child instanceof AugmentationIdentifier) {
+ return fromSchemaAndQNameChecked(schema, ((AugmentationIdentifier) child).getPossibleChildNames()
+ .iterator().next());
+ }
+ return fromSchemaAndQNameChecked(schema, child.getNodeType());
+ }
+
+ protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema2,
+ final QName child) throws DataNormalizationException {
return fromSchemaAndQNameChecked(schema2, child);
}
private DataNormalizationOperation<?> register(final DataNormalizationOperation<?> potential) {
if (potential != null) {
byArg.put(potential.getIdentifier(), potential);
- for (QName qName : potential.getQNameIdentifiers()) {
- byQName.put(qName, potential);
+ for (final QName qname : potential.getQNameIdentifiers()) {
+ byQName.put(qname, potential);
}
}
return potential;
}
- }
-
- private static final class ListItemNormalization extends
- DataContainerNormalizationOperation<NodeIdentifierWithPredicates> {
-
- private final List<QName> keyDefinition;
+ private static DataNormalizationOperation<?> fromSchemaAndQNameChecked(final DataNodeContainer schema,
+ final QName child) throws DataNormalizationException {
- protected ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) {
- super(identifier, schema,schema);
- keyDefinition = schema.getKeyDefinition();
- }
-
- @Override
- protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
- ImmutableMap.Builder<QName, Object> keys = ImmutableMap.builder();
- for (QName key : keyDefinition) {
+ final DataSchemaNode result = findChildSchemaNode(schema, child);
+ if (result == null) {
+ throw new DataNormalizationException(String.format(
+ "Supplied QName %s is not valid according to schema %s, potential children nodes: %s", child,
+ schema,schema.getChildNodes()));
+ }
- SimpleNode<?> valueNode = checkNotNull(compositeNode.getFirstSimpleByName(key),
- "List node %s MUST contain leaf %s with value.", getIdentifier().getNodeType(), key);
- keys.put(key, valueNode.getValue());
+ // We try to look up if this node was added by augmentation
+ if (schema instanceof DataSchemaNode && result.isAugmenting()) {
+ return fromAugmentation(schema, (AugmentationTarget) schema, result);
}
+ return fromDataSchemaNode(result);
+ }
+ }
- return Builders.mapEntryBuilder().withNodeIdentifier(
- new NodeIdentifierWithPredicates(getIdentifier().getNodeType(), keys.build()));
+ private static final class ListItemNormalization extends
+ DataContainerNormalizationOperation<NodeIdentifierWithPredicates> {
+ ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) {
+ super(identifier, schema, schema);
}
@Override
+ @SuppressFBWarnings("BC_UNCONFIRMED_CAST")
public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
- DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders
.mapEntryBuilder().withNodeIdentifier((NodeIdentifierWithPredicates) currentArg);
- for (Entry<QName, Object> keyValue : ((NodeIdentifierWithPredicates) currentArg).getKeyValues().entrySet()) {
+ for (final Entry<QName, Object> keyValue : ((NodeIdentifierWithPredicates) currentArg).entrySet()) {
builder.addChild(Builders.leafBuilder()
//
.withNodeIdentifier(new NodeIdentifier(keyValue.getKey())).withValue(keyValue.getValue())
return builder.build();
}
-
@Override
public boolean isKeyedEntry() {
return true;
}
}
- private static final class UnkeyedListItemNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
-
- protected UnkeyedListItemNormalization(final ListSchemaNode schema) {
+ private static final class UnkeyedListItemNormalization
+ extends DataContainerNormalizationOperation<NodeIdentifier> {
+ UnkeyedListItemNormalization(final ListSchemaNode schema) {
super(new NodeIdentifier(schema.getQName()), schema,schema);
}
@Override
- protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
- return Builders.unkeyedListEntryBuilder().withNodeIdentifier(getIdentifier());
- }
-
- @Override
+ @SuppressFBWarnings("BC_UNCONFIRMED_CAST")
public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
return Builders.unkeyedListEntryBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
}
-
}
private static final class ContainerNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
-
- protected ContainerNormalization(final ContainerSchemaNode schema) {
+ ContainerNormalization(final ContainerSchemaNode schema) {
super(new NodeIdentifier(schema.getQName()),schema, schema);
}
@Override
- protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
- return Builders.containerBuilder().withNodeIdentifier(getIdentifier());
- }
-
- @Override
+ @SuppressFBWarnings("BC_UNCONFIRMED_CAST")
public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
return Builders.containerBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
}
-
}
- private static abstract class MixinNormalizationOp<T extends PathArgument> extends
- CompositeNodeNormalizationOperation<T> {
+ private abstract static class MixinNormalizationOp<T extends PathArgument>
+ extends CompositeNodeNormalizationOperation<T> {
- protected MixinNormalizationOp(final T identifier, final DataSchemaNode schema) {
+ MixinNormalizationOp(final T identifier, final DataSchemaNode schema) {
super(identifier,schema);
}
public final boolean isMixin() {
return true;
}
-
}
-
private static final class OrderedLeafListMixinNormalization extends UnorderedLeafListMixinNormalization {
-
-
- public OrderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
+ OrderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
super(potential);
}
- @Override
- protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
- return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier());
- }
-
@Override
public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier()).build();
private final DataNormalizationOperation<?> innerOp;
- public UnorderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
+ UnorderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
super(new NodeIdentifier(potential.getQName()),potential);
innerOp = new LeafListEntryNormalization(potential);
}
- @Override
- protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
- return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier());
- }
-
@Override
public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier()).build();
}
}
- private static final class AugmentationNormalization extends DataContainerNormalizationOperation<AugmentationIdentifier> {
+ private static final class AugmentationNormalization
+ extends DataContainerNormalizationOperation<AugmentationIdentifier> {
- public AugmentationNormalization(final AugmentationSchema augmentation, final DataNodeContainer schema) {
- //super();
+ AugmentationNormalization(final AugmentationSchemaNode augmentation, final DataNodeContainer schema) {
super(augmentationIdentifierFrom(augmentation), augmentationProxy(augmentation,schema),null);
}
+ 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
public boolean isMixin() {
return true;
}
-
-
@Override
- protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema, final QName child)
- throws DataNormalizationException {
- Optional<DataSchemaNode> potential = findChildSchemaNode(schema, child);
- if (!potential.isPresent()) {
+ protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema,
+ final QName child) {
+ final DataSchemaNode result = findChildSchemaNode(schema, child);
+ if (result == null) {
return null;
}
- DataSchemaNode result = potential.get();
// 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);
return getIdentifier().getPossibleChildNames();
}
- @SuppressWarnings("rawtypes")
- @Override
- protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
- return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier());
- }
-
@Override
public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier()).build();
}
-
}
private static class UnorderedMapMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
-
private final ListItemNormalization innerNode;
- public UnorderedMapMixinNormalization(final ListSchemaNode list) {
+ UnorderedMapMixinNormalization(final ListSchemaNode list) {
super(new NodeIdentifier(list.getQName()),list);
- this.innerNode = new ListItemNormalization(new NodeIdentifierWithPredicates(list.getQName(),
- Collections.<QName, Object> emptyMap()), list);
- }
-
- @SuppressWarnings("rawtypes")
- @Override
- protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
- return Builders.mapBuilder().withNodeIdentifier(getIdentifier());
+ this.innerNode = new ListItemNormalization(NodeIdentifierWithPredicates.of(list.getQName(),
+ Collections.<QName, Object>emptyMap()), list);
}
@Override
}
return null;
}
-
}
-
private static class UnkeyedListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
-
private final UnkeyedListItemNormalization innerNode;
- public UnkeyedListMixinNormalization(final ListSchemaNode list) {
+ UnkeyedListMixinNormalization(final ListSchemaNode list) {
super(new NodeIdentifier(list.getQName()),list);
this.innerNode = new UnkeyedListItemNormalization(list);
}
- @SuppressWarnings("rawtypes")
- @Override
- protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
- return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier());
- }
-
@Override
public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier()).build();
}
return null;
}
-
}
private static final class OrderedMapMixinNormalization extends UnorderedMapMixinNormalization {
-
- public OrderedMapMixinNormalization(final ListSchemaNode list) {
+ OrderedMapMixinNormalization(final ListSchemaNode list) {
super(list);
}
- @SuppressWarnings("rawtypes")
- @Override
- protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
- return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier());
- }
-
@Override
public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier()).build();
}
-
}
private static class ChoiceNodeNormalization extends MixinNormalizationOp<NodeIdentifier> {
-
private final ImmutableMap<QName, DataNormalizationOperation<?>> byQName;
private final ImmutableMap<PathArgument, DataNormalizationOperation<?>> byArg;
- protected ChoiceNodeNormalization(final org.opendaylight.yangtools.yang.model.api.ChoiceNode schema) {
+ ChoiceNodeNormalization(final ChoiceSchemaNode schema) {
super(new NodeIdentifier(schema.getQName()),schema);
- ImmutableMap.Builder<QName, DataNormalizationOperation<?>> byQNameBuilder = ImmutableMap.builder();
- ImmutableMap.Builder<PathArgument, DataNormalizationOperation<?>> byArgBuilder = ImmutableMap.builder();
+ final ImmutableMap.Builder<QName, DataNormalizationOperation<?>> byQNameBuilder = ImmutableMap.builder();
+ final ImmutableMap.Builder<PathArgument, DataNormalizationOperation<?>> byArgBuilder =
+ ImmutableMap.builder();
- for (ChoiceCaseNode caze : schema.getCases()) {
- for (DataSchemaNode cazeChild : caze.getChildNodes()) {
- DataNormalizationOperation<?> childOp = fromDataSchemaNode(cazeChild);
+ for (final CaseSchemaNode caze : schema.getCases().values()) {
+ for (final DataSchemaNode cazeChild : caze.getChildNodes()) {
+ final DataNormalizationOperation<?> childOp = fromDataSchemaNode(cazeChild);
byArgBuilder.put(childOp.getIdentifier(), childOp);
- for (QName qname : childOp.getQNameIdentifiers()) {
+ for (final QName qname : childOp.getQNameIdentifiers()) {
byQNameBuilder.put(qname, childOp);
}
}
return byQName.get(child);
}
- @Override
- protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
- return Builders.choiceBuilder().withNodeIdentifier(getIdentifier());
- }
-
@Override
public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
return Builders.choiceBuilder().withNodeIdentifier(getIdentifier()).build();
}
}
- private static class AnyXmlNormalization extends DataNormalizationOperation<NodeIdentifier> {
-
- protected AnyXmlNormalization( final AnyXmlSchemaNode schema) {
- super( new NodeIdentifier(schema.getQName()), schema);
+ private static class AnyxmlNormalization extends DataNormalizationOperation<NodeIdentifier> {
+ AnyxmlNormalization(final AnyxmlSchemaNode schema) {
+ super(new NodeIdentifier(schema.getQName()), schema);
}
@Override
- public DataNormalizationOperation<?> getChild( final PathArgument child ) throws DataNormalizationException {
+ public DataNormalizationOperation<?> getChild(final PathArgument child) {
return null;
}
@Override
- public DataNormalizationOperation<?> getChild( final QName child ) throws DataNormalizationException {
+ public DataNormalizationOperation<?> getChild(final QName child) {
return null;
}
- @Override
- public NormalizedNode<?, ?> normalize( final Node<?> legacyData ) {
- NormalizedNodeAttrBuilder<NodeIdentifier, DOMSource, AnyXmlNode> builder =
- Builders.anyXmlBuilder().withNodeIdentifier(
- new NodeIdentifier( legacyData.getNodeType() ) );
- // Will be removed
-// builder.withValue(legacyData);
- return builder.build();
- }
-
@Override
public boolean isLeaf() {
return false;
}
@Override
- public NormalizedNode<?, ?> createDefault( final PathArgument currentArg ) {
+ public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
return null;
}
}
- private static final Optional<DataSchemaNode> findChildSchemaNode(final DataNodeContainer parent,final QName child) {
- DataSchemaNode potential = parent.getDataChildByName(child);
- if (potential == null) {
- Iterable<org.opendaylight.yangtools.yang.model.api.ChoiceNode> choices = FluentIterable.from(
- parent.getChildNodes()).filter(org.opendaylight.yangtools.yang.model.api.ChoiceNode.class);
- potential = findChoice(choices, child);
- }
- return Optional.fromNullable(potential);
- }
-
- private static DataNormalizationOperation<?> fromSchemaAndQNameChecked(final DataNodeContainer schema,
- final QName child) throws DataNormalizationException {
-
- Optional<DataSchemaNode> potential = findChildSchemaNode(schema, child);
- if (!potential.isPresent()) {
- throw new DataNormalizationException(String.format("Supplied QName %s is not valid according to schema %s, potential children nodes: %s", child, schema,schema.getChildNodes()));
- }
-
- DataSchemaNode result = potential.get();
- // We try to look up if this node was added by augmentation
- if ((schema instanceof DataSchemaNode) && result.isAugmenting()) {
- return fromAugmentation(schema, (AugmentationTarget) schema, result);
- }
- return fromDataSchemaNode(result);
+ private static @Nullable DataSchemaNode findChildSchemaNode(final DataNodeContainer parent, final QName child) {
+ final DataSchemaNode potential = parent.getDataChildByName(child);
+ return potential != null ? potential : findChoice(parent, child);
}
- private static org.opendaylight.yangtools.yang.model.api.ChoiceNode findChoice(
- final Iterable<org.opendaylight.yangtools.yang.model.api.ChoiceNode> choices, final QName child) {
- org.opendaylight.yangtools.yang.model.api.ChoiceNode foundChoice = null;
- choiceLoop: for (org.opendaylight.yangtools.yang.model.api.ChoiceNode choice : choices) {
- for (ChoiceCaseNode caze : choice.getCases()) {
- if (findChildSchemaNode(caze, child).isPresent()) {
- foundChoice = choice;
- break choiceLoop;
+ private static @Nullable ChoiceSchemaNode findChoice(final DataNodeContainer parent, final QName child) {
+ for (final ChoiceSchemaNode choice : Iterables.filter(parent.getChildNodes(), ChoiceSchemaNode.class)) {
+ for (final CaseSchemaNode caze : choice.getCases().values()) {
+ if (findChildSchemaNode(caze, child) != null) {
+ return choice;
}
}
}
- return foundChoice;
+ return null;
}
- public static AugmentationIdentifier augmentationIdentifierFrom(final AugmentationSchema augmentation) {
- ImmutableSet.Builder<QName> potentialChildren = ImmutableSet.builder();
- for (DataSchemaNode child : augmentation.getChildNodes()) {
+ public static AugmentationIdentifier augmentationIdentifierFrom(final AugmentationSchemaNode augmentation) {
+ final ImmutableSet.Builder<QName> potentialChildren = ImmutableSet.builder();
+ for (final DataSchemaNode child : augmentation.getChildNodes()) {
potentialChildren.add(child.getQName());
}
return new AugmentationIdentifier(potentialChildren.build());
}
- private static DataNodeContainer augmentationProxy(final AugmentationSchema augmentation, final DataNodeContainer schema) {
- Set<DataSchemaNode> children = new HashSet<>();
- for (DataSchemaNode augNode : augmentation.getChildNodes()) {
- children.add(schema.getDataChildByName(augNode.getQName()));
- }
- return new DataSchemaContainerProxy(children);
- }
-
/**
- * Returns a DataNormalizationOperation for provided child node
+ * Returns a DataNormalizationOperation for provided child node.
*
+ * <p>
* If supplied child is added by Augmentation this operation returns
* a DataNormalizationOperation for augmentation,
* otherwise returns a DataNormalizationOperation for child as
* call for {@link #fromDataSchemaNode(DataSchemaNode)}.
- *
- *
- * @param parent
- * @param parentAug
- * @param child
- * @return
*/
+ @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "https://github.com/spotbugs/spotbugs/issues/811")
private static DataNormalizationOperation<?> fromAugmentation(final DataNodeContainer parent,
final AugmentationTarget parentAug, final DataSchemaNode child) {
- AugmentationSchema augmentation = null;
- for (AugmentationSchema aug : parentAug.getAvailableAugmentations()) {
- DataSchemaNode potential = aug.getDataChildByName(child.getQName());
+ AugmentationSchemaNode augmentation = null;
+ for (final AugmentationSchemaNode aug : parentAug.getAvailableAugmentations()) {
+ final DataSchemaNode potential = aug.getDataChildByName(child.getQName());
if (potential != null) {
augmentation = aug;
break;
return fromListSchemaNode((ListSchemaNode) potential);
} else if (potential instanceof LeafSchemaNode) {
return new LeafNormalization((LeafSchemaNode) potential);
- } else if (potential instanceof org.opendaylight.yangtools.yang.model.api.ChoiceNode) {
- return new ChoiceNodeNormalization((org.opendaylight.yangtools.yang.model.api.ChoiceNode) potential);
+ } else if (potential instanceof ChoiceSchemaNode) {
+ return new ChoiceNodeNormalization((ChoiceSchemaNode) potential);
} else if (potential instanceof LeafListSchemaNode) {
return fromLeafListSchemaNode((LeafListSchemaNode) potential);
- } else if (potential instanceof AnyXmlSchemaNode) {
- return new AnyXmlNormalization( (AnyXmlSchemaNode) potential);
+ } else if (potential instanceof AnyxmlSchemaNode) {
+ return new AnyxmlNormalization((AnyxmlSchemaNode) potential);
}
return null;
}
private static DataNormalizationOperation<?> fromListSchemaNode(final ListSchemaNode potential) {
- List<QName> keyDefinition = potential.getKeyDefinition();
- if(keyDefinition == null || keyDefinition.isEmpty()) {
+ final List<QName> keyDefinition = potential.getKeyDefinition();
+ if (keyDefinition == null || keyDefinition.isEmpty()) {
return new UnkeyedListMixinNormalization(potential);
}
- if(potential.isUserOrdered()) {
+ if (potential.isUserOrdered()) {
return new OrderedMapMixinNormalization(potential);
}
return new UnorderedMapMixinNormalization(potential);
}
private static DataNormalizationOperation<?> fromLeafListSchemaNode(final LeafListSchemaNode potential) {
- if(potential.isUserOrdered()) {
+ if (potential.isUserOrdered()) {
return new OrderedLeafListMixinNormalization(potential);
}
return new UnorderedLeafListMixinNormalization(potential);