org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode.getChildNodes java code examples

Common ways to obtain DataTreeCandidateNode

private void myMethod () {
 DataTreeCandidateNode d =DataTreeCandidate dataTreeCandidate;dataTreeCandidate.getRootNode()
Smart code suggestions by Tabnine
}

@Nonnull
@Override
public Collection<TreeNodeModification<? extends TreeNode>> getModifiedChildren() {
  if (childNodesCache == null) {
    childNodesCache = from(codec, domData.getChildNodes());
  }
  return childNodesCache;
}

@Override
public Collection<DataObjectModification<? extends DataObject>> getModifiedChildren() {
  if (childNodesCache == null) {
    childNodesCache = from(codec, domData.getChildNodes());
  }
  return childNodesCache;
}

@Override
public Collection<LazyDataObjectModification<? extends DataObject>> getModifiedChildren() {
  Collection<LazyDataObjectModification<? extends DataObject>> local = childNodesCache;
  if (local == null) {
    childNodesCache = local = from(codec, domData.getChildNodes());
  }
  return local;
}

private static void populateList(final List<DataObjectModification<? extends DataObject>> result,
    final BindingStructuralType type, final BindingCodecTreeNode<?> childCodec,
    final DataTreeCandidateNode domChildNode) {
  switch (type) {
    case INVISIBLE_LIST:
      // We use parent codec intentionally.
      populateListWithSingleCodec(result, childCodec, domChildNode.getChildNodes());
      break;
    case INVISIBLE_CONTAINER:
      populateList(result, childCodec, domChildNode.getChildNodes());
      break;
    case UNKNOWN:
    case VISIBLE_CONTAINER:
      result.add(create(childCodec, domChildNode));
    default:
      break;
  }
}

private static void populateList(final List<TreeNodeModification<? extends TreeNode>> result,
    final BindingStructuralType type, final BindingTreeNodeCodec<?> childCodec,
    final DataTreeCandidateNode domChildNode) {
  switch (type) {
    case INVISIBLE_LIST:
      // We use parent codec intentionally.
      populateListWithSingleCodec(result, childCodec, domChildNode.getChildNodes());
      break;
    case INVISIBLE_CONTAINER:
      populateList(result, childCodec, domChildNode.getChildNodes());
      break;
    case UNKNOWN:
    case VISIBLE_CONTAINER:
      result.add(create(childCodec, domChildNode));
      break;
    default:
  }
}

private static void populateList(final List<LazyDataObjectModification<? extends DataObject>> result,
    final BindingStructuralType type, final BindingCodecTreeNode<?> childCodec,
    final DataTreeCandidateNode domChildNode) {
  switch (type) {
    case INVISIBLE_LIST:
      // We use parent codec intentionally.
      populateListWithSingleCodec(result, childCodec, domChildNode.getChildNodes());
      break;
    case INVISIBLE_CONTAINER:
      populateList(result, childCodec, domChildNode.getChildNodes());
      break;
    case UNKNOWN:
    case VISIBLE_CONTAINER:
      result.add(create(childCodec, domChildNode));
      break;
    default:
  }
}

@Override
public final Collection<DataTreeCandidateNode> changedRoutes(final DataTreeCandidateNode routes) {
  final DataTreeCandidateNode myRoutes = routes.getModifiedChild(this.routesContainerIdentifier);
  if (myRoutes == null) {
    return Collections.emptySet();
  }
  final DataTreeCandidateNode routesMap = myRoutes.getModifiedChild(routeNid());
  if (routesMap == null) {
    return Collections.emptySet();
  }
  // Well, given the remote possibility of augmentation, we should perform a filter here,
  // to make sure the type matches what routeType() reports.
  return routesMap.getChildNodes();
}

public static void applyRootToCursor(final DataTreeModificationCursor cursor, final DataTreeCandidateNode node) {
  switch (node.getModificationType()) {
    case DELETE:
      throw new IllegalArgumentException("Can not delete root.");
    case WRITE:
    case SUBTREE_MODIFIED:
      AbstractNodeIterator iterator = new RootNonExitingIterator(node.getChildNodes().iterator());
      do {
        iterator = iterator.next(cursor);
      } while (iterator != null);
      break;
    case UNMODIFIED:
      // No-op
      break;
    default:
      throw new IllegalArgumentException("Unsupported modification " + node.getModificationType());
  }
}

public static void applyRootToCursor(final DataTreeModificationCursor cursor, final DataTreeCandidateNode node) {
  switch (node.getModificationType()) {
    case DELETE:
      throw new IllegalArgumentException("Can not delete root.");
    case WRITE:
    case SUBTREE_MODIFIED:
      AbstractNodeIterator iterator = new RootNonExitingIterator(node.getChildNodes().iterator());
      do {
        iterator = iterator.next(cursor);
      } while (iterator != null);
      break;
    case UNMODIFIED:
      // No-op
      break;
    default:
      throw new IllegalArgumentException("Unsupported modification " + node.getModificationType());
  }
}

