Class AnnotationElem

  • All Implemented Interfaces:, java.lang.Cloneable, java.lang.Comparable<AnnotationElem>

    public class AnnotationElem
    extends Declaration
    implements, java.lang.Comparable<AnnotationElem>, java.lang.Cloneable
    Extension of Package java.lang.reflect
    This class provides a hook into the native Java Parser JAR Library AnnotationMemberDeclaration.

    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.
    Java Parser Bridge: 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.
    The purpose of this bridge is provide a pared down, easier-to-use (but-with less-features) version of the publicly available "JavaParser" package. This 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...

    There is a Java-Parser Library that is required to use this Package. The Java Doc Upgrader Package / Tool will not work without this '.jar'file being placed in your CLASSPATH environment-variable. That '.jar'is available here:

    There is a book available and an internet "Gitter" support web-site chat-room with some of the people involved in writing this library. There are quite a number of available jars in the "Master Jar Distribution" - but the core library jar is fully sufficient for running the tasks needed by this Java-Doc Upgrade Tool's logic.

    Reflection-Classes Inheritance-Diagram

    Class Declaration
    Class Callable
    Class Method
    Class Constructor
    Also Inherits Class Callable
    No Additional Fields
    Reflection Class
    Inheritance Diagram

    Class Field
    Class EnumConstant
    Class AnnotationElem
    Class NestedType

    All reflection classes above, also contain an additional (transient, non-Serializable) field that hooks into the native Java-Parser Library classes, providing an option for a more in-depth or complete analysis using that Library's features & extensive utilities.

    O'Rielly Note:
    COPIED VERBATIM FROM: O'Rielly Publishing, Java in a Nutshell (5th Edition, by David Flanagan)
    Defining Annotation Types: An annotation type is an interface, but it is not a normal one. An annotation type differs from a normal interface in the following ways:
    • An annotation type is defined with the keyword @interface rather than with interface. An @interface declaration implicitly extends the interface java.lang.annotation.Annotation and may not have an explicit extends clause of its own.
    • The methods of an annotation type must be declared with no arguments and may not throw exceptions. These methods define annotation members: the method name becomes the member name, and the method return type becomes the member type.
    • The return value of annotation methods may be a primitive type, a String, a Class, an enumerated type, another annotation type, or a single-dimensional array of one of those types.
    • Any method of an annotation type may be followed by the keyword default and a value compatible with the return type of the method. This strange new syntax specifies the default value of the annotation member that corresponds to the method. The syntax for default values is the same as the syntax used to specify member values when writing an annotation. null is never a legal default value.
    • Annotation types and their methods may not have type parameters—annotation types and members cannot be made generic. The only valid use of generics in annotation types is for methods whose return type is Class. These methods may use a bounded wildcard to specify a constraint on the returned class.
    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 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
        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
        Exact Field Declaration Expression:
         public final String type;
      • typeJOW

        public final java.lang.String typeJOW

        JOW: Just One Word

        The Just One Word convention in the upgrader tool elminates package-name information from type-String's.
        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.
        Exact Field Declaration Expression:
         public final String defaultValue;
      • annotationMemberDeclaration

        public final transient com.github.javaparser.ast.body.AnnotationMemberDeclaration annotationMemberDeclaration

        Hook Reference to Java-Parser Refletion Class

        Though this class offers a streamlined set of reflection features, the Native Java-Parser Library Reflection-Classes offer a near-complete set of analysis tools for just about any kind of code-analysis neccessary. If you would like your Java Doc Pages to include more analytical-information, this field is provided as a convenience for such purposes.
        If a user decides to make use of the Java-Parser AnnotationMemberDeclaration instance that was used to build this AnnotationEleme, it may be retrieved from this transient field.
        Exact Field Declaration Expression:
         public final transient AnnotationMemberDeclaration annotationMemberDeclaration;
      • 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 Sun/Oracle MethodTree instance that was used to build this Constructor instance, it may be retrieved from this transient field.

        NOTE: The package com.sun.source.tree "reuses" or "overloads" the MethodTree object such that it may represent either a Method, or an Annotation Element (or even a Constructor).

        Since Java Annotations do not actually have methods or constructors, when a MethodTree instance is one of the Members of a Class-Tree, it should always be treated as an Annotation-Element (rather than a method or constructor),
        Exact Field Declaration Expression:
         public final transient MethodTree methodTree;
    • Constructor Detail

      • AnnotationElem

        public AnnotationElem​(com.sun.source.tree.MethodTree mt,
                              TreeUtils util)
        Constructs an instance of this class, AnnotationElem. A parsed AST node that has been compiled by Java's Source-Parser, and the exact instance of TreeUtils that generated the parsed node must be passed by parameter to this constructor.
        mt - Any instance of a Java AST AnnotationElem Node. It is required that this member / entity AST-Node is one which the Java-Compiler generated using the exact same TreeUtils instance also being passed by parameter here.

        Any time that the Java-Compiler parses a 'AnnotationElem' Member / Entity, that member is converted into an instance of the AST-Node MethodTree.
        util - This utility class will contain references to all of the most important instances that are used when compiling a standard Java Souce-Code ('.java' File). In this Java-Doc Web-Page 'Upgrade' Package, whenever any '.java' file is compiled and converted into an Abstract Syntax Tree, a new instance of TreeUtils will be created / generated.

        Each source-file in a Java-Project will be compiled once, and converted into an instance of TreeUtils. Note that it is imperative that the TreeUtils instance being passed to this method is the same instance that was used to generate the AnnotationElem-Node instance with this constructor-invocation.

        An instance of TreeUtils. is always available as a member-field of the top-level class JavaDocHTMLFile.treeUtils.
    • Method Detail

      • toString

        public java.lang.String toString()
        Generates a String of this Annotation Element, with all information included.
        toString in class Declaration
        A printable string of this AnnotationElem.
        See Also:
        StrCSV.toCSV(String[], boolean, boolean, Integer), toString(int)
        Exact Method Body:
         String def = (defaultValue != null)
             ? ("Default:      [" + StrPrint.abbrevEndRDSF(defaultValue, MAX_STR_LEN, true) +
             : "";
             "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)
        Generates a String of this Annotation Element, with all information included. This will also included any content requested by the 'flags' parameter. For this class (class AnnotationElem), the only additional information printed by this 'toString' method is the Java-Doc Comment String.

        This String may also have UNIX color codes added.
        toString in class Declaration
        flags - These are the toString(...) flags from class PF ("Print Flags"). View available flags listed in class PF.
        A printable String of this AnnotationElem.
        See Also:
        PF, StrCSV.toCSV(String[], boolean, boolean, Integer), toString()
        Exact Method Body:
         boolean color = (flags & UNIX_COLORS) > 0;
             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);
      • clone

        public AnnotationElem clone()
        Java's interface Cloneable requirements. This instantiates a new AnnotationElem with identical fields.
        clone in class java.lang.Object
        A new AnnotationElem whose internal fields are identical to this one. A deep copy on all internal arrays is performed. New arrays are instantiated.
        Exact Method Body:
         return new AnnotationElem(this);
      • compareTo

        public int compareTo​(AnnotationElem ae)
        Java's interface Comparable<T> requirements. This does a very simple comparison using the two elements' 'name' field.
        Specified by:
        compareTo in interface java.lang.Comparable<AnnotationElem>
        ae - Any other AnnotationElem to be compared to 'this' AnnotationElem
        An integer that fulfills Java's interface Comparable<AnnotationElem> public boolean compareTo(AnnotationElem ae) method requirements.
        Exact Method Body:
         return (this == ae) ? 0 :;
      • 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.
        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.
        This method returns TRUE when 'this' instance of AnnotationElem has the same 'name' as the name of input-parameter 'other'
        Exact Method Body: