Class Details


  • public class Details
    extends java.lang.Object
    Details Class Documentation.

    This class helps parse the "Details Section" of JavaDoc Generated Web-Page ('.html file') for any class, interface, or enumerated-type.

    HTML Elements:
    1
    2
    3
    4
    5
    6
    7
    8
    <div class="details">
    
    <!-- All 'details' sections (fields, methods, constructors - but not inner-classes) of
         the Java-Doc detailed-descriptions are here - wrapped inside of an HTML Divider 
         Element whose class name is class='details'
    -->
    
    </div>
    

    The above html-divider has these three sections:

    HTML Elements:
     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
    <!-- The HTML below has been copied from a typical JavaDoc Generated Class HTML
         Documentation Page.  These "Sub-Sections" are all provided as readable HTML
         to programmers who use JavaDoc files on the Internet to learn about a Java
         Package.  This section contains the specific and detail information that a 
         programmer has left for the JavaDoc Utility inside of his/her code.  These
         are the detailed information sections - not the summaries - and any only
         contain three sections: methods, constructors, and fields.  Nested Classes
         are given their own HTML page.
    -->
    
    <div class="details">
    <ul class="blockList">
    <li class="blockList">
    <!-- ============ FIELD DETAIL =========== -->
    <ul class="blockList">
    <li class="blockList"><a name="field.detail">
    <!--   -->
    </a>
    <h3>Field Detail</h3>
    ...
    <h4>Field-Here...</h4>
    ... 
    </ul>
    <!-- ========= CONSTRUCTOR DETAIL ======== -->
    <ul class="blockList">
    <li class="blockList"><a name="constructor.detail">
    <!--   -->
    </a>
    <h3>Constructor Detail</h3>
    ...
    <h4>Constructor-Here...</h4>
    ...
    </ul>
    </ul>
    <!-- ============ METHOD DETAIL ========== -->
    <ul class="blockList">
    <li class="blockList"><a name="method.detail">
    <!--   -->
    </a>
    <h3>Method Detail</h3>
    ...
    <h4>Method-Here</h4>
    ...
    



    • Field Detail

      • errorMsg1

        protected static final java.lang.String errorMsg1
        When a JavaDocError is thrown looking for a Details Section, this message shall be produced. JavaDoc will always produce a details section - however there have been (some, not many) situations where the output HTML was not properly formatted. This can be remedied, but it is advisable to inspect what has caused the problem, and repair the HTML first.

        NOTE: This particular error message is used only when the CommentNode that looks like below is missing:
        '========= FIELD DETAIL =========='

        NOTE:

        • TOK1 will be replaced by the word: Field, Constructor or Method.

        • TOK2 will be replaced by the word: FIELD, CONSTRUCTOR or METHOD.
        See Also:
        Constant Field Values
        Code:
        Exact Field Declaration Expression:
        1
        2
        3
        4
        5
        protected static final String errorMsg1 =
                "Could not find a TOK1 Details Section in this JavaDoc Page.  " +
                "Returned DotPair would be null.  JavaDoc Class HTML Page did not have " +
                "a CommentNode whose body contained sub-string '======= TOK2 DETAIL ======='.  " +
                "Java Error.";
        
      • errorMsg2

        protected static final java.lang.String errorMsg2
        When a JavaDocError is thrown looking for a Details Section, this message shall be produced. JavaDoc will always produce a details section - however there have been (some, not many) situations where the output HTML was not properly formatted. This can be remedied, but it is advisable to inspect what has caused the problem, and repair the HTML first. There are also occasions when a class does not have have Field's, or Constructor's - or possibly even Method's.

        NOTE: This particular error message is used only when the following Unordered list seems to be missing. This should not happen, but this is used with an instance of the 'Error' Throwable.

        NOTE: TOK will be replaced by the word: Field, Constructor or Method.
        See Also:
        Constant Field Values
        Code:
        Exact Field Declaration Expression:
        1
        2
        3
        4
        protected static final String errorMsg2 =
                "Could not find a TOK Details Section in this JavaDoc Page.  " +
                "Returned DotPair would be null.  JavaDoc Class HTML Page did not have " +
                "a TagNode of HTML Element type <UL class='blockNode'>.  Java Error.";
        
      • errorMsg3

        protected static final java.lang.String errorMsg3
        When a JavaDocError is thrown looking for the "sublist <UL>...</UL> Details Section, this message shall be produced. JavaDoc will always produce a details section - however there have been (very few) situations where the output HTML was not properly formatted. This can be remedied, but it is advisable to inspect what has caused the problem, and repair the HTML first.

        NOTE: TOK will be replaced by the word: Field, Constructor or Method.
        See Also:
        Constant Field Values
        Code:
        Exact Field Declaration Expression:
        1
        2
        3
        4
        protected static final String errorMsg3 = 
                "Search for TOK Summaries in this JavaDoc Page returned a null-valued Iterator.  " +
                "Class HNLIInclusive was not instantiated when searching for HTML <UL> Elements having " +
                "'class' Attributes = 'rowColor' or 'altColor.'  Java Error.";
        
    • Method Detail

      • details

        public static DotPair details​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage)
        
        This will return the "details" HTML divider '<DIV>' element from an HTML JavaDoc output-page. Java-Doc creates a single HTML divider that uses the following attributes, listed below. This element is rather large, and keeps three primary sections: fields, methods, and constructors.

        HTML Elements:
        1
        2
        3
        4
        5
        6
        <div class="details">
        <!-- All 'details' sections (fields, methods, constructors - but not inner-classes) of
             the Java-Doc detailed-descriptions are here - wrapped inside of an HTML Divider 
             Element whose class name is class='details'
        -->
        </div>
        
        Parameters:
        javaDocHTMLCIETPage - This should be a vectorized-HTML Java-Doc Generated Documentation Page for a CIET (Class, Interface, or Enumerated-Type). Load a Vector of HTMLNode for JavaDoc generated page the exact same way that any other HTML Page is vectorized into TagNode, TextNode, and CommentNode.
        Returns:
        An instance of class DotPair that points to the begin and end index locations of input parameter 'javaDocHTMLCIETPage' were the primary 'Details Section' resides.
        See Also:
        AVT, InnerTagFindInclusive, DotPair
        Code:
        Exact Method Body:
        1
        2
        3
        4
        5
        6
        7
         DotPair ret = InnerTagFindInclusive.first
             (javaDocHTMLCIETPage, "div", "class", TextComparitor.C, "details");
        
         if (ret == null) throw new JavaDocError
             ("Could not find an HTML Divider Element whose class attribute was class='details'");
        
         return ret;
        
      • constructorDetails

        public static DotPair constructorDetails​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage)
        
        This will return the constructor-details top-level unordered list from an HTML JavaDoc output-page. Java-Doc actually creates an outer HMTL Element 'Unordered List' ('<UL>...</UL>'), where each of the <LI>...</LI> list-elements in that list are also themselves unordered lists. Each of the sub-list elements of the top-level unordered-list contains a detailed description of a particular constructor.

        SURROUNDING BLOCK: The Constructor Details surrounding HTML Element Unordered List looks like the following:

        HTML Elements:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        <!-- The CommentNodeFind and InnerTagFindInclusive are searching for an HTML Unordered List Element
             inside of a Java Doc Generated HTML Class Documentation File that looks like the HTML below.
             The Java Code Itself is in the next code-comment block.  It finds this outer <UL> element by 
             first looking for the "CONSTRUCTOR DETAIL" CommentNode in the Vectorized-HTML documentation-page, 
             and then looking for an HTML <UL> Element whose class is 'blockList"
        -->
        
        <!-- ========= CONSTRUCTOR DETAIL ======== -->
        <ul class="blockList">
        <li class="blockList"><a name="constructor.detail">
        <!--   -->
        </a>
        <h3>Constructor Detail</h3>
        ...
        
        Parameters:
        javaDocHTMLCIETPage - This should be a vectorized-HTML Java-Doc Generated Documentation Page for a CIET (Class, Interface, or Enumerated-Type). Load a Vector of HTMLNode for JavaDoc generated page the exact same way that any other HTML Page is vectorized into TagNode, TextNode, and CommentNode.
        Returns:
        This shall return an instance of class DotPair that contains a start-integer Vector-index, and an end-integer Vector-index. Remember: Unlike loop-variable end-points, in class DotPair BOTH the starting AND the ending Vector indices are 'inclusive' - meaning the Vector element located at v.elementAt(DotPair.end) shall be included in the result set).
        Throws:
        JavaDocError - If there is an actual search routine error trying to find the HTML 'UL' Elements (Unordered Lists) then a JavaDocError is thrown. This error inherits from Java's class java.lang.Error, rather than class Exception because it is generally a problem serious enough to warrant investigation and repair of the problem before ever invoking this method.
        See Also:
        CommentNodeFind, InnerTagFindInclusive, DotPair
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         int constructorDetailsPos = CommentNodeFind.first
             (javaDocHTMLCIETPage, TextComparitor.CN_CI, "== CONSTRUCTOR DETAIL ==");
        
         if (constructorDetailsPos == -1) throw new JavaDocError(
             errorMsg1.replace("TOK1", "Constructor").replace("TOK2", "CONSTRUCTOR")
         );
        
         DotPair ret = InnerTagFindInclusive.first(
             javaDocHTMLCIETPage, constructorDetailsPos, -1, "ul", "class",
             TextComparitor.C, "blockList"
         );
        
         if (ret == null) throw new JavaDocError(errorMsg2.replace("TOK", "Constructor"));
        
         return ret;
        
      • fieldDetails

        public static final DotPair fieldDetails​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage)
        
        This will return the field-details top-level unordered list from an HTML JavaDoc output-page. Java-Doc actually creates an outer HMTL Element 'Unordered List' ('<UL>...</UL>'), where each of the <LI>...</LI> list-elements in that list are also themselves unordered lists. Each of the sub-list elements of the top-level unordered-list contains a detailed description of a particular field.

        SURROUNDING BLOCK: The Field Details surrounding HTML Element Unordered List looks like the following:

        HTML Elements:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        <!-- The CommentNodeFind and InnerTagFindInclusive are searching for an HTML Unordered List Element
             inside of a Java Doc Generated HTML Class Documentation File that looks like the HTML below.
             The Java Code Itself is in the next code-comment block.  It finds this outer <UL> element by 
             first looking for the "FIELD DETAIL" CommentNode in the Vectorized-HTML documentation-page, 
             and then looking for an HTML <UL> Element whose class is 'blockList"
        -->
        
        <!-- ============ FIELD DETAIL =========== -->
        <ul class="blockList">
        <li class="blockList"><a name="field.detail">
        <!--   -->
        </a>
        <h3>Field Detail</h3>
        ... 
        
        Parameters:
        javaDocHTMLCIETPage - This should be a vectorized-HTML Java-Doc Generated Documentation Page for a CIET (Class, Interface, or Enumerated-Type). Load a Vector of HTMLNode for JavaDoc generated page the exact same way that any other HTML Page is vectorized into TagNode, TextNode, and CommentNode.
        Returns:
        This shall return an instance of class DotPair that contains a start-integer Vector-index, and an end-integer Vector-index. Remember: Unlike loop-variable end-points, in class DotPair BOTH the starting AND the ending Vector indices are 'inclusive' - meaning the Vector element located at v.elementAt(DotPair.end) shall be included in the result set).
        Throws:
        JavaDocError - If there is an actual search routine error trying to find the HTML 'UL' Elements (Unordered Lists) then a JavaDocError is thrown. This error inherits from Java's class java.lang.Error, rather than class Exception because it is generally a problem serious enough to warrant investigation and repair of the problem before ever invoking this method.
        See Also:
        CommentNodeFind, InnerTagFindInclusive, DotPair
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         int fieldDetailsPos = CommentNodeFind.first
             (javaDocHTMLCIETPage, TextComparitor.CN_CI, "== FIELD DETAIL ==");
        
         if (fieldDetailsPos == -1) throw new JavaDocError(
             errorMsg1.replace("TOK1", "Field").replace("TOK2", "FIELD")
         );
        
         DotPair ret = InnerTagFindInclusive.first(
             javaDocHTMLCIETPage, fieldDetailsPos, -1, "ul", "class",
             TextComparitor.C, "blockList"
         );
        
         if (ret == null) throw new JavaDocError(errorMsg2.replace("TOK", "Field"));
        
         return ret;
        
      • enumConstDetails

        public static final DotPair enumConstDetails​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage)
        
        This will return the field-details top-level unordered list from an HTML JavaDoc output-page. Java-Doc actually creates an outer HMTL Element 'Unordered List' ('<UL>...</UL>'), where each of the <LI>...</LI> list-elements in that list are also themselves unordered lists. Each of the sub-list elements of the top-level unordered-list contains a detailed description of a particular enumerated-constant.

        SURROUNDING BLOCK: The Enumerated-Constant Details surrounding HTML Element Unordered List looks like the following:

        HTML Elements:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        <!-- The CommentNodeFind and InnerTagFindInclusive are searching for an HTML Unordered List Element
             inside of a Java Doc Generated HTML Class Documentation File that looks like the HTML below.
             The Java Code Itself is in the next code-comment block.  It finds this outer <UL> element by 
             first looking for the "ENUM CONSTANT DETAIL" CommentNode in the Vectorized-HTML documentation-page, 
             and then looking for an HTML <UL> Element whose class is 'blockList"
        -->
        
        <!-- ============ ENUM CONSTANT DETAIL =========== -->
        <ul class="blockList">
        <li class="blockList"><a name="enum.constant.detail">
        <!--   -->
        </a>
        <h3>Enum Constant Detail</h3>
        ... 
        
        Parameters:
        javaDocHTMLCIETPage - This should be a vectorized-HTML Java-Doc Generated Documentation Page for a CIET (Class, Interface, or Enumerated-Type). Load a Vector of HTMLNode for JavaDoc generated page the exact same way that any other HTML Page is vectorized into TagNode, TextNode, and CommentNode.
        Returns:
        This shall return an instance of class DotPair that contains a start-integer Vector-index, and an end-integer Vector-index. Remember: Unlike loop-variable end-points, in class DotPair BOTH the starting AND the ending Vector indices are 'inclusive' - meaning the Vector element located at v.elementAt(DotPair.end) shall be included in the result set).
        Throws:
        JavaDocError - If there is an actual search routine error trying to find the HTML 'UL' Elements (Unordered Lists) then a JavaDocError is thrown. This error inherits from Java's class java.lang.Error, rather than class Exception because it is generally a problem serious enough to warrant investigation and repair of the problem before ever invoking this method.
        See Also:
        CommentNodeFind, InnerTagFindInclusive, DotPair
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         int fieldDetailsPos = CommentNodeFind.first
             (javaDocHTMLCIETPage, TextComparitor.CN_CI, "== ENUM CONSTANT DETAIL ==");
        
         if (fieldDetailsPos == -1) throw new JavaDocError(
             errorMsg1.replace("TOK1", "Enumerated-Constant").replace("TOK2", "ENUM CONSTANT")
         );
        
         DotPair ret = InnerTagFindInclusive.first(
             javaDocHTMLCIETPage, fieldDetailsPos, -1, "ul", "class",
             TextComparitor.C, "blockList"
         );
        
         if (ret == null) throw new JavaDocError(errorMsg2.replace("TOK", "Enumerated-Constant"));
        
         return ret;
        
      • methodDetails

        public static DotPair methodDetails​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage)
        
        This will return the method-details top-level unordered list from an HTML JavaDoc output-page. Java-Doc actually creates an outer HMTL Element 'Unordered List' ('<UL>...</UL>'), where each of the <LI>...</LI> list-elements in that list are also themselves unordered lists. Each of the sub-list elements of the top-level unordered-list contains a detailed description of a particular method.

        SURROUNDING BLOCK: The Method Details surrounding HTML Element Unordered List looks like the following:

        HTML Elements:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        <!-- The CommentNodeFind and InnerTagFindInclusive are searching for an HTML Unordered List Element
             inside of a Java Doc Generated HTML Class Documentation File that looks like the HTML below.
             The Java Code Itself is in the next code-comment block.  It finds this outer <UL> element by 
             first looking for the "METHOD DETAIL" CommentNode in the Vectorized-HTML documentation-page, 
             and then looking for an HTML <UL> Element whose class is 'blockList"
        -->
        
        <!-- ========= METHOD DETAIL ======== -->
        <ul class="blockList">
        <li class="blockList"><a name="method.detail">
        <!--   -->
        </a>
        <h3>Constructor Detail</h3>
        ...
        
        Parameters:
        javaDocHTMLCIETPage - This should be a vectorized-HTML Java-Doc Generated Documentation Page for a CIET (Class, Interface, or Enumerated-Type). Load a Vector of HTMLNode for JavaDoc generated page the exact same way that any other HTML Page is vectorized into TagNode, TextNode, and CommentNode.
        Returns:
        This shall return an instance of class DotPair that contains a start-integer Vector-index, and an end-integer Vector-index. Remember: Unlike loop-variable end-points, in class DotPair BOTH the starting AND the ending Vector indices are 'inclusive' - meaning the Vector element located at v.elementAt(DotPair.end) shall be included in the result set).
        Throws:
        JavaDocError - If there is an actual search routine error trying to find the HTML 'UL' Elements (Unordered Lists) then a JavaDocError is thrown. This error inherits from Java's class java.lang.Error, rather than class Exception because it is generally a problem serious enough to warrant investigation and repair of the problem before ever invoking this method.
        See Also:
        CommentNodeFind, InnerTagFindInclusive, DotPair
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         int methodDetailsPos = CommentNodeFind.first
             (javaDocHTMLCIETPage, TextComparitor.CN_CI, "== METHOD DETAIL ==");
        
         if (methodDetailsPos == -1) throw new JavaDocError(
             errorMsg1.replace("TOK1", "Method").replace("TOK2", "METHOD")
         );
        
         DotPair ret = InnerTagFindInclusive.first(
             javaDocHTMLCIETPage, methodDetailsPos, -1, "ul", "class",
             TextComparitor.C, "blockList"
         );
        
         if (ret == null) throw new JavaDocError
             (errorMsg2.replace("TOK", "Method"));
        
         return ret;
        
      • hasConstructorDetails

        public static DotPair hasConstructorDetails​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage)
        
        This method is identical to the method DotPair constructorDetails(...), but it catches the JavaDocError, and returns null instead. Both methods are preserved in this class, because there are, of course, situations where a class does not have a Constructor Details Section.
        Parameters:
        javaDocHTMLCIETPage - This should be a vectorized-HTML Java-Doc Generated Documentation Page for a CIET (Class, Interface, or Enumerated-Type). Load a Vector of HTMLNode for JavaDoc generated page the exact same way that any other HTML Page is vectorized into TagNode, TextNode, and CommentNode.
        Returns:
        This shall return an instance of class DotPair that contains a start-integer Vector-index, and an end-integer Vector-index. Remember: Unlike loop-variable end-points, in class DotPair BOTH the starting AND the ending Vector indices are 'inclusive' - meaning the Vector element located at v.elementAt(DotPair.end) shall be included in the result set).
        See Also:
        constructorDetails(Vector)
        Code:
        Exact Method Body:
        1
        2
        3
        4
         try
             { return constructorDetails(javaDocHTMLCIETPage); }
         catch (JavaDocError e)
             { return null; }
        
      • hasFieldDetails

        public static DotPair hasFieldDetails​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage)
        
        This method is identical to the method DotPair fieldDetails(...), but it catches the JavaDocError, and returns null instead. Both methods are preserved in this class, because there are, of course, situations where a class does not have a Field Details Section.
        Parameters:
        javaDocHTMLCIETPage - This should be a vectorized-HTML Java-Doc Generated Documentation Page for a CIET (Class, Interface, or Enumerated-Type). Load a Vector of HTMLNode for JavaDoc generated page the exact same way that any other HTML Page is vectorized into TagNode, TextNode, and CommentNode.
        Returns:
        This shall return an instance of class DotPair that contains a start-integer Vector-index, and an end-integer Vector-index. Remember: Unlike loop-variable end-points, in class DotPair BOTH the starting AND the ending Vector indices are 'inclusive' - meaning the Vector element located at v.elementAt(DotPair.end) shall be included in the result set).
        See Also:
        fieldDetails(Vector)
        Code:
        Exact Method Body:
        1
        2
        3
        4
         try
             { return fieldDetails(javaDocHTMLCIETPage); }
         catch (JavaDocError e)
             { return null; }
        
      • hasEnumConstDetails

        public static DotPair hasEnumConstDetails​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage)
        
        This method is identical to the method DotPair enumConstDetails(...), but it catches the JavaDocError, and returns null instead. Both methods are preserved in this class, because there are, of course, situations where a class does not have an Enumerated Constant Details Section.
        Parameters:
        javaDocHTMLCIETPage - This should be a vectorized-HTML Java-Doc Generated Documentation Page for a CIET (Class, Interface, or Enumerated-Type). Load a Vector of HTMLNode for JavaDoc generated page the exact same way that any other HTML Page is vectorized into TagNode, TextNode, and CommentNode.
        Returns:
        This shall return an instance of class DotPair that contains a start-integer Vector-index, and an end-integer Vector-index. Remember: Unlike loop-variable end-points, in class DotPair BOTH the starting AND the ending Vector indices are 'inclusive' - meaning the Vector element located at v.elementAt(DotPair.end) shall be included in the result set).
        See Also:
        fieldDetails(Vector)
        Code:
        Exact Method Body:
        1
        2
        3
        4
         try
             { return enumConstDetails(javaDocHTMLCIETPage); }
         catch (JavaDocError e) 
             { return null; }
        
      • hasMethodDetails

        public static DotPair hasMethodDetails​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage)
        
        This method is identical to the method DotPair methodDetails(...), but it catches the JavaDocError, and returns null instead. Both methods are preserved in this class, because there are, of course, situations where a class does not have a Method Details Section.
        Parameters:
        javaDocHTMLCIETPage - This should be a vectorized-HTML Java-Doc Generated Documentation Page for a CIET (Class, Interface, or Enumerated-Type). Load a Vector of HTMLNode for JavaDoc generated page the exact same way that any other HTML Page is vectorized into TagNode, TextNode, and CommentNode.
        Returns:
        This shall return an instance of class DotPair that contains a start-integer Vector-index, and an end-integer Vector-index. Remember: Unlike loop-variable end-points, in class DotPair BOTH the starting AND the ending Vector indices are 'inclusive' - meaning the Vector element located at v.elementAt(DotPair.end) shall be included in the result set).
        See Also:
        methodDetails(Vector)
        Code:
        Exact Method Body:
        1
        2
        3
        4
         try
             { return methodDetails(javaDocHTMLCIETPage); }
         catch (JavaDocError e)
             { return null; }
        
      • constructorDetailsIterator

        public static HNLIInclusive constructorDetailsIterator​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage)
        
        Iterator for the Constructor Details' Unordered Lists of the Constructor Details Section for a JavaDoc Generated HTML Class Documentation Page.

        This method retrieves each 'constructor-details' entry (Unordered List, <UL>...</UL> Element) in a JavaDoc HTML Documentation Vectorized Page. Generally, if the output produced by the JavaDoc Program looks like 'it could use a little help' here-or-there, use the iterator returned by this method to update, remove or modify the unordered lists in the HTML section:
        <!-- ============ CONSTRUCTOR DETAIL ========== -->.

        What follows is a sample HTML Documentation Page retrieved from the ImageScraper class. One of the constructor details from class ImageScraper are included in this documentation page to show what the HTML looks like - and what is being returned by the HNLIInclusive (an iterator) - when invoking this method.

        HTML Elements:
         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
        <!-- This line contains a comment node indicating that HTML Unordered List Elements depicting comment-details about
             the constructors in this class shall follow.  Beneath this section are Unordered Lists that represent documentation 
             descriptions for each of the constructors in the class ImageScraper.  Note, 'ImageScraper' is being used as an example
             for documentation purposes only, its subsections and code are not related at all to class JavaDoc.Details
        -->
        
        <!-- ========= CONSTRUCTOR DETAIL ======== -->
        <ul class="blockList">
        <li class="blockList"><a name="constructor.detail">
        <!--   -->
        </a>
        <h3>Constructor Detail</h3>
        
        <!-- Below is one of several 'ul' elements in the HTML Documentation Page for 'ImageScraper'  Each HTML 'ul' represents
             what the documentation DETAILS looks like on the JavaDoc Page for the CONSTRUCTORS in class 'ImageScraper'
        -->
        
        <ul class="blockList">
        <li class="blockList">
        <h4>ImageScraper</h4>
        <pre>public&nbsp;<a href="../../../src-html/Torello/HTML/Tools/ImageScraper.html#line.245">ImageScraper</a>(java.lang.Iterable<java.net.URL>&nbsp;source,
                     java.lang.String&nbsp;targetDirectory)</pre>
        <div class="block">This constructor retrieves images from the internet via a source of prepared image URL's.</div>
        <dl>
        <dt><span class="paramLabel">Parameters:</span></dt>
        <dd><code>source</code> - Any {java.lang.Iterable} that provides Image URL's ready for download.</dd>
        <dd><code>targetDirectory</code> - When this constructor is used, this String parameter identifies the directory to where
          files must be saved.</dd>
        <dt><span class="throwsLabel">Throws:</span></dt>
        <dd><code>java.lang.NullPointerException</code> - If any of the elements of the input 'Iterable' are null elements, then this Exception
         shall be thrown.</dd>
        </dl>
        </li>
        </ul>
        
        Parameters:
        javaDocHTMLCIETPage - This should be a vectorized-HTML Java-Doc Generated Documentation Page for a CIET (Class, Interface, or Enumerated-Type). Load a Vector of HTMLNode for JavaDoc generated page the exact same way that any other HTML Page is vectorized into TagNode, TextNode, and CommentNode.
        Returns:
        This will return an instance of the 'HTML Node List Inclusive Iterator.' This Iterator has a suite of methods that facilitate retrieving the contents of a particular element in the underlying HTML Vector's 'Unordered Lists'. These HTML '<UL>' elements may be retrieved, removed, replaced, modified, updated or stored by the various methods exported by the 'HNIInclusive' API.

        The <UL> elements iterated contain Constructor definitions.
        Throws:
        JavaDocError - If there is an actual search routine error trying to find the HTML 'UL' Elements (Unordered Lists) then a JavaDocError is thrown. This error inherits from Java's class java.lang.Error, rather than class Exception because it is generally a problem serious enough to warrant investigation and repair of the problem before ever invoking this method.
        See Also:
        InnerTagInclusiveIterator, HNLIInclusive, constructorDetails(Vector)
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         DotPair constructorDetailsSection = constructorDetails(javaDocHTMLCIETPage);
        
         HNLIInclusive ret = InnerTagInclusiveIterator.get
             (javaDocHTMLCIETPage, "ul", "class", TextComparitor.C, "blockList", "blockListLast");
             // <ul class='blockList'> is used for all entries, except the last in the last
             // <ul class='blockListLast'> is used for last entry.
        
         if (ret == null) throw new JavaDocError(errorMsg3.replace("TOK", "Constructor"));
        
         // '+ 1' is needed since there is an "outer <UL class='blockList'>" TagNode
         // ==>  The "Constructor Details (entire) Section" is 
         //      also a <UL CLASS='blockList'> too!
         ret.restrictCursor(constructorDetailsSection.start + 1, constructorDetailsSection.end);
        
         return ret;
        
      • fieldDetailsIterator

        public static HNLIInclusive fieldDetailsIterator​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage)
        
        Iterator for the Field Details' Unordered Lists of the Field Details Section for a JavaDoc Generated HTML Class Documentation Page.

        This method retrieves each 'field-details' entry (Unordered List, <UL>...</UL> Element) in a JavaDoc HTML Documentation Vectorized Page. Generally, if the output produced by the JavaDoc Program looks like 'it could use a little help' here-or-there, use the iterator returned by this method to update, remove or modify the unordered lists in the HTML section:
        <!-- ============ FIELD DETAIL ========== -->.

        What follows is a sample HTML Documentation Page retrieved from the ImageScraper class. One of the field details from class ImageScraper are included in this documentation page to show what the HTML looks like - and what is being returned by the HNLIInclusive (an iterator) - when invoking this method.

        HTML Elements:
         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
        <!-- This line contains a comment node indicating that HTML Unordered List Elements depicting comment-details about
             the fields in this class shall follow.  Beneath this section are Unordered Lists that represent documentation descriptions
             for each of the fields in the class ImageScraper.  Note, 'ImageScraper' is being used as an example for documentation
             purposes only, its subsections and code are not related at all to class JavaDoc.Details
        -->
        
        <!-- ============ FIELD DETAIL =========== -->
        <ul class="blockList">
        <li class="blockList"><a name="field.detail">
        <!--   -->
        </a>
        <h3>Field Detail</h3>
        
        <!-- Below is one of several 'ul' elements in the HTML Documentation Page for 'ImageScraper'  Each HTML 'ul' represents
             what the documentation DETAILS looks like on the JavaDoc Page for the FIELDS in class 'ImageScraper'
        -->
        
        <ul class="blockList">
        <li class="blockList">
        <h4>MAX_WAIT_TIME</h4>
        <pre>public static final&nbsp;long <a href="../../../src-html/Torello/HTML/Tools/ImageScraper.html#line.55">MAX_WAIT_TIME</a></pre>
        <div class="block">This is the default maximum wait time for an image to download (10L).  This value may be reset or modified
         by instantiating a <code>ImageScraper.AdditionalParameters</code> class, and passing the desired values to the constructor.
         This value is measured in units of <code>public static final java.util.concurrent.TimeUnit MAX_WAIT_TIME_UNIT</code></div>
        <dl>
        <dt><span class="seeLabel">See Also:</span></dt>
        <dd><a href="../../../Torello/HTML/Tools/ImageScraper.html#MAX_WAIT_TIME_UNIT"><code>MAX_WAIT_TIME_UNIT</code></a>, 
        <a href="../../../constant-values.html#Torello.HTML.Tools.ImageScraper.MAX_WAIT_TIME">Constant Field Values</a></dd>
        </dl>
        </li>
        </ul>
        
        Parameters:
        javaDocHTMLCIETPage - This should be a vectorized-HTML Java-Doc Generated Documentation Page for a CIET (Class, Interface, or Enumerated-Type). Load a Vector of HTMLNode for JavaDoc generated page the exact same way that any other HTML Page is vectorized into TagNode, TextNode, and CommentNode.
        Returns:
        This will return an instance of the 'HTML Node List Inclusive Iterator.' This Iterator has a suite of methods that facilitate retrieving the contents of a particular element in the underlying HTML Vector's 'Unordered Lists'. These HTML '<UL>' elements may be retrieved, removed, replaced, modified, updated or stored by the various methods exported by the 'HNIInclusive' API.

        The <UL> elements iterated contain Field definitions.
        Throws:
        JavaDocError - If there is an actual search routine error trying to find the HTML 'UL' Elements (Unordered Lists) then a JavaDocError is thrown. This error inherits from Java's class java.lang.Error, rather than class Exception because it is generally a problem serious enough to warrant investigation and repair of the problem before ever invoking this method.
        See Also:
        InnerTagInclusiveIterator, HNLIInclusive, fieldDetails(Vector)
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         DotPair fieldDetailsSection = fieldDetails(javaDocHTMLCIETPage);
        
         HNLIInclusive ret = InnerTagInclusiveIterator.get(javaDocHTMLCIETPage,
             "ul", "class", TextComparitor.C, "blockList", "blockListLast");
             // <ul class='blockList'> is used for all entries, except the last in the last
             // <ul class='blockListLast'> is used for last entry.
        
         if (ret == null) throw new JavaDocError(errorMsg3.replace("TOK", "Field"));
        
         // '+ 1' is needed since there is an "outer <UL class='blockList'>" TagNode
         // ==> The "Field Details (entire) Section" is also a <UL CLASS='blockList'> too!
         ret.restrictCursor(fieldDetailsSection.start + 1, fieldDetailsSection.end);
        
         return ret;
        
      • enumConstDetailsIterator

        public static HNLIInclusive enumConstDetailsIterator​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage)
        
        Iterator for the Enumerated Constant Details' Unordered Lists of the Enumerated-Constant Details Section for a JavaDoc Generated HTML Enum-Class Documentation Page.

        This method retrieves each 'enumerated-constant details' entry (Unordered List, <UL>...</UL> Element) in a JavaDoc HTML Documentation Vectorized Page. Generally, if the output produced by the JavaDoc Program looks like 'it could use a little help' here-or-there, use the iterator returned by this method to update, remove or modify the unordered lists in the HTML section:
        <!-- ============ ENUM CONSTANT DETAIL ========== -->

        What follows is a sample HTML Documentation Page retrieved from the TC enum. One or two of the enumerated-constant details from public enum TC are included in this documentation page to show what the HTML looks like - and what is being returned by the HNLIInclusive (an iterator) - when invoking this method.

        HTML Elements:
         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
        <!-- This line contains a comment node indicating that HTML Unordered List Elements depicting comment-details about
             the enumerated-constants in this class shall follow.  Beneath this section are Unordered Lists that represent documentation
             descriptions for each of the enumerated-constants in the enum TC.  Note, 'TC' is being used as an example for documentation
             purposes only, its subsections and code are not related at all to class JavaDoc.Details
        -->
        
        <!-- ============ ENUM CONSTANT DETAIL =========== -->
        <ul class="blockList">
        <li class="blockList"><a name="field.detail">
        <!--   -->
        </a>
        <h3>Enum Constant Detail</h3>
        
        <!-- Below is one of several 'ul' elements in the HTML Documentation Page for 'TC'  Each HTML 'ul' represents
             what the documentation DETAILS looks like on the JavaDoc Page for the ENUM CONSTANTS in enum 'TC'
        -->
        
        <ul class="blockList">
        <li class="blockList">
        <h4>OpeningTags</h4>
        <pre>public static final&nbsp;<a href="../../Torello/HTML/TC.html" title="enum in Torello.HTML">TC</a> <a href="../../src-html/Torello/HTML/TC.html#line.20">OpeningTags</a></pre>
        <div class="block">OpeningTags indicates HTML Tag-Nodes that constitute the first of a two-Tag-Node pair like: <DIV> ... </DIV>, where the first is the "opening tag"</div>
        </li>
        </ul>
        <a name="ClosingTags">
        <!--   -->
        </a>
        <ul class="blockList">
        <li class="blockList">
        <h4>ClosingTags</h4>
        <pre>public static final&nbsp;<a href="../../Torello/HTML/TC.html" title="enum in Torello.HTML">TC</a> <a href="../../src-html/Torello/HTML/TC.html#line.23">ClosingTags</a></pre>
        <div class="block">ClosingTag indicates HTML Tag-Nodes that constitute the second of the two-Tag-Node pair as: <A HREF> ... </A>, where the second tag is the "closing tag"</div>
        </li>
        </ul>
        
        Parameters:
        javaDocHTMLCIETPage - This should be a vectorized-HTML Java-Doc Generated Documentation Page for a CIET (Class, Interface, or Enumerated-Type). Load a Vector of HTMLNode for JavaDoc generated page the exact same way that any other HTML Page is vectorized into TagNode, TextNode, and CommentNode.
        Returns:
        This will return an instance of the 'HTML Node List Inclusive Iterator.' This Iterator has a suite of methods that facilitate retrieving the contents of a particular element in the underlying HTML Vector's 'Unordered Lists'. These HTML '<UL>' elements may be retrieved, removed, replaced, modified, updated or stored by the various methods exported by the 'HNIInclusive' API.

        The <UL> elements iterated contain Enumerated-Constant definitions.
        Throws:
        JavaDocError - If there is an actual search routine error trying to find the HTML 'UL' Elements (Unordered Lists) then a JavaDocError is thrown. This error inherits from Java's class java.lang.Error, rather than class Exception because it is generally a problem serious enough to warrant investigation and repair of the problem before ever invoking this method.
        See Also:
        InnerTagInclusiveIterator, HNLIInclusive, enumConstDetails(Vector)
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         DotPair enumConstDetailsSection = enumConstDetails(javaDocHTMLCIETPage);
        
         HNLIInclusive ret = InnerTagInclusiveIterator.get(javaDocHTMLCIETPage,
             "ul", "class", TextComparitor.C, "blockList", "blockListLast");
             // <ul class='blockList'> is used for all entries, except the last in the last
             // <ul class='blockListLast'> is used for last entry.
        
         if (ret == null) throw new JavaDocError(errorMsg3.replace("TOK", "Enumerated-Constant"));
        
         // '+ 1' is needed since there is an "outer <UL class='blockList'>" TagNode
         // ==>  The "Enumerated-Constant Details (entire) Section" is 
         //      also a <UL CLASS='blockList'> too!
         ret.restrictCursor(enumConstDetailsSection.start + 1, enumConstDetailsSection.end);
        
         return ret;
        
      • methodDetailsIterator

        public static HNLIInclusive methodDetailsIterator​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage)
        
        Iterator for the Method Details' Unordered Lists of the Method Details Section for a JavaDoc Generated HTML Class Documentation Page.

        This method retrieves each 'method-details' entry (Unordered List, <UL>...</UL> Element) in a JavaDoc HTML Documentation Vectorized Page. Generally, if the output produced by the JavaDoc Program looks like 'it could use a little help' here-or-there, use the iterator returned by this method to update, remove or modify the unordered lists in the HTML section:
        <!-- ============ METHOD DETAIL ========== -->

        What follows is a sample HTML Documentation Page retrieved from the ImageScraper class. One of the method details from class ImageScraper are included in this documentation page to show what the HTML looks like - and what is being returned by the HNLIInclusive (an iterator) - when invoking this method.

        HTML Elements:
         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
        <!-- This line contains a comment node indicating that HTML Unordered List Elements depicting comment-details about
             the methods in this class shall follow.  Beneath this section are Unordered Lists that represent documentation descriptions
             for each of the methods in the class ImageScraper.  Note, 'ImageScraper' is being used as an example for documentation
             purposes only, its subsections and code are not related at all to class JavaDoc.Details
        -->
        
        <!-- ============ METHOD DETAIL ========== -->
        <ul class="blockList">
        <li class="blockList"><a name="method.detail">
        <!--   -->
        </a>
        <h3>Method Detail</h3>
        
        <!-- Below is one of several 'ul' elements in the HTML Documentation Page for 'ImageScraper'  Each HTML 'ul' represents
             what the documentation DETAILS looks like on the JavaDoc Page for the METHODS in class 'ImageScraper'
        -->
        
        <ul class="blockList">
        <li class="blockList">
        <h4>download</h4>
        <pre>public&nbsp;<a href="../../../Torello/HTML/Tools/ImageScraper.Results.html" title="class in Torello.HTML.Tools">ImageScraper.Results</a>&nbsp;<a href="../../../src-html/Torello/HTML/Tools/ImageScraper.html#line.880">download</a>()
                              throws java.io.IOException,
                                      java.net.MalformedURLException</pre>
        <div class="block">This calls the primary download method with null parameters</div>
        <dl>
        <dt><span class="returnLabel">Returns:</span></dt>
        <dd>a Results of the download</dd>
        <dt><span class="throwsLabel">Throws:</span></dt>
        <dd><code>java.io.IOException</code></dd>
        <dd><code>java.net.MalformedURLException</code></dd>
        </dl>
        </li>
        </ul>
        
        Parameters:
        javaDocHTMLCIETPage - This should be a vectorized-HTML Java-Doc Generated Documentation Page for a CIET (Class, Interface, or Enumerated-Type). Load a Vector of HTMLNode for JavaDoc generated page the exact same way that any other HTML Page is vectorized into TagNode, TextNode, and CommentNode.
        Returns:
        This will return an instance of the 'HTML Node List Inclusive Iterator.' This Iterator has a suite of methods that facilitate retrieving the contents of a particular element in the underlying HTML Vector's 'Unordered Lists'. These HTML '<UL>' elements may be retrieved, removed, replaced, modified, updated or stored by the various methods exported by the 'HNIInclusive' API.

        The <UL> elements iterated contain Method definitions.
        Throws:
        JavaDocError - If there is an actual search routine error trying to find the HTML 'UL' Elements (Unordered Lists) then a JavaDocError is thrown. This error inherits from Java's class java.lang.Error, rather than class Exception because it is generally a problem serious enough to warrant investigation and repair of the problem before ever invoking this method.
        See Also:
        InnerTagInclusiveIterator, HNLIInclusive, methodDetails(Vector)
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         DotPair methodDetailsSection = methodDetails(javaDocHTMLCIETPage);
        
         HNLIInclusive ret = InnerTagInclusiveIterator.get(javaDocHTMLCIETPage,
             "ul", "class", TextComparitor.C, "blockList", "blockListLast");
             // <ul class='blockList'> is used for all entries, except the last in the last
             // <ul class='blockListLast'> is used for last entry.
        
         if (ret == null) throw new JavaDocError(errorMsg3.replace("TOK", "Method"));
        
         // '+ 1' is needed since there is an "outer <UL class='blockList'>" TagNode
         // ==> The "Method Details (entire) Section" is also a <UL CLASS='blockList'> too!
         ret.restrictCursor(methodDetailsSection.start + 1, methodDetailsSection.end);
        
         return ret;