private static NormalizedNode<?, ?> tryDeserializeNormalizedNode(DataInput in) throws IOException { boolean present = in.readBoolean(); if (present) { NormalizedNodeDataInput streamReader = streamReader(in); return streamReader.readNormalizedNode(); } return null; }
private static NormalizedNode<?, ?> tryDeserializeNormalizedNode(DataInput in) throws IOException { boolean present = in.readBoolean(); if(present) { NormalizedNodeDataInput streamReader = streamReader(in); return streamReader.readNormalizedNode(); } return null; }
@Override public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { super.readExternal(in); if (in.readBoolean()) { data = Optional.of(NormalizedNodeInputOutput.newDataInput(in).readNormalizedNode()); } else { data = Optional.empty(); } }
@Override public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { super.readExternal(in); if (in.readBoolean()) { data = Optional.of(NormalizedNodeInputOutput.newDataInput(in).readNormalizedNode()); } else { data = Optional.absent(); } }
@Override public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { final NormalizedNodeDataInput dataInput = NormalizedNodeInputOutput.newDataInput(in); identifier = dataInput.readYangInstanceIdentifier(); node = dataInput.readNormalizedNode(); } }
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); } }
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); } }
private void readObject(final ObjectInputStream stream) throws IOException { NormalizedNodeDataInput reader = NormalizedNodeInputOutput.newDataInput(stream); this.input = reader.readNormalizedNode(); }
static TransactionModification readFrom(final NormalizedNodeDataInput in) throws IOException { final byte type = in.readByte(); switch (type) { case TYPE_DELETE: return new TransactionDelete(in.readYangInstanceIdentifier()); case TYPE_MERGE: return new TransactionMerge(in.readYangInstanceIdentifier(), in.readNormalizedNode()); case TYPE_WRITE: return new TransactionWrite(in.readYangInstanceIdentifier(), in.readNormalizedNode()); default: throw new IllegalArgumentException("Unhandled type " + type); } } }
for(int i = 0; i < size; i++) { YangInstanceIdentifier path = streamReader.readYangInstanceIdentifier(); NormalizedNode<?, ?> node = streamReader.readNormalizedNode(); builder.addCreated(path, node); for(int i = 0; i < size; i++) { YangInstanceIdentifier path = streamReader.readYangInstanceIdentifier(); NormalizedNode<?, ?> before = streamReader.readNormalizedNode(); NormalizedNode<?, ?> after = streamReader.readNormalizedNode(); builder.addUpdated(path, before, after); for(int i = 0; i < size; i++) { YangInstanceIdentifier path = streamReader.readYangInstanceIdentifier(); NormalizedNode<?, ?> node = streamReader.readNormalizedNode(); builder.addRemoved(path, node); builder.setBefore(streamReader.readNormalizedNode()); builder.setAfter(streamReader.readNormalizedNode());
static TransactionModification readFrom(final NormalizedNodeDataInput in) throws IOException { final byte type = in.readByte(); switch (type) { case TYPE_DELETE: return new TransactionDelete(in.readYangInstanceIdentifier()); case TYPE_MERGE: return new TransactionMerge(in.readYangInstanceIdentifier(), in.readNormalizedNode()); case TYPE_WRITE: return new TransactionWrite(in.readYangInstanceIdentifier(), in.readNormalizedNode()); default: throw new IllegalArgumentException("Unhandled type " + type); } } }
private static DataTreeCandidateNode readNode(final NormalizedNodeDataInput in) throws IOException { final byte type = in.readByte(); switch (type) { case APPEARED: return readModifiedNode(ModificationType.APPEARED, in); case DELETE: return DeletedDataTreeCandidateNode.create(in.readPathArgument()); case DISAPPEARED: return readModifiedNode(ModificationType.DISAPPEARED, in); case SUBTREE_MODIFIED: return readModifiedNode(ModificationType.SUBTREE_MODIFIED, in); case UNMODIFIED: return null; case WRITE: return DataTreeCandidateNodes.fromNormalizedNode(in.readNormalizedNode()); default: throw new IllegalArgumentException("Unhandled node type " + type); } }
@Test(expected = InvalidNormalizedNodeStreamException.class, timeout = 10000) public void testInvalidNormalizedNodeStream() throws IOException { byte[] invalidBytes = {1,2,3}; NormalizedNodeDataInput reader = NormalizedNodeInputOutput.newDataInput( ByteStreams.newDataInput(invalidBytes)); reader.readNormalizedNode(); }
public static DataTreeCandidate readDataTreeCandidate(final DataInput in) throws IOException { final NormalizedNodeDataInput reader = new NormalizedNodeInputStreamReader(in); final YangInstanceIdentifier rootPath = reader.readYangInstanceIdentifier(); final byte type = reader.readByte(); final DataTreeCandidateNode rootNode; switch (type) { case DELETE: rootNode = DeletedDataTreeCandidateNode.create(); break; case SUBTREE_MODIFIED: rootNode = ModifiedDataTreeCandidateNode.create(readChildren(reader)); break; case WRITE: rootNode = DataTreeCandidateNodes.fromNormalizedNode(reader.readNormalizedNode()); break; default: throw new IllegalArgumentException("Unhandled node type " + type); } return DataTreeCandidates.newDataTreeCandidate(rootPath, rootNode); }
@Test public void testAnyXmlStreaming() throws Exception { String xml = "<foo xmlns=\"http://www.w3.org/TR/html4/\" x=\"123\"><bar>one</bar><bar>two</bar></foo>"; final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setNamespaceAware(true); Node xmlNode = factory.newDocumentBuilder().parse( new InputSource(new StringReader(xml))).getDocumentElement(); assertEquals("http://www.w3.org/TR/html4/", xmlNode.getNamespaceURI()); NormalizedNode<?, ?> anyXmlContainer = ImmutableContainerNodeBuilder.create().withNodeIdentifier( new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME)).withChild( Builders.anyXmlBuilder().withNodeIdentifier(new NodeIdentifier(TestModel.ANY_XML_QNAME)) .withValue(new DOMSource(xmlNode)).build()).build(); ByteArrayOutputStream bos = new ByteArrayOutputStream(); NormalizedNodeDataOutput nnout = NormalizedNodeInputOutput.newDataOutput(ByteStreams.newDataOutput(bos)); nnout.writeNormalizedNode(anyXmlContainer); NormalizedNodeDataInput nnin = NormalizedNodeInputOutput.newDataInput(ByteStreams.newDataInput( bos.toByteArray())); ContainerNode deserialized = (ContainerNode)nnin.readNormalizedNode(); Optional<DataContainerChild<? extends PathArgument, ?>> child = deserialized.getChild(new NodeIdentifier(TestModel.ANY_XML_QNAME)); assertEquals("AnyXml child present", true, child.isPresent()); StreamResult xmlOutput = new StreamResult(new StringWriter()); Transformer transformer = TransformerFactory.newInstance().newTransformer(); transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes"); transformer.transform(((AnyXmlNode)child.get()).getValue(), xmlOutput); assertEquals("XML", xml, xmlOutput.getWriter().toString()); assertEquals("http://www.w3.org/TR/html4/", ((AnyXmlNode)child.get()).getValue().getNode().getNamespaceURI()); }
@Test public void testNormalizedNodeStreaming() throws IOException { ByteArrayOutputStream bos = new ByteArrayOutputStream(); NormalizedNodeDataOutput nnout = NormalizedNodeInputOutput.newDataOutput(ByteStreams.newDataOutput(bos)); NormalizedNode<?, ?> testContainer = createTestContainer(); nnout.writeNormalizedNode(testContainer); QName toaster = QName.create("http://netconfcentral.org/ns/toaster","2009-11-20","toaster"); QName darknessFactor = QName.create("http://netconfcentral.org/ns/toaster","2009-11-20","darknessFactor"); QName description = QName.create("http://netconfcentral.org/ns/toaster","2009-11-20","description"); ContainerNode toasterNode = Builders.containerBuilder().withNodeIdentifier(new NodeIdentifier(toaster)) .withChild(ImmutableNodes.leafNode(darknessFactor, "1000")) .withChild(ImmutableNodes.leafNode(description, largeString(20))).build(); ContainerNode toasterContainer = Builders.containerBuilder() .withNodeIdentifier(new NodeIdentifier(SchemaContext.NAME)).withChild(toasterNode).build(); nnout.writeNormalizedNode(toasterContainer); NormalizedNodeDataInput nnin = NormalizedNodeInputOutput.newDataInput(ByteStreams.newDataInput( bos.toByteArray())); NormalizedNode<?,?> node = nnin.readNormalizedNode(); Assert.assertEquals(testContainer, node); node = nnin.readNormalizedNode(); Assert.assertEquals(toasterContainer, node); }
@Test public void testNormalizedNodeAndYangInstanceIdentifierStreaming() throws IOException { ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); NormalizedNodeOutputStreamWriter writer = new NormalizedNodeOutputStreamWriter( ByteStreams.newDataOutput(byteArrayOutputStream)); NormalizedNode<?, ?> testContainer = TestModel.createBaseTestContainerBuilder().build(); writer.writeNormalizedNode(testContainer); YangInstanceIdentifier path = YangInstanceIdentifier.builder(TestModel.TEST_PATH) .node(TestModel.OUTER_LIST_QNAME).nodeWithKey( TestModel.INNER_LIST_QNAME, TestModel.ID_QNAME, 10).build(); writer.writeYangInstanceIdentifier(path); NormalizedNodeDataInput reader = NormalizedNodeInputOutput.newDataInput( ByteStreams.newDataInput(byteArrayOutputStream.toByteArray())); NormalizedNode<?,?> node = reader.readNormalizedNode(); Assert.assertEquals(testContainer, node); YangInstanceIdentifier newPath = reader.readYangInstanceIdentifier(); Assert.assertEquals(path, newPath); writer.close(); }