import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
import org.opendaylight.yangtools.yang.binding.OpaqueObject;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-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;
final class BindingToNormalizedStreamWriter implements AnydataBindingStreamWriter,
Delegator<NormalizedNodeStreamWriter> {
- private final Deque<NodeCodecContext> schema = new ArrayDeque<>();
+ private final Deque<CodecContext> schema = new ArrayDeque<>();
private final @NonNull NormalizedNodeStreamWriter delegate;
- private final NodeCodecContext rootContext;
+ private final CodecContext rootContext;
- BindingToNormalizedStreamWriter(final DataContainerCodecContext<?, ?> rootContext,
+ BindingToNormalizedStreamWriter(final DataContainerCodecContext<?, ?, ?> rootContext,
final NormalizedNodeStreamWriter delegate) {
this.rootContext = requireNonNull(rootContext);
this.delegate = requireNonNull(delegate);
delegate.nextDataSchemaNode((DataSchemaNode) schemaNode);
}
- NodeCodecContext current() {
+ CodecContext current() {
return schema.peek();
}
private NodeIdentifier duplicateSchemaEnter() {
final var current = current();
- final NodeCodecContext next;
+ final CodecContext next;
if (current == null) {
// Entry of first node
next = rootContext;
next = current;
}
schema.push(next);
- return (NodeIdentifier) next.getDomPathArgument();
+ return next.getDomPathArgument();
}
@SuppressWarnings({"unchecked", "rawtypes"})
private <T extends YangInstanceIdentifier.PathArgument> T enter(final Class<?> name, final Class<T> identifier) {
final var current = current();
- final NodeCodecContext next;
+ final CodecContext next;
if (current == null) {
// Entry of first node
next = rootContext;
- } else if (current instanceof DataContainerCodecContext<?, ?> currentContainer) {
- next = currentContainer.streamChild((Class) name);
+ } else if (current instanceof DataContainerCodecContext<?, ?, ?> currentContainer) {
+ next = currentContainer.getStreamChild((Class) name);
} else {
throw new IllegalArgumentException("Could not start node " + name + " in non-container " + current);
}
private <T extends YangInstanceIdentifier.PathArgument> T enter(final String localName, final Class<T> identifier) {
final var current = current();
- final var next = ((DataObjectCodecContext<?, ?>) current).getLeafChild(localName);
+ final var next = ((AbstractDataObjectCodecContext<?, ?>) current).getLeafChild(localName);
schema.push(next);
return identifier.cast(next.getDomPathArgument());
}
@Override
public void endNode() throws IOException {
- NodeCodecContext left = schema.pop();
- // NormalizedNode writer does not have entry into case, but into choice
- // so for leaving case, we do not emit endNode.
- if (!(left instanceof CaseNodeCodecContext)) {
+ CodecContext left = schema.pop();
+ // Due to writer does not start a new node on startCase() and on startAugmentationNode()
+ // node ending should not be triggered when associated endNode() is invoked.
+ if (!(left instanceof CaseCodecContext) && !(left instanceof AugmentationCodecContext)) {
delegate.endNode();
}
}
private Map.Entry<NodeIdentifier, Object> serializeLeaf(final String localName, final Object value) {
final var current = current();
- if (!(current instanceof DataObjectCodecContext<?, ?> currentCasted)) {
+ if (!(current instanceof AbstractDataObjectCodecContext<?, ?> currentCasted)) {
throw new IllegalArgumentException("Unexpected current context " + current);
}
}
@Override
- public void startAugmentationNode(final Class<? extends Augmentation<?>> augmentationType)
- throws IOException {
- delegate.startAugmentationNode(enter(augmentationType, AugmentationIdentifier.class));
+ public void startAugmentationNode(final Class<? extends Augmentation<?>> augmentationType) throws IOException {
+ enter(augmentationType, NodeIdentifier.class);
}
@Override
}
@Override
- public void startMapEntryNode(final Identifier<?> key, final int childSizeHint) throws IOException {
+ public void startMapEntryNode(final Key<?> key, final int childSizeHint) throws IOException {
duplicateSchemaEnter();
- NodeIdentifierWithPredicates identifier = ((KeyedListNodeCodecContext<?, ?>) current()).serialize(key);
+ NodeIdentifierWithPredicates identifier = ((MapCodecContext<?, ?>) current()).serialize(key);
delegate.startMapEntryNode(identifier, childSizeHint);
}
@Override
- public <T extends DataObject & Identifiable<?>> void startMapNode(final Class<T> mapEntryType,
- final int childSizeHint) throws IOException {
+ public <T extends DataObject & KeyAware<?>> void startMapNode(final Class<T> mapEntryType, final int childSizeHint)
+ throws IOException {
delegate.startMapNode(enter(mapEntryType, NodeIdentifier.class), childSizeHint);
}
@Override
- public <T extends DataObject & Identifiable<?>> void startOrderedMapNode(final Class<T> mapEntryType,
+ public <T extends DataObject & KeyAware<?>> void startOrderedMapNode(final Class<T> mapEntryType,
final int childSizeHint) throws IOException {
delegate.startOrderedMapNode(enter(mapEntryType, NodeIdentifier.class), childSizeHint);
}