### Example: Docker Server and Maven Configuration

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/PlantumlGenerator.md

This example shows how to start a PlantUML server with Docker and then configure Maven to use this server for Javadoc generation. The server URL is passed as a Maven property.

```bash
# Terminal 1: Start PlantUML server
docker run -d -p 8080:8080 --name plantuml-server plantuml/plantuml-server:latest

# Terminal 2: Use in Maven
mvn javadoc:javadoc -Dplantuml.server.url=http://localhost:8080/
```

--------------------------------

### Create and Configure Method Example

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UML-Diagrams.md

This example demonstrates how to create a Type, then a Method with parameters, set its abstract status, and add it to the Type. Ensure Type and TypeName are properly initialized.

```java
Type myClass = new Type(namespace, Type.Classification.CLASS, new TypeName("MyClass"));

Method method = new Method(myClass, "calculateTotal", new TypeName("double"));
method.addParameter("items", new TypeName("java.util.List"));
method.addParameter("taxRate", new TypeName("double"));
method.isAbstract = false;

myClass.addChild(method);
```

--------------------------------

### Example Resource Bundle Entries

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/Logging.md

These are example entries for resource bundles used for message localization, demonstrating how to define messages and their parameters.

```properties
doclet.usage.createpumlfiles.description=Generate PlantUML source files (.puml)
doclet.usage.createpumlfiles.parameters=
```

--------------------------------

### Create and Add Fields Example

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UML-Diagrams.md

This example shows how to create a Type and then instantiate multiple Field objects with their respective names and types, adding them to the Type. Ensure Type and TypeName are properly initialized.

```java
Type myClass = new Type(namespace, Type.Classification.CLASS, new TypeName("MyClass"));

Field field1 = new Field(myClass, "id", new TypeName("long"));
Field field2 = new Field(myClass, "name", new TypeName("String"));

myClass.addChild(field1);
myClass.addChild(field2);
```

--------------------------------

### Namespace Instantiation Examples

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/types.md

Shows how to create Namespace objects, including the root namespace, package namespaces, and namespaces associated with modules.

```java
Namespace root = new Namespace(null, "", Optional.empty());
Namespace comPkg = new Namespace(root, "com", Optional.empty());
Namespace examplePkg = new Namespace(comPkg, "com.example", Optional.empty());
Namespace modulePkg = new Namespace(null, "com.myapp", Optional.of("my.module"));
```

--------------------------------

### Example Usage of HtmlPostprocessor

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/HtmlPostprocessor.md

Demonstrates how to create an HtmlPostprocessor instance and run the post-processing. Logs an error message if post-processing fails.

```java
Configuration config = new DocletConfig();
HtmlPostprocessor postprocessor = new HtmlPostprocessor(config);
boolean success = postprocessor.postProcessHtml();
if (!success) {
    System.err.println("HTML post-processing failed");
}
```

--------------------------------

### Instantiate PackageDependency

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/types.md

Example of how to create an instance of the PackageDependency class, specifying the source and target packages.

```java
PackageDependency dep = new PackageDependency(
    "com.example.service",
    "com.example.model"
);
```

--------------------------------

### PackageDependency Example Usage

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/Dependencies.md

Demonstrates how to create and use a `PackageDependency` object, accessing its `fromPackage` and `toPackage` properties.

```java
PackageDependency dep = new PackageDependency(
    "com.example.service",
    "com.example.model"
);

System.out.println(dep.fromPackage);  // "com.example.service"
System.out.println(dep.toPackage);    // "com.example.model"
```

--------------------------------

### Example Usage of LocalizedReporter

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/Logging.md

This example demonstrates how to instantiate and use LocalizedReporter to log informational, warning, and error messages with localization.

```java
Logger logger = new LocalizedReporter(config, reporter, Locale.ENGLISH);

logger.info(Message.INFO_GENERATING_FILE, "diagram.svg");
logger.warn(Message.WARNING_PACKAGE_DEPENDENCY_CYCLES, "pkg.a -> pkg.b -> pkg.a");
logger.error(Message.ERROR_UNANTICIPATED_ERROR_GENERATING_UML, exception);
```

--------------------------------

### TypeName Instantiation Examples

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/types.md

Demonstrates how to create TypeName objects for various Java types, including simple types and generic types.

```java
TypeName stringType = new TypeName("java.lang.String");
TypeName listType = new TypeName("java.util.List<java.lang.String>");
TypeName mapType = new TypeName("java.util.Map<java.lang.String, java.lang.Object>");
```

--------------------------------

### Example Usage of DependencyDiagram

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UML-Diagrams.md

Demonstrates how to create a DependencyDiagram, add package dependencies, and render the diagram. Ensure 'config' is properly initialized before use.

```java
DependencyDiagram depDiagram = new DependencyDiagram(
    config, 
    Optional.of("com.example.app"), 
    "package-dependencies.puml"
);

depDiagram.addPackageDependency("com.example.app.service", "com.example.app.model");
depDiagram.addPackageDependency("com.example.app.web", "com.example.app.service");

depDiagram.render();
```

--------------------------------

### Example: Adding Parameters to a Method

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/types.md

This example demonstrates how to create a Method object and add parameters to it using the Parameters class. It shows adding parameters of different types like String, int, and a functional interface.

