Methoden des Standard-Doclets

Das Standard-Doclet besitzt eine statische Variable (Configuration) und folgende Methoden:

  1. boolean start( RootDoc root ) throws IOException
  2. die nötige Start-Methode
  3. public static Configuration configuration()
  4. falls noch keine Configuration existierte, wird sie erzeugt
  5. protected void startGeneration( RootDoc root ) throws DocletAbortException
  6. beginnt mit der Dateierzeugung, indem sie die jewiligen Methoden der Writer-Objekte aufruft.
  7. protected void startGenerationOneOne( RootDoc root ) throws DocletAbortException
  8. wie startGeneration( Root root ) nur für Java 1.1
  9. protected void generateClassFiles(RootDoc root, ClassTree classtree) throws DocletAbortException
  10.  l
  11. protected String classFileName( ClassDoc cd )
  12.  liefert den qualifiedName ClassDoc mit der Endung ".html"
  13. protected void generateClassCycle( ClassDoc[] arr, ClassTree classtree ) throws DocletAbortException
  14. erzeugt zu jedem Objekt im ClassDoc[] ein ClassWriter Objekt
  15. public static int optionLength( String option )
  16. prüft die Optionen der Statuszeile, die Rückgabe ist die Länge bei bekannten, null bei unbekannten
    und negative Werte für Fehler


Und die Implementation im Standard-Doclet :

public static boolean start(RootDoc root) throws IOException{
    try {
        configuration().setOptions(root);
        if (configuration().oneOne)
            (new Standard()).startGenerationOneOne(root);
        else
            (new Standard()).startGeneration(root);
    } catch (DocletAbortException exc) {
        return false; // message has already been displayed
    }
    return true;
}

public static Configuration configuration(){
    if (configuration == null) {
        configuration = new Configuration();
    }
    return configuration;
    }

protected void startGeneration(RootDoc root) throws DocletAbortException{
    ClassTree classtree = new ClassTree(root);
    IndexBuilder indexbuilder = new IndexBuilder(root);
    PackageDoc[] packages = root.specifiedPackages();
    Arrays.sort(packages);
    if (configuration().createTree)
        TreeWriter.generate(classtree, root);
    if (configuration().createIndex){
        if (configuration.breakIndex)
            SplitIndexWriter.generate(indexbuilder);
        else
            SingleIndexWriter.generate(indexbuilder);
    }
    if (!configuration.noDeprecatedList)
        DeprecatedListWriter.generate(root);
    if (packages.length > 0) {
        FrameOutputWriter.generate(root);
        PackageIndexWriter.generate(root);
        PackageIndexFrameWriter.generate(root);
    }
    for(int i = 0; i < packages.length; i++){
        String prev = (i == 0)? null: packages[i-1].name();
        PackageDoc packagedoc = packages[i];
        String next = (i+1 == packages.length)?null:packages[i+1].name();
        PackageWriter.generate(packages[i], prev, next);
        PackageTreeWriter.generate(packages[i], prev, next);
        PackageFrameWriter.generate(packages[i]);
    }
    generateClassFiles(root, classtree);
}

protected void startGenerationOneOne(RootDoc root) throws DocletAbortException{
    ClassTree classtree = new ClassTree(root);
    IndexBuilder indexbuilder = new IndexBuilder(root);
    PackageDoc[] packages = root.specifiedPackages();
    Arrays.sort(packages);
    if (configuration().createTree)
        TreeWriter.generate(classtree, root);
    if (configuration().createIndex)
        SplitIndexWriter.generate(indexbuilder);
    if (packages.length > 0)
        PackageIndex11Writer.generate(root);
    for(int i = 0; i < packages.length; i++)
        Package11Writer.generate(packages[i]);
    generateClassFiles(root, classtree);
}

protected void generateClassFiles(RootDoc root, ClassTree classtree) throws DocletAbortException{
    ClassDoc[] classes = root.specifiedClasses();
    List incl = new ArrayList();
    for (int i = 0; i < classes.length; i++){
        ClassDoc cd = classes[i];
        if (cd.isIncluded())
            incl.add(cd);
    }
    ClassDoc[] inclClasses = new ClassDoc[incl.size()];
    for (int i = 0; i < inclClasses.length; i++)
        inclClasses[i] = (ClassDoc)incl.get(i);
    generateClassCycle(inclClasses, classtree);
    PackageDoc[] packages = root.specifiedPackages();
    for (int i = 0; i < packages.length; i++){
        PackageDoc pkg = packages[i];
        generateClassCycle(pkg.interfaces(), classtree);
        generateClassCycle(pkg.ordinaryClasses(), classtree);
        generateClassCycle(pkg.exceptions(), classtree);
        generateClassCycle(pkg.errors(), classtree);
    }
}

protected String classFileName( ClassDoc cd ){
    return cd.qualifiedName() + ".html";
}

protected void generateClassCycle( ClassDoc[] arr, ClassTree classtree ) throws DocletAbortException{
    Arrays.sort(arr, new ClassComparator());
    for(int i = 0; i < arr.length; i++){
        String prev = (i == 0)? null: classFileName(arr[i-1]);
        ClassDoc curr = arr[i];
        String next = (i+1 == arr.length)? null: classFileName(arr[i+1]);
        if (configuration.oneOne)
            Class11Writer.generate(curr, prev, next, classtree);
        else
            ClassWriter.generate(curr, prev, next, classtree);
    }
}

public static int optionLength(String option){
    return configuration().optionLength(option);
}

weiter

zurück zur Hauptseite