import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
+import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
-import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.eclipse.jdt.annotation.NonNull;
*/
abstract class AbstractLithiumDataOutput extends AbstractNormalizedNodeDataOutput {
private static final Logger LOG = LoggerFactory.getLogger(AbstractLithiumDataOutput.class);
+ private static final TransformerFactory TF = TransformerFactory.newInstance();
private static final ImmutableMap<Class<?>, Byte> KNOWN_TYPES = ImmutableMap.<Class<?>, Byte>builder()
.put(String.class, ValueTypes.STRING_TYPE)
.put(Byte.class, ValueTypes.BYTE_TYPE)
@Override
public final void startLeafNode(final NodeIdentifier name) throws IOException {
LOG.trace("Starting a new leaf node");
- startNode(name, NodeTypes.LEAF_NODE);
+ startNode(name, LithiumNode.LEAF_NODE);
inSimple = true;
}
@Override
public final void startLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException {
LOG.trace("Starting a new leaf set");
- commonStartLeafSet(name, NodeTypes.LEAF_SET);
+ commonStartLeafSet(name, LithiumNode.LEAF_SET);
}
@Override
public final void startOrderedLeafSet(final NodeIdentifier name, final int childSizeHint) throws IOException {
LOG.trace("Starting a new ordered leaf set");
- commonStartLeafSet(name, NodeTypes.ORDERED_LEAF_SET);
+ commonStartLeafSet(name, LithiumNode.ORDERED_LEAF_SET);
}
private void commonStartLeafSet(final NodeIdentifier name, final byte nodeType) throws IOException {
public final void startLeafSetEntryNode(final NodeWithValue<?> name) throws IOException {
LOG.trace("Starting a new leaf set entry node");
- output.writeByte(NodeTypes.LEAF_SET_ENTRY_NODE);
+ output.writeByte(LithiumNode.LEAF_SET_ENTRY_NODE);
// lastLeafSetQName is set if the parent LeafSetNode was previously written. Otherwise this is a
// stand alone LeafSetEntryNode so write out it's name here.
@Override
public final void startContainerNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
LOG.trace("Starting a new container node");
- startNode(name, NodeTypes.CONTAINER_NODE);
+ startNode(name, LithiumNode.CONTAINER_NODE);
}
@Override
public final void startYangModeledAnyXmlNode(final NodeIdentifier name, final int childSizeHint)
throws IOException {
LOG.trace("Starting a new yang modeled anyXml node");
- startNode(name, NodeTypes.YANG_MODELED_ANY_XML_NODE);
+ startNode(name, LithiumNode.YANG_MODELED_ANY_XML_NODE);
}
@Override
public final void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) throws IOException {
LOG.trace("Starting a new unkeyed list");
- startNode(name, NodeTypes.UNKEYED_LIST);
+ startNode(name, LithiumNode.UNKEYED_LIST);
}
@Override
public final void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) throws IOException {
LOG.trace("Starting a new unkeyed list item");
- startNode(name, NodeTypes.UNKEYED_LIST_ITEM);
+ startNode(name, LithiumNode.UNKEYED_LIST_ITEM);
}
@Override
public final void startMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
LOG.trace("Starting a new map node");
- startNode(name, NodeTypes.MAP_NODE);
+ startNode(name, LithiumNode.MAP_NODE);
}
@Override
public final void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint)
throws IOException {
LOG.trace("Starting a new map entry node");
- startNode(identifier, NodeTypes.MAP_ENTRY_NODE);
+ startNode(identifier, LithiumNode.MAP_ENTRY_NODE);
writeKeyValueMap(identifier.entrySet());
}
@Override
public final void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
LOG.trace("Starting a new ordered map node");
- startNode(name, NodeTypes.ORDERED_MAP_NODE);
+ startNode(name, LithiumNode.ORDERED_MAP_NODE);
}
@Override
public final void startChoiceNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
LOG.trace("Starting a new choice node");
- startNode(name, NodeTypes.CHOICE_NODE);
+ startNode(name, LithiumNode.CHOICE_NODE);
}
@Override
requireNonNull(identifier, "Node identifier should not be null");
LOG.trace("Starting a new augmentation node");
- output.writeByte(NodeTypes.AUGMENTATION_NODE);
+ output.writeByte(LithiumNode.AUGMENTATION_NODE);
writeAugmentationIdentifier(identifier);
}
@Override
public final void startAnyxmlNode(final NodeIdentifier name) throws IOException {
LOG.trace("Starting any xml node");
- startNode(name, NodeTypes.ANY_XML_NODE);
+ startNode(name, LithiumNode.ANY_XML_NODE);
inSimple = true;
}
@Override
public final void domSourceValue(final DOMSource value) throws IOException {
+ final StringWriter writer = new StringWriter();
try {
- StreamResult xmlOutput = new StreamResult(new StringWriter());
- TransformerFactory.newInstance().newTransformer().transform(value, xmlOutput);
- writeObject(xmlOutput.getWriter().toString());
- } catch (TransformerException | TransformerFactoryConfigurationError e) {
+ TF.newTransformer().transform(value, new StreamResult(writer));
+ } catch (TransformerException e) {
throw new IOException("Error writing anyXml", e);
}
+ writeObject(writer.toString());
}
@Override
LOG.trace("Ending the node");
if (!inSimple) {
lastLeafSetQName = null;
- output.writeByte(NodeTypes.END_NODE);
+ output.writeByte(LithiumNode.END_NODE);
}
inSimple = false;
}
@SuppressFBWarnings(value = "BC_UNCONFIRMED_CAST",
justification = "The casts in the switch clauses are indirectly confirmed via the determination of 'type'.")
final void writePathArgumentInternal(final PathArgument pathArgument) throws IOException {
- final byte type = PathArgumentTypes.getSerializablePathArgumentType(pathArgument);
+ final byte type = LithiumPathArgument.getSerializablePathArgumentType(pathArgument);
output.writeByte(type);
switch (type) {
- case PathArgumentTypes.NODE_IDENTIFIER:
+ case LithiumPathArgument.NODE_IDENTIFIER:
NodeIdentifier nodeIdentifier = (NodeIdentifier) pathArgument;
writeQNameInternal(nodeIdentifier.getNodeType());
break;
- case PathArgumentTypes.NODE_IDENTIFIER_WITH_PREDICATES:
+ case LithiumPathArgument.NODE_IDENTIFIER_WITH_PREDICATES:
NodeIdentifierWithPredicates nodeIdentifierWithPredicates =
(NodeIdentifierWithPredicates) pathArgument;
writeQNameInternal(nodeIdentifierWithPredicates.getNodeType());
writeKeyValueMap(nodeIdentifierWithPredicates.entrySet());
break;
- case PathArgumentTypes.NODE_IDENTIFIER_WITH_VALUE:
+ case LithiumPathArgument.NODE_IDENTIFIER_WITH_VALUE:
NodeWithValue<?> nodeWithValue = (NodeWithValue<?>) pathArgument;
writeQNameInternal(nodeWithValue.getNodeType());
writeObject(nodeWithValue.getValue());
break;
- case PathArgumentTypes.AUGMENTATION_IDENTIFIER:
+ case LithiumPathArgument.AUGMENTATION_IDENTIFIER:
// No Qname in augmentation identifier
writeAugmentationIdentifier((AugmentationIdentifier) pathArgument);
break;
}
}
+ @Override
+ final void writeYangInstanceIdentifierInternal(final YangInstanceIdentifier identifier) throws IOException {
+ List<PathArgument> pathArguments = identifier.getPathArguments();
+ output.writeInt(pathArguments.size());
+
+ for (PathArgument pathArgument : pathArguments) {
+ writePathArgumentInternal(pathArgument);
+ }
+ }
+
final void defaultWriteAugmentationIdentifier(final @NonNull AugmentationIdentifier aid) throws IOException {
final Set<QName> qnames = aid.getPossibleChildNames();
// Write each child's qname separately, if list is empty send count as 0
if (revision.isPresent()) {
writeString(revision.get().toString());
} else {
- writeByte(TokenTypes.IS_NULL_VALUE);
+ writeByte(LithiumTokens.IS_NULL_VALUE);
}
}
final Integer value = stringCodeMap.get(verifyNotNull(string));
if (value == null) {
stringCodeMap.put(string, stringCodeMap.size());
- writeByte(TokenTypes.IS_STRING_VALUE);
+ writeByte(LithiumTokens.IS_STRING_VALUE);
writeUTF(string);
} else {
- writeByte(TokenTypes.IS_CODE_VALUE);
+ writeByte(LithiumTokens.IS_CODE_VALUE);
writeInt(value);
}
}
Code Review / controller.git / blobdiff