```java
Method method = new Method(myClass, "doWork", new TypeName("void"));
method.addParameter("input", new TypeName("java.lang.String"));
method.addParameter("count", new TypeName("int"));
method.addParameter("callback", new TypeName("java.util.function.Consumer"));
```

--------------------------------

### Run Local PlantUML Server

Source: https://github.com/talsma-ict/umldoclet/blob/main/usage.md

Start a local PlantUML server using Docker for generating UML diagrams. This is recommended over using the central PlantUML server.

```shell
docker run -d -p 8080:8080 plantuml/plantuml-server:latest
```

--------------------------------

### Example: Creating and Modifying a Type

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UML-Diagrams.md

Demonstrates creating a class type, marking it as deprecated, and adding members like fields and methods.

```java
Namespace namespace = new Namespace(null, "com.example", Optional.empty());

// Create a class type
TypeName className = new TypeName("MyClass");
Type myClass = new Type(namespace, Type.Classification.CLASS, className);
myClass.deprecated();  // Mark as deprecated

// Add members
Field field = new Field(myClass, "name", new TypeName("String"));
myClass.addChild(field);

Method method = new Method(myClass, "getName", new TypeName("String"));
myClass.addChild(method);
```

--------------------------------

### Example Usage of PackageDiagram

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UML-Diagrams.md

Demonstrates how to create a PackageDiagram, add types and sub-packages, and render the diagram. Ensure Configuration and Namespace objects are properly initialized.

```java
Namespace pkgNamespace = new Namespace(null, "com.example.myapp", Optional.of("mymodule"));
PackageDiagram diagram = new PackageDiagram(config, pkgNamespace, "com.example.myapp.puml");

Type classA = new Type(pkgNamespace, Type.Classification.CLASS, new TypeName("ClassA"));
diagram.addType(classA);

Namespace subPkg = new Namespace(pkgNamespace, "com.example.myapp.util", Optional.of("mymodule"));
diagram.addSubpackage(subPkg);

diagram.render();
```

--------------------------------

### UMLDoclet run() Method Example

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/HtmlPostprocessor.md

Illustrates how the HtmlPostprocessor is invoked at the end of the UMLDoclet's run method after standard documentation and diagram generation.

```java
@Override
public boolean run(DocletEnvironment environment) {
    config.logger().info(DOCLET_COPYRIGHT, DOCLET_VERSION);
    
    // Generate standard HTML documentation
    if (!super.run(environment)) return false;
    
    try {
        // Generate UML diagrams
        generateDiagrams(environment).forEach(Diagram::render);
        
        // Post-process HTML to embed diagrams
        return new HtmlPostprocessor(config).postProcessHtml();
    } catch (RuntimeException e) {
        config.logger().error(ERROR_UNANTICIPATED_ERROR_GENERATING_UML, e);
        return false;
    }
}
```

--------------------------------

### Scan Package Dependencies Example

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/Dependencies.md

Demonstrates how to use DependenciesElementScanner to scan Javadoc elements and print detected package dependencies. Ensure the DocletEnvironment is properly initialized.

```java
DocletEnvironment environment = /* from Javadoc */;
Configuration config = new DocletConfig();

DependenciesElementScanner scanner = new DependenciesElementScanner(environment, config);
Set<PackageDependency> dependencies = scanner.scan(
    environment.getIncludedElements(),
    null
);

for (PackageDependency dep : dependencies) {
    System.out.println(dep.fromPackage + " -> " + dep.toPackage);
}
```

--------------------------------

### ClassDiagram Usage Example

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UML-Diagrams.md

Demonstrates how to create a Type object, add fields and methods, and then use it to generate a ClassDiagram and render it to a file.

```java
Type myClass = new Type(namespace, Type.Classification.CLASS, new TypeName("MyClass"));
myClass.addChild(new Field(myClass, "field1", new TypeName("String")));
Method method = new Method(myClass, "doSomething", new TypeName("void"));
method.addParameter("param", new TypeName("int"));
myClass.addChild(method);

ClassDiagram diagram = new ClassDiagram(config, myClass, "my-class.puml");
diagram.render();
```

--------------------------------

### StringBufferingWriter Example

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/Utilities.md

Demonstrates how to use StringBufferingWriter to capture diagram source in memory while also writing to a file. This is useful for both file output and further in-memory processing.

```java
StringBufferingWriter buffer = new StringBufferingWriter(fileWriter);

IndentingWriter indented = new IndentingWriter(buffer, config.indentation());
diagram.writeTo(indented);

String diagramSource = buffer.getBuffer().toString();
```

--------------------------------

### PlantUML Class Example with UML Characters

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/Utilities.md

An example of PlantUML output demonstrating the usage of UML character constants for visibility and modifiers within a class definition.

```plantuml
@startuml
class MyClass {
    + publicField: String
    # protectedField: int
    - privateField: boolean
    ~ packageField: Object
    + {abstract} abstractMethod()
    + {static} staticMethod(): void
}
@enduml
```

--------------------------------

### Maven Javadoc Plugin Output Example

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/Logging.md

This output shows typical messages from the Maven Javadoc Plugin when using UMLDoclet, including build information, copyright notices, file generation, and detected package dependency cycles.

```text
[INFO] Building jar: /project/target/myproject-1.0-javadoc.jar
[INFO] Generating UML Doclet (C) Copyright 2016-2026 Talsma ICT
[INFO] PlantUML (ASL) Copyright 2009-2026 Arnaud Roques
[INFO] Generating file: target/apidocs/com/example/MyClass.svg
[INFO] Package dependency cycles detected:
[INFO]  - [com.example.a] -> [com.example.b] -> [com.example.a]
```

