Class ReflHTML<ENTITY extends Declaration>

  • Type Parameters:
    ENTITY - This will take one of five type's: Method, Constructor, Field, EnumConstant, or AnnotationElem. The HTML contained by an instance of this class corresponds directly to the HTML contained by a detail section of one of one of these five Members / Entities.
    All Implemented Interfaces:
    java.io.Serializable, java.lang.Comparable<ReflHTML>
    public class ReflHTML<ENTITY extends Declaration>
extends java.lang.Object
implements java.io.Serializable, java.lang.Comparable<ReflHTML>
    Optional-Extension Class of a Basic-Upgrade:
    Running a Standard-Upgrade on a Java-Doc Web-Page Directory-Tree only requires building an instance of class Upgrade, and executing its upgrade() method!

    The Standard-Upgrade Process will insert CSS-Tags, Hi-Lite Properly-Marked Code-Snippet <DIV>'s, Hi-Lite all Method-Bodies & Field-Declarations, and even create Navigation-Menu Links. If more fine-grained control is needed, this class provides direct access to the Java Doc Web-Page HTML.


    Accessing this Class:
    This class may be accessed by utilizing a configuration method in class Upgrade, specifically calling:

    Upgrade.setExtraTasks(Consumer<JavaDocHTMLFile> handler)

    ... with a handler (a java.util.function.Consumer instance) that receives a JavaDocHTMLFile instance.

    Class JavaDocHTMLFile provides access to every HTML Component on a Java-Doc Web-Page. If programmatic changes to a Java-Doc Web-Page are needed, these Reflection-API classes make it easy to change, update, remove & add-to the HTML on these pages. Simply registering a handler with the Upgrader, make the necessary improvements, and they will be incorporated into the final-output HTML-Page.

    Again, class JavaDocHTMLFile has getters for: HeaderFooterHTML, SummaryTableHTML and ReflHTML


    Alternatively:
    Creating an instance of one of the two offered "User-Processor" classes - both of which have several listener/handler methods - is also a great way to access the Reflection-HTML API. These two Java Interfaces are:

    This class stores the HTML Detail-Descriptions retrieved from a Java Doc web-page 'Details Section', and simultaneously, holds the reflection-data extracted from the '.java' corresponding source-code files - facilitating all changes to a Java Doc Page deemed necessary.

    This Class May be Used to Programmatically Modify JavaDoc HTML

    Modifying JavaDoc HTML can be done using: JavaDocHTMLFile, SummaryTableHTML, ReflHTML and HeaderFooterHTML.

    To get instances of these classes, just register a listener with the Upgrader using: Upgrade.setExtraTasks
    This is optional, as the Standard Upgrader-Features do not necessitate use of this class.

    ReflHTML: "Reflection-HTML"
    This class encapsulates the combination of Reflected Type Information, and the Java Doc HTML that was generated for that reflection. The type-parameter ENTITY should be one of the five NON-Abstract Reflection classes provided by this Upgrader A.P.I. These class can be retrieved from the class JavaDocHTMLFile, using one of it's getter methods.

    The way JavaDocHTMLFile can be retrieved is by registering a handler lambda-expression or method with the Upgrade class, using the method Upgrade.setExtraTasks. Registering a handler with class 'Upgrade' allows a user to make any type of customizations to any Java Doc page needed. It is neither imperative, nor mandatory to understand or use class 'ReflHTML' in order to do a basic Upgrade of a Java-Doc Generated HTML Documentation Directory. Instead, this class is provided for more advanced users who would like a finer-granularity of control in modifying Java Doc Web Pages.

    To begin writing proprietary customizations into Java Doc Web-Pages, an "Extra Tasks Handler" must be registered with the class Upgrade. This handler will be invoked once for each and every Java Doc Web-Page that is processed during the upgrade process. When your handler is called, it may request to change or update just about anything present on the page. The methods that make the Details about methods, fields, constructors on a Java Doc Web-Page are listed in the table below. They may be invoked on the JavaDocHTMLFile that is passed to your handler.
    Reflected Entity JavaDocHTMLFile 'Get' Method
    Methods allMethodDetails()
    Fields allFieldDetails()
    Constructors allConstructorDetails()
    Enum Constants allECDetails()
    Annotation Elements allAEDetails()

    NOTE: The above list is also visible via the "Method Summary Section" for class JavaDocHTMLFile.
    As an example, if the CIET were for class java.util.Vector<E>, and the Entity were Method 'get(int)', the HTML that would be contained by the internal 'html' field Vector<HTMLNode> would be exactly what can be seen in this location on the (Sun-Oracle) page:

    Vector.get(int)

    The Vectorized-HTML in private field 'html' would look as below (copied from the Sun-Oracle site):

    HTML Elements:
    <ul class="blockList">
