public static byte [] serializeNormalizedNode(NormalizedNode<?, ?> node) { ByteArrayOutputStream bos = new ByteArrayOutputStream(); serializeNormalizedNode(node, new DataOutputStream(bos)); return bos.toByteArray(); }
@Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { QName qname = (QName) in.readObject(); executeRpc = new ExecuteRpc(SerializationUtils.deserializeNormalizedNode(in), qname); }
public static YangInstanceIdentifier deserializePath(DataInput in) { try { NormalizedNodeDataInput streamReader = streamReader(in); return streamReader.readYangInstanceIdentifier(); } catch (IOException e) { throw new IllegalArgumentException("Error deserializing path", e); } } }
@Test public void testSerializeDeserializeNodes() { final NormalizedNode<?, ?> normalizedNode = createNormalizedNode(); final byte[] bytes = SerializationUtils.serializeNormalizedNode(normalizedNode); Assert.assertEquals(normalizedNode, SerializationUtils.deserializeNormalizedNode(bytes)); }
@Test public void testSerializeDeserializePathAndNode() { final ByteArrayOutputStream bos = new ByteArrayOutputStream(); final DataOutput out = new DataOutputStream(bos); final NormalizedNode<?, ?> node = createNormalizedNode(); final YangInstanceIdentifier path = YangInstanceIdentifier.create(id("container1")); SerializationUtils.serializePathAndNode(path, node, out); final DataInputStream in = new DataInputStream(new ByteArrayInputStream(bos.toByteArray())); final AtomicBoolean applierCalled = new AtomicBoolean(false); SerializationUtils.deserializePathAndNode(in, applierCalled, (instance, deserializedPath, deserializedNode) -> { Assert.assertEquals(path, deserializedPath); Assert.assertEquals(node, deserializedNode); applierCalled.set(true); }); Assert.assertTrue(applierCalled.get()); }
@Test public void testSerializeDeserializePath() { final ByteArrayOutputStream bos = new ByteArrayOutputStream(); final DataOutput out = new DataOutputStream(bos); final YangInstanceIdentifier path = YangInstanceIdentifier.builder() .node(id("container1")) .node(autmentationId("list1", "list2")) .node(listId("list1", "keyName1", "keyValue1")) .node(leafSetId("leafSer1", "leafSetValue1")) .build(); SerializationUtils.serializePath(path, out); final YangInstanceIdentifier deserialized = SerializationUtils.deserializePath(new DataInputStream(new ByteArrayInputStream(bos.toByteArray()))); Assert.assertEquals(path, deserialized); }
public static void serializeNormalizedNode(NormalizedNode<?, ?> node, DataOutput out) { try { out.writeBoolean(node != null); if (node != null) { NormalizedNodeDataOutput streamWriter = streamWriter(out); streamWriter.writeNormalizedNode(node); } } catch (IOException e) { throw new IllegalArgumentException(String.format("Error serializing NormalizedNode %s", node), e); } }
public static NormalizedNode<?, ?> deserializeNormalizedNode(DataInput in) { try { return tryDeserializeNormalizedNode(in); } catch (IOException e) { throw new IllegalArgumentException("Error deserializing NormalizedNode", e); } }
@Test public void testSerializeDeserializeAnyXmlNode() throws Exception { final ByteArrayInputStream is = new ByteArrayInputStream("<xml><data/></xml>".getBytes(Charset.defaultCharset())); final Document parse = UntrustedXML.newDocumentBuilder().parse(is); final AnyXmlNode anyXmlNode = Builders.anyXmlBuilder() .withNodeIdentifier(id("anyXmlNode")) .withValue(new DOMSource(parse)) .build(); final byte[] bytes = SerializationUtils.serializeNormalizedNode(anyXmlNode); final NormalizedNode<?, ?> deserialized = SerializationUtils.deserializeNormalizedNode(bytes); final DOMSource value = (DOMSource) deserialized.getValue(); final Diff diff = XMLUnit.compareXML((Document) anyXmlNode.getValue().getNode(), value.getNode().getOwnerDocument()); Assert.assertTrue(diff.toString(), diff.similar()); }
public static void serializePath(YangInstanceIdentifier path, DataOutput out) { Preconditions.checkNotNull(path); try { NormalizedNodeDataOutput streamWriter = streamWriter(out); streamWriter.writeYangInstanceIdentifier(path); } catch (IOException e) { throw new IllegalArgumentException(String.format("Error serializing path %s", path), e); } }
public static NormalizedNode<?, ?> deserializeNormalizedNode(byte [] bytes) { try { return tryDeserializeNormalizedNode(new DataInputStream(new ByteArrayInputStream(bytes))); } catch (IOException e) { throw new IllegalArgumentException("Error deserializing NormalizedNode", e); } }
@Override public void writeExternal(ObjectOutput out) { SerializationUtils.serializeNormalizedNode(rpcResponse.getResultNormalizedNode(), out); }
@Override public void readExternal(ObjectInput in) { rpcResponse = new RpcResponse(SerializationUtils.deserializeNormalizedNode(in)); }
private static NormalizedNode<?, ?> tryDeserializeNormalizedNode(DataInput in) throws IOException { boolean present = in.readBoolean(); if (present) { NormalizedNodeDataInput streamReader = streamReader(in); return streamReader.readNormalizedNode(); } return null; }
public static void serializePathAndNode(YangInstanceIdentifier path, NormalizedNode<?, ?> node, DataOutput out) { Preconditions.checkNotNull(path); Preconditions.checkNotNull(node); try { NormalizedNodeDataOutput streamWriter = streamWriter(out); streamWriter.writeNormalizedNode(node); streamWriter.writeYangInstanceIdentifier(path); } catch (IOException e) { throw new IllegalArgumentException(String.format("Error serializing path %s and Node %s", path, node), e); } }
@Override public void writeExternal(ObjectOutput out) throws IOException { out.writeObject(executeRpc.getRpc()); SerializationUtils.serializeNormalizedNode(executeRpc.getInputNormalizedNode(), out); }
public static <T> void deserializePathAndNode(DataInput in, T instance, Applier<T> applier) { try { NormalizedNodeDataInput streamReader = streamReader(in); NormalizedNode<?, ?> node = streamReader.readNormalizedNode(); YangInstanceIdentifier path = streamReader.readYangInstanceIdentifier(); applier.apply(instance, path, node); } catch (IOException e) { throw new IllegalArgumentException("Error deserializing path and Node", e); } }