Class InnerTagPeek

  • public class InnerTagPeek
extends java.lang.Object
    InnerTagPeek 🠞
    1. InnerTag: This implies that Attribute key-value pairs located within the HTML TagNode instances themselves are used as a search criteria for retrieving TagNode's.

    2. Peek: This implies that BOTH the Vector-index / indices where a match occurred, AND the the HTMLNode at that index are SIMULTANEOUSLY returned by these methods - using the data-type classes NodeIndex and SubSection.
    Searches Vectorized-HTML for Tag-Matches by Inner-Tag (attribute) names & values, and returns both the index-locatioon and the tag as instances of TagNodeIndex.

    Methods Available

    Method Explanation
    first (...) This will retrieve the first TagNodeIndex - a data-class which contains a TagNode field and an int field. This data-class encapsulates both the (integer) Vector-index, and the TagNode at that index in a single object. The first match found inside the vectorized-page parameter 'html' is returned.
    nth (...) This will retrieve the nth TagNodeIndex - a data-class which contains a TagNode field and an int field. This data-class encapsulates both the (integer) Vector-index, and the TagNode at that index in a single object. The nth match found inside the vectorized-page parameter 'html' is returned.
    last (...) This will retrieve the last TagNodeIndex - a data-class which contains a TagNode field and an int field. This data-class encapsulates both the (integer) Vector-index, and the TagNode at that index in a single object. The last match found inside the vectorized-page parameter 'html' is returned.
    nthFromEnd (...) This will retrieve the nth-from-last TagNodeIndex - a data-class which contains a TagNode field and an int field. This data-class encapsulates both the (integer) Vector-index, and the TagNode at that index in a single object. The nth-from-last match found inside the vectorized-page parameter 'html' is returned.
    all (...) This will retrieve every TagNodeIndex match found inside the vectorized-page parameter 'html'.

    Method Parameters

    Parameter Explanation
    Vector<? extends HTMLNode> html This represents any vectorized HTML page, sub-page, or list of partial-elements.
    int nth This represents the 'nth' match of a comparison for-loop. When the method-signature used includes the parameter 'nth' , the first n-1 matches that are found - will be skipped, and the 'nth' match is, instead, returned.

    EXCEPTIONS: An NException shall throw if the value of parameter 'nth' is zero, negative, or larger than the size of the input html-Vector.
    int sPos, int ePos When these parameters are present, only HTMLNode's that are found between the specified Vector indices will be considered for matching with the search criteria.

    NOTE: In every situation where the parameters int sPos, int ePos are used, parameter 'ePos' will accept a negative value, but parameter 'sPos' will not. When 'ePos' is passed a negative-value, the internal LV ('Loop Variable Counter') will have its public final int end field set to the length of the vectorized-html page that was passed. (html.size() of parameter Vector<HTMLNode> html).

    EXCEPTIONS: An IndexOutOfBoundsException will be thrown if:

    • If sPos is negative, or if sPos is greater-than or equal-to the size of the input Vector
    • If ePos is zero, or greater than the size of the input Vector.
    • If sPos is a larger integer than ePos
    String htmlTag When this parameter is present, only HTMLNode's which are both instances of class TagNode *and* have a TagNode.tok field whose value is equal to this parameter 'htmlTag', will be returned as matches.

    COMMON EXAMPLES: Some common examples of valid 'htmlTags' are: a, div, img, table, tr, meta as well as all other valid HTML element-tokens.

    NOTE: This comparison is performed using a case-insensitive compare-method.

    EXCEPTIONS: If this parameter is not a valid HTML element, an HTMLTokException will be thrown.
    String... htmlTags When this parameter is present, only HTMLNode's which are both instances of class TagNode *and* whose TagNode.tok field String-value matches (is equal to) at least one of the elements in this VarArgs String parameter-set will be considered for a match. The same example HTML elements used in the previous parameter description apply here as well (a, div, img, table, tr, meta) etc...

    NOTE: This comparison is performed using a case-insensitive compare-method.

    EXCEPTIONS: If even one of the elements in this parameter-set is an invalid HTML token, an HTMLTokException will be thrown.

    FINALLY: This parameter is only available as an option for search-methods that utilize the Predicate<TagNode> parameter-option too. Most of the search-method options available in this class allow only one HTML 'token' element as a search parameter option.
    String innerTag This parameter is mandatory for every method here, except one's that receive a Predicate<TagNode> parameter. This parameter is used to identify the HTML-attribute or "Inner Tag" for whose values the programmer is comparing or testing.

    NOTE: The comparison's performed on the HTML element for the attribute name are performed using a case-insensitive compare-method.

    EXCEPTIONS: An InnerTagKeyException will be thrown if this parameter does not represent a valid HTML attribute name.

    USE: Whenever this parameter is present, the value retrieved from the invokation of tagNode.AV(innerTag) are always passed to the text-comparing methods listed below.

    MOST COMMON: The most common example String's used for parameter 'innerTag' (also called 'attribute') would include tags such as: 'id', 'class', 'src', 'href', 'style', 'width', 'onclick', 'onload', etc...
    TextComparitor tc WORKS WITH: This parameter works in coordination with parameter 'innerTag'. After the Attribute-value is retrieved from an HTML-element by method call: tagNode.AV(innerTag); The results from this invocation are sent to TextComparitor parameter 'tc'.

    ALSO WITH: This parameter also utilizes / works alongside the String... compareStr parameter for performing it's comparisons of the attribute list inside of a given HTML element TagNode.

    When this parameter is present in a method-signature parameter-list, the decision of whether a TagNode is to be included in the search result-set is defined by this parameter's BiPredicate.test(...) method. TextComparitor is a Java BiPredicate<String, String[]>, which compares the attribute-value that was retrieved with a list of compare-String's (parameter 'compareStr').
    Pattern p WORKS WITH: This parameter works in coordination with parameter 'innerTag'. After the Attribute-value is retrieved from HTML-element by method call: tagNode.AV(innerTag); The results from this call are sent to Regular-Expression Pattern 'p'.

    When this parameter is present in the method-signature parameter-list, the decision of whether a TagNode is to be included in the search result-set are made by the regular expression generated 'Matcher' against the attribute-value that was retrieved.

    Specifically: p.asPredicate().test(attribute_value)
    Predicate<String> p WORKS WITH: This parameter works in coordination with parameter 'innerTag'. After the Attribute-value is retrieved from an HTML-element by method call: tagNode.AV(innerTag); The results from this call are sent to this Java Functional Interface Predicate parameter 'p'.

    When this parameter is present in the method-signature parameter-list, the decision of whether a TagNode is to be included in the search result-set are made by the results of the Java Predicate.test(String) method.

    Specifically: p.test(attribute_value)
    String... compareStr WORKS WITH: This parameter works in coordination with parameter TextComparitor tc. This parameter supplies the String's with which the comparisons of the attribute-value may be compared.

    For Example: If the following values (below) were passed to these search-methods:

    1. If: 'innerTag' were equal to 'class'
    2. And: 'tc' were equal to TextComparitor.C
    3. And: 'compareStr' were equal to 'MyMainClass'

    The search would match any and all TagNode instances whose CSS 'class' contained 'MyMainClass'
    Predicate<TagNode> When this parameter is present in the method-signature parameter-list, the decision of whether a TagNode is to be included in the search result-set are made by calling this Predicate's test(TagNode) method.

    Return Values:

    1. TagNodeIndex represents a matched TagNode (and its integer-index position) from the vectorized-page parameter 'html'
    2. A return value of null implies no matches were found.
    3. Vector<TagNodeIndex> - A vector of TagNodeIndex represent all matches (node + vector-index) from the vectorized-page parameter 'html'
    4. A zero-length Vector<TagNodeIndex> means no matches were found on the page or sub-page. Empty Vectors are returned from any method where the possibility existed for multiple-matches being provided as a result-set.



    Stateless Class:
    This class neither contains any program-state, nor can it be instantiated. The @StaticFunctional Annotation may also be called 'The Spaghetti Report'. Static-Functional classes are, essentially, C-Styled Files, without any constructors or non-static member fields. It is a concept very similar to the Java-Bean's @Stateless Annotation.

    • 1 Constructor(s), 1 declared private, zero-argument constructor
    • 100 Method(s), 100 declared static
    • 0 Field(s)


    • Method Summary

       
      All Matches, Any HTML-Tag Will Match
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, String innerTag)
      String-Predicate static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, String innerTag, Pattern p)
      TextComparitor static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, Predicate<TagNode> p)
       
      All Matches, Specified HTML-Tag(s) Only
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag)
      String-Predicate static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag, Pattern p)
      TextComparitor static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, Predicate<TagNode> p, String... htmlTags)
       
      All Matches, Range Limited, Any HTML-Tag Will Match
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag)
      String-Predicate static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag, Pattern p)
      TextComparitor static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, int sPos, int ePos, Predicate<TagNode> p)
       
      All Matches, Range Limited, Specified HTML-Tag(s) Only
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag)
      String-Predicate static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag, Pattern p)
      TextComparitor static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static Vector<TagNodeIndex> all​(Vector<? extends HTMLNode> html, int sPos, int ePos, Predicate<TagNode> p, String... htmlTags)
       
      First Match, Any HTML-Tag Will Match
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static TagNodeIndex first​(Vector<? extends HTMLNode> html, String innerTag)
      String-Predicate static TagNodeIndex first​(Vector<? extends HTMLNode> html, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static TagNodeIndex first​(Vector<? extends HTMLNode> html, String innerTag, Pattern p)
      TextComparitor static TagNodeIndex first​(Vector<? extends HTMLNode> html, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static TagNodeIndex first​(Vector<? extends HTMLNode> html, Predicate<TagNode> p)
       
      First Match, Specified HTML-Tag(s) Only
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static TagNodeIndex first​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag)
      String-Predicate static TagNodeIndex first​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static TagNodeIndex first​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag, Pattern p)
      TextComparitor static TagNodeIndex first​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static TagNodeIndex first​(Vector<? extends HTMLNode> html, Predicate<TagNode> p, String... htmlTags)
       
      First Match, Range Limited, Any HTML-Tag Will Match
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static TagNodeIndex first​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag)
      String-Predicate static TagNodeIndex first​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static TagNodeIndex first​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag, Pattern p)
      TextComparitor static TagNodeIndex first​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static TagNodeIndex first​(Vector<? extends HTMLNode> html, int sPos, int ePos, Predicate<TagNode> p)
       
      First Match, Range Limited, Specified HTML-Tag(s) Only
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static TagNodeIndex first​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag)
      String-Predicate static TagNodeIndex first​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static TagNodeIndex first​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag, Pattern p)
      TextComparitor static TagNodeIndex first​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static TagNodeIndex first​(Vector<? extends HTMLNode> html, int sPos, int ePos, Predicate<TagNode> p, String... htmlTags)
       
      Last Match, Any HTML-Tag Will Match
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static TagNodeIndex last​(Vector<? extends HTMLNode> html, String innerTag)
      String-Predicate static TagNodeIndex last​(Vector<? extends HTMLNode> html, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static TagNodeIndex last​(Vector<? extends HTMLNode> html, String innerTag, Pattern p)
      TextComparitor static TagNodeIndex last​(Vector<? extends HTMLNode> html, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static TagNodeIndex last​(Vector<? extends HTMLNode> html, Predicate<TagNode> p)
       
      Last Match, Specified HTML-Tag(s) Only
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static TagNodeIndex last​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag)
      String-Predicate static TagNodeIndex last​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static TagNodeIndex last​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag, Pattern p)
      TextComparitor static TagNodeIndex last​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static TagNodeIndex last​(Vector<? extends HTMLNode> html, Predicate<TagNode> p, String... htmlTags)
       
      Last Match, Range Limited, Any HTML-Tag Will Match
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static TagNodeIndex last​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag)
      String-Predicate static TagNodeIndex last​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static TagNodeIndex last​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag, Pattern p)
      TextComparitor static TagNodeIndex last​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static TagNodeIndex last​(Vector<? extends HTMLNode> html, int sPos, int ePos, Predicate<TagNode> p)
       
      Last Match, Range Limited, Specified HTML-Tag(s) Only
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static TagNodeIndex last​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag)
      String-Predicate static TagNodeIndex last​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static TagNodeIndex last​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag, Pattern p)
      TextComparitor static TagNodeIndex last​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static TagNodeIndex last​(Vector<? extends HTMLNode> html, int sPos, int ePos, Predicate<TagNode> p, String... htmlTags)
       
      Nth Match, Any HTML-Tag Will Match
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, String innerTag)
      String-Predicate static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, String innerTag, Pattern p)
      TextComparitor static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, Predicate<TagNode> p)
       
      Nth Match, Specified HTML-Tag(s) Only
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, String htmlTag, String innerTag)
      String-Predicate static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, String htmlTag, String innerTag, Pattern p)
      TextComparitor static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, String htmlTag, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, Predicate<TagNode> p, String... htmlTags)
       
      Nth Match, Range Limited, Any HTML-Tag Will Match
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String innerTag)
      String-Predicate static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String innerTag, Pattern p)
      TextComparitor static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, Predicate<TagNode> p)
       
      Nth Match, Range Limited, Specified HTML-Tag(s) Only
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String htmlTag, String innerTag)
      String-Predicate static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String htmlTag, String innerTag, Pattern p)
      TextComparitor static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String htmlTag, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static TagNodeIndex nth​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, Predicate<TagNode> p, String... htmlTags)
       
      Nth Match From End, Any HTML-Tag Will Match
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, String innerTag)
      String-Predicate static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, String innerTag, Pattern p)
      TextComparitor static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, Predicate<TagNode> p)
       
      Nth Match From End, Specified HTML-Tag(s) Only
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, String htmlTag, String innerTag)
      String-Predicate static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, String htmlTag, String innerTag, Pattern p)
      TextComparitor static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, String htmlTag, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, Predicate<TagNode> p, String... htmlTags)
       
      Nth Match From End, Range Limited, Any HTML-Tag Will Match
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String innerTag)
      String-Predicate static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String innerTag, Pattern p)
      TextComparitor static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, Predicate<TagNode> p)
       
      Nth Match From End, Range Limited, Specified HTML-Tag(s) Only
      Attribute-Value Test Modifier and Type Method
      Presence-Of, Only static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String htmlTag, String innerTag)
      String-Predicate static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String htmlTag, String innerTag, Pattern p)
      TextComparitor static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String htmlTag, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static TagNodeIndex nthFromEnd​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, Predicate<TagNode> p, String... htmlTags)

      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait