*/
package org.opendaylight.yangtools.transform;
-import com.google.common.collect.ForwardingObject;
import com.google.common.collect.ImmutableSet;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
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.schema.stream.ForwardingNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
/**
* This class serves as base for Normalized Node Stream Writer decorators with option to transform
* QNames by user-implemented {@link #transform(QName)} function.
*/
-public abstract class QNameTransformingStreamWriter extends ForwardingObject implements NormalizedNodeStreamWriter {
+public abstract class QNameTransformingStreamWriter extends ForwardingNormalizedNodeStreamWriter {
// FIXME: Probably use loading cache to decrease memory
- @Override
- protected abstract NormalizedNodeStreamWriter delegate();
/**
* Returns decorator, which uses supplied function to transform QNames.
return delegate;
}
- @Nonnull
@Override
- protected QName transform(@Nonnull final QName key) {
+ protected QName transform(final QName key) {
return transformation.apply(key);
}
-
};
}
}
@Override
- public void leafNode(final NodeIdentifier name, final Object value) throws IOException {
- delegate().leafNode(transform(name), value);
+ public void startLeafNode(final NodeIdentifier name) throws IOException {
+ super.startLeafNode(transform(name));
}
@Override
public void startLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException {
- delegate().startLeafSet(transform(name), childSizeHint);
+ super.startLeafSet(transform(name), childSizeHint);
}
@Override
public void startOrderedLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException {
- delegate().startOrderedLeafSet(transform(name), childSizeHint);
+ super.startOrderedLeafSet(transform(name), childSizeHint);
}
@Override
- public void leafSetEntryNode(final QName name, final Object value) throws IOException {
- delegate().leafSetEntryNode(transform(name), value);
+ public void startLeafSetEntryNode(final NodeWithValue<?> name) throws IOException {
+ super.startLeafSetEntryNode(transform(name));
}
@Override
public void startContainerNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
- delegate().startContainerNode(transform(name), childSizeHint);
+ super.startContainerNode(transform(name), childSizeHint);
}
@Override
public void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) throws IOException {
- delegate().startUnkeyedList(transform(name), childSizeHint);
+ super.startUnkeyedList(transform(name), childSizeHint);
}
@Override
public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) throws IOException {
- delegate().startUnkeyedListItem(transform(name), childSizeHint);
+ super.startUnkeyedListItem(transform(name), childSizeHint);
}
@Override
public void startMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
- delegate().startMapNode(transform(name), childSizeHint);
+ super.startMapNode(transform(name), childSizeHint);
}
@Override
public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint)
throws IOException {
- delegate().startMapEntryNode(transform(identifier), childSizeHint);
+ super.startMapEntryNode(transform(identifier), childSizeHint);
}
@Override
public void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
- delegate().startOrderedMapNode(transform(name), childSizeHint);
+ super.startOrderedMapNode(transform(name), childSizeHint);
}
@Override
public void startChoiceNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
- delegate().startChoiceNode(transform(name), childSizeHint);
+ super.startChoiceNode(transform(name), childSizeHint);
}
@Override
public void startAugmentationNode(final AugmentationIdentifier identifier) throws IOException {
- delegate().startAugmentationNode(transform(identifier));
+ super.startAugmentationNode(transform(identifier));
}
@Override
- public void anyxmlNode(final NodeIdentifier name, final Object value) throws IOException {
- delegate().anyxmlNode(transform(name), value);
+ public boolean startAnyxmlNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
+ return super.startAnyxmlNode(transform(name), objectModel);
}
@Override
public void startYangModeledAnyXmlNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
- delegate().startYangModeledAnyXmlNode(transform(name), childSizeHint);
- }
-
- @Override
- public void endNode() throws IOException {
- delegate().endNode();
+ super.startYangModeledAnyXmlNode(transform(name), childSizeHint);
}
@Override
- public void close() throws IOException {
- delegate().close();
- }
-
- @Override
- public void flush() throws IOException {
- delegate().flush();
+ public void scalarValue(final Object value) throws IOException {
+ // identityref leaf nodes contain identity QName as a value - it needs to be transformed
+ super.scalarValue(value instanceof QName ? transform((QName) value) : value);
}
/**
* @param key QName to transform.
* @return Returns new value of QName.
*/
- protected abstract @Nonnull QName transform(@Nonnull QName key);
+ protected abstract @NonNull QName transform(@NonNull QName key);
private NodeIdentifier transform(final NodeIdentifier name) {
- return new NodeIdentifier(transform(name.getNodeType()));
+ final QName original = name.getNodeType();
+ final QName transformed = transform(original);
+ return transformed == original ? name : new NodeIdentifier(transformed);
+ }
+
+ private <T> NodeWithValue<T> transform(final NodeWithValue<T> name) {
+ final QName original = name.getNodeType();
+ final QName transformed = transform(original);
+ return transformed == original ? name : new NodeWithValue<>(transformed, name.getValue());
}
private AugmentationIdentifier transform(final AugmentationIdentifier identifier) {
private NodeIdentifierWithPredicates transform(final NodeIdentifierWithPredicates identifier) {
Map<QName, Object> keyValues = new HashMap<>();
- for (Map.Entry<QName, Object> original : identifier.getKeyValues().entrySet()) {
+ for (Map.Entry<QName, Object> original : identifier.entrySet()) {
keyValues.put(transform(original.getKey()), original.getValue());
}
- return new NodeIdentifierWithPredicates(transform(identifier.getNodeType()), keyValues);
+ return NodeIdentifierWithPredicates.of(transform(identifier.getNodeType()), keyValues);
}
}
Code Review / yangtools.git / blobdiff