--------------------------------

### Initialize UMLDoclet Logger

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/Logging.md

Initializes the configuration and logger for UMLDoclet. This method is called during the doclet's setup phase.

```java
public void init(Locale locale, Reporter reporter) {
    config.init(locale, reporter);  // Sets up LocalizedReporter
    super.init(locale, reporter);
}
```

--------------------------------

### Maven Javadoc Plugin Configuration for UMLDoclet

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UMLDoclet.md

Example configuration for the maven-javadoc-plugin to use the UMLDoclet. This includes specifying the doclet class, artifact, and additional options for diagram generation.

```xml
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-javadoc-plugin</artifactId>
    <configuration>
        <doclet>nl.talsmasoftware.umldoclet.UMLDoclet</doclet>
        <docletArtifact>
            <groupId>nl.talsmasoftware</groupId>
            <artifactId>umldoclet</artifactId>
            <version>2.3.1</version>
        </docletArtifact>
        <additionalOptions>
            <additionalOption>--create-puml-files</additionalOption>
            <additionalOption>--uml-image-format SVG</additionalOption>
        </additionalOptions>
    </configuration>
</plugin>
```

--------------------------------

### Generate PlantUML Diagram Locally

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/PlantumlGenerator.md

Example demonstrating how to generate a PlantUML diagram locally using the BuiltinPlantumlGenerator. This code snippet shows the typical usage when no external PlantUML server is configured.

```java
Configuration config = new DocletConfig();
// No server URL = uses BuiltinPlantumlGenerator
PlantumlGenerator generator = PlantumlGenerator.getPlantumlGenerator(config);

String pumlSource = "@startuml\n" +
    "class User { }\n" +
    "class Post { }\n" +
    "User --> Post\n" +
    "@enduml";

try (OutputStream out = new FileOutputStream("diagram.svg")) {
    generator.generatePlantumlDiagramFromSource(
        pumlSource,
        FileFormat.SVG,
        out
    );
    System.out.println("Diagram generated: diagram.svg");
}
```

--------------------------------

### Display All UML Doclet Options

Source: https://github.com/talsma-ict/umldoclet/blob/main/usage.md

Run this command to list all available options for the UML Doclet, including standard Javadoc options and UML-specific parameters.

```bash
javadoc --help -docletpath umldoclet-2.x.jar -doclet nl.talsmasoftware.umldoclet.UMLDoclet
```

--------------------------------

### Create Inheritance and Implementation Links

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/types.md

Demonstrates creating `Link` objects for inheritance and implementation relationships. Ensure the `Link` class is imported.

```java
Link extendsLink = Link.fromType("com.example.Parent")
    .relatesTo("com.example.Child")
    .withRelationship("extends");

Link implementsLink = Link.fromType("com.example.MyClass")
    .relatesTo("java.util.Comparable")
    .withRelationship("implements");

```

--------------------------------

### Handle Cyclic Dependencies Based on Configuration

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/Dependencies.md

This code demonstrates how to check the configured action for cyclic dependencies and log warnings or errors accordingly. The action can be IGNORE, WARN, or ERROR.

```java
Configuration.Action action = config.onCyclicPackageDependencies();

if (action == Configuration.Action.IGNORE) {
    // Do nothing
} else if (action == Configuration.Action.WARN) {
    config.logger().warn("Cycles detected: " + cycles);
} else if (action == Configuration.Action.ERROR) {
    config.logger().error("Cycles detected: " + cycles);
    // May fail build if configured
}
```

--------------------------------

### File Locations with --uml-image-directory

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/README.md

Demonstrates how file locations change when the `--uml-image-directory` option is used to specify a separate directory for images.

```text
docs/
├── com.example.package.svg             (images directory)
├── com.example.MyClass.svg
└── package-dependencies.svg
```

--------------------------------

### Get PlantumlGenerator Factory Method

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/PlantumlGenerator.md

Use this factory method to obtain the appropriate PlantumlGenerator implementation based on the configuration. It returns either a RemotePlantumlGenerator or a BuiltinPlantumlGenerator.

```java
public static PlantumlGenerator getPlantumlGenerator(Configuration config)
```

```java
Configuration config = new DocletConfig();
config.plantumlServerUrl = "http://localhost:8080/";  // Optional
PlantumlGenerator generator = PlantumlGenerator.getPlantumlGenerator(config);
```

--------------------------------

### Main Entry Point

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/README.md

The primary class for integrating UMLDoclet as a Javadoc tool.

```APIDOC
## Main Entry Point

### Description
This section details the main entry point for using UMLDoclet within the Javadoc process.

### Class
`nl.talsmasoftware.umldoclet.UMLDoclet`

### Usage
This class serves as the doclet implementation that Javadoc invokes to generate UML diagrams from source code documentation.
```

--------------------------------

### Run UML Doclet via Commandline

Source: https://github.com/talsma-ict/umldoclet/blob/main/usage.md

Use this command to generate documentation with the UML Doclet from the command line. Ensure the doclet JAR is accessible via -docletpath.

```bash
javadoc -sourcepath src -classpath lib -d apidocs \
    -docletpath umldoclet-2.x.jar -doclet nl.talsmasoftware.umldoclet.UMLDoclet \
    com.foobar
```

