1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
package Torello.HTML.NodeSearch.searchLoops;

import java.util.Vector;
import java.util.function.Predicate;
import java.util.stream.IntStream;

import Torello.HTML.*;
import Torello.Java.LV;

public class ITFind
{
    // *****************************************************************************************************************************
    // MAIN FIND METHODS
    // *****************************************************************************************************************************

    public static int NTH(Vector<? extends HTMLNode> html, int nth, LV l, String htmlTag, String innerTag, Predicate<String> compare)
    {
        HTMLNode n;     TagNode tn;     String itv;                 // Identical-Code Begins **HERE**  (And **ENDS** @ Step 6)
        int MINLEN = 3 + ((htmlTag == null) ? 1 : htmlTag.length()) + innerTag.length();

        for (int i=l.start; i < l.end; i++)                         // Each loop is **SLIGHTLY** different
            if (    
                    ((n = html.elementAt(i)).isTagNode())           // 1) Only TagNode's, not CommentNode nor TextNode
                &&  ((tn = (TagNode) n).isClosing == false)         // 2) Opening-Tags are the only that have LEGAL-attributes
                &&  (tn.str.length() >= MINLEN)                     // 3) MINLEN is computed above, but basically it's name explains it.
                &&  ((htmlTag == null) || htmlTag.equals(tn.tok))   // 4) Must be the appropriate HTML-Element <DIV..., <IMG..., etc...
                &&  ((itv = tn.AVOPT(innerTag)) != null)            // 5) The TagNode must have the inner-tag asked for in method-signature
                &&  compare.test(itv)                               // 6) Argument-marshalled inner-tag value predicate test!
                &&  (--nth == 0)
            )
                return i;
        return -1;
    }

    public static int NTHFE(Vector<? extends HTMLNode> html, int nth, LV l, String htmlTag, String innerTag, Predicate<String> compare)
    {
        HTMLNode n;     TagNode tn;     String itv;                 // Identical-Code Begins **HERE**  (And **ENDS** @ Step 6)
        int MINLEN = 3 + ((htmlTag == null) ? 1 : htmlTag.length()) + innerTag.length();

        for (int i=l.end-1; i >= l.start; i--)                      // Each loop is **SLIGHTLY** different
            if (    
                    ((n = html.elementAt(i)).isTagNode())           // 1) Only TagNode's, not CommentNode nor TextNode
                &&  ((tn = (TagNode) n).isClosing == false)         // 2) Opening-Tags are the only that have LEGAL-attributes
                &&  (tn.str.length() >= MINLEN)                     // 3) MINLEN is computed above, but basically it's name explains it.
                &&  ((htmlTag == null) || htmlTag.equals(tn.tok))   // 4) Must be the appropriate HTML-Element <DIV..., <IMG..., etc...
                &&  ((itv = tn.AVOPT(innerTag)) != null)            // 5) The TagNode must have the inner-tag asked for in method-signature
                &&  compare.test(itv)                               // 6) Argument-marshalled inner-tag value predicate test!
                &&  (--nth == 0)
            )
                return i;
        return -1;
    }

    public static int[] ALL(Vector<? extends HTMLNode> html, LV l, String htmlTag, String innerTag, Predicate<String> compare)
    {

        IntStream.Builder b = IntStream.builder();
        HTMLNode n;     TagNode tn;     String itv;                 // Identical-Code Begins **HERE**  (And **ENDS** @ Step 6)
        int MINLEN = 3 + ((htmlTag == null) ? 1 : htmlTag.length()) + innerTag.length();

        for (int i=l.start; i < l.end; i++)                         // Each loop is **SLIGHTLY** different
            if (    
                    ((n = html.elementAt(i)).isTagNode())           // 1) Only TagNode's, not CommentNode nor TextNode
                &&  ((tn = (TagNode) n).isClosing == false)         // 2) Opening-Tags are the only that have LEGAL-attributes
                &&  (tn.str.length() >= MINLEN)                     // 3) MINLEN is computed above, but basically it's name explains it.
                &&  ((htmlTag == null) || htmlTag.equals(tn.tok))   // 4) Must be the appropriate HTML-Element <DIV..., <IMG..., etc...
                &&  ((itv = tn.AVOPT(innerTag)) != null)            // 5) The TagNode must have the inner-tag asked for in method-signature
                &&  compare.test(itv)                               // 6) Argument-marshalled inner-tag value predicate test!
            )
                b.add(i);
        return b.build().toArray();
    }

    // *****************************************************************************************************************************
    // MAIN FIND METHODS, PART 2 (Predicate<TagNode> stuff)
    // *****************************************************************************************************************************

    public static int NTH(Vector<? extends HTMLNode> html, int nth, LV l, Predicate<TagNode> p, String... htmlTags)
    {
        HTMLNode n;     TagNode tn;                                 // Identical-Code Begins **HERE**  (And **ENDS** @ Step 3)
        for (int i=l.start; i < l.end; i++)                         // Each loop is **SLIGHTLY** different
            if (
                    ((n = html.elementAt(i)).isTagNode())           // 1) ONLY TESTING TagNode's !!!
                &&  (! (tn = (TagNode) n).isClosing)                // 2) Only Opening Tags are allowed to be tested
                &&  ((htmlTags.length == 0) || tn.isTag(htmlTags))  // 3) Make sure the TOKEN Specifier is accurate
                &&  p.test(tn)                                      // 4) Check the Predicate<TagNode> requirement
                &&  (--nth == 0)
             )
                return i;
        return -1;
    }

    public static int NTHFE(Vector<? extends HTMLNode> html, int nth, LV l, Predicate<TagNode> p, String... htmlTags)
    {
        HTMLNode n;     TagNode tn;                                 // Identical-Code Begins **HERE**  (And **ENDS** @ Step 3)
        for (int i=l.end-1; i >= l.start; i--)                      // Each loop is **SLIGHTLY** different
            if (
                    ((n = html.elementAt(i)).isTagNode())           // 1) ONLY TESTING TagNode's !!!
                &&  (! (tn = (TagNode) n).isClosing)                // 2) Only Opening Tags are allowed to be tested
                &&  ((htmlTags.length == 0) || tn.isTag(htmlTags))  // 3) Make sure the TOKEN Specifier is accurate
                &&  p.test(tn)                                      // 4) Check the Predicate<TagNode> requirement
                &&  (--nth == 0)
            )
                return i;
        return -1;
    }

    public static int[] ALL(Vector<? extends HTMLNode> html, LV l, Predicate<TagNode> p, String... htmlTags)
    {
        IntStream.Builder b = IntStream.builder();
        HTMLNode n;     TagNode tn;                                 // Identical-Code Begins **HERE**  (And **ENDS** @ Step 3)
        for (int i=l.start; i < l.end; i++)                         // Each loop is **SLIGHTLY** different
            if (
                    ((n = html.elementAt(i)).isTagNode())           // 1) ONLY TESTING TagNode's !!!
                &&  (! (tn = (TagNode) n).isClosing)                // 2) Only Opening Tags are allowed to be tested
                &&  ((htmlTags.length == 0) || tn.isTag(htmlTags))  // 3) Make sure the TOKEN Specifier is accurate
                &&  p.test(tn)                                      // 4) Check the Predicate<TagNode> requirement
            )
                b.add(i);
        return b.build().toArray();
    }
}