All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
Class |
Description |
AbstractAnnotatedArgumentBinder<A extends java.lang.annotation.Annotation,T,S> |
|
AbstractBeanConstructor<T> |
|
AbstractBeanIntrospection<T> |
|
AbstractBeanIntrospectionReference<T> |
Abstract bean introspection reference used by BeanIntrospector to soft load introspections.
|
AbstractBeanMethod<B,T> |
Abstract implementation of the BeanMethod interface.
|
AbstractBeanProperty<B,P> |
|
AbstractLocaleResolver<T> |
Provides an abstract class which implements LocaleResolver and handles default locale resolution.
|
AccessorsStyle |
Annotate a class (typically a Java Bean) to make it explicit the style of its accessors when not using the standard
getter and setters:
|
AnnotatedArgumentBinder<A extends java.lang.annotation.Annotation,T,S> |
|
AnnotatedElement |
An annotated element is some point in the code, whether it be a constructor, field,
method etc.
|
AnnotatedTypeInfo |
An interface that provides an abstraction for checking for the existence of annotations.
|
AnnotationClassValue<T> |
An annotation class value is a reference to a class in annotation metadata.
|
AnnotationMetadata |
An interface implemented at compile time by Micronaut that allows the inspection of annotation metadata and
stereotypes (meta-annotations)
|
AnnotationMetadataDelegate |
|
AnnotationMetadataProvider |
|
AnnotationMetadataResolver |
|
AnnotationScanner |
Interface for classes that scan for classes with a given annotation.
|
AnnotationSource |
A source of annotations.
|
AnnotationUtil |
Internal utility methods for annotations.
|
AnnotationValue<A extends java.lang.annotation.Annotation> |
A runtime representation of the an annotation and its values.
|
AnnotationValueBuilder<T extends java.lang.annotation.Annotation> |
A build for annotation values.
|
AnnotationValueProvider<A extends java.lang.annotation.Annotation> |
An interface that allows obtaining an underlying annotation value.
|
AnnotationValueResolver |
Interface for types that resolve annotation values.
|
AntPathMatcher |
PathMatcher implementation for Ant-style path patterns.
|
Argument<T> |
Represents an argument to a method or constructor or type.
|
ArgumentBinder<T,S> |
An interface capable of binding the value of an Argument from a source
|
ArgumentBinder.BindingResult<T> |
The result of binding.
|
ArgumentBinderRegistry<S> |
|
ArgumentCoercible<T> |
An interface for types that can be represented as an Argument .
|
ArgumentConversionContext<T> |
|
ArgumentUtils |
Utility methods for checking method argument values.
|
ArgumentUtils.ArgumentCheck<T> |
Allows producing error messages.
|
ArgumentUtils.Check |
Functional interface the check a condition.
|
ArgumentValue<V> |
|
ArrayUtils |
Utility methods for working with arrays.
|
AttributeHolder |
An interface for objects that have attributes.
|
AutomaticFeatureUtils |
Utility methods for implementing Graal's AutomaticFeature .
|
BeanConstructor<T> |
Models a bean constructor.
|
BeanExceptionHandler<T,E extends java.lang.Throwable> |
An exception handler capable of receiving a bean that originated the exception and an exception type.
|
BeanIntrospection<T> |
A BeanIntrospection is the result of compile time computation of a beans properties and annotation metadata.
|
BeanIntrospectionReference<T> |
|
BeanIntrospectionScanner |
|
BeanIntrospector |
Primary interface for obtaining BeanIntrospection instances that are computed at compilation time.
|
BeanMap<T> |
Simple class that provides a map interface over a bean.
|
BeanMethod<B,T> |
|
BeanProperty<B,T> |
Represents a bean property and associated annotation metadata.
|
BeanPropertyBinder |
An interface that provides the ability to bind Maps and Java bean properties
|
BeanWrapper<T> |
Wraps a bean allowing to read and write its properties via a underlying BeanIntrospection .
|
Bindable |
An annotation stereotype for other annotations that indicates a method Argument is bindable.
|
Blocking |
A marker annotation for methods that are blocking.
|
BoundExecutable<T,R> |
|
ByteBuffer<T> |
Interface to allow interfacing with different byte buffer implementations, primarily as an abstraction over Netty.
|
ByteBufferFactory<T,B> |
|
ClassPathResourceLoader |
Abstraction to load resources from the classpath.
|
ClassUtils |
Utility methods for loading classes.
|
ClassUtils.Optimizations |
Optimizations for computing missing types.
|
CollectionUtils |
Utility methods for working with Collection types
|
CommandLine |
Represents the parsed command line options.
|
CommandLine.Builder<T extends CommandLine.Builder> |
A build for constructing a command line parser.
|
ConcurrentLinkedHashMap<K,V> |
A hash table supporting full concurrency of retrievals, adjustable expected
concurrency for updates, and a maximum capacity to bound the map by.
|
ConcurrentLinkedHashMap.Builder<K,V> |
|
ConversionContext |
A conversion context is a context object supplied to a TypeConverter that allows more accurate conversion.
|
ConversionError |
An interface for reporting conversion errors.
|
ConversionErrorException |
|
ConversionService<Impl extends ConversionService> |
A service for allowing conversion from one type to another.
|
ConvertibleMultiValues<V> |
|
ConvertibleMultiValuesMap<V> |
|
ConvertibleValues<V> |
An interface for classes that represent a map-like structure of values that can be converted.
|
ConvertibleValuesMap<V> |
|
Creator |
An annotation applicable to a constructor that provides a hint as to which constructor is the primary constructor.
|
DefaultArgument<T> |
Represents an argument to a constructor or method.
|
DefaultClassPathResourceLoader |
Loads resources from the classpath.
|
DefaultConversionService |
The default conversion service.
|
DefaultExecutableBinder<S> |
|
DefaultFileSystemResourceLoader |
Loads resources from the file system.
|
Described |
An interface for types that are described by a description.
|
EntryPoint |
EntryPoint is a meta-annotation used on other annotations to indicate that the annotated
element is an entry point into the framework from the outside.
|
EntryWeigher<K,V> |
A class that can determine the weight of an entry.
|
EnvironmentProperties |
A mapping from environment variable names to Micronaut
property names.
|
ErrorsContext |
Interface for reporting conversion errors.
|
EvictionListener<K,V> |
A listener registered for notification when an entry is evicted.
|
ExceptionHandler<T extends java.lang.Throwable> |
Common interface for types that handle exceptions.
|
Executable<T,R> |
Represents an executable reference.
|
ExecutableBinder<S> |
An ExecutableBinder is capable of taking a target Executable and fulfilling the argument
requirements using the provided binding source and ArgumentBinderRegistry
|
Experimental |
Annotates a class or method as being experimental and subject to change or removal.
|
FileSystemResourceLoader |
Abstraction to load resources from the file system.
|
FixedLocaleResolver<T> |
|
Format |
Annotation used to describe the format in the case where the format needs to be altered for the purposes of
conversion.
|
FormattingTypeConverter<S,T,A extends java.lang.annotation.Annotation> |
|
Generated |
A marker annotation for methods that are generated though an annotation processor.
|
GenericArgument<T> |
|
GenericPlaceholder<T> |
Extends Argument to allow differentiating the
variable name from the argument name in cases where this is
required (parameters and fields for example).
|
GenericTypeUtils |
Utility methods for dealing with generic types via reflection.
|
GraalReflectionConfigurer |
Interface that allows dynamic configuration of reflection generated by the GraalTypeElementVisitor.
|
GraalReflectionConfigurer.ReflectionConfigurationContext |
Context object for the configuration.
|
Headers |
Common interface for all headers types.
|
ImmutableArgumentConversionContext<T> |
Immutable variant of ArgumentConversionContext that can be used as a constant
in cases where conversion error handling and rejection is not required.
|
Indexed |
An annotation that can be used on types where there may be many implementations of a
particular interface.
|
Indexes |
|
InstantiatedMember |
An annotation that can be used on another annotation member that returns a class to indicate that
the value of the annotation should be populated as an instance of the specified class.
|
InstantiationException |
Thrown when an error occurs instantiating a instance.
|
InstantiationUtils |
Utility methods for instantiating objects.
|
Internal |
Annotates a class or method regarded as internal and not for public consumption.
|
Introspected |
An annotation that indicates a type should produce a BeanIntrospection at compilation time.
|
Introspected.AccessKind |
The access type for bean properties.
|
Introspected.IndexedAnnotation |
Allow pre-computed indexes for property lookups based on an annotation and a member.
|
Introspected.Visibility |
Visibility policy for bean properties and fields.
|
IntrospectionException |
Thrown when an error occurs introspecting a bean type.
|
InvocationException |
Runtime exception equivalent of InvocationTargetException .
|
IOExceptionBiFunction<T,U,R> |
Utility to use a BiFunction which throws internally a IOException.
|
IOUtils |
Utility methods for I/O operations.
|
JdkSerializer |
|
KotlinUtils |
Internal Utility methods for working with Kotlin suspend functions
|
LocaleResolutionConfiguration |
Locale resolution configuration.
|
LocaleResolver<T> |
Responsible for determining the current locale given a context.
|
MapFormat |
Allows configuration how map property values are injected.
|
MapFormat.MapTransformation |
Specifies the type of the map that should be injected.
|
MapPropertyResolver |
|
MethodConvention |
Represents the built in conventions for mapping a method name to an HTTP Method and URI.
|
MultiValuesConverterFactory |
|
MultiValuesConverterFactory.AbstractConverterToMultiValues<T> |
An abstract class to convert to ConvertibleMultiValues.
|
MultiValuesConverterFactory.IterableToMultiValuesConverter |
|
MultiValuesConverterFactory.MapToMultiValuesConverter |
|
MultiValuesConverterFactory.MultiValuesToIterableConverter |
|
MultiValuesConverterFactory.MultiValuesToMapConverter |
|
MultiValuesConverterFactory.MultiValuesToObjectConverter |
|
MultiValuesConverterFactory.ObjectToMultiValuesConverter |
|
MutableArgumentValue<V> |
|
MutableAttributeHolder |
An interface for types that support mutating attributes.
|
MutableConvertibleMultiValues<V> |
|
MutableConvertibleMultiValuesMap<V> |
|
MutableConvertibleValues<V> |
|
MutableConvertibleValuesMap<V> |
|
MutableHeaders |
Common interface for all mutable header types.
|
Named |
An interface for components that are named.
|
NameResolver |
An interface for a components that resolve names.
|
NameUtils |
Naming convention utilities.
|
NonBlocking |
A marker annotation for methods that are non-blocking.
|
NonNull |
A common annotation to declare that annotated elements cannot be null .
|
Nullable |
A common annotation to declare that annotated elements can be null under some circumstance.
|
ObjectSerializer |
Interface for implementations capable of serializing objects.
|
Option |
Represents a command line option.
|
OptionalMultiValues<V> |
An OptionalValues that for each key features an Optional List of values.
|
OptionalValues<V> |
A simple type safe abstraction over a map of optional values.
|
OptionalValuesMap<T> |
|
Order |
Annotation for objects that are ordered.
|
Ordered |
Interface for objects that are ordered.
|
OrderUtil |
Apply the Ordered interface to lists or arrays.
|
ParseException |
Exception that is thrown in command line parsing fails.
|
PathMatcher |
Interface for components that can match source strings against a specified pattern string.
|
PropertyConvention |
Typical conventions used for property names through the system.
|
PropertyNotFoundException |
Thrown when a property cannot be resolved.
|
PropertyResolver |
A property resolver is capable of resolving properties from an underlying property source.
|
Readable |
Abstraction over File and URL based I/O.
|
ReadableBytes |
|
ReadableBytesTypeConverter |
Converts String's to readable bytes.
|
ReferenceCounted |
|
ReflectionConfig |
An annotation that models directly the GraalVM reflect-config.json format.
|
ReflectionConfig.ReflectionConfigList |
Wrapper annotation.
|
ReflectionConfig.ReflectiveFieldConfig |
Field configuration.
|
ReflectionConfig.ReflectiveMethodConfig |
Method configuration.
|
ReflectionUtils |
Utility methods for reflection related tasks.
|
ReflectiveAccess |
Descriptive annotation that can be used to declare a field, method, constructor and types for reflective access.
|
RegexPathMatcher |
PathMatcher implementation for regex-style patterns.
|
ResourceLoader |
Basic abstraction over resource loading.
|
ResourceResolver |
|
ReturnType<T> |
Models a return type of an Executable method in Micronaut.
|
SemanticVersion |
Utility class for comparing semantic versions.
|
SerializationException |
A generic exception that occurs during serialization or deserialization.
|
ServiceDefinition<T> |
A service that may or may not be present on the classpath.
|
SocketUtils |
Utility methods for dealing with sockets.
|
SoftServiceLoader<S> |
Variation of ServiceLoader that allows soft loading and conditional loading of
META-INF/services classes.
|
SoftServiceLoader.Optimizations |
Static optimizations for service loaders.
|
SoftServiceLoader.ServiceCollector<S> |
Service collector for loading services of the given type.
|
SoftServiceLoader.StaticDefinition<S> |
A ServiceDefinition implementation that uses a MethodHandles.Lookup object to find a public constructor.
|
SoftServiceLoader.StaticServiceLoader<S> |
|
StaticOptimizations |
This class is a generic container for pre-computed data
which can be injected at initialization time.
|
StaticOptimizations.Loader<T> |
Interface for an optimization which will be injected via
service loading.
|
Streamable |
Interface for types that can be written to an OutputStream .
|
StreamSoftServiceLoader |
Deprecated.
|
StreamUtils |
Utility methods for working with streams.
|
StringConvention |
An enum representing different conventions.
|
StringUtils |
Utility methods for Strings.
|
SupplierUtil |
Helper methods for dealing with Supplier .
|
ThrowingFunction<T,R,E extends java.lang.Throwable> |
Represents a function that accepts one argument and produces a result.
|
ThrowingSupplier<T,E extends java.lang.Throwable> |
Represents a supplier of results.
|
Toggleable |
An interface for components or configurations that can be toggled on or off.
|
TypeArgumentBinder<T,S> |
|
TypeConvention |
Common conventions for types
|
TypeConverter<S,T> |
A type converter for converting from one type to another.
|
TypeConverterRegistrar |
|
TypeHint |
The type hint annotation is a general annotation that can be used on interfaces to provide
additional information about types used at runtime.
|
TypeHint.AccessType |
The access type.
|
TypeInformation<T> |
Provides information about a type at runtime.
|
TypeInformationProvider |
|
TypeVariableResolver |
An interface for types that hold and can resolve type variables.
|
UncheckedIOException |
Wraps a IOException in a RuntimeException .
|
UnsafeBeanProperty<B,T> |
Unsafe bean property interface adds read/write methods which don't validate the input/output.
|
UnsatisfiedArgumentException |
|
UsedByGeneratedCode |
A marker annotation indicating that a method is used by generated code and should
not be modified or removed otherwise a binary compatibility problem will be introduced.
|
ValueException |
An exception that occurs related to configuration.
|
ValueResolver<K extends java.lang.CharSequence> |
An interface for any type that is able to resolve and convert values.
|
Version |
Annotation used to express the version of a component or method.
|
VersionUtils |
Utility methods for versioning.
|
Weigher<V> |
A class that can determine the weight of a value.
|
Weighers |
|
Writable |
An interface for classes to implement that are capable of writing themselves to a Writer
|