--------------------------------

### HtmlPostprocessor Constructor

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/HtmlPostprocessor.md

Initializes the HtmlPostprocessor with the necessary configuration. Requires a Configuration object.

```java
public HtmlPostprocessor(Configuration config)
```

--------------------------------

### Detected Package Dependencies

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/Dependencies.md

Illustrates the output format for detected package dependencies, showing direct and self-referential dependencies.

```text
com.example.app.service -> com.example.app.model
com.example.app.service -> com.example.app.service
com.example.app.web -> com.example.app.service
```

--------------------------------

### configuration.md File Size

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/MANIFEST.md

Displays the file size of the configuration.md file. This is part of the overall file size breakdown for the project.

```text
configuration.md            11 KB
```

--------------------------------

### Command Line Configuration for UMLDoclet

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/configuration.md

Use the javadoc command with specific options to configure UMLDoclet. Ensure the doclet JAR is in the docletpath.

```bash
javadoc \
    -d docs \
    -docletpath umldoclet-2.3.1-full.jar \
    -doclet nl.talsmasoftware.umldoclet.UMLDoclet \
    --create-puml-files \
    --uml-image-format SVG \
    --uml-excluded-package-dependencies com.example.internal \
    src/main/java
```

--------------------------------

### Total Project Size

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/MANIFEST.md

Displays the total file size of the project. This is a summary of all documented files.

```text
Total                     148 KB
```

--------------------------------

### RemotePlantumlGenerator Constructor

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/PlantumlGenerator.md

Initializes the RemotePlantumlGenerator with configuration and the PlantUML server URL.

```APIDOC
## RemotePlantumlGenerator Constructor

### Description
Initializes the RemotePlantumlGenerator with the provided Doclet configuration and the base URL of the PlantUML server.

### Method Signature
```java
public RemotePlantumlGenerator(Configuration config, String serverUrl)
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
Configuration config = new DocletConfig();
config.plantumlServerUrl = "http://localhost:8080/";

PlantumlGenerator generator = new RemotePlantumlGenerator(config, "http://localhost:8080/");
```

### Response
None (Constructor)
```

--------------------------------

### UMLDoclet Configuration Flow

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/README.md

Illustrates the flow of configuration from command-line options to the DocletConfig object, which is then passed to various components.

```text
Command-line options
    ↓
UMLDoclet.getSupportedOptions() → UMLOptions
    ↓
UMLOptions parses and stores in DocletConfig
    ↓
DocletConfig implements Configuration interface
    ↓
Configuration passed to all components (Factory, Diagrams, etc.)
```

--------------------------------

### Normal Mode Logging Configuration (Default)

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/Logging.md

This is the default mode, showing standard informational messages, package dependency warnings, and errors.

```bash
javadoc -doclet nl.talsmasoftware.umldoclet.UMLDoclet ...
```

--------------------------------

### Diagram getPlantUmlFile() Method

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UML-Diagrams.md

Abstract method to determine the file path for PlantUML source output. Must be implemented by subclasses.

```java
protected abstract File getPlantUmlFile()
```

--------------------------------

### Configure Gradle Javadoc Task for UML Doclet (Kotlin DSL)

Source: https://github.com/talsma-ict/umldoclet/blob/main/usage.md

Set up the Javadoc task in Gradle using the Kotlin DSL to include the UML Doclet. Declare the doclet as a dependency and configure the task options.

```kotlin
val umlDoclet: Configuration by configurations.creating

dependencies {
    umlDoclet("nl.talsmasoftware:umldoclet:2.0.15")
}

configurations {
    umlDoclet
}

tasks.javadoc {
    source = sourceSets.main.get().allJava
    val docletOptions = options as StandardJavadocDocletOptions
    docletOptions.docletpath = umlDoclet.files.toList()
    docletOptions.doclet = "nl.talsmasoftware.umldoclet.UMLDoclet"
    docletOptions.addStringOption("additionalParamName", "additionalParamValue")
}
```

--------------------------------

### UMLDoclet getSupportedOptions Method

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UMLDoclet.md

Returns all supported command-line options for this doclet, merging UML-specific options with StandardDoclet options. This method is part of the Javadoc Doclet API.

```java
    @Override
    public Set<Option> getSupportedOptions()

```

--------------------------------

### UMLFactory Initialization and Element Processing

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UMLFactory.md

Demonstrates how UMLDoclet initializes UMLFactory and uses it to process included elements for diagram generation. This snippet is part of the main run method in UMLDoclet.

```java
UMLFactory factory = new UMLFactory(config, docEnv);
docEnv.getIncludedElements().stream()
    .map(element -> generateDiagram(factory, element))  // Calls factory methods
    .forEach(Diagram::render);  // Renders generated diagrams
```

--------------------------------

### Diagram Constructor

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UML-Diagrams.md

Initializes a Diagram object with a Configuration. Throws NullPointerException if the configuration is null.

```java
protected Diagram(Configuration config)
```

--------------------------------

### HtmlPostprocessor Constructor

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/HtmlPostprocessor.md

Initializes the HtmlPostprocessor with the necessary configuration for Javadoc processing.

```APIDOC
## HtmlPostprocessor Constructor

### Description
Initializes the HtmlPostprocessor with the necessary configuration for Javadoc processing.

### Method Signature
`public HtmlPostprocessor(Configuration config)`

### Parameters
#### Path Parameters
- **config** (`Configuration`) - Required - Doclet configuration containing output paths and settings
```