<li class="blockList">
<h4>get</h4>
<pre>public&nbsp;<a href="../../java/util/Vector.html" title="type parameter in Vector">E</a>&nbsp;get(int&nbsp;index)</pre>
<div class="block">Returns the element at the specified position in this Vector.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../java/util/List.html#get-int-">get</a></code>&nbsp;in interface&nbsp;<code><a href="../../java/util/List.html" title="interface in java.util">List</a>&lt;<a href="../../java/util/Vector.html" title="type parameter in Vector">E</a>&gt;</code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../java/util/AbstractList.html#get-int-">get</a></code>&nbsp;in class&nbsp;<code><a href="../../java/util/AbstractList.html" title="class in java.util">AbstractList</a>&lt;<a href="../../java/util/Vector.html" title="type parameter in Vector">E</a>&gt;</code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>index</code> - index of the element to return</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>object at the specified index</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../java/lang/ArrayIndexOutOfBoundsException.html" title="class in java.lang">ArrayIndexOutOfBoundsException</a></code> - if the index is out of range
            (<code>index &lt; 0 || index &gt;= size()</code>)</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>1.2</dd>
</dl>
</li>
</ul>
    See Also:
    Serialized Form


    • Field Detail

      • serialVersionUID

        🡇  ⇈  ⮫ 🗕  🗗  🗖 
        protected static final long serialVersionUID
        This fulfils the SerialVersion UID requirement for all classes that implement Java's interface java.io.Serializable. Using the Serializable Implementation offered by java is very easy, and can make saving program state when debugging a lot easier. It can also be used in place of more complicated systems like "hibernate" to store data as well.
        See Also:
        Constant Field Values
        Code:
        Exact Field Declaration Expression:
         protected static final long serialVersionUID = 1;

      • entity

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final ENTITY extends Declaration entity
        This is the actual type-reflection (type-mirror) of the Entity extracted from the Java Doc '.html' web-page file, and from the '.java' Source Code File.

        Since the type-parameter ENTITY must extend Declaration, this field will hold all of the information that was parsed & extracted by Java Parser. Depending on what type of instance of Declaration this represents, this will field will contain all of the parameter-names, parameter-types, modifiers, and exceptions that are associated with the entity.

        This will take one of five type's: Method, Constructor, Field, EnumConstant, AnnotationElem. This allows you to retrieve all reflected information, quickly and easily, associated with the Java Doc HTML "Detail Section" for a particular method, field, constructor etc...

      • entityAsEnum

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final Entity entityAsEnum
        This is used as a 'faster-way' to retrieve what type of Entity this "Reference-HTML" detail-section is being represented here. This makes the code more readable than using Java's 'getClass()' reflection to identify whether this 'Detail Section HTML' holds the HTML for a Method, Field, Constructor, Enumeration, etc...

        The value in 'entityAsEnum' shall always be identical to the type of the entity. So for instance, if entity contained a Field instance, this field would be equal to Entity.FIELD. If this entity represented a Method HTML Detail-Section element, then this field would hold Entity.METHOD.

      • htmlID

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final java.lang.String htmlID
        Each Deteail Entity on a JavaDoc Page has a small and empty Anchor-Link, with an ID Attribute that allows the browser to redirect to the detail on a JavaDoc page using a relative URL to redirect to the details location on the web-page. If that detail element was found, it's will be stored in this field. (Otherwise, this field will contain null)

        Below is the <A ID=..> generated by Java Doc for a method that is named 'length', and takes zero parameters as input.

        HTML Elements:
         <a id="length()">
 <!--   -->
 </a>

      • descFromTypeLabel

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final boolean descFromTypeLabel
        This boolean indicates that the HTML description provided by this JavaDoc Detail has been copied from an parent-class or from an interface. In cases where an abstract method is implemented, the programmer may "opt-out" of typing anything about what the method's purpose is. If so, JavaDoc automatically copies the abstract (or parent) method's description, and leaves a little note saying so.

        Note that when this occurs, there will by two HTML <DIV CLASS="block"> elements on the page for that detail.

    • Method Detail

      • name

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.util.Vector<HTMLNode> name()
        Returns an HTML-Vector of the HTML used to display the name of a detail element.

        This also contains the same information as in the field Declaration.name, which is reflected (using Java Parer) from the associated 'java' source-code file. The HTML for this segment is listed, here below:

        HTML Elements:
         <h4> [Name] </h4>


        This returned result of this method is HTML, and it may be modified in any way that the programmer sees fit. Any changes that are made to this HTML will be incorporated into the final version of the Java Doc Page for the detail element HTML.
        Returns:
        An HTML-Vector of the Java Doc name segment of this detail. This method will never return null, as all detail-elements have a name.
        See Also:
        Declaration.name
        Code:
        Exact Method Body:
         return name.html;

      • signature

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.util.Vector<HTMLNode> signature()
        Returns an HTML-Vector of the HTML used to display the signature of a detail element.

        This also contains the same information as in the field Declaration.signature, which is reflected (using Java Parer) from the associated 'java' source-code file. In the HTML below it is the text that appears between the <PRE> tags. Note that the HTML 'class' attribute (present, below) will not always be included in every detail element.

        HTML Elements:
         <h4> [Name] </h4>
 <pre class="Signature"> ... </pre>


        This returned result of this method is HTML, and it may be modified in any way that the programmer sees fit. Any changes that are made to this HTML will be incorporated into the final version of the Java Doc Page for the detail element HTML.
        Returns:
        An HTML-Vector of the Java Doc signature segment of this detail. This method will never return null, as all detail-elements have a signature.
        See Also:
        Declaration.signature
        Code:
        Exact Method Body:
         return signature.html;

      • description

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final java.util.Vector<HTMLNode> description()
        Returns an HTML-Vector of the HTML used to display the description of a detail element.

        This HTML is generated by the Java Doc Tool using the text provided by a programmer in his Java Doc Comments directly above the code in a '.java' file. In a Java Doc '.html' file, the description is always surrounded by an HTML divider ('<DIV>') element, as appears below:

        HTML Elements:
         <div class="block"> ... [Text-Description of Method, Field, etc...] ... </div>


        This returned result of this method is HTML, and it may be modified in any way that the programmer sees fit. Any changes that are made to this HTML will be incorporated into the final version of the Java Doc Page for the detail element HTML.
        Returns:
        An HTML-Vector of the Java Doc description segment of this detail. Since a description is not mandatory, and it is not an auto-generated segment of a detail element, this method will return null if a programmer has not written or included a description for this particular detail element in his source-code for this detail element.
        Code:
        Exact Method Body:
         SubSection s = subSections.get(DESCRIPTION_KEY);
 return (s!= null) ? s.html : null;

      • annotationDefault

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.util.Vector<HTMLNode> annotationDefault()
        Returns an HTML-Vector of the HTML used to display the Default Annotation Element Value of an Annotation-Detail element.

        This also contains the same information as in the field AnnotationElem.defaultValue, which is reflected (using Java Parer) from the associated 'java' source-code file. The HTML for this segment is listed, here below:

        HTML Elements:
         <dl>
 <dt>Default:</dt>
 <dd> [ some values possibly inserted here ]</dd>
 </dl>


        This returned result of this method is HTML, and it may be modified in any way that the programmer sees fit. Any changes that are made to this HTML will be incorporated into the final version of the Java Doc Page for the detail element HTML.

        Unless this detail is an "Annotation Detail", calling this method will generate an exception-throw.
        Returns:
        An HTML-Vector of an annotation detail element's Default Value. If the annotation does not have a default value assigned, or it is not present on the Java Doc Page, this method will return null.
        Throws:
        DetailsException - If the ReflHTML instance on which this method is being invoked is not for an Annotation Detail, the invocation will generate a DetailsException
        See Also:
        AnnotationElem.defaultValue
        Code:
        Exact Method Body:
         if (entityAsEnum != Entity.ANNOTATION_ELEM)

     throw new DetailsException(
         "This ReflHTML is a Reflection of a(n) " + entityAsEnum.toString() + " details, " +
         "however only Annotations may have Annotation-Element Default Values."
     );

 SubSection s = subSections.get(ANNOTATION_DEFAULT_KEY);
 return (s!= null) ? s.html : null;

      • returns

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.util.Vector<HTMLNode> returns()
        Returns an HTML-Vector of the HTML used to display the Returns: segment of a Method Detail element.

        This also contains some of the information present in the field Method.returnType, which is reflected (using Java Parer) from the associated 'java' source-code file.

        This HTML is auto-generated by Java Doc using the @return taglet's, which may be provided by a programmer in his '.java' source-code file. The HTML output generated by Java Doc is as below:

        HTML Elements:
         <dt><span class="returnLabel">Returns:</span></dt>
 <dd> [User-Provided Return-Value Information, as HTML, Here] </dd>


        This returned result of this method is HTML, and it may be modified in any way that the programmer sees fit. Any changes that are made to this HTML will be incorporated into the final version of the Java Doc Page for the detail element HTML.

        Only methods may have return-values. Furthermore, only methods for which the programmer has provided a @return taglet entry will the result of this method be non-null.
        Returns:
        An HTML-Vector of a method detail element's Returns: label. If the method does not have such a label, because the programmer did not provide a @return taglet, this method will return null.
        Throws:
        DetailsException - If the ReflHTML instance on which this method is being invoked is not for an Method Detail, the invocation will generate a DetailsException
        See Also:
        Method.returnType
        Code:
        Exact Method Body:
         if (entityAsEnum != Entity.METHOD)

     throw new DetailsException(
         "This ReflHTML is a Reflection of a(n) " + entityAsEnum.toString() + " details, " +
         "however only Methods may have Return-Values."
     );

 SubSection s = subSections.get(RETURNS_KEY);
 return (s!= null) ? s.html : null;

      • seeAlso

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.util.Vector<HTMLNode> seeAlso()
        Returns an HTML-Vector of the HTML used to display the See Also: segment of any detail element.

        This HTML is auto-generated by Java Doc using the @see taglet's, which may be provided by a programmer in his '.java' source-code file. The HTML output generated by Java Doc is as below:

        HTML Elements:
         <dt><span class="seeLabel">See Also:</span></dt>
 <dd><a href="#someMethod()"><code>someMethod()</code></a></dd>


        This returned result of this method is HTML, and it may be modified in any way that the programmer sees fit. Any changes that are made to this HTML will be incorporated into the final version of the Java Doc Page for the detail element HTML.

        Only detail elements for which the programmer has provided at least one @see taglet entry will the result of this method be non-null.
        Returns:
        An HTML-Vector of a method detail element's See Also: label. If the method does not have such a label, because the programmer did not provide any @see taglet, this method will return null.
        Code:
        Exact Method Body:
         SubSection s = subSections.get(SEE_ALSO_KEY);
 return (s!= null) ? s.html : null;

      • throwing

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.util.Vector<HTMLNode> throwing()
        Returns an HTML-Vector of the HTML used to display the Throws: segment of a Method or Constructor Detail element.

        This also contains some of the information present in the field Callable.exceptions, which is reflected (using Java Parer) from the associated 'java' source-code file.

        This HTML is auto-generated by Java Doc using the @throws taglet's, which may be provided by a programmer in his '.java' source-code file. If a method or constructor is throwing checked exceptions, Java Doc will auto-create a 'Throws:' label / segment. The HTML output generated by Java Doc is as below:

        HTML Elements:
         <dt><span class="throwsLabel">Throws:</span></dt>
 <dd> [Text explaining thrown exceptions by a method or constructor]</dd>


        This returned result of this method is HTML, and it may be modified in any way that the programmer sees fit. Any changes that are made to this HTML will be incorporated into the final version of the Java Doc Page for the detail element HTML.

        Only methods and constructors are capable of throwing exceptions. Furthermore, only details for which the programmer has provided a @throws taglet entry (or which throw checked-exceptions) will the result of this method be non-null.
        Returns:
        An HTML-Vector of a method or constructor detail element's Throws: label. If the detail does not have such a label, this method will return null.
        Throws:
        DetailsException - If the ReflHTML instance on which this method is being invoked is neither a Method Detail nor a Constructor Detail, the invocation will generate a DetailsException
        See Also:
        Callable.exceptions
        Code:
        Exact Method Body:
         if ((entityAsEnum != Entity.METHOD) && (entityAsEnum != Entity.CONSTRUCTOR))

     throw new DetailsException(
         "This ReflHTML is a Reflection of a(n) " + entityAsEnum.toString() + " details, " +
         "however only Methods and Constructors may throw Exceptions."
     );

 SubSection s = subSections.get(THROWS_KEY);
 return (s!= null) ? s.html : null;

      • parameters

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.util.Vector<HTMLNode> parameters()
        Returns an HTML-Vector of the HTML used to display the Parmeters: segment of a Method or Constructor Detail element.

        This also contains some of the information present in the fields Callable.parameterNames and Callable.parameterTypes, which is reflected (using Java Parer) from the associated 'java' source-code file.

        This HTML is auto-generated by Java Doc using the @param taglet's, which may be provided by a programmer in his '.java' source-code file. The HTML output generated by Java Doc is as below:

        HTML Elements:
         <dt><span class="paramLabel">Parameters:</span></dt>
 <dd><code>[Parameter Name]</code> - [Some Parameter Description]</dd>


        This returned result of this method is HTML, and it may be modified in any way that the programmer sees fit. Any changes that are made to this HTML will be incorporated into the final version of the Java Doc Page for the detail element HTML.

        Only methods and constructors may accept input parameters. Furthermore, only details for which the programmer has provided a @param taglet entry will there be parameter descriptive-text on a Java Doc Page. The result of this method will be non-null, only in cases where such descriptions have been included in their JavaDoc commenting.
        Returns:
        An HTML-Vector of a method or constructor detail element's Parameters: label. If the detail does not have such a label, this method will return null.
        Throws:
        DetailsException - If the ReflHTML instance on which this method is being invoked is neither a Method Detail nor a Constructor Detail, the invocation will generate a DetailsException
        See Also:
        Callable.parameterNames, Callable.parameterTypes
        Code:
        Exact Method Body:
         if ((entityAsEnum != Entity.METHOD) && (entityAsEnum != Entity.CONSTRUCTOR))

     throw new DetailsException(
         "This ReflHTML is a Reflection of a " + entityAsEnum.toString() + " details, " +
         "however only Methods and Constructors may have Parameters."
     );

 SubSection s = subSections.get(PARAMETERS_KEY);
 return (s!= null) ? s.html : null;

      • typeParameters

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.util.Vector<HTMLNode> typeParameters()
        Returns an HTML-Vector of the HTML used to display the Type Parmeters: segment of a Method or Constructor Detail element.

        This HTML is auto-generated by Java Doc using the @param <T> taglet's, which may be provided by a programmer in his '.java' source-code file. The HTML output generated by Java Doc is as below:

        HTML Elements:
         <dt><span class="paramLabel">Type Parameters:</span></dt>
 <dd><code>[Type Parameter <T>]</code> - [Some Type Parameter Description]</dd>


        This returned result of this method is HTML, and it may be modified in any way that the programmer sees fit. Any changes that are made to this HTML will be incorporated into the final version of the Java Doc Page for the detail element HTML.

        Only methods and constructors will allow type-parameters. Furthermore, only details for which the programmer has provided a @param <T> taglet entry will there be parameter descriptive-text on a Java Doc Page. The result of this method will be non-null, only in cases where such descriptions have been included in their JavaDoc commenting.
        Returns:
        An HTML-Vector of a method or constructor detail element's Type Parameters: label. If the detail does not have such a label, this method will return null.
        Throws:
        DetailsException - If the ReflHTML instance on which this method is being invoked is neither a Method Detail nor a Constructor Detail, the invocation will generate a DetailsException
        Code:
        Exact Method Body:
         if ((entityAsEnum != Entity.METHOD) && (entityAsEnum != Entity.CONSTRUCTOR))

     throw new DetailsException(
         "This ReflHTML is a Reflection of a(n) " + entityAsEnum.toString() + " details, " +
         "however only Methods and Constructors may have Type-Parameters."
     );

 SubSection s = subSections.get(TYPE_PARAMETERS_KEY);
 return (s!= null) ? s.html : null;

      • overrides

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.util.Vector<HTMLNode> overrides()
        Returns an HTML-Vector of the HTML used to display the Overrides: segment of a Method Detail element.

        This HTML is auto-generated by Java Doc, for methods which override a parent class or interface. The HTML output generated by Java Doc is as below:

        HTML Elements:
         <dt><span class="overrideSpecifyLabel">Overrides:</span></dt>
 <dd><code> [ Some Name ]</code>&nbsp;in interface&nbsp;<code> [Interface Name] </code></dd>


        This returned result of this method is HTML, and it may be modified in any way that the programmer sees fit. Any changes that are made to this HTML will be incorporated into the final version of the Java Doc Page for the detail element HTML.

        Only methods may override other methods. The result of this method will be non-null, only in cases where the Method Detail on which this invocation was made is actually an overrided method.
        Returns:
        An HTML-Vector of a method detail element's Overrides: label. If the detail does not have such a label, this method will return null.
        Throws:
        DetailsException - If the ReflHTML detail instance on which this method is being invoked is not a Method Detail, then a DetailsException will throw.
        Code:
        Exact Method Body:
         if (entityAsEnum != Entity.METHOD)

     throw new DetailsException(
         "This ReflHTML is a Reflection of a(n) " + entityAsEnum.toString() + " details, " +
         "however only Methods may have \"Overrides:\" Labels."
     );

 SubSection s = subSections.get(OVERRIDES_KEY);
 return (s!= null) ? s.html : null;

      • specifiedBy

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.util.Vector<HTMLNode> specifiedBy()
        Returns an HTML-Vector of the HTML used to display the Specified by: segment of a Method Detail element.

        This HTML is auto-generated by Java Doc, for methods which implement another method that was specified by an interface which the type implements, or a method specified by an abstract parent super-class. The HTML output generated by Java Doc is as below:

        HTML Elements:
         <dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
 <dd><code> [ Some Name ]</code>&nbsp;in interface&nbsp;<code> [Interface Name] </code></dd>


        This returned result of this method is HTML, and it may be modified in any way that the programmer sees fit. Any changes that are made to this HTML will be incorporated into the final version of the Java Doc Page for the detail element HTML.

        Only methods may implement a "specified-method" (obviously!) The result of this method will be non-null - only in cases where the Method Detail on which this invocation was made actually implements another abstract method declaration.
        Returns:
        An HTML-Vector of a method detail element's Specified by: label. If the detail does not have such a label, this method will return null.
        Throws:
        DetailsException - If the ReflHTML detail instance on which this method is being invoked is not a Method Detail, then a DetailsException will throw.
        Code:
        Exact Method Body:
         if (entityAsEnum != Entity.METHOD)

     throw new DetailsException(
         "This ReflHTML is a Reflection of a(n) " + entityAsEnum.toString() + " details, " +
         "however only Methods may have \"Specified-By:\" Labels."
     );

 SubSection s = subSections.get(SPECIFIED_BY_KEY);
 return (s!= null) ? s.html : null;

      • since

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.util.Vector<HTMLNode> since()
        Returns an HTML-Vector of the HTML used to display the Specified by: segment of a Method Detail element.

        HTML Elements:
         <dt><span class="simpleTagLabel">Since:</span></dt>
 <dd> [ Version Number Information ]</dd>


        This returned result of this method is HTML, and it may be modified in any way that the programmer sees fit. Any changes that are made to this HTML will be incorporated into the final version of the Java Doc Page for the detail element HTML.

        Only details for which the programmer has provided a @since taglet entry will there be 'since' descriptive-text on a Java Doc Page. The result of this method will be non-null, only in cases where such version-information has been included in their JavaDoc commenting.
        Returns:
        An HTML-Vector of a method detail element's Since: label. If the detail does not have such a label, this method will return null.
        Code:
        Exact Method Body:
         SubSection s = subSections.get(SINCE_KEY);
 return (s!= null) ? s.html : null;

      • detailNavBar

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.util.Vector<HTMLNode> detailNavBar()
        Returns an HTML-Vector of the HTML used to display the Navigation Button-Bar of a detail element.

        This is a row of buttons that is present directly below the signature of an HTML Detail-Entry. This row of buttons is automatically generated by the Java-Doc Upgrader Tool. It isn't Standard JavaDoc HTML.

        The actual HTML inserted by the Upgrader-Tool is included directly below:

        HTML Elements:
         <DIV CLASS=DetailNav>
      <A HREF='#openTagPWA()'>&#129093;</A>
      &nbsp;<A HREF='#isOpenTagPWA()'>&#129095;</A>
      &nbsp;<A onclick="flashSumm('MD244')">&#8648;</A>
      &nbsp;<A HREF='hilite-files/HTMLNode.java.html#L273'>&#11179;</A>
      <SPAN>
          <A onclick='minimize(244)'>&#x1F5D5;</A>
          &nbsp;<A onclick='partialize(244)'>&#x1F5D7;</A>
          &nbsp;<A onclick='maximize(244)'>&#x1F5D6;</A>
      </SPAN>
      <NOSCRIPT>
      <DIV ID=NoScriptMPMAB>JavaScript is disabled on your browser.</DIV>
      </NOSCRIPT>
 </DIV>


        This returned result of this method is HTML, and it may be modified in any way that the programmer sees fit. Any changes that are made to this HTML will be incorporated into the final version of the Java Doc Page for the detail element HTML.
        Returns:
        An HTML-Vector of the Java Doc Navigation Button-Bar segment of this detail. This method will never return null, as all detail-elements have these buttons.
        Code:
        Exact Method Body:
         return detailNavBar;

      • clone

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public ReflHTML<ENTITY> clone()
        Java's interface Cloneable requirements. This provides a "Deep Clone", where all internal Vector's and SubSection's are also cloned, rather than a "Shallow Clone", having identical references.
        Overrides:
        clone in class java.lang.Object
        Returns:
        A new ReflHTML whose internal fields are identical to this one.
        Code:
        Exact Method Body:
         return new ReflHTML<>(this);

      • compareTo

        🡅  ⇈  ⮫ 🗕  🗗  🗖 
        public final int compareTo​(ReflHTML other)
        Java's interface Comparable<T> requirements. This does a very simple comparison using the location field.

        FINAL METHOD: This method is declared final, and cannot be modified by sub-classes.
        Specified by:
        compareTo in interface java.lang.Comparable<ENTITY extends Declaration>
        Parameters:
        other - Any other ReflHTML to be compared to 'this' ReflHTML
        Returns:
        An integer that fulfils Java's interface Comparable<T> public boolean compareTo(T t) method requirements.
        See Also:
        DotPair.compareTo(DotPair)
        Code:
        Exact Method Body:
         return this.location.compareTo(other.location);