Class Field

  • All Implemented Interfaces:
    java.io.Serializable, java.lang.Cloneable, java.lang.Comparable<Field>

    public class Field
    extends Declaration
    implements java.io.Serializable, java.lang.Comparable<Field>, java.lang.Cloneable
    Java Parser Bridge: Holds all information extracted from '.java' Source Files about Field's identified in that file.

    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 Field allows for storing the name, definition and modifiers list of a field.

    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:

    http://developer.torello.directory/ralphsReference/jars/javaparser-core-3.16.2.jar

    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.

    Class Inheritance Diagram for Reflection Classes


    Class Declaration
     
    intid
    Entityentity
     
    Stringname
    Stringsignature
    StringjdComment
     
    String[]modifiers
    String[]annotations
     
    intsignatureLineNumber
    intjdStartLineNumber
    intjdEndLineNumber
     
     
     
     
     
    Class Callable
     
    Stringbody
     
    String[]parameterNames
    String[]parameterTypes
    String[]parameterTypesJOW
    String[][]parameterAnnotations
     
    String[]exceptions
     
     
     
     
     
    Class Method
     
    StringreturnType
    StringreturnTypeJOW
     
     
     
     
     
    Class Constructor
    Inherits Class Callable
    No Additional Fields
    Java Parser Bridge
    Inheritance Diagram


    Class Field
     
    Stringdefinition
    Stringtype
    StringtypeJOW
     
     
     
     
     
    Class EnumConstant
     
    String[]paramExpressions
     
     
     
     
     
    Class AnnotationElem
     
    StringdefaultValue
    Stringtype
    StringtypeJOW
     
     
     
     
     
    Class NestedType
     
    CIETciet
    intnumFields
    intnumMethods
     
    StringfullyQualifiedName
    StringnameWithContainer
    StringpackageName
     
    String[]extendedTypesJOW
    String[]implementedTypesJOW
    String[]genericTypeParameters
     
     
     
     
     




    IMPORTANT:
    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.
    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;
        
      • definition

        🡅  🡇    
        public final java.lang.String definition
        The definition of this field, as a String.
        Code:
        Exact Field Declaration Expression:
        public final String definition;
        
      • type

        🡅  🡇    
        public final java.lang.String type
        The type / class of this field, as a String.
        Code:
        Exact Field Declaration Expression:
        public final String type;
        
      • typeJOW

        🡅  🡇    
        public final java.lang.String typeJOW
        The type / class of this field, as a String.

        JOW: Just One Word

        If the String's in a type-as-String contain complicated or intricate detailed information, and all you need is a simple identifier, the JOW-String stores the type-as-String with all package-name and generic-parameters (if they were present / included) stripped from the String. Furthermore, if the type was originally an inner-class, even the containing class-name is removed from the JOW-String.

        If a parameter to a Method, or the type of a Field had the (fully-qualified) type-name: java.util.stream.Stream.Builder<String>, the JOW-String would simply have the word "Builder".

        NOTE: If the type, itself, is an array of any kind, the array-brackets will be included in this String-name.
        Output Single-Word, Type-StringInput Type
        "Entry" "java.util.Map.Entry<K, V>"
        "Vector" "java.util.Vector<E>"
        "Vector" "Vector<TagNode>"
        "Vector" "Vector<Vector<TagNode>>"
        "Vector" "java.util.Vector<Vector<TagNode>>"
        "String" "String"
        "String" "java.lang.String"
        "String[]" "java.lang.String[]"
        "Integer" "Integer"
        "Integer[]" "java.lang.Integer[]"

        NOTE: You may view the StringParse class' methods removeGeneric, and typeToJavaIdentifier for more information.
        Code:
        Exact Field Declaration Expression:
        public final String typeJOW;
        
      • variableDeclarator

        🡅  🡇    
        public final transient com.github.javaparser.ast.body.VariableDeclarator variableDeclarator
        If a user decides to make use of the Java-Parser VariableDeclarator instance that was used to build this Field, it may be retrieved from this transient field.
        Code:
        Exact Field Declaration Expression:
        public final transient VariableDeclarator variableDeclarator;
        
    • Constructor Detail

      • Field

        🡅  🡇    
        public Field​
                    (com.github.javaparser.ast.body.VariableDeclarator vd,
                     com.github.javaparser.ast.NodeList<com.github.javaparser.ast.expr.AnnotationExpr> annotations,
                     com.github.javaparser.ast.NodeList<com.github.javaparser.ast.Modifier> modifiers,
                     java.lang.String signature,
                     java.util.Optional<com.github.javaparser.ast.comments.JavadocComment> javaDocComment)
        
        Constructs an instance of 'Field' using the parameters that the 'Visitor' class from Java-Parser passes to the class 'SourceFile'. These parameters are passed to this constructor as the class 'SourceFile' parses a '.java' source-code file.

        IMPORTANT NOTE: A field is the line of Java that reads like: public static final int MYINT = 1;

        HOWEVER: A VariableDeclarator and FieldDeclaration are basically the same, but sometimes there are more more than one variable-declarations per field-declaration.

        For example: public static final int myIntA, myIntB;

        IN THAT CASE: The method calling this constructor, will have to call it once for each variable that is defined.
        Parameters:
        vd - This the complete lists of fields defined in the FieldDeclaration. This is also an internal class from the 'JavaParser' JAR-library.
        annotations - Just the list of annotations, provided by JavaParser through FieldDeclaration.
        modifiers - The list of modifiers, provided by JavaParser through FieldDeclaration
        signature - This is the original FieldDeclaration instance that has been converted into a java.lang.String.
        Code:
        Exact Constructor Body:
         super(
             annotations, modifiers, vd.getName().toString(), signature,
             javaDocComment, Entity.FIELD,
             vd.getBegin()
         );
        
         this.type       = vd.getType().toString();
         this.typeJOW    = StringParse.typeToJavaIdentifier(this.type);
        
         this.definition = vd.getInitializer().isPresent()
             ? LexicalPreservingPrinter.print
                 (LexicalPreservingPrinter.setup(vd.getInitializer().get()))
             : null;
        
         // Save a hook to this Java Parser class.
         this.variableDeclarator = vd;
        
    • Method Detail

      • toString

        🡅  🡇    
        public java.lang.String toString()
        Generates a String of this field, with all information included.
        Overrides:
        toString in class Declaration
        Returns:
        A printable String of this field.
        See Also:
        StrCSV.toCSV(String[], boolean, boolean, Integer), toString(int)
        Code:
        Exact Method Body:
         String defStr = (definition == null)
             ? "null" 
             : StringParse.abbrevEndRDSF(definition, MAX_STR_LEN, true);
        
         return
             "Name:         [" + name + "]\n" +
             "Declaration:  [" + StringParse.abbrevEndRDSF(signature, MAX_STR_LEN, true) + "]\n" +
             "Type:         [" + type + "]\n" + 
             "Definition:   [" + defStr + "]\n" +
             "Modifiers:    [" + StrCSV.toCSV(modifiers, true, true, null) + "]\n" +
             "Line Numbers: [sig=" + signatureLineNumber + ", jdStart=" + jdStartLineNumber +
                                     ", jdEnd=" + jdEndLineNumber + "]";
        
      • toString

        🡅  🡇    
        public java.lang.String toString​(int flags)
        Generates a String of this field, with all information included. This will also included any content requested by the 'flags' parameter. For this class (class Field), the only additional information printed by this 'toString' method is the Java-Doc Comment String.

        This String may also have UNIX color codes added.
        Overrides:
        toString in class Declaration
        Parameters:
        flags - These are the toString(...) flags from class PF ("Print Flags"). View available flags listed in class PF.
        Returns:
        A printable String of this Field.
        See Also:
        PF, StrCSV.toCSV(String[], boolean, boolean, Integer), toString()
        Code:
        Exact Method Body:
         boolean color = (flags & UNIX_COLORS) > 0;
        
         return
             printedName("Field", 15, color) + 
             printedDeclaration(15, color) +
             printedType(jowFlags(flags)) +
             printedDefinition(color) +
             printedModifiers(15) +
             printedLineNumbers(15, color) +
        
             // This are optional, it adds a '\n' AT THE BEGINNING if it is included
             printedComments(15, color, (flags & JAVADOC_COMMENTS) > 0);
        
      • clone

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

        🡅  🡇    
        public int compareTo​(Field f)
        Java's interface Comparable<T> requirements. This does a very simple comparison using the two field's 'name' field.
        Specified by:
        compareTo in interface java.lang.Comparable<Field>
        Parameters:
        f - Any other Field to be compared to 'this' Field
        Returns:
        An integer that fulfills Java's interface Comparable<Field> public boolean compareTo(Field f) method requirements.
        Code:
        Exact Method Body:
         return (this == f) ? 0 : this.name.compareTo(f.name);
        
      • equals

        🡅    
        public boolean equals​(Field 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 field defined. The presumption here is that the definition of a 'field' only has meaning - at all - inside the context of a class, interface, or enumerated-type where that field is defined. Since inside any '.java' source-code file, there may only be one field with a given name, this method shall return TRUE whenever the field being compared also has the same name.
        Parameters:
        other - This may be any other field. It is strongly suggested that 'other' be a field defined in the same '.java' source-code file as 'this' field.
        Returns:
        This method returns TRUE when 'this' instance of Field has the same 'name' as the name-field of input-parameter 'other'
        Code:
        Exact Method Body:
         return this.name.equals(other.name);