--------------------------------

### UMLDoclet init Method

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UMLDoclet.md

Initializes the doclet with the given locale and reporter. This method is part of the Javadoc Doclet API.

```java
    @Override
    public void init(Locale locale, Reporter reporter)

```

--------------------------------

### Dependencies.md File Size

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/MANIFEST.md

Displays the file size of the Dependencies.md file. This is part of the overall file size breakdown for the project.

```text
Dependencies.md           8.4 KB
```

--------------------------------

### Configure PlantUML Server URL

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/configuration.md

Set the base URL for the PlantUML server to generate diagrams remotely. If not provided, the built-in renderer is used. Recommended for faster generation.

```bash
docker run -d -p 8080:8080 plantuml/plantuml-server:latest
```

--------------------------------

### DependenciesElementScanner Constructor

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/Dependencies.md

Initializes a new instance of the DependenciesElementScanner class with the provided Javadoc environment and configuration.

```APIDOC
## DependenciesElementScanner Constructor

### Description
Initializes a new instance of the DependenciesElementScanner class.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Constructor Signature
```java
public DependenciesElementScanner(DocletEnvironment environment, Configuration config)
```

#### Parameters
- **environment** (`DocletEnvironment`) - Required - Javadoc environment with source elements
- **config** (`Configuration`) - Required - Doclet configuration
```

--------------------------------

### Diagram.getPlantUmlFile()

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UML-Diagrams.md

Abstract method to determine the file path for the PlantUML source output. Subclasses must implement this.

```APIDOC
## Diagram.getPlantUmlFile()

### Description
Determines the file path for `.puml` output. Implemented by subclasses.

### Method
`protected abstract File getPlantUmlFile()`

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```java
protected abstract File getPlantUmlFile()
```

### Response
#### Success Response
- `File` (File) - The file path for the PlantUML source

#### Response Example
- None
```

--------------------------------

### Detect Package Dependency Cycles

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/types.md

Demonstrates how to use the static detectCycles method from PackageDependencyCycle to find all cyclic dependencies within a set of PackageDependency objects. It then iterates through the detected cycles to print their package names.

```java
Set<PackageDependency> dependencies = /* ... */;
Set<PackageDependencyCycle> cycles = PackageDependencyCycle.detectCycles(dependencies);

for (PackageDependencyCycle cycle : cycles) {
    System.out.println("Cycle detected: " + cycle.getCycle());
}
```

--------------------------------

### README.md File Size

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/MANIFEST.md

Displays the file size of the README.md file. This is part of the overall file size breakdown for the project.

```text
README.md                   14 KB
```

--------------------------------

### Configure PlantUML Server URL (CLI)

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/configuration.md

Specify the PlantUML server URL using the command-line option. This is useful when running the doclet with a local or remote PlantUML server.

```bash
--plantuml-server-url http://localhost:8080/
```

--------------------------------

### PackageDependencyCycle Methods

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/Dependencies.md

Provides information about the methods available on a `PackageDependencyCycle` object, specifically how to retrieve the list of packages forming a detected cycle.

```APIDOC
## getCycle()

### Description
Retrieves the ordered list of packages that form a detected cyclic dependency.

### Method Signature
```java
public List<String> getCycle()
```

### Response
#### Success Response
- **List<String>** - Ordered list of packages forming the cycle
```

--------------------------------

### Utilities

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/README.md

General utility classes for file operations, URI handling, and other helper functions.

```APIDOC
## Utilities

### Description
A collection of utility classes that provide helpful functions for various tasks within the library.

### Classes
- `nl.talsmasoftware.umldoclet.util.FileUtils`: Utility methods for file operations.
- `nl.talsmasoftware.umldoclet.util.UriUtils`: Utility methods for handling URIs.
- `nl.talsmasoftware.umldoclet.uml.util.JavaBeanProperty`: Represents a JavaBean property.
- `nl.talsmasoftware.umldoclet.uml.util.UmlPostProcessors`: Utility for applying post-processing steps to UML diagrams.
```

--------------------------------

### Utilities.md File Size

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/MANIFEST.md

Displays the file size of the Utilities.md file. This is part of the overall file size breakdown for the project.

```text
Utilities.md                11 KB
```

--------------------------------

### SUMMARY.txt File Size

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/MANIFEST.md

Displays the file size of the SUMMARY.txt file. This is part of the overall file size breakdown for the project.

```text
SUMMARY.txt               6.8 KB
```

--------------------------------

### PackageDiagram Constructor

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UML-Diagrams.md

Initializes a new PackageDiagram. It takes configuration, the namespace to diagram, and a base filename for output files.

```APIDOC
## PackageDiagram Constructor

### Description
Initializes a new PackageDiagram. It takes configuration, the namespace to diagram, and a base filename for output files.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Method
```java
public PackageDiagram(Configuration config, Namespace namespace, String pumlFileName)
```

### Parameters
- **config** (`Configuration`) - Required - Diagram configuration
- **namespace** (`Namespace`) - Required - The package namespace to diagram
- **pumlFileName** (`String`) - Required - Base filename for `.puml` and image files

### Request Example
None

### Response
#### Success Response (200)
None

#### Response Example
None
```

--------------------------------

