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.FluentIterable;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
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.InstanceIdentifier.AugmentationIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeWithValue;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+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.model.api.LeafSchemaNode;
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 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;
@Override
public T getIdentifier() {
return identifier;
};
- protected DataNormalizationOperation(final T 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();
+ }
}
public boolean isMixin() {
public abstract boolean isLeaf();
+ public Optional<DataSchemaNode> getDataSchemaNode() {
+ // FIXME
+ return dataSchemaNode;
+ }
+
private static abstract class SimpleTypeNormalization<T extends PathArgument> extends DataNormalizationOperation<T> {
- protected SimpleTypeNormalization(final T identifier) {
- super(identifier);
+ protected SimpleTypeNormalization(final T identifier, final DataSchemaNode potential) {
+ super(identifier,potential);
}
@Override
private static final class LeafNormalization extends SimpleTypeNormalization<NodeIdentifier> {
- protected LeafNormalization(final NodeIdentifier identifier) {
- super(identifier);
+ protected LeafNormalization(final LeafSchemaNode potential) {
+ super(new NodeIdentifier(potential.getQName()),potential);
}
@Override
private static final class LeafListEntryNormalization extends SimpleTypeNormalization<NodeWithValue> {
public LeafListEntryNormalization(final LeafListSchemaNode potential) {
- super(new NodeWithValue(potential.getQName(), null));
+ super(new NodeWithValue(potential.getQName(), null),potential);
}
@Override
private static abstract class CompositeNodeNormalizationOperation<T extends PathArgument> extends
DataNormalizationOperation<T> {
- protected CompositeNodeNormalizationOperation(final T identifier) {
- super(identifier);
+ protected CompositeNodeNormalizationOperation(final T identifier, final DataSchemaNode schema) {
+ super(identifier,schema);
}
@SuppressWarnings({ "rawtypes", "unchecked" })
private final Map<QName, DataNormalizationOperation<?>> byQName;
private final Map<PathArgument, DataNormalizationOperation<?>> byArg;
- protected DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema) {
- super(identifier);
+ protected DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema, final DataSchemaNode node) {
+ super(identifier,node);
this.schema = schema;
this.byArg = new ConcurrentHashMap<>();
this.byQName = new ConcurrentHashMap<>();
private final List<QName> keyDefinition;
protected ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) {
- super(identifier, schema);
+ super(identifier, schema,schema);
keyDefinition = schema.getKeyDefinition();
}
private static final class UnkeyedListItemNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
protected UnkeyedListItemNormalization(final ListSchemaNode schema) {
- super(new NodeIdentifier(schema.getQName()), schema);
+ super(new NodeIdentifier(schema.getQName()), schema,schema);
}
@Override
private static final class ContainerNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
protected ContainerNormalization(final ContainerSchemaNode schema) {
- super(new NodeIdentifier(schema.getQName()), schema);
+ super(new NodeIdentifier(schema.getQName()),schema, schema);
}
@Override
private static abstract class MixinNormalizationOp<T extends PathArgument> extends
CompositeNodeNormalizationOperation<T> {
- protected MixinNormalizationOp(final T identifier) {
- super(identifier);
+ protected MixinNormalizationOp(final T identifier, final DataSchemaNode schema) {
+ super(identifier,schema);
}
@Override
private final DataNormalizationOperation<?> innerOp;
public UnorderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
- super(new NodeIdentifier(potential.getQName()));
+ super(new NodeIdentifier(potential.getQName()),potential);
innerOp = new LeafListEntryNormalization(potential);
}
public AugmentationNormalization(final AugmentationSchema augmentation, final DataNodeContainer schema) {
//super();
- super(augmentationIdentifierFrom(augmentation), augmentationProxy(augmentation,schema));
+ super(augmentationIdentifierFrom(augmentation), augmentationProxy(augmentation,schema),null);
}
@Override
private final ListItemNormalization innerNode;
public UnorderedMapMixinNormalization(final ListSchemaNode list) {
- super(new NodeIdentifier(list.getQName()));
+ super(new NodeIdentifier(list.getQName()),list);
this.innerNode = new ListItemNormalization(new NodeIdentifierWithPredicates(list.getQName(),
Collections.<QName, Object> emptyMap()), list);
}
private final UnkeyedListItemNormalization innerNode;
public UnkeyedListMixinNormalization(final ListSchemaNode list) {
- super(new NodeIdentifier(list.getQName()));
+ super(new NodeIdentifier(list.getQName()),list);
this.innerNode = new UnkeyedListItemNormalization(list);
}
private final ImmutableMap<PathArgument, DataNormalizationOperation<?>> byArg;
protected ChoiceNodeNormalization(final org.opendaylight.yangtools.yang.model.api.ChoiceNode schema) {
- super(new NodeIdentifier(schema.getQName()));
+ super(new NodeIdentifier(schema.getQName()),schema);
ImmutableMap.Builder<QName, DataNormalizationOperation<?>> byQNameBuilder = ImmutableMap.builder();
ImmutableMap.Builder<PathArgument, DataNormalizationOperation<?>> byArgBuilder = ImmutableMap.builder();
private static class AnyXmlNormalization extends DataNormalizationOperation<NodeIdentifier> {
- protected AnyXmlNormalization( final NodeIdentifier identifier ) {
- super( identifier );
+ protected AnyXmlNormalization( final AnyXmlSchemaNode schema) {
+ super( new NodeIdentifier(schema.getQName()), schema);
}
@Override
return fromListSchemaNode((ListSchemaNode) potential);
} else if (potential instanceof LeafSchemaNode) {
- return new LeafNormalization(new NodeIdentifier(potential.getQName()));
+ 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 LeafListSchemaNode) {
return fromLeafListSchemaNode((LeafListSchemaNode) potential);
} else if (potential instanceof AnyXmlSchemaNode) {
- return new AnyXmlNormalization( new NodeIdentifier(potential.getQName() ) );
+ return new AnyXmlNormalization( (AnyXmlSchemaNode) potential);
}
return null;
}