ReportAnalyzer (Quarkus - Core - Deployment 2.5.3.Final API)

java.lang.Object
- io.quarkus.deployment.pkg.steps.ReportAnalyzer

public class ReportAnalyzer
extends Object

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static class ReportAnalyzer.Node

Field Summary

Fields
Modifier and Type	Field	Description
`(package private) Map<String,List<ReportAnalyzer.Node>>`	`byClassMap`
`(package private) Map<String,List<ReportAnalyzer.Node>>`	`constructors`
`(package private) List<ReportAnalyzer.Node>`	`parents`
`(package private) static Pattern`	`PATTERN`

Constructor Summary

Constructors
Constructor Description

ReportAnalyzer(String report)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`String`	`analyse(String className, String methodName)`	Analyze the contents of the call tree report produced by Substrate when using -H:+PrintAnalysisCallTree, and does a more meaningful analysis of what is causing a type to be retained.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - parents
```
final List<ReportAnalyzer.Node> parents
```
  - byClassMap
```
final Map<String,List<ReportAnalyzer.Node>> byClassMap
```
  - constructors
```
final Map<String,List<ReportAnalyzer.Node>> constructors
```
  - PATTERN
```
static Pattern PATTERN
```
- Constructor Detail
  - ReportAnalyzer
```
public ReportAnalyzer(String report)
```
- Method Detail
  - analyse
```
public String analyse(String className,
                      String methodName)
               throws Exception
```
    Analyze the contents of the call tree report produced by Substrate when using -H:+PrintAnalysisCallTree, and does a more meaningful analysis of what is causing a type to be retained. In particular for virtual or interface methods that have multiple implementations what is calling this method is not really important, its what caused this particular instance of the class to be created that is important (e.g. if you have an instance of Runnable, you don't care about all the different parts that call runnable, you care about what created this particular instance). If a virtual or interface call is detected with multiple implementations then printing the current call flow is abandoned, and instead the call flow for the constructor of the current object is printed instead.
    
    Throws:
    
    Exception