Class Method

  • All Implemented Interfaces:
    java.io.Serializable, java.lang.Cloneable, java.lang.Comparable<Method>
    public class Method
extends Callable
implements java.io.Serializable, java.lang.Comparable<Method>, 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' Source-Files about Method's 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 Method allows for storing the name, definition and modifiers list of a method.
    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;

      • returnType

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final java.lang.String returnType
        The return type of the method, as a String. If this is a method with a 'void' return-type, this shall be "void".
        Code:
        Exact Field Declaration Expression:
         public final String returnType;

      • returnTypeJOW

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final java.lang.String returnTypeJOW
        The return type of the method, as a String.

        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.

        As an example of this, If a parameter to a Method, or the type of a Field inside of a class had the fully qualified type-name:

        java.util.stream.Stream.Builder<String>

        the JOW-String for that type would simply be the word "Builder"

        For Arrays:
        If the type, itself, is an array of any kind, any & all Array-Brackets will be included in this String-Name. Please review the Example Table, below:
        Output JOW-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[]"
        "String[]" "String..."
        "String[]" "java.lang.String..."
        Code:
        Exact Field Declaration Expression:
         public final String returnTypeJOW;

      • 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 Method instance, it may be retrieved from this transient field.
        Code:
        Exact Field Declaration Expression:
         public final transient MethodTree methodTree;

    • Method Detail

      • toString

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.lang.String toString()
        Generates a string of this method, with most information included.

        Reduced Information:
        This 'toString' will not return every piece of information contained by this class. For example, both the method body, and any possible JavaDoc Comments are not included. For a more enhanced toString() method version, invoke the toString(PrintFlags) method which accepts Print-Flags.
        Overrides:
        toString in class Callable
        Returns:
        A printable String of this method.
        See Also:
        PF, toString(int)
        Code:
        Exact Method Body:
         return
     "Name:            [" + name + "]\n" +
     "Signature:       [" + StrPrint.abbrevEndRDSF(signature, MAX_STR_LEN, true) + "]\n" +
     "Modifiers:       [" + StrCSV.toCSV(modifiers, true, true, null) + "]\n" +
     printedParameterNamesTS() +
     printedParameterTypesTS() +
     "Return Type:     [" + returnType + "]\n" +
     printedExceptionsTS() +

     // 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.
        Overrides:
        toString in class Callable
        Parameters:
        flags - These are defined in the Print-Flags class
        Returns:
        A printable String of this Method.
        See Also:
        toString(), PF
        Code:
        Exact Method Body:
         boolean color = (flags & UNIX_COLORS) > 0;
 Ret2<Boolean, Boolean> jow = jowFlags(flags);

 return 
     printedName("Method", 20, color) +
     printedSignature(20, color) +
     printedModifiers(20) +
     printedParamNames() + 
     printedParamTypes(jow) +
     printedReturnType(jow, color) +
     printedExceptions() +
     printedLocation(20, 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

     printedComments(20, color, (flags & JAVADOC_COMMENTS) > 0) +
     printedCallableBody(flags);

      • compareTo

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public int compareTo​(Method m)
        Java's interface Comparable<T> requirements. This does a very simple comparison using the two method's Declaration.name field. If the name comparison will not suffice in making a decision, then the number of parameters, and parameter-types are used to making the sort-decision.
        Specified by:
        compareTo in interface java.lang.Comparable<Method>
        Parameters:
        m - Any other Method to be compared to 'this' Method
        Returns:
        An integer that fulfills Java's Comparable<Method> interface requirements.
        Code:
        Exact Method Body:
         // Identical References
 if (this == m) return 0;

 // Sorting by ignoring case is best - usually for the looks of a list
 // NOTE: Returning '0' is bad, because a TreeSet will remove duplicate-elements.  This
 //       means two different meethods with the same name would not "fit" into a treeset.

 int ret = this.name.compareToIgnoreCase(m.name);
 if (ret != 0) return ret;

 // Try to identify a different without ignoring case.
 ret = this.name.compareTo(m.name);
 if (ret != 0) return ret;

 ret = this.numParameters() - m.numParameters();
 if (ret != 0) return ret;

 for (int i=0; i < this.parameterTypesJOW.size(); i++)
 {
     ret = this.parameterTypesJOW.get(i).compareTo(m.parameterTypesJOW.get(i));
     if (ret != 0) return ret;
 }

 return 0;

      • equals

        🡅  ⇈  ⮫ 🗕  🗗  🗖 
        public boolean equals​(Method other)
        This should be called an "atypical version" of the usual equals(Object other) method. This version of equals merely compares the name and parameters-list of the method. The presumption here is that the definition of a 'method' only has meaning - at all - inside the context of a class, interface, or enumerated-type where that method is defined. Since inside any '.java' source-code file, there may only be one method with a given name and parameter-list, this shall return TRUE whenever the method being compared has the same name and parameter types as 'this' does.
        Parameters:
        other - This may be any other method. It is strongly suggested that this be a method defined in the same '.java' source-code file as 'this' method.
        Returns:
        This method returns TRUE when 'this' instance of Method has both the same public final Sting name and the same parameter-list as 'other'.
        Code:
        Exact Method Body:
         // The method's must have the same name!
 if (! this.name.equals(other.name)) return false;

 // If the number of parameters in the 'other' instance of Method differ from the number
 // of parameters in 'this' Method, then return FALSE immediately.  It cannot be a match.

 if (this.numParameters() != other.numParameters()) return false;

 // If both of these have zero parameters, and their names have matched, return true
 // immediately

 if (this.numParameters() == 0) return true;

 // If any of the parameter-names are different, break immediately and return false;
 for (int i=0; i < this.parameterNames.size(); i++)
     if (! this.parameterNames.get(i).equals(other.parameterNames.get(i))) return false;

 // If the parameter-types listed by the javadoc '.html' file differ from the parameter
 // types listed in the original '.java' source-code file, then break immediately.
 //
 // NOTE: The "package-information" for the FULL CLASS OR INTERFACE NAME is not always
 //       available.

 for (int i=0; i < this.parameterTypesJOW.size(); i++)
     if (! this.parameterTypesJOW.get(i).equals(other.parameterTypesJOW.get(i)))
         return false;

 // ALL TEST PASSED
 return true;