Class InnerTagFindInclusive

  • public class InnerTagFindInclusive
extends java.lang.Object
    InnerTagFindInclusive 🠞
    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. Find: This implies that integer values are returned by these methods. These integers are intended to serve as pointers into the underlying input Java Vector.

    3. Inclusive: The word "Inclusive" is used to indicate that all HTMLNode's between an opening and closing HTML-tag are requested. The concept is extremely similar to the Java-Script feature / term '.innerHTML', although in this (JavaHTML) JAR Library, no DOM-Trees are ever constructed. This method will FIND all nodes between a matching, opening, TagNode element, and its corresponding-closing TagNode.
    Searches for Vector-indices of TagNode matches using exactly the same criteria offered by class InnerTagFind, but also retrieves the corresponding Closing-Tag indices from the Vector, and returns both as an instance of DotPair (a sublist-pointer).

    Methods Available

    Method Explanation
    first (...) This will retrieve a DotPair (vector index-pointers) that points to the first Vector<HTMLNode> (sub-list) match found in the vectorized-page parameter 'html'.
    nth (...) This will retrieve a DotPair (vector index-pointers) that points to the nth Vector<HTMLNode> (sub-list) match found in the vectorized-page parameter 'html'.
    last (...) This will retrieve a DotPair (vector index-pointers) that points to the last Vector<HTMLNode> (sub-list) match found in the vectorized-page parameter 'html'.
    nthFromEnd (...) This will retrieve a DotPair (vector index-pointers) that points to the nth-from-last Vector<HTMLNode> (sub-list) match found in the vectorized-page parameter 'html'.
    all (...) This will retrieve a DotPair (vector index-pointers) to every Vector<HTMLNode> (sub-list) match found in 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.

    Also, since this is an inclusive search, an InclusiveException will be thrown if this parameter is an HTML singleton element (and, therefore, may not have a matching, closing tag/element).
    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 invocation 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. DotPair The public class DotPair is just a 2-integer set that identifies the start and ending of a sub-list or "sub-array" inside the html vectorized-page parameter 'html'
    2. A return value of null implies no matching sub-lists or sub-pages were found.
    3. Vector<DotPair> This would be a "list of sub-lists" or an "array of sub-arrays" which are used when multiple results (multiple sub-lists) are needed to be returned to the calling procedure. Such a Vector<DotPair> represent a list of sub-list-pointers into the vectorized-page parameter 'html', with each integer being a different position in the vector that has a matching TagNode
    4. A zero-length Vector<DotPair> vector means no matches were found on the page or sub-page. Zero-length 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<DotPair> all​(Vector<? extends HTMLNode> html, String innerTag)
      String-Predicate static Vector<DotPair> all​(Vector<? extends HTMLNode> html, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static Vector<DotPair> all​(Vector<? extends HTMLNode> html, String innerTag, Pattern p)
      TextComparitor static Vector<DotPair> all​(Vector<? extends HTMLNode> html, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static Vector<DotPair> 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<DotPair> all​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag)
      String-Predicate static Vector<DotPair> all​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static Vector<DotPair> all​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag, Pattern p)
      TextComparitor static Vector<DotPair> 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<DotPair> 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<DotPair> all​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag)
      String-Predicate static Vector<DotPair> all​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static Vector<DotPair> all​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag, Pattern p)
      TextComparitor static Vector<DotPair> 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<DotPair> 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<DotPair> all​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag)
      String-Predicate static Vector<DotPair> all​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static Vector<DotPair> all​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag, Pattern p)
      TextComparitor static Vector<DotPair> 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<DotPair> 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 DotPair first​(Vector<? extends HTMLNode> html, String innerTag)
      String-Predicate static DotPair first​(Vector<? extends HTMLNode> html, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static DotPair first​(Vector<? extends HTMLNode> html, String innerTag, Pattern p)
      TextComparitor static DotPair first​(Vector<? extends HTMLNode> html, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static DotPair 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 DotPair first​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag)
      String-Predicate static DotPair first​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static DotPair first​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag, Pattern p)
      TextComparitor static DotPair 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 DotPair 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 DotPair first​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag)
      String-Predicate static DotPair first​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static DotPair first​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag, Pattern p)
      TextComparitor static DotPair 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 DotPair 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 DotPair first​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag)
      String-Predicate static DotPair first​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static DotPair first​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag, Pattern p)
      TextComparitor static DotPair 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 DotPair 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 DotPair last​(Vector<? extends HTMLNode> html, String innerTag)
      String-Predicate static DotPair last​(Vector<? extends HTMLNode> html, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static DotPair last​(Vector<? extends HTMLNode> html, String innerTag, Pattern p)
      TextComparitor static DotPair last​(Vector<? extends HTMLNode> html, String innerTag, TextComparitor tc, String... compareStr)
      This search expects a customized Predicate<TagNode> or AVT instance
      NONE static DotPair 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 DotPair last​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag)
      String-Predicate static DotPair last​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static DotPair last​(Vector<? extends HTMLNode> html, String htmlTag, String innerTag, Pattern p)
      TextComparitor static DotPair 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 DotPair 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 DotPair last​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag)
      String-Predicate static DotPair last​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static DotPair last​(Vector<? extends HTMLNode> html, int sPos, int ePos, String innerTag, Pattern p)
      TextComparitor static DotPair 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 DotPair 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 DotPair last​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag)
      String-Predicate static DotPair last​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static DotPair last​(Vector<? extends HTMLNode> html, int sPos, int ePos, String htmlTag, String innerTag, Pattern p)
      TextComparitor static DotPair 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 DotPair 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 DotPair nth​(Vector<? extends HTMLNode> html, int nth, String innerTag)
      String-Predicate static DotPair nth​(Vector<? extends HTMLNode> html, int nth, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static DotPair nth​(Vector<? extends HTMLNode> html, int nth, String innerTag, Pattern p)
      TextComparitor static DotPair 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 DotPair 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 DotPair nth​(Vector<? extends HTMLNode> html, int nth, String htmlTag, String innerTag)
      String-Predicate static DotPair nth​(Vector<? extends HTMLNode> html, int nth, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static DotPair nth​(Vector<? extends HTMLNode> html, int nth, String htmlTag, String innerTag, Pattern p)
      TextComparitor static DotPair 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 DotPair 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 DotPair nth​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String innerTag)
      String-Predicate static DotPair nth​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static DotPair nth​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String innerTag, Pattern p)
      TextComparitor static DotPair 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 DotPair 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 DotPair nth​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String htmlTag, String innerTag)
      String-Predicate static DotPair nth​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static DotPair nth​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String htmlTag, String innerTag, Pattern p)
      TextComparitor static DotPair 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 DotPair 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 DotPair nthFromEnd​(Vector<? extends HTMLNode> html, int nth, String innerTag)
      String-Predicate static DotPair nthFromEnd​(Vector<? extends HTMLNode> html, int nth, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static DotPair nthFromEnd​(Vector<? extends HTMLNode> html, int nth, String innerTag, Pattern p)
      TextComparitor static DotPair 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 DotPair 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 DotPair nthFromEnd​(Vector<? extends HTMLNode> html, int nth, String htmlTag, String innerTag)
      String-Predicate static DotPair nthFromEnd​(Vector<? extends HTMLNode> html, int nth, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static DotPair nthFromEnd​(Vector<? extends HTMLNode> html, int nth, String htmlTag, String innerTag, Pattern p)
      TextComparitor static DotPair 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 DotPair 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 DotPair nthFromEnd​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String innerTag)
      String-Predicate static DotPair nthFromEnd​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static DotPair nthFromEnd​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String innerTag, Pattern p)
      TextComparitor static DotPair 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 DotPair 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 DotPair nthFromEnd​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String htmlTag, String innerTag)
      String-Predicate static DotPair nthFromEnd​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String htmlTag, String innerTag, Predicate<String> attributeValuePred)
      Regular-Expression static DotPair nthFromEnd​(Vector<? extends HTMLNode> html, int nth, int sPos, int ePos, String htmlTag, String innerTag, Pattern p)
      TextComparitor static DotPair 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 DotPair 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