private void writeChildren(final RestconfNormalizedNodeWriter nnWriter, final ContainerNode data) throws IOException { for(final DataContainerChild<? extends PathArgument, ?> child : data.getValue()) { nnWriter.write(child); } }
private static void writeChildren(final NormalizedNodeWriter nnWriter, final ContainerNode data) throws IOException { for (final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> child : data.getValue()) { nnWriter.write(child); } }
@Override public final Collection<DataContainerChild<? extends PathArgument, ?>> getValue() { return delegate().getValue(); }
@Override public Collection<DataContainerChild<? extends PathArgument, ?>> getValue() { return delegate().getValue(); }
@Override public final Collection<DataContainerChild<? extends PathArgument, ?>> getValue() { return delegate().getValue(); }
@Override public Collection<DataContainerChild<? extends PathArgument, ?>> getValue() { return delegate().getValue(); }
private void writeDataRoot(final OutputStreamWriter outputWriter, final NormalizedNodeWriter nnWriter, final ContainerNode data) throws IOException { final Iterator<DataContainerChild<? extends PathArgument, ?>> iterator = data.getValue().iterator(); while(iterator.hasNext()) { final DataContainerChild<? extends PathArgument, ?> child = iterator.next(); nnWriter.write(child); nnWriter.flush(); } }
private void writeRootElement(final XMLStreamWriter xmlWriter, final SchemaOrderedNormalizedNodeWriter nnWriter, final ContainerNode data) { try { Collection<DataContainerChild<?, ?>> value = (Collection) data.getValue(); nnWriter.write(value); nnWriter.flush(); xmlWriter.flush(); } catch (XMLStreamException | IOException e) { Throwables.propagate(e); } }
private void writeRootElement(final XMLStreamWriter xmlWriter, final OrderedNormalizedNodeWriter nnWriter, final ContainerNode data) { try { Collection<DataContainerChild<?, ?>> value = (Collection) data.getValue(); nnWriter.write(value); nnWriter.flush(); xmlWriter.flush(); } catch (XMLStreamException | IOException e) { Throwables.propagate(e); } }
private void writeRootElement(final XMLStreamWriter xmlWriter, final NormalizedNodeWriter nnWriter, final ContainerNode data) throws IOException { try { final QName name = SchemaContext.NAME; xmlWriter.writeStartElement(name.getNamespace().toString(), name.getLocalName()); for (final DataContainerChild<? extends PathArgument, ?> child : data.getValue()) { nnWriter.write(child); } nnWriter.flush(); xmlWriter.writeEndElement(); xmlWriter.flush(); } catch (final XMLStreamException e) { Throwables.propagate(e); } }
private boolean spliceTransitives(final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> target, final ContainerNode attributes) { // We want to reuse attributes as much as possible, so the result of the loop // indicates whether we performed a modification. If we have not modified the // attributes, we can reuse them. boolean ret = false; for (final DataContainerChild<? extends PathArgument, ?> child : attributes.getValue()) { if (isTransitiveAttribute(child)) { target.withChild(child); } else { ret = true; } } return ret; }
private void writeElements(final XMLStreamWriter xmlWriter, final RestconfNormalizedNodeWriter nnWriter, final ContainerNode data) throws IOException { try { final QName name = data.getNodeType(); xmlWriter.writeStartElement(XMLConstants.DEFAULT_NS_PREFIX, name.getLocalName(), name.getNamespace().toString()); xmlWriter.writeDefaultNamespace(name.getNamespace().toString()); for(NormalizedNode<?,?> child : data.getValue()) { nnWriter.write(child); } nnWriter.flush(); xmlWriter.writeEndElement(); xmlWriter.flush(); } catch (final XMLStreamException e) { Throwables.propagate(e); } } }
@Nonnull @Override public DataObject getNodeData(@Nonnull YangInstanceIdentifier yangInstanceIdentifier, @Nonnull String resourcePath) { final InputStream resourceStream = this.getClass().getResourceAsStream(resourcePath); checkState(resourceStream != null, "Resource %s not found", resourcePath); final YangInstanceIdentifier nodeParent = getNodeParent(yangInstanceIdentifier).orElse(null); final SchemaNode parentSchema = parentSchema(schemaContext(), serializer(), nodeParent, LOG); // to be able to process containers in root of model if (isRoot(yangInstanceIdentifier)) { // if root ,read as root final ContainerNode data = readJson(schemaContext(), resourceStream, parentSchema); checkState(data.getValue().size() == 1, "Single root expected in %s", resourcePath); //then extracts first child final QName rootNodeType = data.getValue().iterator().next().getNodeType(); final YangInstanceIdentifier realIdentifier = YangInstanceIdentifier.of(rootNodeType); return nodeBinding(serializer(), realIdentifier, data).getValue(); } else { // reads just container final YangInstanceIdentifier.NodeIdentifier nodeIdentifier = containerNodeIdentifier(yangInstanceIdentifier); final ContainerNode data = readContainerEntryJson(schemaContext(), resourceStream, parentSchema, nodeIdentifier); return nodeBinding(serializer(), yangInstanceIdentifier, data.getValue().iterator().next()).getValue(); } }
@Override public Collection<NormalizedNodeUpdate> normalizedUpdates(@Nonnull final YangInstanceIdentifier topLevelIdentifier, @Nonnull final Map.Entry<YangInstanceIdentifier.PathArgument, DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> entry) { final ContainerSchemaNode containerSchemaNode = (ContainerSchemaNode) SchemaContextUtil .findDataSchemaNode(ctx, getSchemaPath(topLevelIdentifier, entry)); if (containerSchemaNode.isPresenceContainer()) { LOG.debug("Processing {} as presence container", topLevelIdentifier); // if presence container - create delete right away return ((ContainerNode) entry.getValue()).getValue().stream() .map(containerNode -> new NormalizedNodeUpdate( YangInstanceIdentifier.builder(topLevelIdentifier) .node(containerNode.getIdentifier()).build(), containerNode, null)) .collect(Collectors.toList()); } else { LOG.debug("Processing {} as non-presence container", topLevelIdentifier); // if non-presence - goes deep with base logic return super.normalizedUpdates(topLevelIdentifier, entry); } }
private void writeRootElement(final XMLStreamWriter xmlWriter, final NormalizedNodeWriter nnWriter, final ContainerNode data) { try { if (data.getNodeType().equals(SchemaContext.NAME)) { for (final DataContainerChild<? extends PathArgument, ?> child : data.getValue()) { nnWriter.write(child); } } else { nnWriter.write(data); } nnWriter.flush(); xmlWriter.flush(); } catch (XMLStreamException | IOException e) { Throwables.propagate(e); } }
private void writeRootElement(final XMLStreamWriter xmlWriter, final NormalizedNodeWriter nnWriter, final ContainerNode data) { try { if (data.getNodeType().equals(SchemaContext.NAME)) { for (final DataContainerChild<? extends PathArgument, ?> child : data.getValue()) { nnWriter.write(child); } } else { nnWriter.write(data); } nnWriter.flush(); xmlWriter.flush(); } catch (XMLStreamException | IOException e) { Throwables.propagate(e); } }
private void writeNormalizedRpc(final ContainerNode normalized, final DOMResult result, final SchemaPath schemaPath, final SchemaContext baseNetconfCtx) throws IOException, XMLStreamException { final OrderedNormalizedNodeWriter normalizedNodeWriter; NormalizedNodeStreamWriter normalizedNodeStreamWriter = null; XMLStreamWriter writer = null; try { writer = NetconfMessageTransformUtil.XML_FACTORY.createXMLStreamWriter(result); normalizedNodeStreamWriter = XMLStreamNormalizedNodeStreamWriter.create(writer, baseNetconfCtx, schemaPath); normalizedNodeWriter = new OrderedNormalizedNodeWriter(normalizedNodeStreamWriter, baseNetconfCtx, schemaPath); Collection<DataContainerChild<?, ?>> value = (Collection) normalized.getValue(); normalizedNodeWriter.write(value); normalizedNodeWriter.flush(); } finally { try { if(normalizedNodeStreamWriter != null) { normalizedNodeStreamWriter.close(); } if(writer != null) { writer.close(); } } catch (final Exception e) { LOG.warn("Unable to close resource properly", e); } } }
private static void writeNormalizedRpc(final DOMNotification normalized, final DOMResult result, final SchemaPath schemaPath, final SchemaContext baseNetconfCtx) throws IOException, XMLStreamException { final XMLStreamWriter writer = XML_FACTORY.createXMLStreamWriter(result); try { try (final NormalizedNodeStreamWriter normalizedNodeStreamWriter = XMLStreamNormalizedNodeStreamWriter.create(writer, baseNetconfCtx, schemaPath)) { try (final NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(normalizedNodeStreamWriter)) { for (DataContainerChild<?, ?> dataContainerChild : normalized.getBody().getValue()) { normalizedNodeWriter.write(dataContainerChild); } normalizedNodeWriter.flush(); } } } finally { try { writer.close(); } catch (final Exception e) { LOG.warn("Unable to close resource properly. Ignoring", e); } } } }
private static NormalizedNode<?, ?> translateRootShardIdentifierToListenerPath( final YangInstanceIdentifier listenerPath, final NormalizedNode<?, ?> node) { if (listenerPath.isEmpty()) { return node; } final NormalizedNodeBuilder nodeBuilder; if (node instanceof ContainerNode) { nodeBuilder = ImmutableContainerNodeBuilder.create().withValue(((ContainerNode) node).getValue()); } else if (node instanceof MapEntryNode) { nodeBuilder = ImmutableMapEntryNodeBuilder.create().withValue(((MapEntryNode) node).getValue()); } else { throw new IllegalArgumentException("Expected ContainerNode or MapEntryNode, but was " + node.getClass()); } nodeBuilder.withNodeIdentifier(listenerPath.getLastPathArgument()); return nodeBuilder.build(); }
.getValue()) { final YangInstanceIdentifier iid = YangInstanceIdentifier.create(dataContainerChild.getIdentifier()); LOG.trace("Restoring {} from {}", iid, path);