*/
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;
/**
- *
* Stateless Normalized Node Stream Writer decorator, which performs QName translation.
*
+ * <p>
* 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.
@Override
protected NormalizedNodeStreamWriter delegate() {
- return delegate;
+ return delegate;
}
@Override
protected QName transform(final QName key) {
return transformation.apply(key);
}
-
};
}
/**
- * Returns decorator, which uses supplied map to transform QNames.
- *
- * QNames not present in map are left unchanged.
+ * Returns decorator, which uses supplied map to transform QNames. QNames not present in map are left unchanged.
*
* @param delegate Underlying normalized node stream writer
* @param mapping Immutable map which represent mapping from original to new values.
}
/**
- * Returns decorator, which uses supplied map to transform QNameModules.
- *
- * QNameModules not present in map are left unchanged.
+ * Returns decorator, which uses supplied map to transform QNameModules. QNameModules not present in map are left
+ * unchanged.
*
* @param delegate Underlying normalized node stream writer
* @param mapping Immutable map which represent mapping from original to new values.
return fromFunction(delegate, new QNameModuleReplacementFunction(mapping));
}
- /**
- * Transforms a QName to new mapping.
- *
- * NOTE: If QName should be unchanged implementation needs to return original QName.
- *
- * @param key QName to transform.
- * @return Returns new value of QName.
- */
- protected abstract @Nonnull QName transform(@Nonnull QName 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);
+ public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint)
+ throws IOException {
+ 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));
- }
-
- @Override
- public void anyxmlNode(final NodeIdentifier name, final Object value) throws IOException {
- delegate().anyxmlNode(transform(name), value);
+ super.startAugmentationNode(transform(identifier));
}
@Override
- public void startYangModeledAnyXmlNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
- delegate().startYangModeledAnyXmlNode(transform(name), childSizeHint);
+ public boolean startAnyxmlNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
+ return super.startAnyxmlNode(transform(name), objectModel);
}
- @Override
- public void endNode() throws IOException {
- delegate().endNode();
- }
-
- @Override
- public void close() throws IOException {
- delegate().close();
- }
+ /**
+ * Transforms a QName to new mapping.
+ *
+ * <p>
+ * NOTE: If QName should be unchanged implementation needs to return original QName.
+ *
+ * @param key QName to transform.
+ * @return Returns new value of QName.
+ */
+ protected abstract @NonNull QName transform(@NonNull QName key);
- @Override
- public void flush() throws IOException {
- delegate().flush();
+ private NodeIdentifier transform(final NodeIdentifier name) {
+ final QName original = name.getNodeType();
+ final QName transformed = transform(original);
+ return transformed == original ? name : new NodeIdentifier(transformed);
}
- private NodeIdentifier transform(final NodeIdentifier name) {
- return new NodeIdentifier(transform(name.getNodeType()));
+ 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