How to use

walk

method

in

jodd.lagarto.dom.NodeSelector

/**
 * Selects nodes using {@link NodeFilter node filter}.
 */
public List<Node> select(final NodeFilter nodeFilter) {
  List<Node> nodes = new ArrayList<>();
  walk(rootNode, nodeFilter, nodes);
  return nodes;
}

protected List<Node> select(final Node rootNode, final List<CssSelector> selectors) {
  // start with the root node
  List<Node> nodes = new ArrayList<>();
  nodes.add(rootNode);
  // iterate all selectors
  for (CssSelector cssSelector : selectors) {
    // create new set of results for current css selector
    List<Node> selectedNodes = new ArrayList<>();
    for (Node node : nodes) {
      walk(node, cssSelector, selectedNodes);
    }
    // post-processing: filter out the results
    List<Node> resultNodes = new ArrayList<>();
    int index = 0;
    for (Node node : selectedNodes) {
      boolean match = filter(selectedNodes, node, cssSelector, index);
      if (match) {
        resultNodes.add(node);
      }
      index++;
    }
    // continue with results
    nodes = resultNodes;
  }
  return nodes;
}

protected void walk(final Node rootNode, final NodeFilter nodeFilter, final List<Node> result) {
  int childCount = rootNode.getChildNodesCount();
  for (int i = 0; i < childCount; i++) {
    Node node = rootNode.getChild(i);
    if (nodeFilter.accept(node)) {
      result.add(node);
    }
    walk(node, nodeFilter, result);
  }
}

public LinkedList<Node> select(NodeFilter nodeFilter) {
  LinkedList<Node> nodes = new LinkedList<Node>();
  walk(rootNode, nodeFilter, nodes);
  return nodes;
}

/**
 * Selects nodes using {@link NodeFilter node filter}.
 */
public List<Node> select(NodeFilter nodeFilter) {
  List<Node> nodes = new ArrayList<>();
  walk(rootNode, nodeFilter, nodes);
  return nodes;
}

/**
 * Selects nodes using {@link NodeFilter node filter}.
 */
public List<Node> select(final NodeFilter nodeFilter) {
  List<Node> nodes = new ArrayList<>();
  walk(rootNode, nodeFilter, nodes);
  return nodes;
}

protected List<Node> select(final Node rootNode, final List<CssSelector> selectors) {
  // start with the root node
  List<Node> nodes = new ArrayList<>();
  nodes.add(rootNode);
  // iterate all selectors
  for (CssSelector cssSelector : selectors) {
    // create new set of results for current css selector
    List<Node> selectedNodes = new ArrayList<>();
    for (Node node : nodes) {
      walk(node, cssSelector, selectedNodes);
    }
    // post-processing: filter out the results
    List<Node> resultNodes = new ArrayList<>();
    int index = 0;
    for (Node node : selectedNodes) {
      boolean match = filter(selectedNodes, node, cssSelector, index);
      if (match) {
        resultNodes.add(node);
      }
      index++;
    }
    // continue with results
    nodes = resultNodes;
  }
  return nodes;
}

protected LinkedList<Node> select(Node rootNode, List<CssSelector> selectors) {
  // start with the root node
  LinkedList<Node> nodes = new LinkedList<Node>();
  nodes.add(rootNode);
  // iterate all selectors
  for (CssSelector cssSelector : selectors) {
    // create new set of results for current css selector
    LinkedList<Node> selectedNodes = new LinkedList<Node>();
    for (Node node : nodes) {
      walk(node, cssSelector, selectedNodes);
    }
    // post-processing: filter out the results
    LinkedList<Node> resultNodes = new LinkedList<Node>();
    int index = 0;
    for (Node node : selectedNodes) {
      boolean match = filter(selectedNodes, node, cssSelector, index);
      if (match == true) {
        resultNodes.add(node);
      }
      index++;
    }
    // continue with results
    nodes = resultNodes;
  }
  return nodes;
}

protected List<Node> select(Node rootNode, List<CssSelector> selectors) {
  // start with the root node
  List<Node> nodes = new ArrayList<>();
  nodes.add(rootNode);
  // iterate all selectors
  for (CssSelector cssSelector : selectors) {
    // create new set of results for current css selector
    List<Node> selectedNodes = new ArrayList<>();
    for (Node node : nodes) {
      walk(node, cssSelector, selectedNodes);
    }
    // post-processing: filter out the results
    List<Node> resultNodes = new ArrayList<>();
    int index = 0;
    for (Node node : selectedNodes) {
      boolean match = filter(selectedNodes, node, cssSelector, index);
      if (match == true) {
        resultNodes.add(node);
      }
      index++;
    }
    // continue with results
    nodes = resultNodes;
  }
  return nodes;
}

protected void walk(final Node rootNode, final NodeFilter nodeFilter, final List<Node> result) {
  int childCount = rootNode.getChildNodesCount();
  for (int i = 0; i < childCount; i++) {
    Node node = rootNode.getChild(i);
    if (nodeFilter.accept(node)) {
      result.add(node);
    }
    walk(node, nodeFilter, result);
  }
}

protected void walk(Node rootNode, NodeFilter nodeFilter, List<Node> result) {
  int childCount = rootNode.getChildNodesCount();
  for (int i = 0; i < childCount; i++) {
    Node node = rootNode.getChild(i);
    if (nodeFilter.accept(node)) {
      result.add(node);
    }
    walk(node, nodeFilter, result);
  }
}

protected void walk(Node rootNode, NodeFilter nodeFilter, LinkedList<Node> result) {
  int childCount = rootNode.getChildNodesCount();
  for (int i = 0; i < childCount; i++) {
    Node node = rootNode.getChild(i);
    if (nodeFilter.accept(node)) {
      result.add(node);
    }
    walk(node, nodeFilter, result);
  }
}