public static void validate(final DataTreeCandidate tree, final LeafRefContext rootLeafRefCtx)
    throws LeafRefDataValidationFailedException {
  final Optional<NormalizedNode<?, ?>> root = tree.getRootNode().getDataAfter();
  if (root.isPresent()) {
    new LeafRefValidation(root.get()).validateChildren(rootLeafRefCtx, tree.getRootNode().getChildNodes());
  }
}

public static void validate(final DataTreeCandidate tree, final LeafRefContext rootLeafRefCtx)
    throws LeafRefDataValidationFailedException {
  final Optional<NormalizedNode<?, ?>> root = tree.getRootNode().getDataAfter();
  if (root.isPresent()) {
    new LeafRefValidation(root.get()).validateChildren(rootLeafRefCtx, tree.getRootNode().getChildNodes());
  }
}

@Override
public void onDataTreeChanged(final Collection<DataTreeCandidate> changes) {
  LOG.debug("Data change received for AdjRibOut {}", changes);
  for (final DataTreeCandidate tc : changes) {
    LOG.trace("Change {} type {}", tc.getRootNode(), tc.getRootNode().getModificationType());
    for (final DataTreeCandidateNode child : tc.getRootNode().getChildNodes()) {
      processSupportedFamilyRoutes(child);
    }
  }
  this.session.flush();
}

private void writeTable(final DOMDataWriteTransaction tx, final NodeIdentifierWithPredicates tableKey, final DataTreeCandidateNode table) {
  final RIBSupportContext ribSupport = getRibSupport(tableKey);
  final YangInstanceIdentifier tablePath = effectiveTablePath(tableKey);
  // Create an empty table
  LOG.trace("Create Empty table", tablePath);
  ribSupport.createEmptyTableStructure(tx, tablePath);
  processTableChildren(tx, ribSupport.getRibSupport(), tablePath, table.getChildNodes());
}

@Override
public void onDataTreeChanged(@Nonnull final Collection<DataTreeCandidate> changes) {
  LOG.trace("Data changed called to effective RIB. Change : {}", changes);
  // we have a lot of transactions created for 'nothing' because a lot of changes
  // are skipped, so ensure we only create one transaction when we really need it
  DOMDataWriteTransaction tx = null;
  for (final DataTreeCandidate tc : changes) {
    final YangInstanceIdentifier rootPath = tc.getRootPath();
    final DataTreeCandidateNode root = tc.getRootNode();
    for (final DataTreeCandidateNode table : root.getChildNodes()) {
      if (tx == null) {
        tx = this.chain.newWriteOnlyTransaction();
      }
      changeDataTree(tx, rootPath, root, table);
    }
  }
  if (tx != null) {
    tx.submit();
  }
}

private void modifyTable(final DOMDataWriteTransaction tx, final NodeIdentifierWithPredicates tableKey, final DataTreeCandidateNode table) {
  final RIBSupportContext ribSupport = getRibSupport(tableKey);
  final YangInstanceIdentifier tablePath = effectiveTablePath(tableKey);
  processTableChildren(tx, ribSupport.getRibSupport(), tablePath, table.getChildNodes());
}

private void updateNodes(final DataTreeCandidateNode table, final PeerId peerId, final DOMDataWriteTransaction tx,
  final Map<RouteUpdateKey, RouteEntry> routes) {
  for (final DataTreeCandidateNode child : table.getChildNodes()) {
    LOG.debug("Modification type {}", child.getModificationType());
    if ((Attributes.QNAME).equals(child.getIdentifier().getNodeType())) {
      if (child.getDataAfter().isPresent()) {
        // putting uptodate attribute in
        LOG.trace("Uptodate found for {}", child.getDataAfter());
        tx.put(LogicalDatastoreType.OPERATIONAL, this.locRibTarget.node(child.getIdentifier()), child.getDataAfter().get());
      }
      continue;
    }
    updateRoutesEntries(child, peerId, routes);
  }
}

Stream<Modification> streamChildren() {
  return dataCandidate.getChildNodes().stream()
    .map(child -> {
      final YangInstanceIdentifier childId = id.node(child.getIdentifier());
      final Object schemaChild = schemaChild(schemaNode, child.getIdentifier());
      // An augment cannot change other augment, so we do not update parent node if we are streaming
      // children of AugmentationSchema (otherwise we would fail to find schema for nested augmentations):
      if (updateParentNode) {
        if (schemaNode instanceof AugmentationSchemaNode) {
          // child nodes would not have nested augmentations, so we stop moving parentNode:
          return new Modification(childId, child, parentNode, schemaChild, false);
        } else {
          // update parent node:
          return new Modification(childId, child, schemaNode, schemaChild, true);
        }
      }
      return new Modification(childId, child, parentNode, schemaChild, updateParentNode);
    });
}

