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 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.
|
| 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.
|
| 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
|