Class AnnotationElem

  • All Implemented Interfaces:
    java.io.Serializable, java.lang.Cloneable, java.lang.Comparable<AnnotationElem>
    public class AnnotationElem
extends Declaration
implements java.io.Serializable, java.lang.Comparable<AnnotationElem>, java.lang.Cloneable
    Similar to java.lang.reflect
    This class is heavily used internally, and can be used (if needed) to modify Java Doc Web-Pages, programmatically.

    HTML Processors that sort the Web-Page "Summary-Tables" will provide instances of this class to your Summary-Sorter Handler methods. Summary-Sorter handlers usually implement the SummarySorterHelper interface; please review that class for more about sorting Java-Doc Page Summary Tables.

    The HTML Processors that upgrade Web-Page "Detail Elements" also rely heavily on this class. Please review the class: ReflHTML for more information about Java-Doc Web-Page Detail Sections.
    Reflection Class:
    Holds all information extracted from '.java' Annotation (@interface) Source-Files about all Elements identified in that file.

    Instances of this Class are Obtained From: ReflHTML & SummaryTableHTML

    Use of the Reflection-HTML API is *NOT REQUIRED* to perform a standard Java Doc HTML File Upgrade. This "extra API" allows for programmatic modification of Java Doc HTML. This class contains quite a bit of reflected information, and furthermore, here there is a hook to the Native Java Parser Reflection Class.
    Class class AnnotationElem allows for storing the name, definition, default-value, etc... of an Annotation Element. Note that an 'Annotation Element' is not the same as a Java 'Annotation' (@interface). An 'Annotation Element' is merely the (optional) element / parameter which may (if used) help specify the contents of a Java Annotation.

    For Instance: With the commonly-used annotation named @SuppressWarnings(...), the Value-Parameters that are passed inside the parenthesis are the 'value' Annotation-Element. This 'value' may be assigned several Java String's such as: 'rawtypes', 'unchecked', etc...
    See Also:
    Serialized Form


    • Field Detail

      • serialVersionUID

        🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public 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:
         public static final long serialVersionUID = 1;

      • type

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final java.lang.String type
        An Annotation-Element may only assume one of several types, as per the Java Sun / Oracle Documentation. The type must be one of the following, or a compile-time error occurs:

        • a primitive type
        • String
        • Class or an invocation of Class
        • An enum type
        • An annotation type
        • An (1 dimensional) array type whose component type is one of the preceding types
        Code:
        Exact Field Declaration Expression:
         public final String type;

      • typeJOW

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final java.lang.String typeJOW
        JOW: Just One Word
        The Just One Word convention used by the JDU Tool elminates BOTH Package-Name Information AND (for Inner-Types / Nested-Types) any & all Container-Class Information from the Type-String's.

        The Java-Doc Upgrader does not perform a Compiler-Styled "Linking Pass" on the Java-Doc Web-Pages it parses, and must suffice with the unlinked Type-Names provided by the Oracle AST-Parser and Java-Doc '.html' Output Pages.
        Code:
        Exact Field Declaration Expression:
         public final String typeJOW;

      • defaultValue

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final java.lang.String defaultValue
        The default value assigned to this element. This may be null if there is no assigned default value.
        Code:
        Exact Field Declaration Expression:
         public final String defaultValue;

      • methodTree

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final transient com.sun.source.tree.MethodTree methodTree

        Hook Reference to Sun/Oracle Parser-Refletion Class

        Though this class offers a streamlined set of reflection features, the Native Oracle Library Reflection-Classes offer a detailed AST interface into the standard Java Compiler. If you would like to use these Tree's to provide further code analysis on your Java-Doc Pages, this field is provided as a convenience for such purposes.
        If a user decides to make use of the native Oracle MethodTree instance that was used to build this AnnotationElem instance, it may be retrieved from this transient field.

        MethodTree Note:
        The package com.sun.source.tree "reuses" or "overloads" the MethodTree class. com.sun.source.tree.MethodTree can actually represent either a Method, or an Annotation-Element (or even a Constructor! but that's besides the point).
        Code:
        Exact Field Declaration Expression:
         public final transient MethodTree methodTree;

    • Method Detail

      • toString

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.lang.String toString()
        Generates a String of this Annotation Element, with all information included.
        Overrides:
        toString in class Declaration
        Returns:
        A printable string of this AnnotationElem.
        See Also:
        toString(int)
        Code:
        Exact Method Body:
         String def = (defaultValue != null)
     ? ("Default:      [" + StrPrint.abbrevEndRDSF(defaultValue, MAX_STR_LEN, true) +
         "]\n") 
     : "";
    
 return
     "Name:         [" + name + "]\n" +
     "Declaration:  [" + StrPrint.abbrevEndRDSF(signature, MAX_STR_LEN, true) + "]\n" +
     "Type:         [" + typeJOW + "]\n" +
     "Modifiers:    [" + StrCSV.toCSV(modifiers, true, true, null) + "]\n" +
     def +

     // This will **NEVER** be null - unless 'this' instance was built from an HTML File,
     // rather than a source-code file.  Instances like that are only used temporarily, and
     // are garbage collected instantly.  Do this check anyway (just in case).

     "Location:     " + ((this.location == null)
         ? "null" 
         : ('[' + this.location.quickSummary() + ']'));

      • toString

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.lang.String toString​(int flags)
        This method accepts a 'flags' parameter which has been constructed using the Bit-Masks provided by the PF class. Please view the Static-Constants which are provided by class PF for more information about modifying the return-value of this toString(int) method.

        There is additional information printed by this 'toString' method (versus the zero-argument, standard, Java 'toString'). This method will print any available Java-Doc Comment's that were placed on this AnnotationElem.

        This 'toString' also allows for adding UNIX-Terminal color codes.
        Overrides:
        toString in class Declaration
        Parameters:
        flags - These are defined in the Print-Flags class
        Returns:
        A printable String of this AnnotationElem.
        See Also:
        PF, toString()
        Code:
        Exact Method Body:
         boolean color = (flags & UNIX_COLORS) > 0;

 return
     printedName("Element", 14, color) + 
     printedDeclaration(14, color) +
     "Type-JOW:     [" + typeJOW + "]\n" + 
     printedModifiers(14) +
     printedLocation(14, color, (flags & BRIEF_LOCATION) > 0) +

     // The previous method does not add a '\n' end to the end of the returned string
     // These are both optional, they add a '\n' AT THE BEGINNING if one of them is included

     printedDefault(color) +
     printedComments(14, color, (flags & JAVADOC_COMMENTS) > 0);

      • compareTo

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public int compareTo​(AnnotationElem ae)
        Java's interface Comparable<T> requirements. This does a very simple comparison using the two elements' Declaration.name field.
        Specified by:
        compareTo in interface java.lang.Comparable<AnnotationElem>
        Parameters:
        ae - Any other AnnotationElem to be compared to 'this' AnnotationElem
        Returns:
        An integer that fulfills Java's Comparable<AnnotationElem> interface requirements.
        Code:
        Exact Method Body:
         return (this == ae) ? 0 : this.name.compareTo(ae.name);

      • equals

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public boolean equals​(AnnotationElem other)
        This should be called an "atypical version" of the usual equals(Object other) method. This version of equals merely compares the name of the element defined. The presumption here is that the definition of an 'element' only has meaning - at all - inside the context of an Annotation where that element has been defined. Since inside any '.java' Annotation, there may only be one element with a given name, this method shall return TRUE whenever the element being compared also has the same name.
        Parameters:
        other - This may be any other Annotation-Element. It is strongly suggested that 'other' be an element defined in the same '.java' source-code file as 'this' element.
        Returns:
        This method returns TRUE when 'this' instance of AnnotationElem has the same 'name' as the name of input-parameter 'other'
        Code:
        Exact Method Body:
         return this.name.equals(other.name);

      • getTokenStreams

        🡅  ⇈  ⮫ 🗕  🗗  🗖 
        public ReadOnlyList<ReadOnlyList<java.lang.String>> getTokenStreams()
        Description copied from class: Declaration
        Chat-GPT and me wrote a Token-Stream Generator-Method that can be used for creating the List-Data that needs to be sent to the Embeddings-Generator for creating an Embeddings-RAG using my Reflection-Classes.
        Specified by:
        getTokenStreams in class Declaration
        Returns:
        A proper list of "Chunked Tokens" that may be sent to the Open-AI REST-API to generate an Embeddings-Vector
        Code:
        Exact Method Body:
         final ROArrayListBuilder<ReadOnlyList<String>>  tokens  = new ROArrayListBuilder<>();
 ROArrayListBuilder<String>                      b       = new ROArrayListBuilder<>();

 tokens.add(ReadOnlyList.of("SECTION", "entity", "annotation-element"));
 tokens.add(ReadOnlyList.of("SECTION", "name", this.name));
 tokens.add(ReadOnlyList.of("SECTION", "type", this.typeJOW));
    
 if ((this.defaultValue != null) && (!this.defaultValue.isEmpty()))
     tokens.add(ReadOnlyList.of("SECTION", "default", this.defaultValue));
    
 if ((this.annotations != null) && (this.annotations.size() > 0))
 {
     b.add("SECTION");
     b.add("annotations");
     for (String a : this.annotations) b.add(a);
     tokens.add(b.build());
 }
    
 return tokens.build();