private void validateNode(final DataTreeCandidateNode node, final LeafRefContext referencedByCtx,
  final LeafRefContext referencingCtx, final YangInstanceIdentifier current) {
  if (node.getModificationType() == ModificationType.WRITE && node.getDataAfter().isPresent()) {
    validateNodeData(node.getDataAfter().get(), referencedByCtx, referencingCtx, node.getModificationType(),
      current);
    return;
  }
  if (node.getModificationType() == ModificationType.DELETE && referencedByCtx != null) {
    validateNodeData(node.getDataBefore().get(), referencedByCtx, null, node.getModificationType(), current);
    return;
  }
  for (final DataTreeCandidateNode childNode : node.getChildNodes()) {
    if (childNode.getModificationType() != ModificationType.UNMODIFIED) {
      final LeafRefContext childReferencedByCtx = getReferencedByCtxChild(referencedByCtx, childNode);
      final LeafRefContext childReferencingCtx = getReferencingCtxChild(referencingCtx, childNode);
      if (childReferencedByCtx != null || childReferencingCtx != null) {
        validateNode(childNode, childReferencedByCtx,childReferencingCtx,
          current.node(childNode.getIdentifier()));
      }
    }
  }
}

private void validateNode(final DataTreeCandidateNode node, final LeafRefContext referencedByCtx,
  final LeafRefContext referencingCtx, final YangInstanceIdentifier current) {
  if (node.getModificationType() == ModificationType.WRITE && node.getDataAfter().isPresent()) {
    validateNodeData(node.getDataAfter().get(), referencedByCtx, referencingCtx, node.getModificationType(),
      current);
    return;
  }
  if (node.getModificationType() == ModificationType.DELETE && referencedByCtx != null) {
    validateNodeData(node.getDataBefore().get(), referencedByCtx, null, node.getModificationType(), current);
    return;
  }
  for (final DataTreeCandidateNode childNode : node.getChildNodes()) {
    if (childNode.getModificationType() != ModificationType.UNMODIFIED) {
      final LeafRefContext childReferencedByCtx = getReferencedByCtxChild(referencedByCtx, childNode);
      final LeafRefContext childReferencingCtx = getReferencingCtxChild(referencingCtx, childNode);
      if (childReferencedByCtx != null || childReferencingCtx != null) {
        validateNode(childNode, childReferencedByCtx,childReferencingCtx,
          current.node(childNode.getIdentifier()));
      }
    }
  }
}

  private void notifyNode(final YangInstanceIdentifier path, final RegistrationTreeNode<AbstractDOMDataTreeChangeListenerRegistration<?>> regNode, final DataTreeCandidateNode candNode) {
    if (candNode.getModificationType() == ModificationType.UNMODIFIED) {
      LOG.debug("Skipping unmodified candidate {}", path);
      return;
    }

    final Collection<AbstractDOMDataTreeChangeListenerRegistration<?>> regs = regNode.getRegistrations();
    if (!regs.isEmpty()) {
      notifyListeners(regs, path, candNode);
    }

    for (DataTreeCandidateNode candChild : candNode.getChildNodes()) {
      if (candChild.getModificationType() != ModificationType.UNMODIFIED) {
        final RegistrationTreeNode<AbstractDOMDataTreeChangeListenerRegistration<?>> regChild = regNode.getExactChild(candChild.getIdentifier());
        if (regChild != null) {
          notifyNode(path.node(candChild.getIdentifier()), regChild, candChild);
        }

        for (RegistrationTreeNode<AbstractDOMDataTreeChangeListenerRegistration<?>> rc : regNode.getInexactChildren(candChild.getIdentifier())) {
          notifyNode(path.node(candChild.getIdentifier()), rc, candChild);
        }
      }
    }
  }
}

Javadoc

Get an unmodifiable collection of modified child nodes.

Popular methods of DataTreeCandidateNode

getIdentifier
Get the node identifier.
getModificationType
Return the type of modification this node is undergoing.
getDataAfter
Return the after-image of data corresponding to the node.
getDataBefore
Return the before-image of data corresponding to the node.
getModifiedChild
Returns modified child or null if child was not modified / does not exists.

Popular in Java

Reactive rest calls using spring rest template
onCreateOptionsMenu (Activity)
putExtra (Intent)
getContentResolver (Context)
FileOutputStream (java.io)
An output stream that writes bytes to a file. If the output file exists, it can be replaced or appen
FileWriter (java.io)
A specialized Writer that writes to a file in the file system. All write requests made by calling me
ArrayList (java.util)
ArrayList is an implementation of List, backed by an array. All optional operations including adding
SortedSet (java.util)
SortedSet is a Set which iterates over its elements in a sorted order. The order is determined eithe
Manifest (java.util.jar)
The Manifest class is used to obtain attribute information for a JarFile and its entries.
LoggerFactory (org.slf4j)
The LoggerFactory is a utility class producing Loggers for various logging APIs, most notably for lo
Sublime Text for Python

How to use getChildNodesmethodin org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode

Best Java code snippets using org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode.getChildNodes (Showing top 20 results out of 315)

How to use
getChildNodes
method
in
org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode