Class Details


  • public class Details
    extends java.lang.Object
    Java Doc HTML-File Reader: Find and retrieve the entities of any of the five Java Doc generated Detail Sections.

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

    HTML Elements:
    <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:
    <!-- 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>
    ...
    


Stateless Class: This class neither contains any program-state, nor can it be instantiated. The @StaticFunctional Annotation may also be called 'The Spaghetti Report'. Static-Functional classes are, essentially, C-Styled Files, without any constructors or non-static member field. It is very similar to the Java-Bean @Stateless Annotation.
  • 1 Constructor(s), 1 declared private, zero-argument constructor
  • 20 Method(s), 20 declared static
  • 5 Field(s), 5 declared static, 5 declared final


    • Field Detail

      • JAVADOC_CONSTRUCTOR_DETAIL_MARKER

        🡇    
        protected static final java.lang.String JAVADOC_CONSTRUCTOR_DETAIL_MARKER
        Every JavaDoc Page that documents its Constructor's will include a 'Constructor Details' section. Finding the HTML for this section is easy, the section is prefaced by an HTML Comment ("Constructor Detail Marker") that looks as follows:

        HTML Elements:
        <!-- ========= CONSTRUCTOR DETAIL ======== -->
        


        The "Constructor Details" Section is an HTML Unordered List that has a header element which placed before the list that looks like this:



          Constructor Detail  




        See Also:
        Constant Field Values
        Code:
        Exact Field Declaration Expression:
        protected static final String JAVADOC_CONSTRUCTOR_DETAIL_MARKER =
                "==== CONSTRUCTOR DETAIL ====";
        
      • JAVADOC_FIELD_DETAIL_MARKER

        🡅  🡇    
        protected static final java.lang.String JAVADOC_FIELD_DETAIL_MARKER
        Every JavaDoc Page that documents its Field's will include a 'Field Detail' section. Finding the HTML for this section is easy, the section is prefaced by an HTML Comment ("Field Detail Marker") that looks as follows:

        HTML Elements:
        <!-- ============ FIELD DETAIL =========== -->
        


        The "Field Details" Section is an HTML Unordered List that has a header element which placed before the list that looks like this:



          Field Detail  




        See Also:
        Constant Field Values
        Code:
        Exact Field Declaration Expression:
        protected static final String JAVADOC_FIELD_DETAIL_MARKER =
                "==== FIELD DETAIL ====";
        
      • JAVADOC_METHOD_DETAIL_MARKER

        🡅  🡇    
        protected static final java.lang.String JAVADOC_METHOD_DETAIL_MARKER
        Every JavaDoc Page that documents its Method's will include a 'Method Detail' section. Finding the HTML for this section is easy, the section is prefaced by an HTML Comment ("Method Detail Marker") that looks as follows:

        HTML Elements:
        <!-- ============ METHOD DETAIL ========== -->
        


        The "Method Details" Section is an HTML Unordered List that has a header element which placed before the list that looks like this:



          Method Detail  




        See Also:
        Constant Field Values
        Code:
        Exact Field Declaration Expression:
        protected static final String JAVADOC_METHOD_DETAIL_MARKER =
                "==== METHOD DETAIL ====";
        
      • JAVADOC_ENUM_CONST_DETAIL_MARKER

        🡅  🡇    
        protected static final java.lang.String JAVADOC_ENUM_CONST_DETAIL_MARKER
        Every JavaDoc Page that is an 'Enum', will include an 'Enum Constant Detail' section. Finding the HTML for this section is easy, the section is prefaced by an HTML Comment ("Enum Constant Detail Marker") that looks as follows:

        HTML Elements:
        <!-- ============ ENUM CONSTANT DETAIL =========== -->
        


        NOTE: Only Java Source-Code Files which are actual enum's will ever have such a section. Enumerated-Constants are not allowed in other Java Type's.

        The "Enum Constant Details" Section is an HTML Unordered List that has a header element which placed before the list that looks like this:



          Enum Constant Detail  




        See Also:
        Constant Field Values
        Code:
        Exact Field Declaration Expression:
        protected static final String JAVADOC_ENUM_CONST_DETAIL_MARKER =
                "==== ENUM CONSTANT DETAIL ====";
        
      • JAVADOC_ANNOTATION_ELEMENT_DETAIL_MARKER

        🡅  🡇    
        protected static final java.lang.String JAVADOC_ANNOTATION_ELEMENT_DETAIL_MARKER
        JavaDoc Pages that are built from Annotation's ('@interface'), may include an 'Element Detail' section. Finding the HTML for this section is easy, the section is prefaced by an HTML Comment ("Annotation Detail Marker") that looks as follows:

        HTML Elements:
        <!-- ============ ANNOTATION TYPE MEMBER DETAIL =========== -->
        


        NOTE: Only Java Source-Code Files which are actual Annotation's could have such a section. Annotation Element's (required or optional) simply cannot be defined inside other Java Type's.

        ALSO: The 'Summary' section for Annotation Elements is split into 'Required Element Summary' and 'Optional Element Summary'. However, the 'Details' section puts both of these lists into a single 'Element Details' detail group.

        The "Annotation Element Details" Section is an HTML Unordered List that has a header element which placed before the list that looks like this:



          Element Detail  




        See Also:
        Constant Field Values
        Code:
        Exact Field Declaration Expression:
        protected static final String JAVADOC_ANNOTATION_ELEMENT_DETAIL_MARKER =
                "==== ANNOTATION TYPE MEMBER DETAIL ====";
        
    • Method Detail

      • entityToMarker

        🡅  🡇    
        protected static java.lang.String entityToMarker​(Entity section)
        Converts a Java 'Entity' to one of the 'Detail Section' MARKER String's.
        Parameters:
        section - This may be any of the entities, except Entity.INNER_CLASS.
        Returns:
        The appropriate 'MARKER', all of which are listed in the 'Fields' section at the top of this class.
        Code:
        Exact Method Body:
         if (section == null) throw new NullPointerException
             ("You have passed null to parameter 'section'.  This is not allowed here.");
        
         switch (section)
         {
             case METHOD:            return JAVADOC_METHOD_DETAIL_MARKER;
             case FIELD:             return JAVADOC_FIELD_DETAIL_MARKER;
             case CONSTRUCTOR:       return JAVADOC_CONSTRUCTOR_DETAIL_MARKER;
             case ENUM_CONSTANT:     return JAVADOC_ENUM_CONST_DETAIL_MARKER;
             case ANNOTATION_ELEM:   return JAVADOC_ANNOTATION_ELEMENT_DETAIL_MARKER;
        
             case INNER_CLASS:
                 throw new DetailsException(
                     "You have passed 'innerClass' to this method in class Details, but inner-" +
                     "classes do not have a 'Detail' section."
                 );
        
             default:
                 System.out.println("There are no other Entities.");
                 throw new UnreachableError();
         }
        
      • allEntityMarkers

        🡅  🡇    
        public static int[] allEntityMarkers​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage)
        
        All Detail-Marker CommentNode positions that are available on the page.
        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:
        The same int[] returned by CommentNodeFind.all
        See Also:
        CommentNodeFind
        Code:
        Exact Method Body:
         return CommentNodeFind.all(
             javaDocHTMLCIETPage, TextComparitor.CN_OR,
             JAVADOC_CONSTRUCTOR_DETAIL_MARKER,
             JAVADOC_FIELD_DETAIL_MARKER,
             JAVADOC_METHOD_DETAIL_MARKER,
             JAVADOC_ENUM_CONST_DETAIL_MARKER,
             JAVADOC_ANNOTATION_ELEMENT_DETAIL_MARKER
         );
        
      • sectionAllDetails

        🡅  🡇    
        public static java.util.Vector<SubSectionsectionAllDetails​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage,
                     Entity section)
        
        Retrieves all HTML description/explanation 'Detail Section' elements inside the provided page, for a specific type of detail. If parameter 'section' receives Entity.METHOD, all of the HTML 'Method Details' will be provided, as instances of SubSection, in the returned Vector.

        NOTE: This method is identical to sectionAllDetailsDP(Vector, Entity), except that it returns SubSection instances, rather than DotPair instances.
        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.
        section - Specifies which 'Detail Section' is being requested. Note that Entity.INNER_CLASS may not be used here.
        Returns:
        A call to a Peek method is made, so this means that SubSection is being returned. The Vector<SubSection> will contain the HTML, and the location in the page Vector for every detail (HTML Explanation) available in the specified 'Detail Section'.
        Throws:
        DetailsException - If Entity.INNER_CLASS is pssed to parameter 'section'
        See Also:
        hasAnnotationElemDetails(Vector), detailsSection(Vector, String), InnerTagPeekInclusive
        Code:
        Exact Method Body:
         // The Annotation Element Details have HTML that differs slightly from the other four
         // detail sections for the other four 'Entities'
        
         if (section == Entity.ANNOTATION_ELEM)
         {
             DotPair aeDetailsSection = hasAnnotationElemDetails(javaDocHTMLCIETPage);
        
             if (aeDetailsSection == null) return new Vector<>();
        
             return InnerTagPeekInclusive.all(
                 javaDocHTMLCIETPage, aeDetailsSection.start, aeDetailsSection.end,
                 "section", "role", TextComparitor.EQ, "region"
             );
         }
         else
         {
             DotPair detailsSection = detailsSection(javaDocHTMLCIETPage, entityToMarker(section));
        
             if (detailsSection == null) return new Vector<>();
        
             return InnerTagPeekInclusive.all(
                 javaDocHTMLCIETPage, detailsSection.start, detailsSection.end,
                 "ul", "class", TextComparitor.C, "blockList", "blockListLast"
             );
         }
        
      • sectionAllDetailsDP

        🡅  🡇    
        public static java.util.Vector<DotPairsectionAllDetailsDP​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage,
                     Entity section)
        
        Retrieves all HTML description/explanation 'Detail Section' elements inside the provided page, for a specific type of detail. If parameter 'section' receives Entity.METHOD, all of the HTML 'Method Details' will be provided, as instances of SubSection, in the returned Vector.

        NOTE: This method is identical to sectionAllDetails(Vector, Entity), except that it returns DotPair instances, rather than SubSection instances.
        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.
        section - Specifies which 'Detail Section' is being requested. Note that Entity.INNER_CLASS may not be used here.
        Returns:
        A call to a Find method is made, so this means that DotPair is being returned. The Vector<DotPair> will contain the HTML, and the location in the page Vector for every detail (HTML Explanation) available in the specified 'Detail Section'.
        Throws:
        DetailsException - If Entity.INNER_CLASS is pssed to parameter 'section'
        See Also:
        hasAnnotationElemDetails(Vector), detailsSection(Vector, String), InnerTagFindInclusive
        Code:
        Exact Method Body:
         // The Annotation Element Details have HTML that differs slightly from the other four
         // detail sections for the other four 'Entities'
        
         if (section == Entity.ANNOTATION_ELEM)
         {
             DotPair aeDetailsSection = hasAnnotationElemDetails(javaDocHTMLCIETPage);
        
             if (aeDetailsSection == null) return new Vector<>();
        
             return InnerTagFindInclusive.all(
                 javaDocHTMLCIETPage, aeDetailsSection.start, aeDetailsSection.end,
                 "section", "role", TextComparitor.EQ, "region"
             );
         }
         else
         {
             DotPair detailsSection = detailsSection(javaDocHTMLCIETPage, entityToMarker(section));
        
             if (detailsSection == null) return new Vector<>();
        
             return InnerTagFindInclusive.all(
                 javaDocHTMLCIETPage, detailsSection.start, detailsSection.end,
                 "ul", "class", TextComparitor.C, "blockList", "blockListLast"
             );
         }
        
      • hasDetails

        🡅  🡇    
        public static DotPair hasDetails​
                    (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:
        <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:
        InnerTagFindInclusive
        Code:
        Exact Method Body:
         return InnerTagFindInclusive.first
             (javaDocHTMLCIETPage, "div", "class", TextComparitor.C, "details");
        
      • detailsSection

        🡅  🡇    
        protected static DotPair detailsSection​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage,
                     java.lang.String commentMarker)
        
        This will return a specific Java Doc Details Section on a Java Doc Generated HTML page. This class is used internally.
        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.
        commentMarker - This must be one of the five 'MARKER' String's, which are the static constants defined at the top of this class. This marker will denote which JavaDoc Details Section is being requested.
        Returns:
        This will return an index-pointer pair to an HTML <UL> and </UL> opening-closing pair. This HTML <UL>-pointer should be the requested Details Section.

        Null will be returned if there is no CommentNode containing the 'commentMarker', or if - once that CommentNode is found - there is not <UL CLASS='blockList'> element found in the vicinity.
        See Also:
        CommentNodeFind, InnerTagFindInclusive
        Code:
        Exact Method Body:
         int pos = CommentNodeFind.first
             (javaDocHTMLCIETPage, TextComparitor.CN_CI, commentMarker);
        
         if (pos == -1) return null;
        
         DotPair ret = InnerTagFindInclusive.first
             (javaDocHTMLCIETPage, pos, -1, "ul", "class", TextComparitor.C, "blockList");
        
         // Make sure a <TABLE CLASS="memberSummary"...> was found, and that it is in the
         // CLOSE VICINITY of pos - OTHERWISE return null;
         if ((ret == null) || ((ret.start - pos) > 25)) return null;
        
         return ret;
        
      • detailsIterator

        🡅  🡇    
        public static HNLIInclusive detailsIterator​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage,
                     DotPair detailsSection)
        
        This method will retrieve an HNLIInclusive Iterator that iterates the unordered lists of any details section which is passed to this method. This Iterator example retrieves the 'Details' Unordered Lists for a JavaDoc Generated Web-Page.

        What follows is a sample HTML Documentation Page retrieved from the class ImageScraper. One of the methods' details from class ImageScraper are included here to show what the HTML looks like - and what is being returned by the HNLIInclusive (an iterator).

        HTML Elements:
        <!-- 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>
        


        WARNING: This method cannot be used to retrieve details for Annotation Elements! The HTML for these details are wrapped in something that differs (albeit very slightly). To retrieve the specific details elements for Annotation Element, use the method annotationElemDetailsIterator(Vector)
        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.
        detailsSection - This instance of DotPair should contain a complete Java Doc 'Details' section! This index-pointer pair should be retrieved from the 'has' methods in this class. If an incorrect pointer is passed here, an exception is thrown!
        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. The return values with this iterator may be used in conjuction with class DetailsParts to retrieve the details of the entity.
        Throws:
        DetailsException - If the reference passed to 'detailsSection' is null, or if it does not point to a proper opening and closing HTML <UL> element. See the code included below to view the range of possible exception throws.
        See Also:
        InnerTagInclusiveIterator, TagNodeExpectedException, OpeningTagNodeExpectedException, ClosingTagNodeExpectedException, HTMLTokException
        Code:
        Exact Method Body:
         if (javaDocHTMLCIETPage == null)
             throw new NullPointerException("Parameter 'javaDocHTMLCIETPage' may not be null.");
        
         if (detailsSection == null) throw new DetailsException(
             "The Details Section Iterator you have requested cannot be built without a proper " +
             "index-pointer 'DotPair' instance which points to a Details Section on the page " +
             "you have passed to 'javadocHTMLCIETPage'.  The reference you have passed to " +
             "'detailsSection' is null."
         );
        
         try
         {
             // Temporary Variables, used to do a few (quick) checks
             HTMLNode    n;
             TagNode     tn;
            
             n = javaDocHTMLCIETPage.elementAt(detailsSection.start);
        
             if (! (n instanceof TagNode)) throw new TagNodeExpectedException(
                 "The HTMLNode at index 'detailsSection.start' did not contain a TagNode, but " +
                 "rather a " + n.getClass().getSimpleName()
             );
        
             tn = (TagNode) n;
        
             if (tn.isClosing) throw new OpeningTagNodeExpectedException(
                 "The TagNode at index 'detailsSection.start' was a closing element whose " +
                 "'.isClosing' field was true.  This should be an HTML Opening <UL ...> " +
                 "element"
             );
        
             if (! tn.tok.equals("ul")) throw new HTMLTokException(
                 "The TagNode at index 'detailsSection.start' was not an HTML <UL> element " +
                 "because its '.tok' field was not \"ul\", but rather \"" + tn.tok + "\""
             );
        
             n = javaDocHTMLCIETPage.elementAt(detailsSection.end);
        
             if (! (n instanceof TagNode)) throw new TagNodeExpectedException(
                 "The HTMLNode at index 'detailsSection.end' did not contain a TagNode, but " +
                 "rather a " + n.getClass().getSimpleName()
             );
        
             tn = (TagNode) n;
        
             if (! tn.isClosing) throw new ClosingTagNodeExpectedException(
                 "The TagNode at index 'detailsSection.end' was an opening element whose " +
                 "'.isClosing' field was false.  This should be an HTML Opening </UL> " +
                 "element"
             );
        
             if (! tn.tok.equals("ul")) throw new HTMLTokException(
                 "The TagNode at index 'detailsSection.end' was not an HTML </UL> element " +
                 "because its '.tok' field was not \"ul\", but rather \"" + tn.tok + "\""
             );
         }
         catch (Exception e)
         {
             throw new DetailsException(
                 "There was a problem with the DotPair Vector-index pointer you have passed  " +
                 "(parameter 'detailsSection').  This DotPair should contain a valid Detail " +
                 "Section Pointer for the Java Doc Web Page you have passed, but it did not.  " +
                 "Please see this exception getCause() method for more information.", e
             );
         }
        
         // Actually building the iterator is really easy.  It is one line, followed by the
         // cursor-restriction method-call!
         HNLIInclusive ret = InnerTagInclusiveIterator.get(javaDocHTMLCIETPage,
             "ul", "class", TextComparitor.C, "blockList", "blockListLast");
        
         // '+ 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(detailsSection.start + 1, detailsSection.end);
        
         return ret;
        
      • detailsIterator

        🡅  🡇    
        protected static HNLIInclusive detailsIterator​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage,
                     java.lang.String commentMarker)
        
        This is a helper method that is used by the 'iterator' Convenience Methods defined in this class.

        Note that it is (likely) much more efficient to invoke the detailsIterator(Vector, DotPair) method directly - assuming you have already obtained a valid DotPair instance of the requisite 'Details Section' (using one of the 'has' methods!)

        WARNING: Do not invoke this method with the 'commentMarker' JAVADOC_ANNOTATION_ELEMENT_DETAIL_MARKER. Annotation Details use HTML that differs (slightly) from the other details sections. You must use the method annotationElemDetailsIterator(Vector), instead.
        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.
        commentMarker - This Java String should be any one of the listed static, final 'Comment Marker' String's, all of which are defined at the top of this class.
        Returns:
        This will return a 'Details Section Iterator' that iterates the table rows (a.k.a. 'The Summaries') in the specified 'Details Section'.
        Throws:
        DetailsException - This will throw if the specified 'Details Section' isn't found.
        See Also:
        detailsSection(Vector, String), detailsIterator(Vector, DotPair)
        Code:
        Exact Method Body:
         DotPair dp = detailsSection(javaDocHTMLCIETPage, commentMarker);
        
         if (dp == null) throw new SummariesException(
             "The detail-section iterator you have requested cannot be built.  There was no " +
             "Detail Section that matches the 'commentMarker' parameter you have passed (or " +
             "you have not passed a valid comment marker).  Did you use one of the markers " +
             "which are defined as static-final fields at the top of this class?"
         );
        
         return detailsIterator(javaDocHTMLCIETPage, dp);
        
      • hasConstructorDetails

        🡅  🡇    
        public static final DotPair hasConstructorDetails​
                    (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:
        <!-- ========= CONSTRUCTOR DETAIL ======== -->
        <ul class="blockList">
        <li class="blockList"><a name="constructor.detail">
        <!--   -->
        </a>
        <h3>Constructor Detail</h3>
        


        The "Constructor Details" Section is an HTML Unordered List that has a header element which placed before the list that looks like this:



          Constructor Detail  




        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 a Vector index-pointer, an instance of DotPair, that contains the 'Constructor Details Section' for a JavaDoc Generated Page. The Vector contents pointed-to by the returned DotPair will have the list of all Constructor Details contained by this page.
        See Also:
        detailsSection(Vector, String), JAVADOC_CONSTRUCTOR_DETAIL_MARKER
        Code:
        Exact Method Body:
         return detailsSection(javaDocHTMLCIETPage, JAVADOC_CONSTRUCTOR_DETAIL_MARKER);
        
      • hasFieldDetails

        🡅  🡇    
        public static final DotPair hasFieldDetails​
                    (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:
        <!-- ============ FIELD DETAIL =========== -->
        <ul class="blockList">
        <li class="blockList"><a name="field.detail">
        <!--   -->
        </a>
        <h3>Field Detail</h3>
        ... 
        


        The "Field Details" Section is an HTML Unordered List that has a header element which placed before the list that looks like this:



          Field Detail  




        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 a Vector index-pointer, an instance of DotPair, that contains the 'Field Details Section' for a JavaDoc Generated Page. The Vector contents pointed-to by the returned DotPair will have the list of all Field Details contained by this page.
        See Also:
        detailsSection(Vector, String), JAVADOC_FIELD_DETAIL_MARKER
        Code:
        Exact Method Body:
         return detailsSection(javaDocHTMLCIETPage, JAVADOC_FIELD_DETAIL_MARKER);
        
      • hasMethodDetails

        🡅  🡇    
        public static final DotPair hasMethodDetails​
                    (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:
        <!-- ========= METHOD DETAIL ======== -->
        <ul class="blockList">
        <li class="blockList"><a name="method.detail">
        <!--   -->
        </a>
        <h3>Method Detail</h3>
        ...
        


        The "Method Details" Section is an HTML Unordered List that has a header element which placed before the list that looks like this:



          Method Detail  




        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 a Vector index-pointer, an instance of DotPair, that contains the 'Method Details Section' for a JavaDoc Generated Page. The Vector contents pointed-to by the returned DotPair will have the list of all Method Details contained by this page.
        See Also:
        detailsSection(Vector, String), JAVADOC_METHOD_DETAIL_MARKER
        Code:
        Exact Method Body:
         return detailsSection(javaDocHTMLCIETPage, JAVADOC_METHOD_DETAIL_MARKER);
        
      • hasEnumConstDetails

        🡅  🡇    
        public static final DotPair hasEnumConstDetails​
                    (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:
        <!-- ============ ENUM CONSTANT DETAIL =========== -->
        <ul class="blockList">
        <li class="blockList"><a name="enum.constant.detail">
        <!--   -->
        </a>
        <h3>Enum Constant Detail</h3>
        ... 
        


        The "Enum Constant Details" Section is an HTML Unordered List that has a header element which placed before the list that looks like this:



          Enum Constant Detail  




        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 a Vector index-pointer, an instance of DotPair, that contains the 'Enum Constant Details Section' for a JavaDoc Generated Page. The Vector contents pointed-to by the returned DotPair will have the list of all Enum Constant Details contained by this page.
        See Also:
        detailsSection(Vector, String), JAVADOC_ENUM_CONST_DETAIL_MARKER
        Code:
        Exact Method Body:
         return detailsSection(javaDocHTMLCIETPage, JAVADOC_ENUM_CONST_DETAIL_MARKER);
        
      • hasAnnotationElemDetails

        🡅  🡇    
        public static final DotPair hasAnnotationElemDetails​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage)
        
        This will return the element-details (for the element-types of a Java Annotation - the stuff in an Annotation's parenthesis). The element-details are placed inside a 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 annotation-element.

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

        HTML Elements:
        <!-- The CommentNodeFind and InnerTagFindInclusive are searching for an HTML Unordered List Element
             inside of a Java Doc Generated HTML @interface 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 "ANNOTATION TYPE MEMBER DETAIL" CommentNode in the
             Vectorized-HTML documentation-page, and then looking for an HTML <UL> Element whose class is
             'blockList"
        
             ***NOTE: This is *slightly* different than the other four "Details" sections.
                      The salient Unordered list comes before the comment!
        -->
        
        <div class="details">
        <ul class="blockList"> <!-- Wee need this Unordered List!!! (slightly different) -->
        <li class="blockList">
        <!-- ============ ANNOTATION TYPE MEMBER DETAIL =========== -->
        <section role="region">
        <ul class="blockList">
        <li class="blockList"><a id="annotation.type.element.detail">
        <!--   -->
        </a>
        <h3>Element Detail</h3>
        ...
        


        The "Annotation Element Details" Section is an HTML Unordered List that has a header element which placed before the list that looks like this:



          Element Detail  




        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 a Vector index-pointer, an instance of DotPair, that contains the 'Element Details Section' for a JavaDoc Generated Page. The Vector contents pointed-to by the returned DotPair will have the list of all Element Details contained by this page.
        See Also:
        CommentNodeFind, InnerTagFind, Util.Inclusive.find(Vector, int), JAVADOC_ANNOTATION_ELEMENT_DETAIL_MARKER
        Code:
        Exact Method Body:
         int elemDetailsPos = CommentNodeFind.first
             (javaDocHTMLCIETPage, TextComparitor.CN_CI, JAVADOC_ANNOTATION_ELEMENT_DETAIL_MARKER);
        
         if (elemDetailsPos == -1) return null;
        
         // NOTE: We use 'last' and 'elemDetailsPos' as the endPos here (slightly different)
         int sPos = InnerTagFind.last(
             javaDocHTMLCIETPage, 0, elemDetailsPos, "ul", "class",
             TextComparitor.C, "blockList"
         );
        
         if (sPos == -1) return null;
        
         int ePos = Util.Inclusive.find(javaDocHTMLCIETPage, sPos);
        
         if (ePos == -1) return null;
        
         return new DotPair(sPos, ePos);
        
      • annotationElemDetailsIterator

        🡅    
        public static HNLIInclusive annotationElemDetailsIterator​
                    (java.util.Vector<HTMLNode> javaDocHTMLCIETPage)
        
        Iterator for the Annotation Element Details' Sections of the Element-Details Section for a JavaDoc Generated HTML Annotation Documentation Page.

        IMPORTANT: The Element Details section for Annotations has HTML that differs, ever so slightly, from the other four HTML Details Sections. This is why this method doesn't use the Convenience Method - as per the other four iterator retrieveal methods in this class.

        What follows is a sample HTML Documentation Page retrieved from the @StaticFunctional Annotation. One of the element-details from @interface StaticFunctional 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:
        <!-- Below is one of several 'section' elements in the HTML Documentation Page for the
             '@StaticFunctional' Annotation.  Each HTML 'section' represents what the documentation
             DETAILS looks like on the JavaDoc Page for the Annotation-Elements in Annotation
             '@StaticFunctional'
        -->
        
        <section role="region">
        <ul class="blockList">
        <li class="blockList"><a id="annotation.type.element.detail">
        <!--   -->
        </a>
        <h3>Element Detail</h3>
        <a id="Excused()">
        <!--   -->
        </a>
        <ul class="blockList">
        <li class="blockList">
        <H4 CLASS='C20'>Excused</h4>
        <pre class='C09'>java.lang.String[]&nbsp;<a href="../../../../src-html/Torello/HTML/Tools/JavaDoc/StaticFunctional.html#line.20">Excused</a></pre>
        <div class='C12 block'>This must contain the names of fields in this <code>class</code> or <code>interface</code> that
         have been declared <code>static</code>, but have not been declared <code>final</code>.
         
         <BR/><BR/><B STYLE='color: red;'>NOTE:</B> The values in the <code>'Excused'</code> array
         must be parallel to the values in the <code>'Excuses'</code> array.</div>
        <dl>
        <dt><SPAN CLASS=C21></SPAN>Default:</dt>
        <dd>{}</dd>
        </dl>
        </li>
        </ul>
        </li>
        </ul>
        </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 will return an instance of the 'HTML Node List Inclusive Iterator.' This Iterator has a suite of methods that facilitate retrieving the contents of an Element Details section's Unordered Lists. The return values with this Iterator may be used in conjuction with class DetailsParts to retrieve the details of the entity.

        The <UL> elements iterated contain Annotation Element explanations & definitions.
        Throws:
        DetailsException - If there is not Element Details section on this page.
        See Also:
        InnerTagInclusiveIterator, hasAnnotationElemDetails(Vector)
        Code:
        Exact Method Body:
         DotPair annotationElemDetailsSection = hasAnnotationElemDetails(javaDocHTMLCIETPage);
        
         if (annotationElemDetailsSection == null) throw new DetailsException(
             "The detail-section iterator you have requested cannot be built.  There was no " +
             "Annotation Element Detail Section on this page."
         );
        
         HNLIInclusive ret = InnerTagInclusiveIterator.get
             (javaDocHTMLCIETPage, "section", "role", TextComparitor.EQ, "region");
        
         ret.restrictCursor(annotationElemDetailsSection);
        
         return ret;