All Classes and Interfaces
Class
Description
Base class for code generators which need access to the generation
context (for example to get a handle on the analyzed application classloader,
or to register resources to be excluded from the final binary).
Base class for source generators which generate a single class file.
A source generator is the main entity of the AOT project.
The source generation context is used by source generators
to get configuration details.
Writes the structured Micronaut AOT diagnostics report.
Annotation which must be present on AOT optimizers.
An application context analyzer is responsible for instantiating
an application context and inferring whether a bean should be
included in the application binaries.
The "optimized" entry point generator is the main source generator:
it is responsible for generating a new entry point, which delegates
to the original entry point of the application, and injects a number
of optimizations before starting the application.
Generates the code used to enable environment variables and system
properties caching in Micronaut.
Rewrites the class files of an application's runtime class path at build time, for the build plugins to package
the result instead of the original jars.
What to rewrite.
Builds a
ClassPathTransform.Request.What a run did.
What the steps did to one class path entry, a jar or a directory.
Configuration keys which may be found in the properties
used to configure the AOT analyzer, but shouldn't be
declared directly by the user.
Read-only configuration for source generators.
Generates a "constant" property source, that is to say a
PropertySource which properties are known at build time
(and constant).This code generator is responsible for taking the result
of the environment deduction, which is the set of active
environment names and the package names, and inject is
via a custom application context configurer.
An implementation of configuration which uses properties
as the backing store.
The source generation context.
Base class for source generation context which need to delegate
to another one.
A code generator which is responsible for precomputing the Micronaut property
names from environment variable names at build time.
Constants used for configuration of environments.
A source generator which will generate a static
PropertySource
from a given configuration file, in order to substitute the dynamic loader
with a static configuration.Generates the GraalVM configuration file which is going to configure
the native image code generation, typically asking to initialize
the optimized entry point at build time.
A source generator which will check for existence of a number of classes
at build time.
A source generator responsible for converting a logback.xml configuration into
Java configuration.
Compiles an application's
logback.xml into a Logback Configurator at build time, so that the
application does not parse XML and run Joran on the main thread at every start.What to compile and for which class path: plain paths, no build tool type.
Builds a
LogbackPrecompiler.Request.The outcome of one precompilation: its
LogbackPrecompiler.Result.status(), one LogbackPrecompiler.Result.message() for the caller to log, the
generated LogbackPrecompiler.Result.entries(), and the LogbackPrecompiler.Result.warnings() the caller logs at warning level, which most
results do not have.What a precompilation did.
Entry point for the Micronaut AOT command line interface.
A helper class to generate maps.
A source generator which generates a map property source with a fixed
set of values at build time.
Runtime reflection utils for analyzing AOT modules.
The Micronaut AOT optimizer is the main entry point for code
generation at build time.
The main AOT optimizer runner.
A code generator which is responsible for setting up Netty properties.
Describes a configuration option of a source generator.
Represents default class name rules.
An optimizer which is responsible for determining what reactive
types are found at build time.
The targeted type of runtime.
Generates micronaut-core's service index for a packaged application: a
StaticOptimizations.Loader that
registers a ServiceIndex of the application's class path, so that service loading at run time does not
scan META-INF/services and META-INF/micronaut.The class path an index is generated for: plain paths, no build tool type.
Builds a
ServiceIndexGenerator.Request.The outcome of one generation: its
ServiceIndexGenerator.Result.status(), one ServiceIndexGenerator.Result.message() for the caller to log, the
ServiceIndexGenerator.Result.entries() to write into the holder and the ServiceIndexGenerator.Result.removals() to delete from it, which the caller
applies whatever the status.What a generation did.
This class is responsible for loading the source generators
for a particular target runtime, and sort them in execution
order according to their dependencies.
Describes how a discovered source generator was selected for an AOT run.
Utility methods to deal with exceptions being
thrown in streams.
A helper interface for runnables which may
throw an exception.
A helper interface to capture suppliers which
may throw an exception.
Reads the version.txt generated file to feed it to picocli.