Class ParsedFile

  • All Implemented Interfaces:
    java.io.Serializable
    Direct Known Subclasses:
    JavaDocHTMLFile
    public abstract class ParsedFile
extends java.lang.Object
implements java.io.Serializable
    Parent-class of JavaDocHTMLFile and the source-code parsing classes.

    This class is abstract and there are two primary classes which extend it. This class is designed to hold all of the information - in java.lang.String format - about a Java class, interface or enumerated type. This information generally includes lists of fields, methods and constructor declarations. This class accepts String's (in its constructor) from the two classes which extend it. Those String's are found by the JavaParser Tool.

    The easiest way to think about this is that this is a (tremendously) pared down version of the JavaParser Library, that holds the essential information need to HiLite & Update a JavaDoc Web-Page using this Upgrade Tool. The standard Java Reflection API, inside Java Package java.lang.reflect.* is capable of supplying all of the method, constructor and field names (and parameters) for just about any Java Class. However, what the Reflect API cannot supply are Method Bodies & Constructor Bodies as instances of java.lang.String. These are required so that they may be syntax hilited by the hiliter, and that's what makes the Java Parser Library JAR necessary.

    This class serves as the root-class for both parsed Java-Doc HTML Pages, and parsed Java Source-Code '.java' pages.
    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;

      • typeAnnotationMirrors

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        protected Torello.JDUInternal.Annotations.TypeAnnotations.Mirror.TypeAnnotationMirrors typeAnnotationMirrors
        Stores information provided by the JavaDoc Upgrader Annotations. Note, this Annotation Mirror does not contain information about any / all annotations used inside of Java Source Code Files, but rather only the ones created by this API.

        These include @StaticFunctional and also @JDHeaderBackgroundImg
        Code:
        Exact Field Declaration Expression:
         protected TypeAnnotationMirrors typeAnnotationMirrors = null;

      • javaSrcFileAsStr

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final java.lang.String javaSrcFileAsStr
        This field simply contains the entire contents of the '.java' Source-Code File from whence this ParsedFile instance originated.

        Note that for in for the sub-class JavaDocHTMLFile, when the HTML file which was parsed represents an inner-class / nested-type, this field will still contain the entire contents of the top-level enclosing java type (as a String) in this field.

        For instance, if a JavaDocHTMLFile (which inherits this class, ParsedFile) instance had been generated for the Java-HTML inner-class Torello.HTML.Attributes.Filter, which happens to be a nested type of class Torello.HTML.Attributes, this field would contain the text-characters of the Source-File Torello/HTML/Attributes.java in String-format (as character data).
        Code:
        Exact Field Declaration Expression:
         public final String javaSrcFileAsStr;

      • fileName

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final java.lang.String fileName
        Contains the file-name from which this instance was derived
        Code:
        Exact Field Declaration Expression:
         public final String fileName;

      • simpleNameWithContainersAndGenerics

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final java.lang.String simpleNameWithContainersAndGenerics
        Holds the name of a Class / CIET / Type. A 'ParsedFile' represents a class, interface, or enumerated-type. This name stored in this field IS NOT the fully-qualified (Package-Name information included) name. The Java-Package in which this Class or Type resides isn't incorporated into the name stored in this field.

        This String-Field will have any & all Generic Type Parameters appended to its name - if this CIET represents a generic with such Type-Parameters.

        If this CIET/Type represents a Nested-Class / Inner-Type, the names of the containing CIET / Types are included in this String-Field.

        Output Value Input CIET / Type
        "Integer" interface java.lang.Integer
        "Vector<E>" class java.util.Vector<E>
        "Base.Decoder" class java.util.Base64.Decoder
        "Map.Entry<K, V>" interface java.util.Map.Entry<K, V>
        Code:
        Exact Field Declaration Expression:
         public final String simpleNameWithContainersAndGenerics;

      • fullNameNoGenerics

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final java.lang.String fullNameNoGenerics
        This String-Field holds the fully qualified CIET name - which simply means that any Java-Package information that is available shall be included in the name that is stored in this field. By implication, if the Package-Name is stored, then this String-Field must also hold any Container-Class names for this CIET/Type - in cases where this type is, indeed, a nested or inner type.

        If this CIET-Type happens to be a Java Generic with Generic Type Parameters (the 'E' in type java.util.Vector<E>, this information WILL NOT include that text stored within this String-Field.
        Output Value Input CIET / Type
        "java.lang.Integer" interface java.lang.Integer
        "java.util.Vector" class java.util.Vector<E>
        "java.util.Base64.Decoder" class java.util.Base64.Decoder
        "java.util.Map.Entry" interface java.util.Map.Entry<K, V>
        Code:
        Exact Field Declaration Expression:
         public final String fullNameNoGenerics;

      • simpleNameWithPossibleContainers

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final java.lang.String simpleNameWithPossibleContainers
        This the same as the simpleNameWithContainersAndGenerics field, but leaves off the Generic Type-Parameter String's. If this class is representing a CIET Type that happens to be a Nested-Type / Inner-Class, then the containing CIET name(s) ARE included in this String-Field.
        Output Value Input CIET / Type
        "Integer" interface java.lang.Integer
        "Vector" class java.util.Vector<E>
        "Base64.Decoder" class java.util.Base64.Decoder
        "Map.Entry" interface java.util.Map.Entry<K, V>
        Code:
        Exact Field Declaration Expression:
         public final String simpleNameWithPossibleContainers;

      • typeNameJOW

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final java.lang.String typeNameJOW
        JOW: Just One Word
        The Java-Doc Upgrader utilizes a few naming conventions, one of which is that any time the acronym 'JOW' is used, it is intending to provide a name to a Java-Type. Since there isn't an exact consensus on what information should be included in a Type-Name, the 'JOW' Acronym simply implies that the simplest name possible (a single word name) is being stored in this field.

        If this name is representing a CIET-Type that happens to be a Java-Generic, and having Generic-Type Parameters, such String-Text WILL NOT be included in this String-Field.

        If this name is representing a CIET-Type that happens to be a Nested-Type / Inner-Class, then the containing CIET name(s) ARE NOT included in this String-Field.

        Package-Name information will also not be stored in this field.
        Output Value Input CIET / Type
        "Integer" interface java.lang.Integer
        "Vector" class java.util.Vector<E>
        "Decoder" class java.util.Base64.Decoder
        "Entry" interface java.util.Map.Entry<K, V>
        Code:
        Exact Field Declaration Expression:
         public final String typeNameJOW;

      • packageName

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final java.lang.String packageName
        Holds the package-name. If this ParsedFile were for class java.lang.String the 'packageName' would be 'java.lang'.
        Code:
        Exact Field Declaration Expression:
         public final String packageName;

      • ciet

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final CIET ciet
        The acronym 'CIET' simply means "Class, Interface or Enumerated-Type. This public field identifies whether this ParsedFile is for a class, an interface or an enumerated-type.
        Code:
        Exact Field Declaration Expression:
         public final CIET ciet;

      • isInner

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final boolean isInner
        This identifies inner classes and interfaces.
        'isInner' Field Value Input CIET
        false interface java.lang.Integer
        false class java.util.Vector<E>
        true class java.util.Base64.Decoder
        true interface java.util.Map.Entry<K, V>
        Code:
        Exact Field Declaration Expression:
         public final boolean isInner;

      • containerClasses

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final ReadOnlyList<java.lang.String> containerClasses
        This identifies inner classes and interfaces. For any class that is not an inner class, this will be a zero-length String[] array.
        'containerClasses' Value Input CIET
        <EMPTY-LIST> interface java.lang.Integer
        <EMPTY-LIST> class java.util.Vector<E>
        { "Base64" } class java.util.Base64.Decoder
        { "Map" } interface java.util.Map.Entry<K, V>
        Code:
        Exact Field Declaration Expression:
         public final ReadOnlyList<String> containerClasses;

      • genericParameters

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final ReadOnlyList<java.lang.String> genericParameters
        If this represents a Java Generic Class or Interface, with generic type information, the generic type parameters shall be saved here.
        Code:
        Exact Field Declaration Expression:
         public final ReadOnlyList<String> genericParameters;

      • startLineNumber

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final int startLineNumber
        The line-number in the source-code file where this class definition actually begins.

        Note that if this instance of ParsedFile is representing a Nessted-Type / Inner-Class, then this field will contain the line-number where that inner-type's definition begins inside the Enclosing-Class' '.java' file.
        Code:
        Exact Field Declaration Expression:
         public final int startLineNumber;

      • endLineNumber

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final int endLineNumber
        The line-number in the source-code file where this class definition ends. Often this will just be the line-number of the last line in the '.java' file.

        If this is a Nested-Type, this field will contain the line-number where the definition of the Nested-type ends.
        Code:
        Exact Field Declaration Expression:
         public final int endLineNumber;

      • jdStartLineNumber

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final int jdStartLineNumber
        The starting line-number of the JavaDoc Comment at the top of the class. If this class does not have a Java-Doc Comment, this field will contain -1.
        Code:
        Exact Field Declaration Expression:
         public final int jdStartLineNumber;

      • jdEndLineNumber

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final int jdEndLineNumber
        The endiing line-number of the JavaDoc Comment at the top of the class. If this class does not have a Java-Doc Comment, this field will contain -1.
        Code:
        Exact Field Declaration Expression:
         public final int jdEndLineNumber;

      • typeLineCount

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final int typeLineCount
        The number of lines of Source-Code inside this '.java' File. If this instance of ParsedFile represents an Inner-Type (Nested-Class), then this field will contain a value that corresponds only to the number of lines used by the Nested-Type within the context of the entire Enclosing-Class '.java' file.
        Code:
        Exact Field Declaration Expression:
         public final int typeLineCount;

      • typeSizeChars

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final int typeSizeChars
        The number of characters / bytes of Source-Code inside this '.java' File. If this instance of ParsedFile represents an Inner-Type (Nested-Class), then this field will contain a value that corresponds only to the number of characters / bytes used by the Nested-Type within the context of the entire Enclosing-Class '.java' file.
        Code:
        Exact Field Declaration Expression:
         public final int typeSizeChars;

      • annotationElems

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final ReadOnlyList<AnnotationElem> annotationElems
        This is the list of AnnotationElem instances identified by the parser for this ParsedFile

        IMPORTANT: The vast majority of source-files will not contain any AnnotationElem's. Unless the source-file used to build 'this' was an annotation it would simply not be possible to define an AnnotationElem for the annotation
        Code:
        Exact Field Declaration Expression:
         public final ReadOnlyList<AnnotationElem> annotationElems;

      • enumConstants

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public final ReadOnlyList<EnumConstant> enumConstants
        This is the list of EnumConstant instances identified by the parser for this ParsedFile

        IMPORTANT: The vast majority of source-files will not contain any EnumConstant's. Unless the source-file used to build 'this' was an enum it would simply not be possible to define an EnumConstant for the enum
        See Also:
        enumConstants
        Code:
        Exact Field Declaration Expression:
         public final ReadOnlyList<EnumConstant> enumConstants;

    • Method Detail

      • findMethod

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public Method findMethod​
            (Torello.JDUInternal.Parse.HTML.Signature.D1_CallableSignature cSig)
        Finds a Method having the characteristics specified by parameter 'cSig'.
        Parameters:
        cSig - An internally generated representation of a Java-Method extrapolated from the information available on a Java-Doc HTML Detail Section
        Returns:
        A method that matches the requested Method-Signature
        Code:
        Exact Method Body:
         for (Method method : methods)

     if (    method.name.equals(cSig.name)
         &&  method.returnTypeJOW.equals(cSig.returnTypeJOW)
         &&  method.nearlyEqualsCallableSig(cSig)
     )
         return method;

 return null;

      • findConstructor

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public Constructor findConstructor​
            (Torello.JDUInternal.Parse.HTML.Signature.D1_CallableSignature cSig)
        Finds a Constructor having the characteristics specified by parameter 'cSig'.
        Parameters:
        cSig - An internally generated representation of a Java-Constructor extrapolated from the information available on a Java-Doc HTML Detail Section
        Returns:
        A Constructor that matches the requested Constructor-Signature
        Code:
        Exact Method Body:
         for (Constructor ctor : constructors) if (ctor.nearlyEqualsCallableSig(cSig)) return ctor;
 return null;

      • findMethods

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.util.stream.Stream<Method> findMethods​
            (java.lang.String methodName)
        Returns all internally-stored Method instances whose Method#name field matches 'name'
        Parameters:
        methodName - The name of the Method
        Returns:
        An instance of Stream<Method>of all Method's named 'name'
        See Also:
        methods, Declaration.name
        Code:
        Exact Method Body:
         Stream.Builder<Method> b = Stream.builder();
 for (Method method : methods) if (method.name.equals(methodName)) b.accept(method);
 return b.build();

      • findConstructors

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.util.stream.Stream<Constructor> findConstructors​
            (int numParameters)
        Returns all internally-stored Constructor instances for instances whose accepted parameters-list has a length equal to numParameters.
        Parameters:
        numParameters - The number of parameters accepted by the Constructor being searched.
        Returns:
        An instance of Stream<Constructor> containing all Constructor's whose number of parameterss equals 'numParameters'
        See Also:
        constructors, Callable.numParameters()
        Code:
        Exact Method Body:
         Stream.Builder<Constructor> b = Stream.builder();

 for (Constructor constructor : constructors)
     if (constructor.numParameters() == numParameters)
         b.accept(constructor);

 return b.build();

      • findField

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public Field findField​(java.lang.String name)
        Returns the internally-stored Field instance whose name matches parameter 'name'
        Parameters:
        name - The name of the Field
        Returns:
        The Field whose name matches parameter 'name'. If there is no such Field with that name defined in this parsed-file, then null is returned.
        See Also:
        Declaration.name, fields
        Code:
        Exact Method Body:
         for (Field field : fields) if (field.name.equals(name)) return field;
 return null;

      • findAnnotationElem

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public AnnotationElem findAnnotationElem​(java.lang.String name)
        Returns the internally-stored AnnotationElem instance whose name matches parameter 'name'

        IMPORTANT: The vast majority of source-files will not contain any AnnotationElem's. Unless the source-file used to build 'this' was an annotation it would simply not be possible to define an AnnotationElem for the annotation
        Parameters:
        name - The name of the AnnotationElem
        Returns:
        The AnnotationElem whose name matches parameter 'name'. If there is no such AnnotationElem with that name defined in this parsed-file, then null is returned.
        See Also:
        Declaration.name, annotationElems
        Code:
        Exact Method Body:
         for (AnnotationElem ae : annotationElems) if (ae.name.equals(name)) return ae;
 return null;

      • findEnumConstant

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public EnumConstant findEnumConstant​(java.lang.String name)
        Returns the internally-stored EnumConstant instance whose name matches parameter 'name'

        IMPORTANT: The vast majority of source-files will not contain any EnumConstant's. Unless the source-file used to build 'this' was an enum it would simply not be possible to define an EnumConstant for the enum
        Parameters:
        name - The name of the EnumConstant
        Returns:
        The EnumConstant whose name matches parameter 'name'. If there is no such EnumConstant with that name defined in this parsed-file, then null is returned.
        See Also:
        Declaration.name, enumConstants
        Code:
        Exact Method Body:
         for (EnumConstant ec : enumConstants) if (ec.name.equals(name)) return ec;
 return null;

      • findNestedType

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public NestedType findNestedType​(java.lang.String name)
        Returns the internally-stored NestedType instance whose name matches parameter 'name'
        Parameters:
        name - The name of the NestedType
        Returns:
        The NestedType whose name matches parameter 'name'. If there is no such NestedType with that name defined in this parsed-file, then null is returned.
        See Also:
        Declaration.name, nestedTypes
        Code:
        Exact Method Body:
         for (NestedType nt : nestedTypes) if (nt.name.equals(name)) return nt;
 return null;

      • toString

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.lang.String toString()
        Turns a ParsedFile result object, 'this', into a String. Passes '0' to the standard flags-print method.
        Overrides:
        toString in class java.lang.Object
        Code:
        Exact Method Body:
         return toString(0);

      • toString

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.lang.String toString​(int flags)
        Turns a ParsedFile result object, 'this', into a java.lang.String.

        This will check for the 'UNIX_COLORS' flag in class PF. If this flag is identified, then a few unix color codes are added to the output.

        IMPORTANT NOTE: The value of this flag will be propagated to the individual toString(int flag) methods in each of the Method, Field, Constructor etc... - toString(flag) methods.
        Returns:
        This returns a String that obeys the flag-requests by parameter flag.
        See Also:
        Method.toString(int), Constructor.toString(int), Field.toString(int)
        Code:
        Exact Method Body:
         StringBuilder   sb  = new StringBuilder();
 boolean         c   = (flags & PF.UNIX_COLORS) > 0;

 StringBuilder typeParamsSB = new StringBuilder();
 for (String p : genericParameters) typeParamsSB.append(p + ", ");

 String typeParamsStr = (typeParamsSB.length() > 0)
     ? typeParamsSB.subSequence(0, typeParamsSB.length() - 1).toString()
     : "-";

 StringBuilder containerClassesSB = new StringBuilder();
 for (String p : containerClasses) containerClassesSB.append(p + ", ");

 String containerClassesStr = (containerClassesSB.length() > 0)
     ? containerClassesSB.subSequence(0, containerClassesSB.length() - 1).toString()
     : "-";
    
 sb.append(
     "******************************************************************\n" +
     "Fields in this 'ParsedFile' instance:\n"                              +
     "******************************************************************\n" +
     "fileName:                             " + fileName + '\n' +
     "simpleNameWithContainersAndGenerics:  " + simpleNameWithContainersAndGenerics + '\n' +
     "CIET:                                 " + ciet + '\n' +
     "packageName:                          " + packageName + '\n' +
     "simpleNameWithPossibleContainers:     " + simpleNameWithPossibleContainers + '\n' +
     "fullNameNoGenerics:                   " + fullNameNoGenerics + '\n' +
     "isGeneric:                            " + isGeneric + '\n' +
     "Type Parameters:                      " + typeParamsStr + '\n' +
     "isInner:                              " + isInner + '\n' +
     "Container Classes:                    " + containerClassesStr + "\n" +
     "\n" +
     "fields.size():                        " + fields.size() + '\n' +
     "methods.size():                       " + methods.size() + '\n' +
     "constructors.size():                  " + constructors.size() + '\n' +
     "annotationElems.size():               " + annotationElems.size() + '\n' +
     "enumConstants.size():                 " + enumConstants.size() + '\n' +
     "nestedTypes.size():                   " + nestedTypes.size() + "\n\n"
 );

 if (methods.size() > 0)
 {
     sb.append(  "******************************************************************\n" + 
                 (c ? BRED : "") + "Methods:\n" + (c ? RESET : "") +
                 "******************************************************************\n"  );

     for (Method m : methods) sb.append(m.toString(flags) + "\n\n");
 }

 if (constructors.size() > 0)
 {
     sb.append(  "******************************************************************\n" + 
                 (c ? BRED : "") + "Constructors:\n" + (c ? RESET : "") +
                 "******************************************************************\n"  );

     for (Constructor cs : constructors)  sb.append(cs.toString(flags) + "\n\n");
 }

 if (fields.size() > 0)
 {
     sb.append(  "******************************************************************\n" + 
                 (c ? BRED : "") + "Fields:\n" + (c ? RESET : "") +
                 "******************************************************************\n"  );

     for (Field f : fields) sb.append(f.toString(flags) + "\n\n");
 }

 if (annotationElems.size() > 0)
 {
     sb.append(  "******************************************************************\n" + 
                 (c ? BRED : "") + "Annotation-Elements:\n" + (c ? RESET : "") +
                 "******************************************************************\n"  );

     for (AnnotationElem ae : annotationElems) sb.append(ae.toString(flags) + "\n\n");
 }

 if (enumConstants.size() > 0)
 {
     sb.append(  "******************************************************************\n" + 
                 (c ? BRED : "") + "Enumerated Constants:\n" + (c ? RESET : "") +
                 "******************************************************************\n"  );

     for (EnumConstant ec : enumConstants) sb.append(ec.toString(flags) + "\n\n");
 }

 if (nestedTypes.size() > 0)
 {
     sb.append(  "******************************************************************\n" + 
                 (c ? BRED : "") + "Nested Types:\n" + (c ? RESET : "") +
                 "******************************************************************\n"  );

     for (NestedType nt : nestedTypes) sb.append(nt.toString(flags) + "\n\n");
 }

 return sb.toString();

      • quickSummary

        🡅  🡇  ⇈  ⮫ 🗕  🗗  🗖 
        public java.lang.String quickSummary()
        Provides a Quick Summary for this file.
        Returns:
        The summary as a java.lang.String. Nothing is actually printed by this method.
        Code:
        Exact Method Body:
         String typeParams = (genericParameters.size() == 0)
     ? ""
     : ("Generic Type-Parameters: " + 
         StrCSV.toCSV(this.genericParameters, true, true, null) + '\n');

 String ae = (annotationElems.size() == 0)
     ? ""
     : (", [" + BBLUE + StringParse.zeroPad(annotationElems.size()) + RESET +
         "] Annotation-Elements");

 String ec = (enumConstants.size() == 0)
     ? ""
     : (", [" + BBLUE + StringParse.zeroPad(enumConstants.size()) + RESET +
         "] Enum-Constants");

 String nt = (nestedTypes.size() == 0)
     ? ""
     : (", [" + BBLUE + StringParse.zeroPad(nestedTypes.size()) + RESET +
         "] Nested-Types");
    
 return
     "Name w/ Containers & Generics [" + BYELLOW + simpleNameWithContainersAndGenerics + RESET + "]\n" + 
     "Name w/ Any Containers        [" + BYELLOW + simpleNameWithPossibleContainers + RESET + "]\n" +
     "Name w/ Package-Info          [" + BYELLOW + fullNameNoGenerics + RESET + "]\n" +
     "Package [" + BYELLOW + packageName + RESET + "]\n" +
     "CIET    [" + BYELLOW + ciet        + RESET + "]\n" +
     typeParams +
     '[' + BBLUE + StringParse.zeroPad(fields.size())          + RESET + "] Fields, " +
     '[' + BBLUE + StringParse.zeroPad(constructors.size())    + RESET + "] Constructors, " +
     '[' + BBLUE + StringParse.zeroPad(methods.size())         + RESET + "] Methods" +
     ae + ec + nt + '\n';

      • abbreviatedSummary

        🡅  ⇈  ⮫ 🗕  🗗  🗖 
        public java.lang.String abbreviatedSummary​(int lineWidth)
        Provides a Vertical-List Abbreviated Summary for this file.
        Parameters:
        lineWidth - The number of characters wide the member-summary lines should be.
        Returns:
        The summary as a java.lang.String. Nothing is actually printed by this method.
        Code:
        Exact Method Body:
         String typeParams = (genericParameters.size() == 0)
     ? ""
     : ("Generic Type-Parameters: " + 
         StrCSV.toCSV(this.genericParameters, true, true, null) + '\n');

 String m = (methods.size() == 0)
     ? "Methods: *NONE*\n"
     : ("Methods:" + StrPrint.printListAbbrev
         (methods, lineWidth, 4, false, true, true) + '\n');

 String f = (fields.size() == 0)
     ? "Fields: *NONE*\n"
     : ("Fields:" + StrPrint.printListAbbrev
         (fields, lineWidth, 4, false, true, true) + '\n');

 String c = (constructors.size() == 0)
     ? "Constructors: *NONE*\n"
     : ("Constructors:" + StrPrint.printListAbbrev
         (constructors, lineWidth, 4, false, true, true) + '\n');
    
 String ec = (enumConstants.size() == 0)
     ? ""
     : ("Enum-Constants:" + StrPrint.printListAbbrev
         (enumConstants, lineWidth, 4, false, true, true) + '\n');
    
 String ae = (annotationElems.size() == 0)
     ? ""
     : ("Annotation-Elements:" + StrPrint.printListAbbrev
         (annotationElems, lineWidth, 4, false, true, true) + '\n');

 String nt = (nestedTypes.size() == 0)
     ? ""
     : ('[' + BBLUE + StringParse.zeroPad(nestedTypes.size()) + RESET +
         "] Nested-Types");
    
 return
     "Name w/ Containers & Generics " +
         '[' + BYELLOW + simpleNameWithContainersAndGenerics + RESET + "]\n" +

     "Name w/ Any Containers        " +
         '[' + BYELLOW + simpleNameWithPossibleContainers + RESET + "]\n" +

     "Package-Name Qualified        " +
         '[' + BYELLOW + fullNameNoGenerics + RESET + "]\n" +

     "Package [" + BYELLOW + packageName           + RESET + "]\n" +
     "CIET    [" + BYELLOW + ciet                  + RESET + "]\n" +

     typeParams +
     m + f + c + ec + ae + nt + '\n';