Tabnine Logo
NodeSelector.walk
Code IndexAdd Tabnine to your IDE (free)

How to use
walk
method
in
jodd.lagarto.dom.NodeSelector

Best Java code snippets using jodd.lagarto.dom.NodeSelector.walk (Showing top 12 results out of 315)

origin: oblac/jodd

/**
 * 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;
}
origin: oblac/jodd

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;
}
origin: oblac/jodd

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);
  }
}
origin: org.jodd/jodd-wot

public LinkedList<Node> select(NodeFilter nodeFilter) {
  LinkedList<Node> nodes = new LinkedList<Node>();
  walk(rootNode, nodeFilter, nodes);
  return nodes;
}
origin: fivesmallq/web-data-extractor

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

/**
 * 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;
}
origin: org.jodd/jodd-lagarto

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;
}
origin: org.jodd/jodd-wot

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;
}
origin: fivesmallq/web-data-extractor

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;
}
origin: org.jodd/jodd-lagarto

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);
  }
}
origin: fivesmallq/web-data-extractor

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);
  }
}
origin: org.jodd/jodd-wot

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);
  }
}
jodd.lagarto.domNodeSelectorwalk

Javadoc

Finds nodes in the tree that matches single selector.

Popular methods of NodeSelector

  • <init>
  • select
    Selects nodes using NodeFilter.
  • filter
    Filter nodes.
  • selectAndAdd
    Selects single node for single selector and appends it to the results.
  • walkDescendantsIteratively
    Walks over the child notes, maintaining the tree order and not using recursion.
  • processSelectors
    Process selectors and keep adding results.
  • createCSSelly
    Creates CSSelly instance for parsing files.
  • selectFirst
    Selects nodes using NodeFilter and return the very first one.

Popular in Java

  • Start an intent from android
  • setContentView (Activity)
  • getContentResolver (Context)
  • requestLocationUpdates (LocationManager)
  • RandomAccessFile (java.io)
    Allows reading from and writing to a file in a random-access manner. This is different from the uni-
  • LinkedHashMap (java.util)
    LinkedHashMap is an implementation of Map that guarantees iteration order. All optional operations a
  • Queue (java.util)
    A collection designed for holding elements prior to processing. Besides basic java.util.Collection o
  • TimeZone (java.util)
    TimeZone represents a time zone offset, and also figures out daylight savings. Typically, you get a
  • Location (org.springframework.beans.factory.parsing)
    Class that models an arbitrary location in a Resource.Typically used to track the location of proble
  • Option (scala)
  • Top 25 Plugins for Webstorm
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyStudentsTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now