### Main Execution Logging in UMLDoclet

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/Logging.md

Logs copyright information and initiates diagram generation during the main execution phase. Handles runtime exceptions by logging errors.

```java
public boolean run(DocletEnvironment environment) {
    config.logger().info(DOCLET_COPYRIGHT, DOCLET_VERSION);
    config.logger().info(PLANTUML_COPYRIGHT);
    
    try {
        generateDiagrams(environment).forEach(Diagram::render);
        return new HtmlPostprocessor(config).postProcessHtml();
    } catch (RuntimeException unanticipatedException) {
        config.logger().error(ERROR_UNANTICIPATED_ERROR_GENERATING_UML, unanticipatedException);
        return false;
    }
}
```

--------------------------------

### Default File Locations

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/README.md

Shows the default directory structure and file naming conventions for generated Javadoc and UML diagrams.

```text
docs/
├── index.html                          (with dependency diagram)
├── package-dependencies.svg            (or .puml, .png, .eps)
├── com/example/package-summary.html    (with package diagram)
├── com/example/package.svg
├── com/example/MyClass.html            (with class diagram)
└── com/example/MyClass.svg
```

--------------------------------

### Diagram render() Method

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UML-Diagrams.md

Renders the UML diagram to various output formats. Skips rendering if the diagram is empty and renderEmptyDiagrams is false. Generates PlantUML source, optionally writes a .puml file, generates images, and post-processes links. Throws IllegalStateException on I/O errors.

```java
public void render()
```

--------------------------------

### Handle Cyclic Package Dependencies

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/configuration.md

Configure the action to take when cyclic dependencies between packages are detected. Options include ignoring, warning, or reporting an error.

```java
onCyclicPackageDependencies(Configuration.Action.WARN);
```

--------------------------------

### Configuration Action Enum

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/types.md

Defines actions for handling cyclic package dependencies. Use IGNORE to skip, WARN to log, or ERROR to fail the build.

```java
public enum Action {
    IGNORE,  // Ignore cyclic dependencies
    WARN,    // Log warning about cycles
    ERROR    // Fail with error on cycles
}
```

--------------------------------

### INDEX.md File Size

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/MANIFEST.md

Displays the file size of the INDEX.md file. This is part of the overall file size breakdown for the project.

```text
INDEX.md                  8.6 KB
```

--------------------------------

### Diagram.render()

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UML-Diagrams.md

Renders the UML diagram to configured output formats. This method handles the entire process from generating PlantUML source to creating image files.

```APIDOC
## Diagram.render()

### Description
Renders this diagram to configured output formats (SVG, PNG, EPS, etc.).

### Method
`public void render()`

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```java
public void render()
```

### Response
#### Success Response
- None

#### Response Example
- None

**Behavior:**

1. Skips rendering if diagram is empty and `renderEmptyDiagrams()` is false
2. Generates PlantUML source code
3. If `renderPumlFile()` is enabled, writes `.puml` file
4. For each configured image format, generates diagram image
5. Post-processes links to reference correct documentation paths

**Throws:** `IllegalStateException` on I/O errors
```

--------------------------------

### DependenciesElementScanner Constructor

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/Dependencies.md

Initializes a new instance of the DependenciesElementScanner class. Requires a DocletEnvironment and Configuration.

```java
public DependenciesElementScanner(DocletEnvironment environment, Configuration config)
```

--------------------------------

### Running Javadoc with Maven

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/README.md

Execute the Maven javadoc plugin to generate documentation with UML diagrams. This command processes your Java source code according to the configuration in your pom.xml.

```bash
mvn javadoc:javadoc
```

--------------------------------

### UMLFactory.md File Size

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/MANIFEST.md

Displays the file size of the UMLFactory.md file. This is part of the overall file size breakdown for the project.

```text
UMLFactory.md             6.7 KB
```

--------------------------------

### Diagram writeTo() Method

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UML-Diagrams.md

Writes the PlantUML source code for the diagram to an IndentingWriter. Includes delimiters, copyright, version, custom directives, and footer. Throws UncheckedIOException on I/O errors.

```java
@Override
public IndentingWriter writeTo(IndentingWriter output)
```

--------------------------------

### Scan and Detect Package Dependencies

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/Dependencies.md

This snippet shows how to use `DependenciesElementScanner` to scan included elements, detect package dependencies, and then generate a dependency diagram.

```java
DependenciesElementScanner scanner = new DependenciesElementScanner(docEnv, config);
Set<PackageDependency> packageDependencies = scanner.scan(
    docEnv.getIncludedElements(),
    null
);

// Detect cycles
detectPackageDependencyCycles(packageDependencies);

// Generate dependency diagram
DependencyDiagram dependencyDiagram = new DependencyDiagram(
    config,
    scanner.getModuleName(),
    "package-dependencies.puml"
);

packageDependencies.forEach(dep ->
    dependencyDiagram.addPackageDependency(dep.fromPackage, dep.toPackage)
);

dependencyDiagram.render();
```

--------------------------------

### Diagram writeCustomDirectives() Method

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UML-Diagrams.md

Writes custom PlantUML directives from configuration to the output writer. Returns the output writer for chaining.

```java
protected IndentingWriter writeCustomDirectives(List<String> customDirectives, IndentingWriter output)
```

--------------------------------

### Logging.md File Size

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/MANIFEST.md

Displays the file size of the Logging.md file. This is part of the overall file size breakdown for the project.

