@Override public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { final NormalizedNodeDataInput dataInput = NormalizedNodeInputOutput.newDataInput(in); identifier = dataInput.readYangInstanceIdentifier(); node = dataInput.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); } } }
@Override public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException { rpcInvoker = JavaSerializer.currentSystem().value().provider().resolveActorRef((String) in.readObject()); final NormalizedNodeDataInput nnin = NormalizedNodeInputOutput.newDataInput(in); final int size = nnin.readInt(); rpcs = new ArrayList<>(size); for (int i = 0; i < size; ++i) { rpcs.add(DOMRpcIdentifier.create(nnin.readSchemaPath(), nnin.readYangInstanceIdentifier())); } }
public static YangInstanceIdentifier deserializePath(DataInput in) { try { NormalizedNodeDataInput streamReader = streamReader(in); return streamReader.readYangInstanceIdentifier(); } catch (IOException e) { throw new IllegalArgumentException("Error deserializing path", e); } } }
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 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); } }
private static Collection<DataTreeCandidateNode> readChildren(final NormalizedNodeDataInput in) throws IOException { final int size = in.readInt(); if (size != 0) { final Collection<DataTreeCandidateNode> ret = new ArrayList<>(size); for (int i = 0; i < size; ++i) { final DataTreeCandidateNode child = readNode(in); if (child != null) { ret.add(child); } } return ret; } else { return Collections.emptyList(); } }
@Test public void testSchemaPathSerialization() throws Exception { final SchemaPath expected = SchemaPath.create(true, TestModel.ANY_XML_QNAME); ByteArrayOutputStream bos = new ByteArrayOutputStream(); NormalizedNodeDataOutput nnout = NormalizedNodeInputOutput.newDataOutput(ByteStreams.newDataOutput(bos)); nnout.writeSchemaPath(expected); NormalizedNodeDataInput nnin = NormalizedNodeInputOutput.newDataInput(ByteStreams.newDataInput( bos.toByteArray())); SchemaPath actual = nnin.readSchemaPath(); assertEquals(expected, actual); }
private static DataTreeCandidateNode readModifiedNode(final ModificationType type, final NormalizedNodeDataInput in) throws IOException { final PathArgument identifier = in.readPathArgument(); final Collection<DataTreeCandidateNode> children = readChildren(in); if (children.isEmpty()) { LOG.debug("Modified node {} does not have any children, not instantiating it", identifier); return null; } else { return ModifiedDataTreeCandidateNode.create(identifier, type, children); } }
public static YangInstanceIdentifier deserializePath(DataInput in) { try { NormalizedNodeDataInput streamReader = streamReader(in); return streamReader.readYangInstanceIdentifier(); } catch (IOException e) { throw new IllegalArgumentException("Error deserializing path", e); } } }
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 <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); } }
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); } } }
@Override public final void readExternal(final ObjectInput in) throws ClassNotFoundException, IOException { super.readExternal(in); path = NormalizedNodeInputOutput.newDataInput(in).readYangInstanceIdentifier(); }
@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(); } }
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 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); }
@Override public final void readExternal(final ObjectInput in) throws ClassNotFoundException, IOException { super.readExternal(in); path = NormalizedNodeInputOutput.newDataInput(in).readYangInstanceIdentifier(); }
@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(); } }
YangInstanceIdentifier path = streamReader.readYangInstanceIdentifier(); NormalizedNode<?, ?> node = streamReader.readNormalizedNode(); builder.addCreated(path, node); YangInstanceIdentifier path = streamReader.readYangInstanceIdentifier(); NormalizedNode<?, ?> before = streamReader.readNormalizedNode(); NormalizedNode<?, ?> after = streamReader.readNormalizedNode(); builder.addUpdated(path, before, after); YangInstanceIdentifier path = streamReader.readYangInstanceIdentifier(); NormalizedNode<?, ?> node = streamReader.readNormalizedNode(); builder.addRemoved(path, node); builder.setBefore(streamReader.readNormalizedNode()); builder.setAfter(streamReader.readNormalizedNode());