Class JS


  • public class JS
    extends java.lang.Object
    Java-Script "Similar-Functions" - Documentation.

    This class attempts to mimic the java-scripts methods:

    • getElementsByTagName()
    • getElementsByClassName()
    • getElementById()
    • getElementsByName()

    This class adds many additional versions of these standard Java-Script library methods which assist a programmer to retrieve the vector-index integer-pointer using a 'find' method instead of a 'get' method. The other five versions including count, get, remove, peek, and poll are also included. Below is a table that describes the precise-meaning of the key-words used in these "Extra Java-Script Methods."

    1. Count: This implies that a count of the number of nodes that have matched a specified search criteria shall be computed. Methods named 'Count' will always return single-integers that represent this count.
    2. Find: This implies that integer-arrays, or single-integer are returned by the methods that use this word. These integers are intended to function as pointers into the underlying Java Vector.
    3. Get: This implies that HTMLNode's (TagNode, TextNode) are returned by these Java-Script-like methods. Integer-pointers (a.k.a. the integer-index into the underlying vector) are not returned.
    4. Peek: This implies that BOTH the vector-index AND the HTML node found at-that-integer-index-location are SIMULTANEOUSLY returned by these methods. It is here that these "sort-of" simple and extra data-classes NodeIndex, TagNodeIndex, TextNodeIndex are used. These data-classes are always used as return values for methods with the word "PEEK".
    5. Poll: This refers to the operation of both removing a node from the vectorized-html web-page, and also returning that nodes (or those nodes) back to the programmer as a return value. Remember, for all methods that use the work "POLL" in their name, after a 'poll' operation has completed, the initial vectorized-html itself will contain fewer elements.
    6. Remove: This implies that neither nodes nor node-pointers are returned, but rather in this case - the case where classes use the key-word 'remove' - the nodes themselves are simply removed from the vectorized html-page, and an integer return-value stating clearly exactly how many nodes were removed is returned. Remember, after a 'remove' operation, the initial vectorized-html will contain fewer elements.


    Static (Functional) API: The methods in this class are all (100%) defined with the Java Key-Word / Key-Concept 'static'. Furthermore, there is no way to obtain an instance of this class, because there are no public (nor private) constructors. Java's Spring-Boot, MVC feature is *not* utilized because it flies directly in the face of the light-weight data-classes philosophy. This has many advantages over the rather ornate Component Annotations (@Component, @Service, @AutoWired, etc... 'Java Beans') syntax:

    • The methods here use the key-word 'static' which means (by implication) that there is no internal-state. Without any 'internal state' there is no need for constructors in the first place! (This is often the complaint by MVC Programmers).
    • A 'Static' (Functional-Programming) API expects to use fewer data-classes, and light-weight data-classes, making it easier to understand and to program.
    • The Vectorized HTML data-model allows more user-control over HTML parse, search, update & scrape. Also, memory management, memory leakage, and the Java Garbage Collector ought to be intelligible through the 'reuse' of the standard JDK class Vector for storing HTML Web-Page data.

    The power that object-oriented programming extends to a user is (mostly) limited to data-representation. Thinking of "Services" as "Objects" (Spring-MVC, 'Java Beans') is somewhat 'over-applying' the Object Oriented Programming Model. Like most classes in the Java-HTML JAR Library, this class backtracks to a more C-Styled Functional Programming Model (no Objects) - by re-using (quite profusely) the key-word static with all of its methods, and by sticking to Java's well-understood class Vector

    Internal-State: A user may click on this class' source code (see link below) to view any and all internally defined fields class. A cursory inspection of the code would prove that this class has precisely zero internally defined global fields (Spaghetti). All variables used by the methods in this class are local fields only, and therefore this class ought to be though of as 'state-less'.



    • Method Detail

      • findElementById

        public static int findElementById​(java.util.Vector<HTMLNode> html,
                                          java.lang.String id)
        Java-Script's Element by ID function retrieves all HTML TagNode Elements that have a specified CSS 'ID' Attribute.

        FIND: These operations return the integer Vector-indices which point to nodes in the original html-Vector that match the specified criteria.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        id - This should be a valid HTML 'ID' Attribute-Value (inner-tag value). This is also known as a CSS-Style-Sheet 'ID' Tag.
        Returns:
        The integer vector-index of the first HTML TagNode Element that matches the specified criteria.
        Throws:
        CSSStrException - This exception will throw if the String passed to the 'id' parameter is not a valid CSS 'ID'. Please review the Exception class CSSStrException to see what constitutes a valid CSS 'ID'.
        See Also:
        InnerTagFind
        Code:
        Exact Method Body:
        1
        2
         CSSStrException.check(id);
         return InnerTagFind.first(html, "id", TextComparitor.EQ_CI_TRM, id);
        
      • getElementById

        public static TagNode getElementById​(java.util.Vector<HTMLNode> html,
                                             java.lang.String id)
        Java-Script's Element by ID function retrieves all HTML TagNode Elements that have a specified CSS 'ID' Attribute.

        GET: These operations return the nodes that match the specified criteria.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        id - This should be a valid HTML 'ID' Attribute-Value (inner-tag value). This is also known as a CSS-Style-Sheet 'ID' Tag.
        Returns:
        The first HTML TagNode Element that matches the specified criteria.
        Throws:
        CSSStrException - This exception will throw if the String passed to the 'id' parameter is not a valid CSS 'ID'. Please review the Exception class CSSStrException to see what constitutes a valid CSS 'ID'.
        See Also:
        InnerTagGet
        Code:
        Exact Method Body:
        1
        2
         CSSStrException.check(id);
         return InnerTagGet.first(html, "id", TextComparitor.EQ_CI_TRM, id);
        
      • removeElementById

        public static int removeElementById​(java.util.Vector<HTMLNode> html,
                                            java.lang.String id)
        Java-Script's Element by ID function retrieves all HTML TagNode Elements that have a specified CSS 'ID' Attribute.

        REMOVE: These operations remove the nodes that match the specified criteria, and then, also, return an integer 'count' - informing the user how many nodes were ultimately removed.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        id - This should be a valid HTML 'ID' Attribute-Value (inner-tag value). This is also known as a CSS-Style-Sheet 'ID' Tag.
        Returns:
        The total number of HTML Nodes that were removed from the input-Vector 'html'
        Throws:
        CSSStrException - This exception will throw if the String passed to the 'id' parameter is not a valid CSS 'ID'. Please review the Exception class CSSStrException to see what constitutes a valid CSS 'ID'.
        See Also:
        InnerTagRemove
        Code:
        Exact Method Body:
        1
        2
         CSSStrException.check(id);
         return InnerTagRemove.first(html, "id", TextComparitor.EQ_CI_TRM, id);
        
      • peekElementById

        public static TagNodeIndex peekElementById​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String id)
        
        Java-Script's Element by ID function retrieves all HTML TagNode Elements that have a specified CSS ID Attribute.

        PEEK: The elements / nodes themselves, along with the Vector-indices where they were found / identified are returned, together, as a single data-class Object-instance 'TagNodeIndex'.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        id - This should be a valid HTML 'ID' Attribute-Value (inner-tag value). This is also known as a CSS-Style-Sheet 'ID' Tag.
        Returns:
        A list of all 'TagNode' elements that match the specified input-criteria, along with the Vector-index as an integer included in the 'TagNodeIndex' return-type. class 'TagNodeIndex' includes both the 'TagNode', and the Vector-index from whence it came.
        Throws:
        CSSStrException - This exception will throw if the String passed to the 'id' parameter is not a valid CSS 'ID'. Please review the Exception class CSSStrException to see what constitutes a valid CSS 'ID'.
        See Also:
        InnerTagPeek
        Code:
        Exact Method Body:
        1
        2
         CSSStrException.check(id);
         return InnerTagPeek.first(html, "id", TextComparitor.EQ_CI_TRM, id);
        
      • pollElementById

        public static TagNode pollElementById​(java.util.Vector<HTMLNode> html,
                                              java.lang.String id)
        Java-Script's Element by ID function retrieves all HTML TagNode Elements that have a specified CSS ID Attribute.

        POLL: These operations simply behave like a combination of the 'GET' operation and the 'REMOVE' operation. HTMLNode's are removed, and afterwards, these removed nodes are returned back to the the invoking method.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        id - This should be a valid HTML 'ID' Attribute-Value (inner-tag value). This is also known as a CSS-Style-Sheet 'ID' Tag.
        Returns:
        The first HTML TagNode Element that matches the specified criteria.
        Throws:
        CSSStrException - This exception will throw if the String passed to the 'id' parameter is not a valid CSS 'ID'. Please review the Exception class CSSStrException to see what constitutes a valid CSS 'ID'.
        See Also:
        InnerTagPoll
        Code:
        Exact Method Body:
        1
        2
         CSSStrException.check(id);
         return InnerTagPoll.first(html, "id", TextComparitor.EQ_CI_TRM, id);
        
      • findElementByIdInclusive

        public static DotPair findElementByIdInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String id)
        
        Java-Script's Element by ID function retrieves all HTML TagNode Elements that have a specified CSS ID Attribute.

        FIND: These operations return the integer Vector-indices which point to nodes in the original html-Vector that match the specified criteria.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        id - This should be a valid HTML 'ID' Attribute-Value (inner-tag value). This is also known as a CSS-Style-Sheet 'ID' Tag.
        Returns:
        Integer vector-index pointers, for a sublist, that match the specified input criteria.
        Throws:
        CSSStrException - This exception will throw if the String passed to the 'id' parameter is not a valid CSS 'ID'. Please review the Exception class CSSStrException to see what constitutes a valid CSS 'ID'.
        See Also:
        InnerTagFindInclusive
        Code:
        Exact Method Body:
        1
        2
         CSSStrException.check(id);
         return InnerTagFindInclusive.first  (html, "id", TextComparitor.EQ_CI_TRM, id);
        
      • getElementByIdInclusive

        public static java.util.Vector<HTMLNodegetElementByIdInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String id)
        
        Java-Script's Element by ID function retrieves all HTML TagNode Elements that have a specified CSS ID Attribute.

        GET: These operations return the nodes that match the specified criteria.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        id - This should be a valid HTML 'ID' Attribute-Value (inner-tag value). This is also known as a CSS-Style-Sheet 'ID' Tag.
        Returns:
        The complete sub-list of HTMLNode's that match the specified input criteria.
        Throws:
        CSSStrException - This exception will throw if the String passed to the 'id' parameter is not a valid CSS 'ID'. Please review the Exception class CSSStrException to see what constitutes a valid CSS 'ID'.
        See Also:
        InnerTagGetInclusive
        Code:
        Exact Method Body:
        1
        2
         CSSStrException.check(id);
         return InnerTagGetInclusive.first(html, "id", TextComparitor.EQ_CI_TRM, id);
        
      • removeElementByIdInclusive

        public static int removeElementByIdInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String id)
        
        Java-Script's Element by ID function retrieves all HTML TagNode Elements that have a specified CSS ID Attribute.

        REMOVE: These operations remove the nodes that match the specified criteria, and then, also, return an integer 'count' - informing the user how many nodes were ultimately removed.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        id - This should be a valid HTML 'ID' Attribute-Value (inner-tag value). This is also known as a CSS-Style-Sheet 'ID' Tag.
        Returns:
        The total number of HTML Nodes that were removed from the input-Vector 'html'
        Throws:
        CSSStrException - This exception will throw if the String passed to the 'id' parameter is not a valid CSS 'ID'. Please review the Exception class CSSStrException to see what constitutes a valid CSS 'ID'.
        See Also:
        InnerTagRemoveInclusive
        Code:
        Exact Method Body:
        1
        2
         CSSStrException.check(id);
         return InnerTagRemoveInclusive.first(html, "id", TextComparitor.EQ_CI_TRM, id);
        
      • peekElementByIdInclusive

        public static SubSection peekElementByIdInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String id)
        
        Java-Script's Element by ID function retrieves all HTML TagNode Elements that have a specified CSS ID Attribute.

        PEEK: The elements / nodes themselves, along with the Vector-indices where they were found / identified are returned as a single data-Object simply named 'SubSection.' class SubSection and class TagNodeIndex differ in that instances of class SubSection contain an entire sub-list, while instances of class TagNodeIndex only contain a single node. Both have index & node information encapsulated, together.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        id - This should be a valid HTML 'ID' Attribute-Value (inner-tag value). This is also known as a CSS-Style-Sheet 'ID' Tag.
        Returns:
        Instances of 'SubSection' contain both the html sub-page as a Vector, and the matching 'DotPair' Vector index-pointer from the original Vector from whence they came.
        Throws:
        CSSStrException - This exception will throw if the String passed to the 'id' parameter is not a valid CSS 'ID'. Please review the Exception class CSSStrException to see what constitutes a valid CSS 'ID'.
        See Also:
        InnerTagPeekInclusive
        Code:
        Exact Method Body:
        1
        2
         CSSStrException.check(id);
         return InnerTagPeekInclusive.first(html, "id", TextComparitor.EQ_CI_TRM, id);
        
      • pollElementByIdInclusive

        public static java.util.Vector<HTMLNodepollElementByIdInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String id)
        
        Java-Script's Element by ID function retrieves all HTML TagNode Elements that have a specified CSS 'ID' Attribute.

        POLL: These operations simply behave like a combination of the 'GET' operation and the 'REMOVE' operation. HTMLNode's are removed, and afterwards, these removed nodes are returned back to the the invoking method.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        id - This should be a valid HTML 'ID' Attribute-Value (inner-tag value). This is also known as a CSS-Style-Sheet 'ID' Tag.
        Returns:
        The complete sub-list of HTMLNode's that match the specified input criteria.
        Throws:
        CSSStrException - This exception will throw if the String passed to the 'id' parameter is not a valid CSS 'ID'. Please review the Exception class CSSStrException to see what constitutes a valid CSS 'ID'.
        See Also:
        InnerTagPollInclusive
        Code:
        Exact Method Body:
        1
        2
         CSSStrException.check(id);
         return InnerTagPollInclusive.first(html, "id", TextComparitor.EQ_CI_TRM, id);
        
      • countElementsByTagName

        public static int countElementsByTagName​(java.util.Vector<HTMLNode> html,
                                                 java.lang.String htmlTok)
        Java-Script's Elements by TagName function retrieves all HTML TagNode Elements having a certain "HTML Token." For instance, one could specify all 'div' elements, or all HTML anchor '<A HREF=...>' elements.

        COUNT: These operations return a count on the number of matches of the specified criteria.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        htmlTok - This is an HTML Element Token - also known as "The HTML Element Name." For instance: 'DIV', 'SPAN', 'IMG', etc...
        Returns:
        The number of 'TagNode' elements that match the specified input criteria.
        Throws:
        HTMLTokException - This exception will be thrown by class ARGCHECK if the HTML Element Name provided is not a valid HTML Element.
        See Also:
        TagNodeCount
        Code:
        Exact Method Body:
        1
         return TagNodeCount.all(html, TC.OpeningTags, htmlTok);
        
      • findElementsByTagName

        public static int[] findElementsByTagName​(java.util.Vector<HTMLNode> html,
                                                  java.lang.String htmlTok)
        Java-Script's Elements by TagName function retrieves all HTML TagNode Elements having a certain "HTML Token." For instance, one could specify all 'div' elements, or all HTML anchor '<A HREF=...>' elements.

        FIND: These operations return the integer Vector-indices which point to nodes in the original html-Vector that match the specified criteria.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        htmlTok - This is an HTML Element Token - also known as "The HTML Element Name." For instance: 'DIV', 'SPAN', 'IMG', etc...
        Returns:
        A list of integer vector-index pointers into the input vector parameter 'html.'
        Throws:
        HTMLTokException - This exception will be thrown by class ARGCHECK if the HTML Element Name provided is not a valid HTML Element.
        See Also:
        TagNodeFind
        Code:
        Exact Method Body:
        1
         return TagNodeFind.all(html, TC.OpeningTags, htmlTok);
        
      • getElementsByTagName

        public static java.util.Vector<TagNodegetElementsByTagName​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String htmlTok)
        
        Java-Script's Elements by TagName function retrieves all HTML TagNode Elements having a certain "HTML Token." For instance, one could specify all 'div' elements, or all HTML anchor '<A HREF=...>' elements.

        GET: These operations return the nodes that match the specified criteria.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        htmlTok - This is an HTML Element Token - also known as "The HTML Element Name." For instance: 'DIV', 'SPAN', 'IMG', etc...
        Returns:
        A list of all 'TagNode' elements that match the specified input-criteria.
        Throws:
        HTMLTokException - This exception will be thrown by class ARGCHECK if the HTML Element Name provided is not a valid HTML Element.
        See Also:
        TagNodeGet
        Code:
        Exact Method Body:
        1
         return TagNodeGet.all(html, TC.OpeningTags, htmlTok);
        
      • removeElementsByTagName

        public static int removeElementsByTagName​(java.util.Vector<HTMLNode> html,
                                                  java.lang.String htmlTok)
        Java-Script's Elements by TagName function retrieves all HTML TagNode Elements having a certain "HTML Token." For instance, one could specify all 'div' elements, or all HTML anchor '<A HREF=...>' elements.

        REMOVE: These operations remove the nodes that match the specified criteria, and then, also, return an integer 'count' - informing the user how many nodes were ultimately removed.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        htmlTok - This is an HTML Element Token - also known as "The HTML Element Name." For instance: 'DIV', 'SPAN', 'IMG', etc...
        Returns:
        The total number of HTML Nodes that were removed from the input-Vector 'html'
        Throws:
        HTMLTokException - This exception will be thrown by class ARGCHECK if the HTML Element Name provided is not a valid HTML Element.
        See Also:
        TagNodeRemove
        Code:
        Exact Method Body:
        1
         return TagNodeRemove.all(html, TC.OpeningTags, htmlTok);
        
      • peekElementsByTagName

        public static java.util.Vector<TagNodeIndexpeekElementsByTagName​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String htmlTok)
        
        Java-Script's Elements by TagName function retrieves all HTML TagNode Elements having a certain "HTML Token." For instance, one could specify all 'div' elements, or all HTML anchor '<A HREF=...>' elements.

        PEEK: The elements / nodes themselves, along with the Vector-indices where they were found / identified are returned, together, as a single data-class Object-instance 'TagNodeIndex'.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        htmlTok - This is an HTML Element Token - also known as "The HTML Element Name." For instance: 'DIV', 'SPAN', 'IMG', etc...
        Returns:
        A list of all 'TagNode' elements that match the specified input-criteria, along with the Vector-index as an integer included in the 'TagNodeIndex' return-type. class 'TagNodeIndex' includes both the 'TagNode', and the Vector-index from whence it came.
        Throws:
        HTMLTokException - This exception will be thrown by class ARGCHECK if the HTML Element Name provided is not a valid HTML Element.
        See Also:
        TagNodePeek
        Code:
        Exact Method Body:
        1
         return TagNodePeek.all(html, TC.OpeningTags, htmlTok);
        
      • pollElementsByTagName

        public static java.util.Vector<TagNodepollElementsByTagName​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String htmlTok)
        
        Java-Script's Elements by TagName function retrieves all HTML TagNode Elements having a certain "HTML Token." For instance, one could specify all 'div' elements, or all HTML anchor '<A HREF=...>' elements.

        POLL: These operations simply behave like a combination of the 'GET' operation and the 'REMOVE' operation. HTMLNode's are removed, and afterwards, these removed nodes are returned back to the the invoking method.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        htmlTok - This is an HTML Element Token - also known as "The HTML Element Name." For instance: 'DIV', 'SPAN', 'IMG', etc...
        Returns:
        A list of all 'TagNode' elements that match the specified input-criteria.
        Throws:
        HTMLTokException - This exception will be thrown by class ARGCHECK if the HTML Element Name provided is not a valid HTML Element.
        See Also:
        TagNodePoll
        Code:
        Exact Method Body:
        1
         return TagNodePoll.all(html, TC.OpeningTags, htmlTok);
        
      • findElementsByTagNameInclusive

        public static java.util.Vector<DotPairfindElementsByTagNameInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String htmlTok)
        
        Java-Script's Elements by TagName function retrieves all HTML TagNode Elements having a certain "HTML Token." For instance, one could specify all 'div' elements, or all HTML anchor '<A HREF=...>' elements.

        FIND: These operations return the integer Vector-indices which point to nodes in the original html-Vector that match the specified criteria.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        htmlTok - This is an HTML Element Token - also known as "The HTML Element Name." For instance: 'DIV', 'SPAN', 'IMG', etc...
        Returns:
        A "list of lists" where each DotPair element contains the starting and ending index-pointers (as integers, wrapped in a 'DotPair' instance) for each match of the input parameter criteria-specifications.
        Throws:
        HTMLTokException - This exception will be thrown by class ARGCHECK if the HTML Element Name provided is not a valid HTML Element.
        See Also:
        TagNodeFindInclusive
        Code:
        Exact Method Body:
        1
         return TagNodeFindInclusive.all(html, htmlTok);
        
      • getElementsByTagNameInclusive

        public static java.util.Vector<java.util.Vector<HTMLNode>> getElementsByTagNameInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String htmlTok)
        
        Java-Script's Elements by TagName function retrieves all HTML TagNode Elements having a certain "HTML Token." For instance, one could specify all 'div' elements, or all HTML anchor '<A HREF=...>' elements.

        GET: These operations return the nodes that match the specified criteria.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        htmlTok - This is an HTML Element Token - also known as "The HTML Element Name." For instance: 'DIV', 'SPAN', 'IMG', etc...
        Returns:
        A "list of lists" for each opening and closing HTML Element match.
        Throws:
        HTMLTokException - This exception will be thrown by class ARGCHECK if the HTML Element Name provided is not a valid HTML Element.
        See Also:
        TagNodeGetInclusive
        Code:
        Exact Method Body:
        1
         return TagNodeGetInclusive.all(html, htmlTok);
        
      • removeElementsByTagNameInclusive

        public static int removeElementsByTagNameInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String htmlTok)
        
        Java-Script's Elements by TagName function retrieves all HTML TagNode Elements having a certain "HTML Token." For instance, one could specify all 'div' elements, or all HTML anchor '<A HREF=...>' elements.

        REMOVE: These operations remove the nodes that match the specified criteria, and then, also, return an integer 'count' - informing the user how many nodes were ultimately removed.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        htmlTok - This is an HTML Element Token - also known as "The HTML Element Name." For instance: 'DIV', 'SPAN', 'IMG', etc...
        Returns:
        The total number of HTML Nodes that were removed from the input-Vector 'html'
        Throws:
        HTMLTokException - This exception will be thrown by class ARGCHECK if the HTML Element Name provided is not a valid HTML Element.
        See Also:
        TagNodeRemoveInclusive
        Code:
        Exact Method Body:
        1
         return TagNodeRemoveInclusive.all(html, htmlTok);
        
      • peekElementsByTagNameInclusive

        public static java.util.Vector<SubSectionpeekElementsByTagNameInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String htmlTok)
        
        Java-Script's Elements by TagName function retrieves all HTML TagNode Elements having a certain "HTML Token." For instance, one could specify all 'div' elements, or all HTML anchor '<A HREF=...>' elements.

        PEEK: The elements / nodes themselves, along with the Vector-indices where they were found / identified are returned as a single data-Object simply named 'SubSection.' class SubSection and class TagNodeIndex differ in that instances of class SubSection contain an entire sub-list, while instances of class TagNodeIndex only contain a single node. Both have index & node information encapsulated, together.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        htmlTok - This is an HTML Element Token - also known as "The HTML Element Name." For instance: 'DIV', 'SPAN', 'IMG', etc...
        Returns:
        A "list of lists" for each opening and closing HTML Element match. Instances of 'SubSection' contain both the html sub-page as a Vector, and the matching 'DotPair' Vector index-pointer from the original Vector from whence they came.
        Throws:
        HTMLTokException - This exception will be thrown by class ARGCHECK if the HTML Element Name provided is not a valid HTML Element.
        See Also:
        TagNodePeekInclusive
        Code:
        Exact Method Body:
        1
         return TagNodePeekInclusive.all(html, htmlTok);
        
      • pollElementsByTagNameInclusive

        public static java.util.Vector<java.util.Vector<HTMLNode>> pollElementsByTagNameInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String htmlTok)
        
        Java-Script's Elements by TagName function retrieves all HTML TagNode Elements having a certain "HTML Token." For instance, one could specify all 'div' elements, or all HTML anchor '<A HREF=...>' elements.

        POLL: These operations simply behave like a combination of the 'GET' operation and the 'REMOVE' operation. HTMLNode's are removed, and afterwards, these removed nodes are returned back to the the invoking method.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        htmlTok - This is an HTML Element Token - also known as "The HTML Element Name." For instance: 'DIV', 'SPAN', 'IMG', etc...
        Returns:
        A "list of lists" for each opening and closing HTML Element match.
        Throws:
        HTMLTokException - This exception will be thrown by class ARGCHECK if the HTML Element Name provided is not a valid HTML Element.
        See Also:
        TagNodePollInclusive
        Code:
        Exact Method Body:
        1
         return TagNodePollInclusive.all(html, htmlTok);
        
      • countElementsByClassName

        public static int countElementsByClassName​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String className)
        
        Java-Script's Elements by Class Name function retrieves all HTML TagNode Elements that match a specified CSS 'CLASS'.

        COUNT: These operations return a count on the number of matches of the specified criteria.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        className - This should be a valid HTML CSS 'CLASS' Attribute-Value (inner-tag value).
        Returns:
        The number of 'TagNode' elements that match the specified input criteria.
        Throws:
        CSSStrException - Whenever the TextComparitor's for CSS 'Classes' are used, passed or invoked, the 'class-name', or list of class-name's (as String's) provided to the TextComparitor will be checked for validity according to CSS naming conventions. If parameter 'className' does not meet the strict requirements for CSS Class-Names, this exception will throw immediately.
        See Also:
        InnerTagCount
        Code:
        Exact Method Body:
        1
         return InnerTagCount.all(html, "class", TextComparitor.C, className);
        
      • findElementsByClassName

        public static int[] findElementsByClassName​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String className)
        
        Java-Script's Elements by Class Name function retrieves all HTML TagNode Elements that match a specified CSS 'CLASS'.

        FIND: These operations return the integer Vector-indices which point to nodes in the original html-Vector that match the specified criteria.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        className - This should be a valid HTML CSS 'CLASS' Attribute-Value (inner-tag value).
        Returns:
        A list of integer vector-index pointers into the input vector parameter 'html.'
        Throws:
        CSSStrException - Whenever the TextComparitor's for CSS 'Classes' are used, passed or invoked, the 'class-name', or list of class-name's (as String's) provided to the TextComparitor will be checked for validity according to CSS naming conventions. If parameter 'className' does not meet the strict requirements for CSS Class-Names, this exception will throw immediately.
        See Also:
        InnerTagFind
        Code:
        Exact Method Body:
        1
         return InnerTagFind.all(html, "class", TextComparitor.C, className);
        
      • getElementsByClassName

        public static java.util.Vector<TagNodegetElementsByClassName​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String className)
        
        Java-Script's Elements by Class Name function retrieves all HTML TagNode Elements that match a specified CSS 'CLASS'.

        GET: These operations return the nodes that match the specified criteria.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        className - This should be a valid HTML CSS 'CLASS' Attribute-Value (inner-tag value).
        Returns:
        A list of all 'TagNode' elements that match the specified input-criteria.
        Throws:
        CSSStrException - Whenever the TextComparitor's for CSS 'Classes' are used, passed or invoked, the 'class-name', or list of class-name's (as String's) provided to the TextComparitor will be checked for validity according to CSS naming conventions. If parameter 'className' does not meet the strict requirements for CSS Class-Names, this exception will throw immediately.
        See Also:
        InnerTagGet
        Code:
        Exact Method Body:
        1
         return InnerTagGet.all(html, "class", TextComparitor.C, className);
        
      • removeElementsByClassName

        public static int removeElementsByClassName​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String className)
        
        Java-Script's Elements by Class Name function retrieves all HTML TagNode Elements that match a specified CSS 'CLASS'.

        REMOVE: These operations remove the nodes that match the specified criteria, and then, also, return an integer 'count' - informing the user how many nodes were ultimately removed.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        className - This should be a valid HTML CSS 'CLASS' Attribute-Value (inner-tag value).
        Returns:
        The total number of HTML Nodes that were removed from the input-Vector 'html'
        Throws:
        CSSStrException - Whenever the TextComparitor's for CSS 'Classes' are used, passed or invoked, the 'class-name', or list of class-name's (as String's) provided to the TextComparitor will be checked for validity according to CSS naming conventions. If parameter 'className' does not meet the strict requirements for CSS Class-Names, this exception will throw immediately.
        See Also:
        InnerTagRemove
        Code:
        Exact Method Body:
        1
         return InnerTagRemove.all(html, "class", TextComparitor.C, className);
        
      • peekElementsByClassName

        public static java.util.Vector<TagNodeIndexpeekElementsByClassName​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String className)
        
        Java-Script's Elements by Class Name function retrieves all HTML TagNode Elements that match a specified CSS 'CLASS'.

        PEEK: The elements / nodes themselves, along with the Vector-indices where they were found / identified are returned, together, as a single data-class Object-instance 'TagNodeIndex'.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        className - This should be a valid HTML CSS 'CLASS' Attribute-Value (inner-tag value).
        Returns:
        A list of all 'TagNode' elements that match the specified input-criteria, along with the Vector-index as an integer included in the 'TagNodeIndex' return-type. class 'TagNodeIndex' includes both the 'TagNode', and the Vector-index from whence it came.
        Throws:
        CSSStrException - Whenever the TextComparitor's for CSS 'Classes' are used, passed or invoked, the 'class-name', or list of class-name's (as String's) provided to the TextComparitor will be checked for validity according to CSS naming conventions. If parameter 'className' does not meet the strict requirements for CSS Class-Names, this exception will throw immediately.
        See Also:
        InnerTagPeek
        Code:
        Exact Method Body:
        1
         return InnerTagPeek.all(html, "class", TextComparitor.C, className);
        
      • pollElementsByClassName

        public static java.util.Vector<TagNodepollElementsByClassName​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String className)
        
        Java-Script's Elements by Class Name function retrieves all HTML TagNode Elements that match a specified CSS 'CLASS'.

        POLL: These operations simply behave like a combination of the 'GET' operation and the 'REMOVE' operation. HTMLNode's are removed, and afterwards, these removed nodes are returned back to the the invoking method.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        className - This should be a valid HTML CSS 'CLASS' Attribute-Value (inner-tag value).
        Returns:
        A list of all 'TagNode' elements that match the specified input-criteria.
        Throws:
        CSSStrException - Whenever the TextComparitor's for CSS 'Classes' are used, passed or invoked, the 'class-name', or list of class-name's (as String's) provided to the TextComparitor will be checked for validity according to CSS naming conventions. If parameter 'className' does not meet the strict requirements for CSS Class-Names, this exception will throw immediately.
        See Also:
        InnerTagPoll
        Code:
        Exact Method Body:
        1
         return InnerTagPoll.all(html, "class", TextComparitor.C, className);
        
      • findElementsByClassNameInclusive

        public static java.util.Vector<DotPairfindElementsByClassNameInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String className)
        
        Java-Script's Elements by Class Name function retrieves all HTML TagNode Elements that match a specified CSS 'CLASS'.

        FIND: These operations return the integer Vector-indices which point to nodes in the original html-Vector that match the specified criteria.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        className - This should be a valid HTML CSS 'CLASS' Attribute-Value (inner-tag value).
        Returns:
        A "list of lists" where each DotPair element contains the starting and ending index-pointers (as integers, wrapped in a 'DotPair' instance) for each match of the input parameter criteria-specifications.
        Throws:
        CSSStrException - Whenever the TextComparitor's for CSS 'Classes' are used, passed or invoked, the 'class-name', or list of class-name's (as String's) provided to the TextComparitor will be checked for validity according to CSS naming conventions. If parameter 'className' does not meet the strict requirements for CSS Class-Names, this exception will throw immediately.
        See Also:
        InnerTagFindInclusive
        Code:
        Exact Method Body:
        1
         return InnerTagFindInclusive.all(html, "class", TextComparitor.C, className);
        
      • getElementsByClassNameInclusive

        public static java.util.Vector<java.util.Vector<HTMLNode>> getElementsByClassNameInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String className)
        
        Java-Script's Elements by Class Name function retrieves all HTML TagNode Elements that match a specified CSS 'CLASS'.

        GET: These operations return the nodes that match the specified criteria.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        className - This should be a valid HTML CSS 'CLASS' Attribute-Value (inner-tag value).
        Returns:
        A "list of lists" for each opening and closing HTML Element match.
        Throws:
        CSSStrException - Whenever the TextComparitor's for CSS 'Classes' are used, passed or invoked, the 'class-name', or list of class-name's (as String's) provided to the TextComparitor will be checked for validity according to CSS naming conventions. If parameter 'className' does not meet the strict requirements for CSS Class-Names, this exception will throw immediately.
        See Also:
        InnerTagGetInclusive
        Code:
        Exact Method Body:
        1
         return InnerTagGetInclusive.all(html, "class", TextComparitor.C, className);
        
      • removeElementsByClassNameInclusive

        public static int removeElementsByClassNameInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String className)
        
        Java-Script's Elements by Class Name function retrieves all HTML TagNode Elements that match a specified CSS 'CLASS'.

        REMOVE: These operations remove the nodes that match the specified criteria, and then, also, return an integer 'count' - informing the user how many nodes were ultimately removed.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        className - This should be a valid HTML CSS 'CLASS' Attribute-Value (inner-tag value).
        Returns:
        The total number of HTML Nodes that were removed from the input-Vector 'html'
        Throws:
        CSSStrException - Whenever the TextComparitor's for CSS 'Classes' are used, passed or invoked, the 'class-name', or list of class-name's (as String's) provided to the TextComparitor will be checked for validity according to CSS naming conventions. If parameter 'className' does not meet the strict requirements for CSS Class-Names, this exception will throw immediately.
        See Also:
        InnerTagRemoveInclusive
        Code:
        Exact Method Body:
        1
         return InnerTagRemoveInclusive.all(html, "class", TextComparitor.C, className);
        
      • peekElementsByClassNameInclusive

        public static java.util.Vector<SubSectionpeekElementsByClassNameInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String className)
        
        Java-Script's Elements by Class Name function retrieves all HTML TagNode Elements that match a specified CSS 'CLASS'.

        PEEK: The elements / nodes themselves, along with the Vector-indices where they were found / identified are returned as a single data-Object simply named 'SubSection.' class SubSection and class TagNodeIndex differ in that instances of class SubSection contain an entire sub-list, while instances of class TagNodeIndex only contain a single node. Both have index & node information encapsulated, together.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        className - This should be a valid HTML CSS 'CLASS' Attribute-Value (inner-tag value).
        Returns:
        A "list of lists" for each opening and closing HTML Element match. Instances of "SubSection" contain both the html sub-page as a vector, and the matching DotPair Vector index-pointer from the original Vector from whence they came.
        Throws:
        CSSStrException - Whenever the TextComparitor's for CSS 'Classes' are used, passed or invoked, the 'class-name', or list of class-name's (as String's) provided to the TextComparitor will be checked for validity according to CSS naming conventions. If parameter 'className' does not meet the strict requirements for CSS Class-Names, this exception will throw immediately.
        See Also:
        InnerTagPeekInclusive
        Code:
        Exact Method Body:
        1
         return InnerTagPeekInclusive.all(html, "class", TextComparitor.C, className);
        
      • pollElementsByClassNameInclusive

        public static java.util.Vector<java.util.Vector<HTMLNode>> pollElementsByClassNameInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String className)
        
        Java-Script's Elements by Class Name function retrieves all HTML TagNode Elements that match a specified CSS 'CLASS'.

        POLL: These operations simply behave like a combination of the 'GET' operation and the 'REMOVE' operation. HTMLNode's are removed, and afterwards, these removed nodes are returned back to the the invoking method.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        className - This should be a valid HTML CSS 'CLASS' Attribute-Value (inner-tag value).
        Returns:
        A "list of lists" for each opening and closing HTML Element match.
        Throws:
        CSSStrException - Whenever the TextComparitor's for CSS 'Classes' are used, passed or invoked, the 'class-name', or list of class-name's (as String's) provided to the TextComparitor will be checked for validity according to CSS naming conventions. If parameter 'className' does not meet the strict requirements for CSS Class-Names, this exception will throw immediately.
        See Also:
        InnerTagPollInclusive
        Code:
        Exact Method Body:
        1
         return InnerTagPollInclusive.all(html, "class", TextComparitor.C, className);
        
      • countElementsByName

        public static int countElementsByName​(java.util.Vector<HTMLNode> html,
                                              java.lang.String name)
        Java-Script's Elements by Name function retrieves all HTML Elements whose 'NAME' attribute matches the specified String name parameter.

        COUNT: These operations return a count on the number of matches of the specified criteria.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        name - This should be a valid HTML 'NAME' Attribute- Value (inner-tag value). This a "pre-HTML-5" used tag, that has been largely deprecated, and subsequently replaced by the 'ID' and 'CLASS' CSS-Attributes.
        Returns:
        The number of 'TagNode' elements that match the specified input criteria.
        See Also:
        InnerTagCount
        Code:
        Exact Method Body:
        1
         return InnerTagCount.all(html, "name", TextComparitor.EQ_CI_TRM, name);
        
      • findElementsByName

        public static int[] findElementsByName​(java.util.Vector<HTMLNode> html,
                                               java.lang.String name)
        Java-Script's Elements by Name function retrieves all HTML Elements whose 'NAME' attribute matches the specified String name parameter.

        FIND: These operations return the integer Vector-indices which point to nodes in the original html-Vector that match the specified criteria.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        name - This should be a valid HTML 'NAME' Attribute- Value (inner-tag value). This a "pre-HTML-5" used tag, that has been largely deprecated, and subsequently replaced by the 'ID' and 'CLASS' CSS-Attributes.
        Returns:
        A list of integer vector-index pointers into the input vector parameter 'html.'
        See Also:
        InnerTagFind
        Code:
        Exact Method Body:
        1
         return InnerTagFind.all(html, "name", TextComparitor.EQ_CI_TRM, name);
        
      • getElementsByName

        public static java.util.Vector<TagNodegetElementsByName​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String name)
        
        Java-Script's Elements by Name function retrieves all HTML Elements whose 'NAME' attribute matches the specified String name parameter.

        GET: These operations return the nodes that match the specified criteria.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        name - This should be a valid HTML 'NAME' Attribute- Value (inner-tag value). This a "pre-HTML-5" used tag, that has been largely deprecated, and subsequently replaced by the 'ID' and 'CLASS' CSS-Attributes.
        Returns:
        A list of all 'TagNode' elements that match the specified input-criteria.
        See Also:
        InnerTagGet
        Code:
        Exact Method Body:
        1
         return InnerTagGet.all(html, "name", TextComparitor.EQ_CI_TRM, name);
        
      • removeElementsByName

        public static int removeElementsByName​(java.util.Vector<HTMLNode> html,
                                               java.lang.String name)
        Java-Script's Elements by Name function retrieves all HTML Elements whose 'NAME' attribute matches the specified String name parameter.

        REMOVE: These operations remove the nodes that match the specified criteria, and then, also, return an integer 'count' - informing the user how many nodes were ultimately removed.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        name - This should be a valid HTML 'NAME' Attribute- Value (inner-tag value). This a "pre-HTML-5" used tag, that has been largely deprecated, and subsequently replaced by the 'ID' and 'CLASS' CSS-Attributes.
        Returns:
        The total number of HTML Nodes that were removed from the input-Vector 'html'
        See Also:
        InnerTagRemove
        Code:
        Exact Method Body:
        1
         return InnerTagRemove.all(html, "name", TextComparitor.EQ_CI_TRM, name);
        
      • peekElementsByName

        public static java.util.Vector<TagNodeIndexpeekElementsByName​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String name)
        
        Java-Script's Elements by Name function retrieves all HTML Elements whose 'NAME' attribute matches the specified String name parameter.

        PEEK: The elements / nodes themselves, along with the Vector-indices where they were found / identified are returned, together, as a single data-class Object-instance 'TagNodeIndex'.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        name - This should be a valid HTML 'NAME' Attribute- Value (inner-tag value). This a "pre-HTML-5" used tag, that has been largely deprecated, and subsequently replaced by the 'ID' and 'CLASS' CSS-Attributes.
        Returns:
        A list of all 'TagNode' elements that match the specified input-criteria, along with the Vector-index as an integer included in the 'TagNodeIndex' return-type. class 'TagNodeIndex' includes both the 'TagNode', and the Vector-index from whence it came.
        See Also:
        InnerTagPeek
        Code:
        Exact Method Body:
        1
         return InnerTagPeek.all(html, "name", TextComparitor.EQ_CI_TRM, name);
        
      • pollElementsByName

        public static java.util.Vector<TagNodepollElementsByName​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String name)
        
        Java-Script's Elements by Name function retrieves all HTML Elements whose 'NAME' attribute matches the specified String name parameter.

        POLL: These operations simply behave like a combination of the 'GET' operation and the 'REMOVE' operation. HTMLNode's are removed, and afterwards, these removed nodes are returned back to the the invoking method.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        name - This should be a valid HTML 'NAME' Attribute- Value (inner-tag value). This a "pre-HTML-5" used tag, that has been largely deprecated, and subsequently replaced by the 'ID' and 'CLASS' CSS-Attributes.
        Returns:
        A list of all 'TagNode' elements that match the specified input-criteria.
        See Also:
        InnerTagPoll
        Code:
        Exact Method Body:
        1
         return InnerTagPoll.all(html, "name", TextComparitor.EQ_CI_TRM, name);
        
      • findElementsByNameInclusive

        public static java.util.Vector<DotPairfindElementsByNameInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String name)
        
        Java-Script's Elements by Name function retrieves all HTML Elements whose 'NAME' attribute matches the specified String name parameter.

        FIND: These operations return the integer Vector-indices which point to nodes in the original html-Vector that match the specified criteria.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        name - This should be a valid HTML 'NAME' Attribute- Value (inner-tag value). This a "pre-HTML-5" used tag, that has been largely deprecated, and subsequently replaced by the 'ID' and 'CLASS' CSS-Attributes.
        Returns:
        A "list of lists" where each DotPair element contains the starting and ending index-pointers (as integers, wrapped in a 'DotPair' instance) for each match of the input parameter criteria-specifications.
        See Also:
        InnerTagFindInclusive
        Code:
        Exact Method Body:
        1
         return InnerTagFindInclusive.all(html, "name", TextComparitor.EQ_CI_TRM, name);
        
      • getElementsByNameInclusive

        public static java.util.Vector<java.util.Vector<HTMLNode>> getElementsByNameInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String name)
        
        Java-Script's Elements by Name function retrieves all HTML Elements whose 'NAME' attribute matches the specified String name parameter.

        GET: These operations return the nodes that match the specified criteria.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        name - This should be a valid HTML 'NAME' Attribute- Value (inner-tag value). This a "pre-HTML-5" used tag, that has been largely deprecated, and subsequently replaced by the 'ID' and 'CLASS' CSS-Attributes.
        Returns:
        A "list of lists" for each opening and closing HTML Element match.
        See Also:
        InnerTagGetInclusive
        Code:
        Exact Method Body:
        1
         return InnerTagGetInclusive.all(html, "name", TextComparitor.EQ_CI_TRM, name);
        
      • removeElementsByNameInclusive

        public static int removeElementsByNameInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String name)
        
        Java-Script's Elements by Name function retrieves all HTML Elements whose 'NAME' attribute matches the specified String name parameter.

        REMOVE: These operations remove the nodes that match the specified criteria, and then, also, return an integer 'count' - informing the user how many nodes were ultimately removed.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        name - This should be a valid HTML 'NAME' Attribute- Value (inner-tag value). This a "pre-HTML-5" used tag, that has been largely deprecated, and subsequently replaced by the 'ID' and 'CLASS' CSS-Attributes.
        Returns:
        The total number of HTML Nodes that were removed from the input-Vector 'html'
        See Also:
        InnerTagRemoveInclusive
        Code:
        Exact Method Body:
        1
         return InnerTagRemoveInclusive.all(html, "name", TextComparitor.EQ_CI_TRM, name);
        
      • peekElementsByNameInclusive

        public static java.util.Vector<SubSectionpeekElementsByNameInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String name)
        
        Java-Script's Elements by Name function retrieves all HTML Elements whose 'NAME' attribute matches the specified String name parameter.

        PEEK: The elements / nodes themselves, along with the Vector-indices where they were found / identified are returned as a single data-Object simply named 'SubSection.' class SubSection and class TagNodeIndex differ in that instances of class SubSection contain an entire sub-list, while instances of class TagNodeIndex only contain a single node. Both have index & node information encapsulated, together.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        name - This should be a valid HTML 'NAME' Attribute- Value (inner-tag value). This a "pre-HTML-5" used tag, that has been largely deprecated, and subsequently replaced by the 'ID' and 'CLASS' CSS-Attributes.
        Returns:
        A "list of lists" for each opening and closing HTML Element match. Instances of 'SubSection' contain both the html sub-page as a Vector, and the matching 'DotPair' Vector index-pointer from the original Vector from whence they came.
        See Also:
        InnerTagPeekInclusive
        Code:
        Exact Method Body:
        1
         return InnerTagPeekInclusive.all(html, "name", TextComparitor.EQ_CI_TRM, name);
        
      • pollElementsByNameInclusive

        public static java.util.Vector<java.util.Vector<HTMLNode>> pollElementsByNameInclusive​
                    (java.util.Vector<HTMLNode> html,
                     java.lang.String name)
        
        Java-Script's Elements by Name function retrieves all HTML Elements whose 'NAME' attribute matches the specified String name parameter.

        POLL: These operations simply behave like a combination of the 'GET' operation and the 'REMOVE' operation. HTMLNode's are removed, and afterwards, these removed nodes are returned back to the the invoking method.

        INCLUSIVE: In this html search library, all the word 'inclusive' means, is that when an opening TagNode is found by an 'inclusive method', before returning that node, the matching, and closing pair of that TagNode, along with all HTMLNode's in-between, are included in the result. This, effectively, means these methods will all return either a complete vectorized-html sublist, or a 'DotPair' (instead) start-index and end-index demarcating a sublist. For instance, an HTML divider-element like <DIV class=someClass ...> ... </DIV> as an 'inclusive return-value' might have many HTMLNode's in this list.
        Parameters:
        html - This may be any vectorized-html page, or sub-page.
        name - This should be a valid HTML 'NAME' Attribute- Value (inner-tag value). This a "pre-HTML-5" used tag, that has been largely deprecated, and subsequently replaced by the 'ID' and 'CLASS' CSS-Attributes.
        Returns:
        A "list of lists" for each opening and closing HTML Element match.
        See Also:
        InnerTagPollInclusive
        Code:
        Exact Method Body:
        1
         return InnerTagPollInclusive.all(html, "name", TextComparitor.EQ_CI_TRM, name);