public static Optional<NormalizedNode<?, ?>> findNode(final Optional<NormalizedNode<?, ?>> parent, final PathArgument... relativePath) { return findNode(parent, Arrays.asList(relativePath)); }
@Override public void enter(@Nonnull final PathArgument child) { final Optional<NormalizedNode<?, ?>> maybeChildNode = NormalizedNodes.getDirectChild(stack.peek(), child); checkArgument(maybeChildNode.isPresent(), "Child %s not found", child); final NormalizedNode<?, ?> childNode = maybeChildNode.get(); checkArgument(childNode instanceof NormalizedNodeContainer, "Child %s is not a container", child); stack.push((NormalizedNodeContainer<?, ?, ?>) childNode); }
private Attributes routeAttributes(final MapEntryNode route) { if (LOG.isDebugEnabled()) { LOG.debug("AdjRibOut parsing route {}", NormalizedNodes.toStringTree(route)); } final ContainerNode advertisedAttrs = (ContainerNode) NormalizedNodes.findNode(route, this.support.routeAttributesIdentifier()).orNull(); return this.codecs.deserializeAttributes(advertisedAttrs); }
/** * Convert a data subtree under a node into a human-readable string format. * * @param node Data subtree root * @return String containing a human-readable form of the subtree. */ public static String toStringTree(final NormalizedNode<?, ?> node) { final StringBuilder builder = new StringBuilder(); toStringTree(builder, node, 0); return builder.toString(); }
/** * Convert a data subtree under a node into a human-readable string format. * * @param node Data subtree root * @return String containing a human-readable form of the subtree. */ public static String toStringTree(final NormalizedNode<?, ?> node) { final StringBuilder builder = new StringBuilder(); toStringTree(builder, node, 0); return builder.toString(); }
public static Optional<NormalizedNode<?, ?>> findNode(final NormalizedNode<?, ?> parent, final PathArgument... relativePath) { return findNode(parent, Arrays.asList(relativePath)); }
public static Optional<NormalizedNode<?, ?>> findNode(final Optional<NormalizedNode<?, ?>> parent, final Iterable<PathArgument> relativePath) { requireNonNull(parent, "Parent must not be null"); requireNonNull(relativePath, "Relative path must not be null"); Optional<NormalizedNode<?, ?>> currentNode = parent; final Iterator<PathArgument> pathIterator = relativePath.iterator(); while (currentNode.isPresent() && pathIterator.hasNext()) { currentNode = getDirectChild(currentNode.get(), pathIterator.next()); } return currentNode; }
@Override public String toString() { final TreeNode r = root; return MoreObjects.toStringHelper(this).add("data", NormalizedNodes.toStringTree(r.getData())).toString(); } }
public static Optional<NormalizedNode<?, ?>> findNode(final NormalizedNode<?, ?> parent, final Iterable<PathArgument> relativePath) { return findNode(Optional.ofNullable(parent), relativePath); }
@Override public void enter(@Nonnull final PathArgument child) { final Optional<NormalizedNode<?, ?>> maybeChildNode = NormalizedNodes.getDirectChild(stack.peek(), child); checkArgument(maybeChildNode.isPresent(), "Child %s not found", child); final NormalizedNode<?, ?> childNode = maybeChildNode.get(); checkArgument(childNode instanceof NormalizedNodeContainer, "Child %s is not a container", child); stack.push((NormalizedNodeContainer<?, ?, ?>) childNode); }
@Override public String toString() { final TreeNode r = root; return MoreObjects.toStringHelper(this).add("data", NormalizedNodes.toStringTree(r.getData())).toString(); } }
public static Optional<NormalizedNode<?, ?>> findNode(final NormalizedNode<?, ?> parent, final Iterable<PathArgument> relativePath) { return findNode(Optional.ofNullable(parent), relativePath); }
public static Optional<NormalizedNode<?, ?>> findNode(final Optional<NormalizedNode<?, ?>> parent, final Iterable<PathArgument> relativePath) { requireNonNull(parent, "Parent must not be null"); requireNonNull(relativePath, "Relative path must not be null"); Optional<NormalizedNode<?, ?>> currentNode = parent; final Iterator<PathArgument> pathIterator = relativePath.iterator(); while (currentNode.isPresent() && pathIterator.hasNext()) { currentNode = getDirectChild(currentNode.get(), pathIterator.next()); } return currentNode; }
private static void toStringTree(final StringBuilder builder, final NormalizedNode<?, ?> node, final int offset) { final String prefix = Strings.repeat(" ", offset); builder.append(prefix).append(toStringTree(node.getIdentifier())); if (node instanceof NormalizedNodeContainer<?, ?, ?>) { final NormalizedNodeContainer<?, ?, ?> container = (NormalizedNodeContainer<?, ?, ?>) node; builder.append(" {\n"); for (NormalizedNode<?, ?> child : container.getValue()) { toStringTree(builder, child, offset + STRINGTREE_INDENT); } builder.append(prefix).append('}'); } else { builder.append(' ').append(node.getValue()); } builder.append('\n'); }
public static Optional<NormalizedNode<?, ?>> findNode(final Optional<NormalizedNode<?, ?>> parent, final PathArgument... relativePath) { return findNode(parent, Arrays.asList(relativePath)); }
private static Optional<NormalizedNode<?, ?>> findParentNode( final Optional<NormalizedNode<?, ?>> root, final YangInstanceIdentifier path) { Optional<NormalizedNode<?, ?>> currentNode = root; final Iterator<PathArgument> pathIterator = path.getPathArguments().iterator(); while (pathIterator.hasNext()) { final PathArgument childPathArgument = pathIterator.next(); if (pathIterator.hasNext() && currentNode.isPresent()) { currentNode = NormalizedNodes.getDirectChild(currentNode.get(), childPathArgument); } else { return currentNode; } } return Optional.empty(); }
private static void toStringTree(final StringBuilder builder, final NormalizedNode<?, ?> node, final int offset) { final String prefix = Strings.repeat(" ", offset); builder.append(prefix).append(toStringTree(node.getIdentifier())); if (node instanceof NormalizedNodeContainer<?, ?, ?>) { final NormalizedNodeContainer<?, ?, ?> container = (NormalizedNodeContainer<?, ?, ?>) node; builder.append(" {\n"); for (NormalizedNode<?, ?> child : container.getValue()) { toStringTree(builder, child, offset + STRINGTREE_INDENT); } builder.append(prefix).append('}'); } else { builder.append(' ').append(node.getValue()); } builder.append('\n'); }
public static Optional<NormalizedNode<?, ?>> findNode(final NormalizedNode<?, ?> parent, final PathArgument... relativePath) { return findNode(parent, Arrays.asList(relativePath)); }
private static Optional<NormalizedNode<?, ?>> findParentNode( final Optional<NormalizedNode<?, ?>> root, final YangInstanceIdentifier path) { Optional<NormalizedNode<?, ?>> currentNode = root; final Iterator<PathArgument> pathIterator = path.getPathArguments().iterator(); while (pathIterator.hasNext()) { final PathArgument childPathArgument = pathIterator.next(); if (pathIterator.hasNext() && currentNode.isPresent()) { currentNode = NormalizedNodes.getDirectChild(currentNode.get(), childPathArgument); } else { return currentNode; } } return Optional.empty(); }
@Override public void commit(final DataTreeCandidate candidate) { if (candidate instanceof NoopDataTreeCandidate) { return; } checkArgument(candidate instanceof InMemoryDataTreeCandidate, "Invalid candidate class %s", candidate.getClass()); final InMemoryDataTreeCandidate c = (InMemoryDataTreeCandidate)candidate; if (LOG.isTraceEnabled()) { LOG.trace("Data Tree is {}", NormalizedNodes.toStringTree(c.getTipRoot().getData())); } final TreeNode newRoot = c.getTipRoot(); DataTreeState currentState; DataTreeState newState; do { currentState = state; final TreeNode currentRoot = currentState.getRoot(); LOG.debug("Updating datastore from {} to {}", currentRoot, newRoot); final TreeNode oldRoot = c.getBeforeRoot(); if (oldRoot != currentRoot) { final String oldStr = simpleToString(oldRoot); final String currentStr = simpleToString(currentRoot); throw new IllegalStateException("Store tree " + currentStr + " and candidate base " + oldStr + " differ."); } newState = currentState.withRoot(newRoot); LOG.trace("Updated state from {} to {}", currentState, newState); } while (!STATE_UPDATER.compareAndSet(this, currentState, newState)); }