import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
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.builder.api.DataContainerNodeAttrBuilder;
+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;
public abstract DataNormalizationOperation<?> getChild(QName child) throws DataNormalizationException;
-
public abstract boolean isLeaf();
public Optional<DataSchemaNode> getDataSchemaNode() {
private abstract static class SimpleTypeNormalization<T extends PathArgument>
extends DataNormalizationOperation<T> {
-
- protected SimpleTypeNormalization(final T identifier, final DataSchemaNode potential) {
+ SimpleTypeNormalization(final T identifier, final DataSchemaNode potential) {
super(identifier,potential);
}
}
private static final class LeafNormalization extends SimpleTypeNormalization<NodeIdentifier> {
-
- protected LeafNormalization(final LeafSchemaNode potential) {
+ LeafNormalization(final LeafSchemaNode potential) {
super(new NodeIdentifier(potential.getQName()),potential);
}
-
}
private static final class LeafListEntryNormalization extends SimpleTypeNormalization<NodeWithValue> {
-
LeafListEntryNormalization(final LeafListSchemaNode potential) {
super(new NodeWithValue(potential.getQName(), null),potential);
}
private abstract static class CompositeNodeNormalizationOperation<T extends PathArgument>
extends DataNormalizationOperation<T> {
-
- protected CompositeNodeNormalizationOperation(final T identifier, final DataSchemaNode schema) {
+ CompositeNodeNormalizationOperation(final T identifier, final DataSchemaNode schema) {
super(identifier,schema);
}
public boolean isLeaf() {
return false;
}
-
-
}
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,
+ DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema,
final DataSchemaNode node) {
super(identifier,node);
this.schema = schema;
}
return potential;
}
-
}
private static final class ListItemNormalization extends
DataContainerNormalizationOperation<NodeIdentifierWithPredicates> {
-
- protected ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) {
+ ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) {
super(identifier, schema, schema);
}
@Override
+ @SuppressFBWarnings("BC_UNCONFIRMED_CAST")
public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders
.mapEntryBuilder().withNodeIdentifier((NodeIdentifierWithPredicates) currentArg);
- for (final 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) {
+ UnkeyedListItemNormalization(final ListSchemaNode schema) {
super(new NodeIdentifier(schema.getQName()), schema,schema);
}
@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
+ @SuppressFBWarnings("BC_UNCONFIRMED_CAST")
public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
return Builders.containerBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
}
-
}
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 {
OrderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
super(potential);
return true;
}
-
-
@Override
protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema,
- final QName child) throws DataNormalizationException {
+ final QName child) {
final Optional<DataSchemaNode> potential = findChildSchemaNode(schema, child);
if (!potential.isPresent()) {
return null;
}
private static class UnorderedMapMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
-
private final ListItemNormalization innerNode;
UnorderedMapMixinNormalization(final ListSchemaNode list) {
super(new NodeIdentifier(list.getQName()),list);
- this.innerNode = new ListItemNormalization(new NodeIdentifierWithPredicates(list.getQName(),
+ this.innerNode = new ListItemNormalization(NodeIdentifierWithPredicates.of(list.getQName(),
Collections.<QName, Object>emptyMap()), list);
}
}
return null;
}
-
}
-
private static class UnkeyedListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
-
private final UnkeyedListItemNormalization innerNode;
UnkeyedListMixinNormalization(final ListSchemaNode list) {
}
return null;
}
-
}
private static final class OrderedMapMixinNormalization extends UnorderedMapMixinNormalization {
-
OrderedMapMixinNormalization(final ListSchemaNode list) {
super(list);
}
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 ChoiceSchemaNode schema) {
+ ChoiceNodeNormalization(final ChoiceSchemaNode schema) {
super(new NodeIdentifier(schema.getQName()),schema);
final ImmutableMap.Builder<QName, DataNormalizationOperation<?>> byQNameBuilder = ImmutableMap.builder();
final ImmutableMap.Builder<PathArgument, DataNormalizationOperation<?>> byArgBuilder =
}
private static class AnyXmlNormalization extends DataNormalizationOperation<NodeIdentifier> {
-
- protected AnyXmlNormalization(final AnyXmlSchemaNode schema) {
+ 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;
}