```text
Logging.md                7.7 KB
```

--------------------------------

### DependencyDiagram Constructor

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UML-Diagrams.md

Initializes a new DependencyDiagram. Use this to set up the diagram with configuration, an optional module name, and the output filename.

```java
public DependencyDiagram(Configuration config, Optional<String> moduleName, String pumlFileName)
```

--------------------------------

### Configure UML Doclet in Ant

Source: https://github.com/talsma-ict/umldoclet/blob/main/usage.md

Use the javadoc task in Ant to integrate the UML Doclet. Ensure the 'umlDoclet.classpath' path reference points to the doclet JAR.

```xml
<javadoc destdir="target/javadoc" sourcepath="src">
    <doclet name="nl.talsmasoftware.umldoclet.UMLDoclet" pathref="umlDoclet.classpath">
        <param name="additionalParamName" value="additionalParamValue"/>
    </doclet>
</javadoc>
```

--------------------------------

### Configure Gradle Javadoc Task for UML Doclet (Groovy DSL)

Source: https://github.com/talsma-ict/umldoclet/blob/main/usage.md

Configure the Javadoc task in Gradle using the Groovy DSL to incorporate the UML Doclet. Define the doclet dependency and set the task options accordingly.

```groovy
apply plugin: 'java'

configurations {
    umlDoclet
}

dependencies {
    umlDoclet "nl.talsmasoftware:umldoclet:2.x"
}

javadoc {
    source = sourceSets.main.allJava
    options.docletpath = configurations.umlDoclet.files.asType(List)
    options.doclet = "nl.talsmasoftware.umldoclet.UMLDoclet"
    options.addStringOption "additionalParamName", "additionalParamValue"
}
```

--------------------------------

### Complete UML Generation Workflow

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UMLFactory.md

This snippet demonstrates a complete workflow for generating class and package diagrams using UMLFactory within a custom Javadoc doclet or processing code. It iterates through included elements, creates diagrams, and renders them.

```java
Configuration config = new DocletConfig();
DocletEnvironment environment = /* provided by Javadoc */; 

UMLFactory factory = new UMLFactory(config, environment);

// Generate class diagrams for all types
for (TypeElement type : environment.getIncludedElements()) {
    if (type.getKind().isClass() || type.getKind().isInterface()) {
        ClassDiagram diagram = factory.createClassDiagram(type);
        if (diagram != null) {
            diagram.render();
        }
    }
}

// Generate package diagrams
for (PackageElement pkg : environment.getIncludedElements()) {
    PackageDiagram diagram = factory.createPackageDiagram(pkg);
    if (diagram != null) {
        diagram.render();
    }
}
```

--------------------------------

### HTML Integration

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/README.md

Class for post-processing generated HTML documentation.

```APIDOC
## HTML Integration

### Description
This class provides functionality to modify or enhance the generated HTML documentation after the main Javadoc process.

### Class
`nl.talsmasoftware.umldoclet.html.HtmlPostprocessor`
```

--------------------------------

### UMLDoclet Type Display Options

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/README.md

Demonstrates options for controlling how type names are displayed in diagrams, including NONE, SIMPLE, QUALIFIED, and QUALIFIED_GENERICS.

```java
TypeDisplay.NONE                // Omit type names
TypeDisplay.SIMPLE              // Simple names: String
TypeDisplay.QUALIFIED           // Qualified: java.lang.String
TypeDisplay.QUALIFIED_GENERICS  // Qualified with generics: List<String>
```

--------------------------------

### postProcessHtml Method

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/HtmlPostprocessor.md

Executes the HTML post-processing tasks to embed UML diagrams. Returns true on success, false on failure.

```java
public boolean postProcessHtml()
```

--------------------------------

### UmlPostProcessors.includeFile

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/Utilities.md

Generates a PlantUML `!include` directive for a given file. This allows you to include external PlantUML definitions or styles into your diagrams.

```APIDOC
## includeFile(File)

### Description
Generates PlantUML `!include` directive for external file.

### Method Signature
```java
public static String includeFile(File file)
```

### Parameters
#### Path Parameters
- **file** (File) - Required - File to include

### Return
#### Success Response (String)
- **String** - PlantUML include directive

### Example
```java
File styleFile = new File("styles.puml");
String include = UmlPostProcessors.includeFile(styleFile);
// Result: "!include styles.puml"
```
```

--------------------------------

### postProcessHtml()

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/HtmlPostprocessor.md

Executes the main HTML post-processing logic, including discovering files, embedding diagrams, and updating links.

```APIDOC
## postProcessHtml()

### Description
Main method that performs all HTML post-processing tasks. It scans for HTML files, identifies diagrams, embeds them, and updates links.

### Method Signature
`public boolean postProcessHtml()`

### Return
- **boolean** - `true` if post-processing completed successfully, `false` on error

### Throws
- `RuntimeException` on I/O errors

### Example
```java
Configuration config = new DocletConfig();
HtmlPostprocessor postprocessor = new HtmlPostprocessor(config);
boolean success = postprocessor.postProcessHtml();
if (!success) {
    System.err.println("HTML post-processing failed");
}
```
```

--------------------------------

### types.md File Size

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/MANIFEST.md

Displays the file size of the types.md file. This is part of the overall file size breakdown for the project.

```text
types.md                  8.9 KB
```

--------------------------------

### Logging

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/README.md

Classes for handling logging within the UMLDoclet process.

```APIDOC
## Logging

### Description
Utilities for managing logging output during the UMLDoclet execution.

### Classes
- `nl.talsmasoftware.umldoclet.logging.Logger`: Interface for logging messages.
- `nl.talsmasoftware.umldoclet.logging.Message` (enum): Defines different types of log messages.
```

--------------------------------

### Define Method Parameters in Java

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/types.md

Use the Parameters class to add method parameters with their names and types. Ensure the TypeName is correctly instantiated.

```java
public class Parameters extends UMLNode {
    public void add(String name, TypeName type);
    public List<Parameter> getParameters();
}
```

--------------------------------

### Create Package Diagram from PackageElement

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UMLFactory.md

Generates a UML package diagram for a given Java package. This method creates a namespace, includes classes and sub-packages, and adheres to configuration settings for package diagram rendering and empty diagrams.

```java
PackageElement pkg = /* from DocletEnvironment */;
UMLFactory factory = new UMLFactory(config, environment);
PackageDiagram diagram = factory.createPackageDiagram(pkg);
diagram.render();
```

--------------------------------

### Configure Maven Javadoc Plugin with UML Doclet

Source: https://github.com/talsma-ict/umldoclet/wiki/UML-Doclet-usage

Configure the maven-javadoc-plugin to use the UML Doclet. Ensure the umldoclet artifact version is specified.

```xml
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-javadoc-plugin</artifactId>
            <version>2.10.3</version>
            <executions>
                <execution>
                    <id>attach-javadocs</id>
                    <goals>
                        <goal>jar</goal>
                    </goals>
                    <configuration>
                        <doclet>nl.talsmasoftware.umldoclet.UMLDoclet</doclet>
                        <docletArtifact>
                            <groupId>nl.talsmasoftware</groupId>
                            <artifactId>umldoclet</artifactId>
                            <version>...</version>
                        </docletArtifact>
                        <additionalParam>
                            ...
                        </additionalParam>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>
```

--------------------------------

### Configuration Interfaces

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/README.md

Interfaces for configuring various aspects of UML diagram generation, including general settings, image export, and element visibility.

```APIDOC
## Configuration Interfaces

### Description
These interfaces allow users to customize the appearance and behavior of the generated UML diagrams.

### Interfaces
- `nl.talsmasoftware.umldoclet.configuration.Configuration`: General configuration for the doclet.
- `nl.talsmasoftware.umldoclet.configuration.ImageConfig`: Configuration specific to image export settings.
- `nl.talsmasoftware.umldoclet.configuration.FieldConfig`: Configuration for displaying fields in diagrams.
- `nl.talsmasoftware.umldoclet.configuration.MethodConfig`: Configuration for displaying methods in diagrams.
- `nl.talsmasoftware.umldoclet.configuration.Visibility` (enum): Defines visibility levels (e.g., public, private) for elements.
- `nl.talsmasoftware.umldoclet.configuration.TypeDisplay` (enum): Defines how types are displayed in diagrams.
```

--------------------------------

### UML-Diagrams.md File Size

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/MANIFEST.md

Displays the file size of the UML-Diagrams.md file. This is part of the overall file size breakdown for the project.

```text
UML-Diagrams.md             13 KB
```

--------------------------------

### Detecting Package Dependency Cycles

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/Dependencies.md

The `detectCycles` static method in `PackageDependencyCycle` analyzes a set of package dependencies to find all cyclic relationships. It builds a graph and uses DFS to identify cycles.

```APIDOC
## detectCycles

### Description
Detects all cyclic dependencies in a set of package dependencies.

### Method Signature
```java
public static Set<PackageDependencyCycle> detectCycles(Set<PackageDependency> dependencies)
```

### Parameters
#### Path Parameters
- **dependencies** (`Set<PackageDependency>`) - Required - Package dependencies to analyze

### Response
#### Success Response
- **Set<PackageDependencyCycle>** - All detected cycles

### Request Example
```java
Set<PackageDependency> dependencies = new HashSet<>();
dependencies.add(new PackageDependency("pkg.a", "pkg.b"));
dependencies.add(new PackageDependency("pkg.b", "pkg.c"));
dependencies.add(new PackageDependency("pkg.c", "pkg.a"));  // Cycle!

Set<PackageDependencyCycle> cycles = PackageDependencyCycle.detectCycles(dependencies);

for (PackageDependencyCycle cycle : cycles) {
    System.out.println("Cycle: " + cycle.getCycle());
    // Output: Cycle: [pkg.a, pkg.b, pkg.c, pkg.a]
}
```
```

--------------------------------

### Diagram.writeCustomDirectives(List<String>, IndentingWriter)

Source: https://github.com/talsma-ict/umldoclet/blob/main/_autodocs/UML-Diagrams.md

Writes custom PlantUML directives to the diagram output, based on configuration.

```APIDOC
## Diagram.writeCustomDirectives(List<String>, IndentingWriter)

### Description
Writes custom PlantUML directives to the diagram.

### Method
`protected IndentingWriter writeCustomDirectives(List<String> customDirectives, IndentingWriter output)`

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```java
protected IndentingWriter writeCustomDirectives(List<String> customDirectives, IndentingWriter output)
```

### Response
#### Success Response
- `IndentingWriter` (IndentingWriter) - Same output instance

#### Response Example
- None
```