core library Jetleaf
π± Jetleaf Core Subsystem & Runtime Context
This library provides the primary application kernel, declarative annotations, application context abstractions, event dispatching, method interception, and internationalized messaging for the Jetleaf framework.
It aggregates and re-exports core functionality from jetleaf_core:
- Stereotype Annotations:
@Component,@Service,@Repository,@Controller,@RestController,@Configuration,@Pod. - Injection & Wiring Annotations:
@Autowired,@Value,@Primary,@Order,@Lazy,@Scope,@Profile. - Lifecycle Hooks:
@PostConstruct,@PreDestroy,@OnApplicationReady,@OnApplicationStarting. - Application Contexts: ApplicationContext, ConfigurableApplicationContext, AnnotationConfigApplicationContext.
- Event Bus: ApplicationEvent,
ApplicationListener,ApplicationEventPublisher. - Health & Availability: ApplicationAvailability, LivenessState, ReadinessState.
- Method Interception:
@Intercept, Interceptable, MethodInterceptor,InvocationContext. - Message Sources: MessageSource, localized string resolution.
ποΈ Core Context & Application Topology
ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β Jetleaf Core Application Kernel β
βββββββββββββββββββββββ¬βββββββββββββββββββββββ¬ββββββββββββββββββββββββββββ€
β Context Model β Event Infrastructureβ Cross-Cutting AOP β
βββββββββββββββββββββββΌβββββββββββββββββββββββΌββββββββββββββββββββββββββββ€
β β’ ApplicationContextβ β’ ApplicationEvent β β’ @Intercept β
β β’ AnnotationConfig β β’ EventPublisher β β’ MethodInterceptor β
β β’ GenericContext β β’ ApplicationListenerβ β’ InvocationContext β
βββββββββββββββββββββββ΄βββββββββββββββββββββββ΄ββββββββββββββββββββββββββββ€
β Availability & Health Lifecycle β
βββββββββββββββββββββββββββββββββββββββββββββ¬βββββββββββββββββββββββββββββ€
β LivenessState β ReadinessState β
βββββββββββββββββββββββββββββββββββββββββββββΌβββββββββββββββββββββββββββββ€
β β’ CORRECT (healthy internal state) β β’ ACCEPTING_TRAFFIC (ready)β
β β’ BROKEN (fatal failure, restart needed) β β’ REFUSING_TRAFFIC (warmup)β
βββββββββββββββββββββββββββββββββββββββββββββ΄βββββββββββββββββββββββββββββ
π¦ Exports Categorization
π·οΈ Declarative Component Stereotypes
@Componentβ marks an auto-discoverable managed pod.@Serviceβ business layer stereotype with semantics for transactional/audited processing.@Repositoryβ data access and persistence abstraction layer.@Controller,@RestControllerβ web presentation and HTTP API endpoint handlers.@Configuration,@Podβ programmatic pod definition factory classes.
π Injection & Wiring Directives
@Autowiredβ container dependency injection directive for fields and properties.@Valueβ configuration expression evaluation and property value injection.@Primaryβ designates the primary candidate when multiple pods match a dependency type.@Orderβ precedence and ordering index for listeners, filters, and runners.@Lazyβ defers pod initialization until first explicit retrieval.@Profileβ restricts pod registration to specific active environment profiles.
π Lifecycle & Event Callbacks
@PostConstructβ invoked immediately following complete dependency resolution.@PreDestroyβ invoked during graceful application shutdown.@OnApplicationReady,@OnApplicationStartingβ framework startup phase notifications.- ApplicationEvent,
ApplicationListenerβ decoupled observer pub/sub engine.
π‘οΈ Method Interception & AOP
@Interceptβ declarative interception pointcut annotation.- MethodInterceptor β around-advice interceptor contract for logging, metrics, or security.
InvocationContextβ reflective invocation descriptor with target, arguments, and proceed handle.
π― Usage Example: Service Component with Lifecycle & Events
import 'package:jetleaf/core.dart';
// Custom domain event
class UserRegisteredEvent extends ApplicationEvent {
final String email;
UserRegisteredEvent(this.email) : super(email);
}
@Service('userService')
class UserService {
final ApplicationEventPublisher _eventPublisher;
bool _initialized = false;
UserService(this._eventPublisher);
@PostConstruct()
void init() {
_initialized = true;
print('UserService initialized and ready.');
}
void registerUser(String email) {
print('Registering user: $email');
_eventPublisher.publishEvent(UserRegisteredEvent(email));
}
@PreDestroy()
void dispose() {
print('UserService shutting down.');
}
}
@Component()
class WelcomeEmailSender implements ApplicationListener<UserRegisteredEvent> {
@override
void onApplicationEvent(UserRegisteredEvent event) {
print('Sending welcome email to: ${event.email}');
}
}
Classes
- AbsolutePathValidator
- Validates that a URI contains an absolute path (starting with '/').
- AbstractApplicationContext
- The base implementation of a configurable Jetleaf Application Context.
- AbstractAutowirePodFactory
- Abstract base class for pod factories that support autowiring capabilities.
- AbstractEnvironment
- Base class for creating environment implementations in Jetleaf.
-
AbstractExceptionDiagnoser<
E extends Exception> -
Base class for creating typed exception diagnosers that target a
specific exception type
E. - AbstractMessageSource
- Base implementation of MessageSource providing common functionality.
- AbstractMethodDispatcher
- A foundational implementation of MethodInterceptorDispatcher and MethodInterceptor providing a unified interception pipeline for Jetleaf's runtime and AOP subsystems.
- AbstractPodDefinition
- An abstract base class for pod definitions that extends PodDefinition.
- AbstractPodFactory
- Abstract base implementation of PodFactory that provides core functionality for pod creation, management, and lifecycle handling in the Jetleaf framework.
- AbstractPodProviderFactory
- Retrieves the PodProvider backing a pod.
-
AbstractRuntimeHint<
T> - A generic, opt-in base class for implementing strongly typed RuntimeHint providers.
- AdaptableList
- A specialized list collection that can adapt itself or another source into a strongly-typed List of elements.
- AdaptableMap
- A specialized map collection that can adapt itself or another source into a strongly-typed Map of keys and values.
- AdaptableSet
- A specialized set collection that can adapt itself or another source into a strongly-typed Set of elements.
- AfterInvocationInterceptor
- Defines an interceptor that executes after method completion, regardless of whether the invocation succeeded or failed.
- AfterReturningInterceptor
- An interceptor that executes after a method successfully returns a value, without throwing an exception.
- AfterThrowingInterceptor
- An interceptor triggered when a target method throws an exception.
- AliasRegistry
- An abstract interface for managing name aliases in a registry system.
- AliasRegistryAware
- Contract for objects that support alias registration.
- AllowedDomainsValidator
- Validates that a URI's host matches one of the allowed domains.
- AnnotatedScopeMetadataResolver
-
A Jetleaf-provided implementation of ScopeMetadataResolver that
determines scope metadata based on the presence of the
@Scopeannotation. - Annotation
- Provides reflective access to annotations applied to declarations.
- AnnotationAwareOrderComparator
-
A Jetleaf-provided OrderComparator implementation that determines ordering
based on the presence of the
@Orderannotation or the Ordered interface. - AnnotationConfigApplicationContext
- ApplicationContext implementation that supports annotation-based configuration.
- AnnotationConfigRegistry
- Annotation-Based Configuration Registry
- AnnotationDeclaration
- Represents an annotation that has been applied to a class, method, field, parameter, or other Dart declarations at runtime.
- AnnotationFieldDeclaration
- Represents a field of an annotation.
-
AnnotationFormatterFactory<
A extends ReflectableAnnotation, T> - A contextual SPI (Service Provider Interface) factory responsible for dynamically generating tailored FormatPrinter and FormatParser instances based on declarative metadata ReflectableAnnotations.
- AnnotationTypeFilter
- A TypeFilter that matches classes based on the presence of specific annotations.
- AnsiColor
- A utility class to apply ANSI terminal color codes to strings.
- AnsiOutput
- A utility class for formatting terminal output using ANSI colors and background styles.
- AotRuntimeExecutor
- An RuntimeExecutor implementation that leverages Ahead-of-Time (AOT) generative hints to perform instance creation, method invocation, and field access at runtime without relying on mirrors or dynamic reflection.
- ApplicationAnnotatedLifecycleProcessor
-
Processor for application lifecycle annotations that discovers and invokes
methods annotated with
@OnApplicationStoppingand@OnApplicationStopped. - ApplicationArguments
- Defines the contract for accessing and parsing command-line arguments passed to an application.
- ApplicationAvailability
- Defines the contract for accessing and tracking an application's availability information, including both its liveness and readiness states.
- ApplicationAvailabilityAutoConfiguration
- Provides the default auto-configuration for managing and tracking application availability statesβincluding both liveness and readiness.
- ApplicationContext
- The central interface for a Jetleaf application context.
- ApplicationContextAware
- π« Interface for components that need access to the ApplicationContext.
- ApplicationContextEvent
- A base class for all events that are published within the context of an ApplicationContext.
-
ApplicationContextInitializer<
T extends ConfigurableApplicationContext> - Strategy interface for initializing an ApplicationContext before it is refreshed.
- ApplicationConversionService
- A Jetleaf-managed, application-wide conversion service responsible for managing and coordinating all registered type converters.
- ApplicationDiagnostics
- High-level diagnostics orchestrator combining both:
- ApplicationEnvironment
- A concrete environment for standard Jetleaf applications.
- ApplicationEvent
- A base class for application-specific events within the Jetleaf framework.
- ApplicationEventBus
-
Defines the contract for an event multicaster that manages the registration,
removal, and dispatching of
ApplicationEvents toApplicationListeners. - ApplicationEventBusAware
- π« Interface for components that need access to the ApplicationEventBus.
-
ApplicationEventListener<
E extends ApplicationEvent> - A listener for a specific type of ApplicationEvent.
- ApplicationEventMethodAdapter
- An adapter class in Jetleaf that bridges ApplicationEvents with listener methods.
- ApplicationModule
- An interface in Jetleaf that defines a configurable application module.
- ApplicationStartup
- Instruments the application startup phase using StartupSteps.
- ApplicationStartupAware
- Defines a contract for components that are aware of and can interact with an ApplicationStartup strategy.
- ArgumentValue
- Holder for a constructor argument value, including its optional type and name metadata.
- ArgumentValueHolder
- Argument Value Holder
- AroundMethodInterceptor
- A comprehensive interceptor that wraps the entire method invocation process, allowing developers to control when and how the target method executes.
-
ArrayList<
E> - A resizable array implementation similar to Java's ArrayList.
- ArrayListToCollectionGenericConverter
- A converter that transforms an ArrayList to a specific collection subtype.
- Assert
- A utility class that provides static assertion methods for validating arguments and states in your application.
- Asset
- Represents a non-Dart static resource (e.g., HTML, CSS, images).
- AssetBuilder
- Defines a contract for classes that build Asset instances from a given template identifier.
- AssetLoader
- A configurable asset bundler for loading files from Dart packages.
- AssetLoaderInterface
- Abstract interface for asset bundling operations.
- AssetLoaderManager
- Core manager class that handles all asset bundling logic.
- AssetPathResource
- Represents a resource that can be loaded from a path-based asset.
- AssetResource
- An abstract representation of a resource that wraps either:
- AssignableTypeFilter
- A TypeFilter that matches classes assignable to a specific target type.
- Author
- Annotation to describe the author of a declaration.
- AutoConfiguration
- Declares a class as a source of automatic configuration.
- AutowireCandidateDescriptor
- Describes whether a component is eligible for autowiring.
- Autowired
- Autowired annotation for dependency injection
- AutowiredIgnore
- An annotation used to mark a field as ignored by the dependency injection container.
- AutowirePodFactory
- Extends PodFactory with automatic dependency injection capabilities.
-
AvailabilityEvent<
Available extends AvailabilityState> - Represents an application-level event that conveys a change or report regarding an application's availability state.
- AvailabilityState
- A marker interface representing any application availability state.
- BaseDeclaration
- Base abstraction for all Jetleaf declaration models.
-
BaseStream<
T, S extends BaseStream< T, S> > - Base interface for streams, which are sequences of elements supporting sequential and parallel aggregate operations.
- BigDecimal
- A wrapper class for precise decimal arithmetic.
- BigDecimalGenericConverter
- A converter that transforms a BigDecimal to a specific numeric subtype.
- BigInteger
- A wrapper class for arbitrary precision integers.
- BigIntegerGenericConverter
- A converter that transforms a BigInteger to a specific numeric subtype.
- BigIntGenericConverter
- A converter that transforms a BigInt to a specific numeric subtype.
- BinaryBuilder
- Builder for constructing binary data efficiently.
- BinaryReader
- Reader for parsing binary data produced by BinaryBuilder.
- Boolean
- A wrapper class for bool that provides Java-like functionality and methods.
- BooleanGenericConverter
- A converter that transforms a Boolean to a specific numeric subtype.
- BoolGenericConverter
- A converter that transforms a bool to a specific numeric subtype.
- BufferedInputStream
- A BufferedInputStream adds functionality to another input stream-namely, the ability to buffer the input and to support the mark and reset methods.
- BufferedOutputStream
- The class implements a buffered output stream.
- BufferedReader
- Reads text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.
- BufferedWriter
- Writes text to a character-output stream, buffering characters to provide efficient writing of characters, arrays, and strings.
- BulkChange
- Represents multiple observable events grouped together.
- Byte
- A comprehensive wrapper class for byte operations, supporting both single bytes and byte collections.
- ByteArray
- A wrapper for byte arrays similar to Java's byte[] with utility methods.
- ByteArrayInputStream
- A byte-based input stream that reads from a Uint8List buffer.
- ByteArrayOutputStream
- An OutputStream that writes to a growable internal byte buffer.
- ByteMultiConverter
- A Converter that converts between Byte, String, List, and Uint8List.
- ByteStream
- A stream of bytes similar to Java's InputStream/OutputStream.
- CachedRuntimeProvider
- A RuntimeProvider subclass optimized for cache-mode operation.
- CacheSerializable
- Interface for declarations that can serialize/deserialize to/from binary cache.
-
CaseInsensitiveMap<
V> - A map that performs case-insensitive string key lookups while preserving the original casing of keys.
- Character
- A wrapper class for single characters that provides Java-like functionality.
- CharacterGenericConverter
- A converter that transforms a Character to a specific numeric subtype.
-
Class<
T> - Provides a unified, reflective interface to access Dart class types and their associated metadata at runtime.
- ClassDeclaration
- Represents a reflected Dart class and all of its metadata, including fields, methods, constructors, superclasses, mixins, interfaces, and declaration-level modifiers (abstract, sealed, etc.).
-
ClassGettable<
T> - Provides a contract for types capable of exposing their associated runtime Class metadata representation within the Jetleaf reflection system.
- ClassPathResource
- Provides access to resources, classes, methods, and fields located in a package's classpath.
- ClassReference
- A lightweight class reference containing minimal structural information about a Dart class.
-
ClassType<
T> -
The
ClassTypeclass in Jetleaf represents a reference to a Dart class, optionally including metadata such as package, protection domain, or type declaration. - ClassUtils
- A utility class that provides static methods for working with class hierarchies and type relationships in Dart's reflection system.
- Cleanup
- Marks a method to be invoked after a pod is destroyed.
- Closeable
- An object that may hold resources until it is closed.
- ClosureDeclaration
- Represents a closure or anonymous function as a class-like declaration within the Jetleaf reflection system.
- CollectionToCollectionConverter
- An abstract base class for converting between different types of Dart collections, with optional element type conversion.
-
Collector<
T, A, R> - A mutable reduction operation that accumulates input elements into a mutable result container, optionally transforming the accumulated result into a final representation after all input elements have been processed.
- Collectors
- Implementations of Collector that implement various useful reduction operations, such as accumulating elements into collections, summarizing elements according to various criteria, etc.
-
Comparator<
T> -
An abstract class that imposes a total ordering on a collection of objects of type
T. - CompletedInitializationEvent
- Event published when the ApplicationContext has completed its initialization phase.
- Component
- Component annotation for generic Jetleaf components
- ComponentScan
- Annotation for Jetleaf component scanning.
- ComponentScanFilter
- Represents a filter definition for component scanning.
- Condition
- The base interface for all Jetleaf condition evaluators.
- Conditional
- An annotation that conditionally enables or disables Jetleaf-managed constructs such as Component, Pod, or configuration classes based on one or more declarative Condition evaluators.
- ConditionalContext
- Represents the conditional evaluation context in Jetleaf applications.
- ConditionalConverter
- A contract for a converter that only matches under certain conditions.
- ConditionalOnAsset
- An annotation that conditionally activates a Component, Pod, or configuration class based on the presence of a specific asset in the application's resources.
- ConditionalOnClass
- An annotation that conditionally activates a Component, Pod, or configuration class only if specific classes are present in the Dart runtime or compilation environment.
- ConditionalOnDart
- An annotation that conditionally activates a Component, Pod, or configuration class based on the current Dart SDK version.
- ConditionalOnExpression
- An annotation that conditionally activates a Component, Pod, or configuration class based on the evaluation of a custom expression.
- ConditionalOnMissingClass
- An annotation that conditionally activates a Component, Pod, or configuration class only if certain classes are absent from the Dart runtime or compilation environment.
- ConditionalOnMissingPod
- An annotation that activates a component only when specific pods are absent from the ConditionalContext.
- ConditionalOnPod
- An annotation that conditionally activates a Component, Pod, or configuration class based on the presence of other pods within the current ConditionalContext.
- ConditionalOnProfile
- An annotation that conditionally activates a Component, Pod, or configuration class based on the currently active profiles in the ConditionalContext.
- ConditionalOnProperty
- An annotation that conditionally enables a Component, Pod, or configuration class based on the value(s) of one or more properties.
- ConditionEvaluator
-
The
ConditionEvaluatorin Jetleaf is responsible for evaluating conditional annotations (e.g., Conditional, ConditionalOnClass, ConditionalOnPod) and determining whether a given source (class, method, or configuration) should be included in the Jetleaf application context. - ConfigurableApplicationContext
- A specialized ApplicationContext that allows for full configuration and lifecycle management.
- ConfigurableConversionService
- A configurable conversion service that allows dynamic registration of converters.
- ConfigurableEnvironment
- A configurable extension of the Environment interface that allows mutation of environment internals such as active profiles and property sources.
- ConfigurableListablePodFactory
- The most comprehensive pod factory interface combining listing and configuration capabilities.
- ConfigurableMessageSource
- Main implementation of MessageSource that supports loading messages from multiple resources and formats.
- ConfigurablePodFactory
- A comprehensive pod factory interface with configuration capabilities.
- Configuration
- Configuration annotation for configuration classes
- ConfigurationProperty
- Annotation used to bind externalized configuration properties from the Environment into a Dart object.
- ConsolePrintStream
- A concrete implementation of PrintStream that writes to the console using stdout.
- Constant
- Constant class containing predefined constants used across the application.
- Constructor
- Provides reflective access to class constructor metadata and instantiation.
- ConstructorArgumentValues
- Holder for constructor argument values used when instantiating a pod.
- ConstructorDeclaration
- Creates a new language range.
- ContextClosedEvent
- Event published when an ApplicationContext is closed.
- ContextFailedEvent
- Event published when the ApplicationContext fails to start or refresh.
- ContextReadyEvent
- Event published when the ApplicationContext is ready.
- ContextRestartedEvent
- Event published when the ApplicationContext is restarted.
- ContextSetupEvent
- Event published when the ApplicationContext is refreshed or initialized.
- ContextStartedEvent
- Event published when the ApplicationContext is started or restarted.
- ContextStoppedEvent
- Event published when the ApplicationContext is explicitly stopped.
- ConversionAdapterUtils
- Utility class for converting generic or adaptable collections into strongly typed collections based on Jetleaf Class metadata.
- ConversionService
- A strategy interface for type conversion.
- ConversionServiceAware
- π« Interface for components that need access to a ConversionService.
- ConversionServiceConfigurer
- A Jetleaf extension interface for programmatically configuring type conversion within the applicationβs ConversionService.
-
ConversionServiceConverter<
S, T> - A Converter that delegates to a ConversionService for converting values.
- ConversionServiceFactory
- Utility class for registering a set of converters with a ConverterRegistry.
- ConversionUtils
- Utility class containing common operations used by conversion infrastructure.
-
Converter<
S, T> -
A generic interface for converting an input of type
Sinto an output of typeT. -
ConverterFactory<
S, R> -
A factory for creating Converter instances that convert from a source type
Sto a target typeT, whereTis a subtype ofR. - ConverterRegistry
- A registry of converters and converter factories used to perform type conversions at runtime.
- ConvertiblePair
- Represents a pair of source and target types for type conversion.
- ConvertibleValue
- Abstraction for holding a raw value and its converted state.
-
ConvertingComparator<
S, T> -
A comparator that compares source values of type
Sby first converting them to another typeTusing a Converter, then applying a Comparator onT. - Currency
- Abstract base class for currency operations following ISO 4217 standards.
- CurrencyToStringConverter
- A Converter that converts a Currency to a String.
- DartParser
- A parser for Dart configuration files in Jetleaf.
- DateTimeFormat
- A declarative metadata annotation instructing type conversion pipelines, object-document mappers (ODMs), and presentation layer data binders on how to serialize, deserialize, parse, and print chronological properties.
- DateTimeFormatter
- A formatter and parser for date-time objects based on patterns, similar to Java's DateTimeFormatter.
- DateTimeToIntConverter
- Converts DateTime to int (epoch milliseconds)
- DateTimeToLocalDateConverter
- Converts DateTime to LocalDate
- DateTimeToLocalDateTimeConverter
- Converts DateTime to LocalDateTime
- DateTimeToLocalTimeConverter
- Converts DateTime to LocalTime
- DateTimeToStringConverter
- Converts DateTime to String using ISO 8601 format
- DateTimeToZonedDateTimeConverter
- Converts DateTime to ZonedDateTime with specified zone
- Declaration
- A named, typed declaration representing a concrete program element.
- DefaultApplicationArguments
- Default implementation of ApplicationArguments that wraps command-line arguments and exposes them via a PropertySource-based backing system.
- DefaultApplicationStartup
- A no-op implementation of ApplicationStartup that always returns a singleton DefaultStartupStep for any startup operation.
- DefaultConversionService
- A fully configured, ready-to-use conversion service suitable for most Jetleaf environments.
- DefaultListablePodFactory
- Default implementation of ConfigurableListablePodFactory that provides comprehensive pod management capabilities in the Jetleaf framework.
- DefaultLoggingListener
- A default implementation of LoggingListener that outputs logs to the console.
- DefaultMethodInterceptor
- Default implementation of MethodInterceptorRegistry and related intercept processing.
-
DefaultObjectProvider<
T> - Default implementation of ObjectProvider in Jetleaf.
- DefaultRuntimeExecutor
- A robust runtime executor that coordinates between two resolver strategies to handle dynamic operations on objects, methods, and fields at runtime.
- DefaultRuntimeHintDescriptor
- A concrete implementation of RuntimeHintDescriptor that stores hints in a simple list.
- DefaultStartupStep
- A no-op implementation of StartupStep used by DefaultApplicationStartup.
- DefaultStartupStepTags
- A no-op, empty tag collection returned by DefaultStartupStep.
- DependencyCycle
- Represents a detected circular dependency within a dependency graph.
- DependencyDescriptor
- Describes a dependency required by a component or pod.
- DependencyDesign
- Describes a dependency required by a component or pod.
- DependsOn
- A Jetleaf annotation that declares explicit dependencies between pods.
- Description
- Provides a human-readable description of a class or method.
- DesignDescriptor
- Describes the design role configuration of a component.
- DisposablePod
- Interface to be implemented by pods that need to release resources or perform cleanup when being removed from the container or shut down.
- Double
- A wrapper class for double that provides Java-like functionality and methods.
- DoubledGenericConverter
- A converter that transforms a Double to a specific numeric subtype.
- DoubleGenericConverter
- A converter that transforms a double to a specific numeric subtype.
- DoubleStream
-
A sequence of primitive
double-valued elements supporting sequential and parallel aggregate operations. - DurationFormat
- A declarative aspect-oriented metadata annotation instructing structural type conversion registries, data binders, and serialization encoders on how to process, format, and reconstruct Duration domain model properties.
- DurationToIntConverter
- Converts Duration to int (milliseconds)
- DurationToStringConverter
- Converts Duration to String in readable format
- Dynamic
- Abstract base class representing a dynamic or unconstrained type within the Jetleaf type system.
- EmbeddedValueResolutionSupport
- A mixin-style infrastructure base support utility class designed to automate the mechanics of string value resolver capture and execution hooks.
- EmbeddedValueResolver
- An advanced structural string interpolation engine that orchestrates dynamic value extraction, property placeholder substitution, and expression evaluation within a component container framework.
- EmbeddedValueResolverAware
- An inversion-of-control (IoC) infrastructure contract indicating that a component or lifecycle instance requires access to an external StringValueResolver utility.
- EntityDeclaration
- A uniquely identifiable declaration representing a runtime entity.
- EntryApplicationAware
- π Interface for components that need access to the entry application class.
- EnumDeclaration
-
Represents a reflected Dart
enumtype, providing access to its enum entry names, metadata, and declared members (fields, methods). - EnumFieldDeclaration
- Abstract base class representing a field (value) within an enum declaration.
- EnumToIntConverter
- A Converter that converts an Enum to an int.
- EnumToStringConverter
- A Converter that converts an Enum to a String.
- EnumValue
- Represents a single value within an enum type, providing full reflective access to its metadata, declaration details, and runtime behavior.
-
Env<
T> - A generic configuration property accessor for environment variables.
- Environment
- Environment Contract
- EnvironmentAware
- π« Interface for components that can be configured with an Environment.
- EnvParser
-
Parses dotenv (
.env) style files into aMap<String, dynamic>. - EventListener
- Annotation to mark a method that should run when the application is listening to a specific type of ApplicationEvent.
- EventObject
- A base class for all framework-level events.
-
EventType<
T extends ApplicationEvent> - π« Represents a typed application event associated with a specific package.
- ExceptionDiagnoser
- Defines the contract for components capable of analyzing exceptions and producing structured diagnostic information.
- ExceptionDiagnosis
- Represents a structured diagnostic report for an exception, providing human-readable context, optional recommended actions, and the originating exception itself.
- ExceptionDiagnosisReporter
- Defines the contract for components responsible for handling and reporting structured exception diagnoses.
- ExceptionReporter
- Provides an abstraction for reporting, logging, or forwarding exceptions that occur within the application.
- Executable
- Abstract base class for executable elements (methods, constructors, functions).
- ExecutableArgument
- Represents a fully normalized and transport-safe view of arguments passed to an executable entity (constructor, method, function, or tear-off).
- ExecutableArgumentResolver
- A type-driven dependency injection utility for resolving arguments required by an Executable such as a constructor, method, or function.
- ExecutableHolder
- Executable Holder
- ExecutableInstantiator
- Provides a high-level, reflection-based utility to dynamically instantiate classes and invoke methods on objects at runtime, while automatically resolving arguments and selecting the most appropriate executable.
- ExecutableSelector
- A flexible executable filtering and selection utility used to pick a single Executable (e.g., a constructor, method, or function overload) from a provided list based on declarative matching rules.
- ExecutableStrategy
- Executable Strategy
- ExitCodeEvent
- An ApplicationEvent that signals the application should exit with a specific exit code.
- ExitCodeExceptionHandler
- A strategy interface for mapping a specific Exception to a process exit code.
- ExitCodeGenerator
- Strategy interface for determining the exit code returned from a Jetleaf application or a process.
- ExitCodeGenerators
- A container and manager for multiple ExitCodeGenerator instances.
- FactoryAwareOrderSourceProvider
- An OrderSourceProvider implementation that is aware of the containerβs DefaultListablePodFactory.
- FactoryMethodDesign
- Describes a factory method used to create a pod (component).
- FallbackObjectToStringConverter
- A Converter that converts any object to string using toString().
- Field
- Provides reflective access to class field metadata and value manipulation.
- FieldAccess
- Provides reflective access to fields of a class.
- FieldDeclaration
- Represents a field (variable) declared within a Dart class, extension, enum, or mixin.
- FileInputStream
- A FileInputStream obtains input bytes from a file in a file system.
- FileOutputStream
- A file output stream is an output stream for writing data to a File or to a file descriptor.
- FileReader
- Convenience class for reading character files.
- FileWriter
- Convenience class for writing character files.
- Float
- A wrapper class for single-precision floating point numbers.
- FloatGenericConverter
- A converter that transforms a Float to a specific numeric subtype.
- Flushable
- An object that can be flushed.
-
FormatParser<
T> - An abstraction responsible for parsing a localized text string and reconstructing a strongly typed domain object or structural primitive.
-
FormatPrinter<
T> - An abstraction responsible for converting a strongly typed domain object or structural primitive into a localized, human-readable text string representation.
-
Formatter<
T> - A unified symmetric interface combining both FormatPrinter and FormatParser contracts to manage bidirectional type-to-string lifecycle mappings.
- FormatterRegistrar
- An orchestration interface wrapper allowing independent system modules, plugins, or domain packages to isolate and declare their unique parsing and formatting infrastructure configurations cleanly.
- FormatterRegistry
- A specialized structural registry configuration management subsystem extending ConverterRegistry to coordinate, cache, and resolve bidirectional localization formatting abstractions.
- FunctionDeclaration
- Specialized LinkDeclaration for function type references.
-
Garbage<
T> - A lightweight, generic wrapper representing a tracked runtime resource managed by the Jetleaf garbage collection system.
- GarbageCollector
- A centralized, map-backed runtime garbage manager used by Jetleaf to track, evict, and periodically clean up cached or temporary objects.
- GenerativeAsset
- Base class representing a resource asset with a no-args constructor.
- GenerativePackage
- Base class representing a package resource with a no-args constructor.
- Generic
- A reflectable annotation that marks generic classes for type reflection.
- GenericApplicationContext
- Generic ApplicationContext implementation that holds a single internal DefaultListablePodFactory instance and does not assume a specific pod definition format.
- GenericNullConverter
- A contract for a converter that only matches under certain conditions.
-
GenericStream<
T> - A sequence of elements supporting sequential and parallel aggregate operations.
- GenericTypeParser
- Provides utilities for parsing and analyzing generic type strings in Dart.
- GenericTypeParsingResult
- Represents the parsed structure of a generic type.
- GlobalEnvironment
- A concrete implementation of AbstractEnvironment that represents the default runtime environment for most applications.
-
HashMap<
K, V> -
A custom implementation of a hash map that implements the
Map<K, V>interface. -
HashSet<
E> -
A custom implementation of a hash set that implements the
Set<E>interface. - HashSetToCollectionGenericConverter
- A converter that transforms a HashSet to a specific collection subtype.
- HierarchicalPodFactory
- Extends PodFactory with hierarchical capabilities for parent-child relationships.
- Hint
- Represents the outcome of a runtime hint operation within the Jetleaf execution pipeline.
- HostValidator
- Validates that a URI contains a hostname component.
- HttpUrlConnection
- A concrete implementation of UrlConnection for HTTP and HTTPS protocols.
- Import
-
The
Importannotation in Jetleaf is used to import other configuration classes. - ImportClass
- π« Represents a logical import entry with qualification and enablement metadata.
- ImportSelector
- π« A strategy interface for selecting which imports should be applied.
- InitializingPod
- Interface to be implemented by pods that require initialization logic after their properties have been set by the container.
- InputStream
- This abstract class is the superclass of all classes representing an input stream of bytes.
- InputStreamSource
- A simple interface for objects that provide an InputStream.
- Instance
-
A utility class for type checking, similar to Java's
instanceof. It also provides additional methods for type checking. - Integer
- A wrapper class for int that provides Java-like functionality and methods.
- IntegerGenericConverter
- A converter that transforms a Integer to a specific numeric subtype.
- Interceptable
- Provides runtime interception support for method invocations within Jetleaf-managed components.
- InterceptorDependencyCycle
- A DependencyCycle implementation that represents a circular dependency between method interceptors in the interceptor chain.
- IntGenericConverter
- A converter that transforms an int to a specific numeric subtype.
- IntStream
-
A sequence of primitive
int-valued elements supporting sequential and parallel aggregate operations. - IntToDateTimeConverter
- Converts int (epoch milliseconds) to DateTime
- IntToDurationConverter
- Converts int (milliseconds) to Duration
- IntToEnumConverterFactory
- A ConverterFactory that provides converters to convert integers to enums.
- IntToZonedDateTimeConverter
- Converts int (epoch milliseconds) to ZonedDateTime
- IterableIntToStringConverter
- Workaround converter for Iterable<int> to String.
- IterableToCollectionGenericConverter
- A converter that transforms an Iterable to a specific collection subtype.
- JetleafEntry
-
A reflectable annotation that marks a top-level
void main()as a JetLeaf application entry. - JetleafTest
-
A reflectable annotation that marks a top-level
void main()as a JetLeaf test entry. - JitRuntimeExecutor
- Pure Dart runtime executor for JIT and AOT environments.
- JsonParser
- A parser for JSON configuration files.
- KeepAlive
- A lifecycle-aware component that keeps the Dart VM alive as long as the ApplicationContext is running.
-
KeyValueOf<
K, V> - KeyValueOf Annotation
- LanguageRange
- Represents a language range as defined in RFC 4647.
- Lazy
- Indicates that a pod should be lazily initialized.
- LibraryDeclaration
- Represents a Dart library declaration within Jetleafβs reflection and generation system.
- Lifecycle
- A common interface defining methods for start/stop lifecycle control.
- LifecycleDesign
- Describes lifecycle behavior of a component, such as initialization and destruction methods.
- LifecycleProcessor
- Defines a contract for components that participate in the application lifecycle.
- LinkDeclaration
- Abstract base class for type references in reflection systems.
- LinkedHashSetToCollectionGenericConverter
- A converter that transforms a col.LinkedHashSet to a specific collection subtype.
-
LinkedList<
E> -
A custom implementation of a doubly linked list that implements the standard
List<E>interface. - LinkedListToCollectionGenericConverter
- A converter that transforms a LinkedList to a specific collection subtype.
-
LinkedQueue<
E> - A queue implementation using a linked list structure, mimicking Java's LinkedList as Queue.
- LinkedQueueToCollectionGenericConverter
- A converter that transforms a LinkedQueue to a specific collection subtype.
-
LinkedStack<
E> - A stack implementation using a linked list structure, mimicking Java's LinkedList as Stack.
- LinkedStackToCollectionGenericConverter
- A converter that transforms a LinkedStack to a specific collection subtype.
- ListableConverterRegistry
- A ConverterRegistry that also provides access to registered UriValidator instances.
- ListablePodDefinitionRegistry
- Interface for registries that provides additional functionality for listing and enumeration.
- ListablePodFactory
- Extends PodFactory with capabilities to list and query pods.
- ListBaseToCollectionConverter
- A converter that transforms a col.ListBase to a specific collection subtype.
-
ListChange<
T> -
Represents a change in a
List. - ListToCollectionConverter
- A converter that transforms a List to a specific collection subtype.
- ListToObjectConverter
- A Converter that converts a List to an Object (extracts single element).
- LocalDate
- Represents a calendar date without time or timezone.
- LocalDateAndLocalTimeToLocalDateTimeConverter
- Converts LocalDate and LocalTime to LocalDateTime
- LocalDateTime
- A date-time object without a timezone, composed of a LocalDate and LocalTime.
- LocalDateTimeToDateTimeConverter
- Converts LocalDateTime to DateTime (assumes UTC)
- LocalDateTimeToLocalDateConverter
- Converts LocalDateTime to LocalDate
- LocalDateTimeToLocalTimeConverter
- Converts LocalDateTime to LocalTime
- LocalDateTimeToStringConverter
- Converts LocalDateTime to String using ISO 8601 format
- LocalDateTimeToZonedDateTimeConverter
- Converts LocalDateTime to ZonedDateTime with specified zone
- LocalDateToDateTimeConverter
- Converts LocalDate to DateTime (at midnight UTC)
- LocalDateToStringConverter
- Converts LocalDate to String using ISO 8601 format
- Locale
- A representation of a locale, consisting of a language code and optional country and variant codes.
- LocaleToStringConverter
-
LocalThread<
T> -
A Dart equivalent of Java's
ThreadLocal, scoped to the current Isolate. -
LocalThreadStorageBucket<
T> - A mutable storage container for a LocalThread value, bound to a specific Isolate.
- LocalTime
- A value object representing a time of day without any date or timezone information.
- LocalTimeToStringConverter
-
Converts LocalTime to String using HH:mm:ss
.SSSformat - Log
- A convenient logging utility built on top of LogFactory.
- LogCommons
- A utility class that provides common styling and symbols for different LogLevels.
- LogConfig
- Configuration class that controls the appearance and content of log output.
- LogFactory
- A base class for building structured logging mechanisms within Jet-based applications.
- LoggableExceptionDiagnosisReporter
- An implementation of ExceptionDiagnosisReporter that outputs structured exception diagnosis information using the Jetleaf logging system.
- Logger
- A flexible and extensible logging interface.
- LoggingListener
- A listener interface for reacting to logging events within an application.
- LogPrinter
- A base class for implementing custom log output formatting.
- LogProperties
- A small, thread-safe global registry for logging configuration and diagnostic properties within Jetleaf.
- LogRecord
-
A
LogRecordrepresents a single logging event captured by the logging system. - Long
- A wrapper class for large integers that provides Java-like functionality.
- LongGenericConverter
- A converter that transforms a Long to a specific numeric subtype.
-
MapChange<
K, V> -
Represents a change in a
Map. - MapToMapGenericConverter
- A converter that transforms a Map (or any map-like type) into another Map type, optionally converting keys and values.
- MapToStringGenericConverter
- A converter that transforms different types of Map into a String.
- MaterialAsset
- A concrete, immutable implementation of the Asset interface.
-
MaterializedRuntimeHint<
T> -
A materialized runtime hint that provides a concrete representation
of its target type
Twhile allowing runtime behavior overrides. - MaterialLibrary
- A centralized, immutable registry of materialized Dart libraries within the Jetleaf reflection and generation system. This is the backbone registry of Jetleafβs reflection system. It materializes raw libraries into a frozen, queryable structure that enables fast, deterministic, and cross-domain type resolution.
- MaterialPackage
- A concrete, immutable implementation of the Package interface.
- Member
- Abstract base class representing a member of a class that extends Executable.
- MemberDeclaration
- A source-level declaration that is owned by a class.
- Mergeable
- Interface for objects that can merge with other objects of the same type.
- MessageSource
- Interface for resolving messages, with support for parameterization and internationalization.
- MessageSourceAware
- π« Interface for components that need access to a MessageSource.
- MessageSourceLoader
- Interface for loading messages from different resource formats.
- Method
- Provides reflective access to class method metadata and invocation capabilities.
- MethodBeforeInterceptor
- Defines an interceptor that executes logic before the target method invocation begins.
- MethodDeclaration
- Represents a method declaration in a Dart class, extension, mixin, or top-level scope.
- MethodInterceptor
- Defines the core interception contract for Jetleafβs AOP (Aspect-Oriented Programming) framework, allowing runtime interception and augmentation of method invocations.
- MethodInterceptorConfigurer
- Strategy interface for configuring method interceptors in Jetleaf intercept.
- MethodInterceptorDispatcher
- Defines an advanced interception dispatcher that coordinates multiple method interceptors.
- MethodInterceptorRegistry
- Central registry for managing method-level interceptors and their dispatching.
-
MethodInvocation<
T> - Represents a reflective method invocation within the interception pipeline.
- MethodUtils
- Provides reflective utility functions for working with Jetleaf runtime Method and MethodDeclaration instances.
- MimeType
- An immutable, industry-standard value object representing a Multipurpose Internet Mail Extensions (MIME) type, as defined in RFC 2045 and RFC 2046.
- MimeTypeUtils
- A low-level parsing and validation engine providing stateless utilities for handling MIME/Media Types according to RFC 2045, RFC 2046, and RFC 7231 structural rules.
- MixinDeclaration
-
Represents a reflected Dart
mixindeclaration, providing access to its members, type constraints, and metadata. - MutablePropertyValues
- Mutable implementation of PropertyValues interface.
- Named
- Explicitly specifies a name for a Pod (Dependency Injection component) that overrides all other naming mechanisms in the Jetleaf framework.
-
NamedLocalThread<
T> - A specialized LocalThread that includes a descriptive name for better debugging and identification.
- NestedPlaceholderPart
- A PlaceholderPart that represents a nested placeholder expression with optional fallback.
- NetworkInputStream
- An InputStream implementation that reads bytes from a Dart Stream<List<int>>.
- NetworkOutputStream
-
An OutputStream implementation that writes bytes to a Dart
HttpClientRequest. - NoCredentialsValidator
- Validates that a URI doesn't contain user credentials (username/password).
- NoIpAddressValidator
- Validates that a URI uses a domain name rather than a raw IP address.
- NoOpDependencyCycle
- A no-op implementation of DependencyCycle.
- NoSpacesValidator
- Validates that a URI string doesn't contain any spaces.
- Null
- A minimal placeholder class representing a null-like object.
- NullablePod
- A special marker pod instance that represents a nullable or absent pod value.
- NumberFormat
- A declarative, aspect-oriented metadata annotation instructing structural type conversion registries, data binders, and serialization encoders on how to format, print, and parse primitive numerical types and custom numeric wrapper structures.
- NumberGenericConverter
- A converter that transforms a num to a specific numeric subtype.
- NumberUtils
- An administrative utilities toolkit providing type-safe conversions, numerical downcasting safety, boundary overflow assertions, and contextual string radix decoding across standard platform primitives and custom object-wrapped types.
-
ObjectFactory<
T> -
A generic factory interface for producing instances of a given type
T. -
ObjectHolder<
T> - A generic container that holds an object along with optional metadata such as its package name and qualified name.
-
ObjectProvider<
T> - A flexible, functional-style provider interface for retrieving and interacting with pods or objects of a particular type.
- ObjectToListConverter
- A Converter that converts an Object to a List.
- ObjectToObjectConverter
- A Converter that converts an Object to another Object using reflection.
- ObjectToSetConverter
- A Converter that converts an Object to a Set.
-
Obs<
T> - A reactive wrapper for values, lists, or maps.
- ObsEvent
- A base class representing an event in an observable system.
- OnApplicationFailed
- Annotation to mark a method that should run when the application fails to start or refresh.
- OnApplicationReady
- Annotation to mark a method that should run when the application is fully ready to serve requests.
- OnApplicationStarted
- Annotation to mark a method that should run when the application has started, meaning the context is refreshed but the app is not yet fully ready.
- OnApplicationStarting
- Annotation to mark a method that should run when the application is starting, before the context refresh occurs.
- OnApplicationStopped
- Annotation to mark a method that should run when the application has fully stopped.
- OnApplicationStopping
- Annotation to mark a method that should run when the application is stopping.
- OnAssetCondition
- A Condition implementation that determines whether an annotated component, configuration, or pod should be activated based on the presence of a specific asset within the application's resource path.
- OnClassCondition
- A Condition implementation that evaluates the presence or absence of classes in the current runtime to determine if a component, pod, or configuration should be activated.
- OnContextLoaded
- Annotation to mark a method that should run when the application context has been loaded, but before it is fully refreshed.
- OnContextPrepared
- Annotation to mark a method that should run when the application context has been prepared.
- OnDartCondition
- A Condition implementation that evaluates the current Dart SDK version to determine whether an annotated component, configuration, or pod should be activated.
- OnEnvironmentPrepared
- Annotation to mark a method that should run when the application environment has been prepared, but before the context is loaded.
- OnExpressionCondition
- A Condition implementation that dynamically evaluates an expression to determine whether a component, configuration, or pod should be activated.
- OnPodCondition
- A Condition implementation that evaluates the presence or absence of pods in the current ConditionalContext to determine whether a component, configuration, or definition should be activated.
- OnProfileCondition
- A Condition implementation that evaluates the application's currently active profiles to determine whether a component, configuration, or pod should be activated.
- OnPropertyCondition
- A Condition implementation that evaluates whether a component or pod should be activated based on the presence and value of properties in the current ConditionalContext.environment.
-
Optional<
T> - A container object which may or may not contain a non-null value.
- Order
- Specifies the order of precedence for a class when processed by the framework or runtime system.
- OrderComparator
- A comparator that sorts objects based on the Ordered and PriorityOrdered interfaces.
- Ordered
- A contract for objects that are assigned an order or precedence value.
- OrderSourceProvider
- A strategy interface for providing an alternative source of order metadata for a given object.
- OutputStream
- This abstract class is the superclass of all classes representing an output stream of bytes.
- Package
- Represents a Dart package within the Jetleaf reflection and code generation system.
- PackageIdentifier
- Represents an abstraction for identifying the package that an object, resource, or service belongs to.
- PackageNames
- A central collection of constant package name identifiers used throughout the Jetleaf framework.
- PackageOrderComparator
- A comparator that orders classes based on their package hierarchy and origin.
- PackageUtils
- Utility class for resolving and caching Dart packages at runtime.
- PairedConditionalConverter
- A bridge interface combining PairedConverter and ConditionalConverter.
- PairedConverter
- A general-purpose converter that can convert between multiple sourceβtarget type pairs.
- Parameter
- Provides reflective access to method/constructor parameter metadata.
- ParameterDeclaration
- Represents a parameter in a constructor or method, with metadata about its name, type, position (named or positional), and default value.
- Parser
- A base interface for all configuration parsers in Jetleaf.
- PatternToStringConverter
- A Converter that converts a Pattern to a String.
- PermissionManager
- Abstract interface for elements that can have protection domains.
- Phased
- Interface for objects that may participate in a phased process such as lifecycle management.
- PlaceholderAbstractPart
- Base class for all PlaceholderPart implementations that represent a segment of a parsed placeholder expression.
- PlaceholderParsedSection
-
Represents a parsed section of a placeholder string,
typically extracted from a raw placeholder like
#{key:default}. - PlaceholderParsedValue
-
A container for a parsed text and its constituent
Partobjects. - PlaceholderParser
- A utility class for parsing and resolving placeholders within a string.
- PlaceholderPart
- Represents a segment or fragment of a placeholder expression.
- PlaceholderPartResolutionContext
- A resolution context for placeholder expressions, providing configuration, resolution logic, and tracking for visited placeholders.
- PlaceholderResolver
- Strategy interface for resolving placeholder values in configuration strings.
- PlaceholderTextPart
- A PlaceholderPart implementation that represents literal, already-resolved text within a placeholder expression.
- Pod
- Marks a method as a pod provider, enabling it to participate in the dependency injection (DI) lifecycle of the application.
- PodDefinition
- Defines the blueprint of a pod (component) in the dependency injection system.
- PodDefinitionRegistry
- Interface for registries that hold PodDefinition instances.
- PodDestructionProcessor
- Processor that provides hooks into the pod destruction and cleanup lifecycle.
-
PodExpression<
T> - Pod Expression Contract
- PodExpressionContext
- Context for evaluating expressions in a pod environment.
- PodExpressionResolver
- Strategy interface for resolving pod definition values and expressions.
- PodFactory
- The core factory interface for managing and retrieving pods (components) in Jetleaf.
- PodFactoryAware
- π« Interface for components that need access to the PodFactory.
-
PodFactoryCustomizer<
T extends ConfigurablePodFactory> - A lifecycle hook interface for customizing the PodFactory before it is fully initialized or configured within the Jetleaf framework.
- PodFactoryPostProcessor
- Factory hook that allows for custom modification of an application context's pod definitions, adapting the pod property values of the context's underlying pod factory.
- PodInitializationProcessor
- Processor that provides hooks into the pod initialization lifecycle phases.
- PodInstantiationProcessor
- Processor that provides hooks into the pod instantiation and property population lifecycle.
- PodNameAware
- π« Interface for components that need to know their assigned pod name.
- PodNameGenerator
- Strategy interface for generating pod names for PodDefinitions.
- PodPostProcessorManager
- Manager for coordinating pod factory post-processors and pod-aware processors with proper ordering and lifecycle management.
- PodProcessor
- Abstract interface for processors that handle or manipulate pods in the Jetleaf framework.
-
PodProvider<
T> - Interface for objects that are themselves factories for other objects.
- PodRegistrar
- A contract in Jetleaf for components that can register pods into the applicationβs dependency container.
- PodRegistry
- A contract in Jetleaf that provides methods for managing pods in the container.
- PodScope
- Interface for pod scopes that manage object lifecycle and contextual storage.
- PodSmartInstantiationProcessor
- Advanced processor that provides sophisticated control over pod instantiation.
-
PodSpec<
T> -
A concrete implementation of the
`Spec`API in Jetleaf. - PodSpecContext
-
An implementation of
`SpecContext`in Jetleaf that resolves dependencies during pod creation and supplier evaluation. - PostConstruct
- Marks a method to be invoked after a pod has been fully constructed and its dependencies injected, but before it is made available for use in the context.
- PreConstruct
- Marks a method to be invoked before a pod has been fully constructed and its dependencies injected, but before it is made available for use in the context.
- PreDestroy
- Marks a method to be invoked before a pod is destroyed.
- Primary
- Primary annotation for marking a primary pod
- PrintStream
- An abstract interface representing a stream for formatted text output.
- PriorityOrdered
- A special marker interface for Ordered objects that should be given priority over other Ordered objects during sorting or processing.
- Profile
- Profile annotation for profile-specific pods
- Profiles
- A profile predicate used by Environment to determine if given profile expressions match the active/default profiles.
- PropertiesParser
- A parser for Java-style properties files.
- PropertyPlaceholderHelper
-
A utility class for resolving string values that contain placeholders
in the format
#{name}. - PropertyValue
-
Represents a property with a
_nameand its associated_value. - PropertyValues
- Interface for accessing a collection of PropertyValue objects.
- ProtectionDomain
- The protection domain used for type conversion.
-
Provider<
T> -
A generic provider interface for supplying instances of type
T. - QualifiedName
- Defines a contract for objects that expose a fully-qualified, stable name within the Jetleaf type and metadata system.
- Qualifier
- A Jetleaf annotation used to disambiguate injection targets when multiple candidate pods of the same type exist.
- QueryParamValidator
- Validates that a URI contains all required query parameters.
-
Queue<
E> - A first-in-first-out (FIFO) queue interface implementation, mimicking Java's Queue.
- QueueToCollectionGenericConverter
- A converter that transforms a Queue to a specific collection subtype.
- Reader
- Abstract class for reading character streams.
- RecordDeclaration
- Represents a reflected Dart record type.
- RecordField
- A representation of an individual field within a Dart record type in the Jetleaf reflection system.
- RecordFieldDeclaration
- A representation of an individual field within a Dart record type in the Jetleaf reflection system.
- ReflectableAnnotation
- Represents an annotation that has been applied to a class, method, field, parameter, or other Dart declarations at runtime.
- ReflectionUtils
- Pure Dart runtime reflection and type-inspection utility.
- RegexPatternTypeFilter
- A TypeFilter that matches classes based on regular expression patterns against class names.
- RegExpToStringConverter
- A Converter that converts a RegExp to a String.
- RegexUtils
- A collection of commonly used regular expressions, provided as constants.
- Repository
- Marks a class as a Repository Component for data access and persistence.
- RequiredAll
- An annotation used for dependency injection that automatically injects all eligible fields into a class.
- Resolved
- An annotation used to mark classes for which AOT-compatible runtime resolvers should be generated.
-
Resource<
Key, Value> - A generic abstraction for Jetleaf-compatible resource.
- Role
- Declares the design role of a class or method within a Jetleaf application.
- RootPodDefinition
- A concrete implementation of AbstractPodDefinition that serves as the default pod definition in the system.
- RunAfter
- A reflective annotation that declares that the annotated interceptor, filter, or handler should execute after one or more specified targets within the Jetleaf request processing pipeline.
- RunBefore
- A reflective annotation that declares that the annotated interceptor, filter, or handler should execute before one or more specified targets within the Jetleaf request processing pipeline.
- RunesToStringConverter
- A Converter that converts a Runes to a String.
- Runnable
- A simple contract for objects that can be executed.
- RuntimeExecutor
- Defines an interface for executing runtime operations in a Dart environment, providing a high-level abstraction for dynamic object creation, method invocation, and field manipulation.
- RuntimeExecutorResolving
- An abstract base class responsible for orchestrating the runtime resolution of types, methods, and fields across multiple libraries.
- RuntimeHint
- A contract for providing runtime-level behavioral overrides to the Jetleaf execution system.
- RuntimeHintDescriptor
- An abstract descriptor that represents a collection of RuntimeHint instances.
- RuntimeHintProvider
- A factory interface responsible for producing concrete RuntimeHint instances.
- RuntimeProvider
- A runtime-backed extension of MaterialLibrary that exposes environment-level metadata and execution capabilities.
- SchemeValidator
- Validates that a URI contains a scheme component (e.g., "https://").
- Scope
- Annotation that specifies the scope of a pod within the Jetleaf container.
- ScopeDesign
- Describes the scope configuration of a component.
-
ScopedObjectFactory<
T> - An ObjectFactory implementation that retrieves objects from a specific PodScope.
- ScopeMetadataResolver
- Strategy interface for resolving scope metadata for a given class in Jetleaf.
- SecureSchemeValidator
- Validates that a URI uses a secure scheme (https or wss by default).
- Service
- Service annotation for service layer components
- SetBaseToCollectionGenericConverter
- A converter that transforms a col.SetBase to a specific collection subtype.
- SetToCollectionGenericConverter
- A converter that transforms a Set to a specific collection subtype.
- SetToObjectConverter
- A Converter that converts a Set to an Object (extracts single element).
- Short
- A wrapper class for int representing a 16-bit signed integer.
- ShortGenericConverter
- A converter that transforms a Short to a specific numeric subtype.
- SimpleAliasRegistry
- A thread-safe implementation of AliasRegistry using LocalThread storage.
- SimpleApplicationEventBus
- A straightforward implementation of ApplicationEventBus that manages application event listeners.
- SimpleConversionService
- A configurable and extensible conversion service that provides a central mechanism for converting between types in Jetleaf applications.
-
SimpleMethodInvocation<
T> - Represents a reflective invocation of a method on a target object, forming the core join point within Jetleafβs interception system.
-
SimpleObjectFactory<
T> - Default implementation of the ObjectFactory interface that uses a creator function.
- SimplePlaceholderPart
- A PlaceholderPart that represents a basic placeholder expression with an optional fallback.
- SimplePodDefinitionRegistry
- A basic registry for managing pod definitions.
- SimplePodNameGenerator
- Default implementation of the PodNameGenerator interface.
-
SimpleProvider<
T> - Simple, immutable implementation of Provider that always returns a pre-defined, constant value.
- SingletonPodRegistry
- Interface for registries that hold singleton pod instances.
- SinkOutputStream
- A concrete implementation of OutputStream that wraps a Dart IOSink, allowing byte, list of bytes, and string data to be written to any underlying sink, such as files, sockets, or stdout.
- SmartInitializingSingleton
- Callback interface triggered at the end of the singleton pre-instantiation phase.
- SmartLifecycle
- An extension of the Lifecycle interface for those objects that require to be started upon ApplicationContext refresh and/or shutdown in a particular order.
- Source
- Abstract base class for all reflection metadata that can be annotated.
- SourceDeclaration
- A declaration that originates directly from source-level Dart code.
- SourceLibrary
- A first-class representation of a Dart libraryβs source code within the Jetleaf framework. SourceLibrary is the canonical source-level library abstraction in Jetleaf. It bridges file systems, packages, analyzers, and generators while remaining lightweight, stable, and environment-agnostic.
-
Spec<
T> - A Jetleaf definition describing how a pod should be instantiated, configured, and managed inside the container.
- SpecContext
- A context object in Jetleaf provided to suppliers and pod definitions for resolving dependencies at runtime.
-
Stack<
E> - A last-in-first-out (LIFO) stack implementation, mimicking Java's Stack.
- StackToCollectionGenericConverter
- A converter that transforms a Stack to a specific collection subtype.
- StackTraceParser
- A comprehensive stack trace parsing utility for Jetleaf applications.
- StandardAnnotationDeclaration
- A standard implementation of AnnotationDeclaration that provides reflection metadata about an annotation applied to a declaration.
- StandardAnnotationFieldDeclaration
- Enhanced annotation field metadata
- StandardClassDeclaration
- A standard implementation of ClassDeclaration that provides runtime metadata and reflection capabilities for Dart classes.
- StandardClosureDeclaration
- A concrete, internal implementation of ClosureDeclaration.
- StandardConstructorDeclaration
- A standard implementation of ConstructorDeclaration that provides metadata and instantiation logic for class constructors.
- StandardDeclaration
- StandardDoubleStream
- Private implementation of DoubleStream that wraps an Iterable of doubles.
- StandardEntityDeclaration
- Concrete implementation of EntityDeclaration providing standard reflection metadata.
- StandardEnumDeclaration
- A standard implementation of EnumDeclaration that provides reflection metadata about an enum declaration in a Dart program.
- StandardEnumFieldDeclaration
- Concrete implementation of EnumFieldDeclaration representing an enum value.
- StandardFieldDeclaration
- A standard implementation of FieldDeclaration that provides metadata and runtime access to class fields in a reflective system.
- StandardFunctionDeclaration
- Standard implementation of FunctionDeclaration for representing function type references with full type information.
-
StandardGenericStream<
T> - Implementation of GenericStream that wraps an Iterable and provides some basic stream operations.
- StandardIntStream
- Private implementation of IntStream.
- StandardLibraryDeclaration
- A standard implementation of LibraryDeclaration that provides access to all top-level declarations in a Dart library.
- StandardLinkDeclaration
- A standard implementation of LinkDeclaration for representing links to other types.
- StandardMethodDeclaration
- A standard implementation of MethodDeclaration representing a method, constructor, getter, or setter in a Dart class or library.
- StandardMixinDeclaration
- A standard implementation of MixinDeclaration that provides reflection metadata about a Dart mixin declaration.
- StandardParameterDeclaration
- A standard implementation of ParameterDeclaration used to represent metadata about a parameter in a Dart function, method, or constructor.
- StandardRecordDeclaration
- A standard implementation of RecordDeclaration used to represent Dart Record types, including their positional and named fields, type arguments, annotations, and parent library metadata.
- StandardRecordFieldDeclaration
- Represents an individual field within a Dart record type, either positional or named.
- StandardSourceDeclaration
- Concrete implementation of SourceDeclaration representing source-level declarations.
- StandardStartupTracker
- Standard implementation of the {@macro startup} interface.
- StartupEvent
- An applicationβlevel event signaling that the Jetleaf application has completed its startup sequence.
- StartupStep
- Step recording metrics about a particular phase or action happening during the ApplicationStartup.
- StartupStepTag
-
Attaches a static key/value
tagto this step. - StartupStepTags
- Returns the complete list of StartupStepTags associated with this step.
- StartupTracker
- Represents a startup lifecycle monitor for Jetleaf-based applications.
-
StreamBuilder<
T> - A mutable builder for a GenericStream.
- StreamSupport
- Low-level utility methods for creating and manipulating streams.
- StringBuilder
- A mutable sequence of characters similar to Java's StringBuilder.
- StringGenericConverter
- A converter that transforms a String to a specific numeric subtype.
- StringInputStream
- A character-based input stream backed by an encoded String.
- StringInternPool
- A simple string interning pool for deduplicating identical strings in memory.
- StringReader
- A Reader implementation that reads characters from a String buffer.
- StringToCurrencyConverter
- A Converter that converts a String to a Currency.
- StringToDateTimeConverter
- Comprehensive collection of converters for time-related objects.
- StringToDurationConverter
- Converts String to Duration using Duration parsing
- StringToEnumConverterFactory
- A ConverterFactory that provides converters to convert strings to enums.
- StringToLocalDateConverter
- Converts String to LocalDate using LocalDate.parse()
- StringToLocalDateTimeConverter
- Converts String to LocalDateTime using LocalDateTime.parse()
- StringToLocaleConverter
- A Converter that converts a String to a Locale.
- StringToLocalTimeConverter
- Converts String to LocalTime using LocalTime.parse()
- StringToMapGenericConverter
- A converter that transforms a String into different types of Map implementations.
- StringToPatternConverter
- A Converter that converts a String to a Pattern.
- StringToRegExpConverter
- A Converter that converts a String to a RegExp.
- StringToRunesConverter
- A Converter that converts a String to a Runes.
- StringToSymbolConverter
- A Converter that converts a String to a Symbol.
- StringToUriConverter
- A Converter that converts a String to a Uri.
- StringToUuidConverter
- A Converter that converts a String to a Uuid.
- StringToZonedDateTimeConverter
- Converts String to ZonedDateTime using ZonedDateTime.parse()
- StringToZoneIdConverter
- Converts String to ZoneId using ZoneId()
- StringUtils
-
π
StringUtilsβ A collection of common string manipulation utilities. - StringValueResolver
- An architectural interface defining the contractual protocol for transforming, mapping, and expanding raw string expressions into fully resolved text values.
-
SuppliedNamedLocalThread<
T> - A NamedLocalThread that provides an initial value using a Supplier function.
- SymbolToStringConverter
- A Converter that converts a Symbol to a String.
- SynchronizedLock
- A reentrant async lock for critical section execution.
- SystemDetector
- Strategy interface for detecting and creating SystemEnvironment instances.
- SystemProperties
- The SystemProperties interface provides a clean, method-based API for querying the runtime environment. Unlike direct property access, all system state is exposed via methods to enforce immutability and ensure consistent naming conventions.
- SystemPropertiesBuilder
-
Builder for creating
_SystemPropertiesinstances using a fluent API. - SystemPropertyPlaceholderResolver
- A PlaceholderResolver implementation that resolves placeholders using system properties and environment variables.
- SystemPropertyUtils
-
Utility class for resolving
#{...}-style placeholders within strings using system properties or environment variables. -
TargetType<
T> - TargetType Annotation
-
Thread<
T> -
Emulates Java's
Threadclass using Dart'sIsolate. - ThreadMessage
- Wrapper message passed to the Isolate's entry point function.
- ToStringOptions
-
Configuration options for customizing
toStringoutput in Jetleaf objects. - TraceFrame
- Represents a single structured entry in a Jetleaf stack trace.
- TraceMapping
- A structured representation of a complete stack trace with analysis capabilities.
- TypeFilter
- Abstract base class for type filtering strategies used in component scanning.
- UnresolvedClass
- Represents a class whose type could not be fully resolved at runtime.
- UriTemplate
-
A utility class for defining and working with URI templates that include
path variables (e.g.,
/users/{id}/orders/{orderId}). - UriToStringConverter
- A Converter that converts a Uri to a String.
- UriValidator
- An abstract validator for URI/URL validation.
- Url
- Represents a Uniform Resource Locator (URL) and provides methods to parse, construct, and open connections to the referenced resource.
- UrlConnection
- Represents a communication link between the application and a Url.
- Uuid
- A powerful, secure implementation of Universally Unique Identifiers (UUIDs) following RFC 4122 specifications.
- UuidToStringConverter
- A Converter that converts a Uuid to a String.
- Value
- Value annotation for property injection
-
ValueChanged<
T> - Represents a change in a single observable value.
- Version
- Represents a semantic version in Jetleaf with major, minor, and patch components.
- VersionRange
- Represents a simple semantic version range in Jetleaf.
- Void
- Abstract base class representing a marker or placeholder type in the Jetleaf type system.
- WhenConditional
- The base class for all annotations that are eligible for conditional evaluation in the Jetleaf framework.
- Writer
- Abstract class for writing to character streams.
- XmlParser
- A parser for XML configuration files.
- YamlParser
- A parser for YAML configuration files.
- ZonedDateTime
- Represents a date-time with timezone information.
- ZonedDateTimeToDateTimeConverter
- Converts ZonedDateTime to DateTime
- ZonedDateTimeToIntConverter
- Converts ZonedDateTime to int (epoch milliseconds)
- ZonedDateTimeToLocalDateConverter
- Converts ZonedDateTime to LocalDate
- ZonedDateTimeToLocalDateTimeConverter
- Converts ZonedDateTime to LocalDateTime
- ZonedDateTimeToLocalTimeConverter
- Converts ZonedDateTime to LocalTime
- ZonedDateTimeToStringConverter
- Converts ZonedDateTime to String using ISO 8601 format with timezone
- ZonedDateTimeToZoneIdConverter
- Converts ZonedDateTime to ZoneId
- ZoneId
- Represents a time zone identifier, abstracting the concept of region-based or offset-based zone IDs (e.g., 'UTC', 'America/New_York').
- ZoneIdToStringConverter
- Converts ZoneId to String using the zone ID
Enums
- ApplicationType
- Enumeration of types of applications that can be run in a Jetleaf environment.
- AutowireMode
- Defines strategies for automatically wiring dependencies in a system.
- DateTimeFormatIso
- Common standard ISO-8601 date-time format patterns supported natively by the DateTimeFormat annotation framework.
- DependencyCheck
- Defines the type of dependency validation to be performed when initializing a component or system.
- DesignRole
- Defines the architectural role of a component within a system.
- DomainPermission
- Enumeration of reflection-based permissions for secure access to class metadata, fields, methods, constructors, and annotations within a container or framework.
- DurationFormatStyle
- Defines the structural strategies available for formatting and parsing Duration string representations.
- DurationFormatUnit
- A comprehensive structural enumeration mapping out the supported execution units for duration parsing, formatting, and mathematical conversion layers.
- FilterType
- Enumeration of supported filter types for component scanning.
- ListChangeType
-
Represents the type of change that occurs in a
List. - LivenessState
- Represents the liveness state of an application.
- LogLevel
- Defines various levels of logging severity for controlling logging output.
- LogStep
- Defines individual components (steps) that can be included in log output.
- LogType
- Specifies the overall formatting strategy used for log output.
- MapChangeType
-
Represents the type of change that occurs in a
Map. - NumberFormatStyle
- Defines the structural strategies available for formatting and parsing numerical representations, aligning with localized internationalization standards and enterprise metadata-driven architectures.
- ReadinessState
- Represents the readiness state of an application.
- ScopeType
- Defines the lifecycle scope of a component within a dependency injection container.
- TypeKind
- Enumerates the different kinds of Dart types recognized by Jetleafβs reflection and type resolution system.
Mixins
- ConfigurationPropertySource
- A mixin that provides access to a globally attached Environment.
- EqualsAndHashCode
-
Mixin-style contract for value-based equality,
hashCode, andtoString. - ToString
- A mixin that provides customizable toString implementation using the same properties defined in EqualsAndHashCode.equalizedProperties.
Extensions
- BoolExtensions on bool
- ClassExtension on Object
- Extension providing reflection capabilities to all Dart objects.
- DateTimeExtensions on DateTime
- DoubleExtensions on double
- DurationExtension on Duration
- DynamicExtensions on dynamic
- ErrorExtensions on Error
- Extension on Error for printing full stack traces conveniently.
- ExceptionExtensions on Exception
- Extension on Exception to provide utility methods such as printing stack traces.
- IntExtensions on int
-
IterableExtension
on Iterable<
T> -
ListExtensions
on List<
T> -
MapExtensions
on Map<
K, V> - NumExtensions on num
- PlaceholderResolverExtension on PlaceholderResolverFn
- Extension to provide a method-style interface on PlaceholderResolverFn functions.
- RuntimeExceptionExtensions on RuntimeException
- Extension on RuntimeException to support pretty stack trace printing.
-
SetUtils
on Set<
Object?> - Utility extension methods for working with sets in Dart.
- StackTraceExtensions on StackTrace
- Extension on StackTrace to print itself.
- StdExtension on Stdout
-
Extension to simulate Java's
System.outandSystem.errutilities in Dart. - StringExtensions on String
- SystemExtension on _System
-
Extension on
InternalSystemContextthat provides access to system-level and environment-related properties similar to Java'sSystem.getProperties()andSystem.getenv(). - TExtensions on T?
- ThrowableExtensions on Throwable
- Extension on Throwable to support printing stack traces in a unified way.
-
ThrowingSupplierGet
on ThrowingSupplier<
T> - A functional interface that supplies a value and may throw an exception.
- TypeExtension on Type
-
UnresolvedClassExtension
on Iterable<
UnresolvedClass> -
πΉ Extension:
UnresolvedClassExtension - UriExtension on Uri
- Extension on Dart's Uri class to convert it into a Url instance.
Constants
- DEFAULT_ENCODING β const Utf8Codec
- The default character encoding used for JSON serialization and deserialization.
Properties
- console β Logger
-
Global singleton logger instance for convenience.
final
-
DYNAMIC_CLASS
β Class<
Dynamic> -
Represents the reflective wrapper for Dart's built-in
dynamictype.final - GC β GarbageCollector
-
The global, singleton garbage collector instance used by Jetleaf.
final
- isolateLocalValueStore β _IsolateLocalValueStore
-
Singleton instance of the
_IsolateLocalValueStore.final - jetLeafAssetLoader β AssetLoaderInterface
-
The default asset bundler used by Jetleaf to load internal framework assets.
final
-
OBJECT_CLASS
β Class<
Object> -
Represents the reflective wrapper for Dart's built-in
Objecttype.final - Runtime β RuntimeProvider
-
πΉ Jetleaf Runtime Singleton
final
- System β _System
-
Internal system facade for the Jetleaf framework.
final
-
VOID_CLASS
β Class<
Void> -
Represents the reflective wrapper for Dart's
voidreturn type.final
Functions
-
addRuntimeAsset(
Asset asset) β void - Adds an Asset representing a non-Dart resource to the runtime context.
-
addRuntimeAssets(
List< Asset> assets, {bool replace = false}) β void - Adds multiple Asset instances to the runtime context.
-
addRuntimePackage(
Package package) β void - Adds a Package representing a scanned or resolved Dart package to the active runtime reflection context.
-
addRuntimePackages(
List< Package> packages, {bool replace = false}) β void - Adds multiple Package instances to the runtime context.
-
addRuntimeSourceLibrary(
Package package, String sourceCode, bool isSdkLibrary, dynamic library) β void - Adds and materializes a source-level Dart library into the runtime registry.
-
createBuiltInPackage(
Map< String, Package> cache) β Package - Creates a built-in Dart SDK Package instance.
-
createDefaultPackage(
String name) β Package - Creates a default Package instance with placeholder values.
-
freezeRuntimeLibrary(
) β void - Freezes the runtime materialized library registry.
-
getCachedDeclarations(
) β List< ClassDeclaration> - Returns all registered ClassDeclaration objects from the name cache.
-
hashCode(
Object current) β int - Computes a deep hash code for an object.
-
optional<
T> (T? value) β Optional< T> -
Wraps the given
valuein an Optional container. -
registerCachedDeclarations(
List< ClassDeclaration> declarations) β void - Registers pre-built ClassDeclaration objects from cache into the runtime's name and qualified-name lookup caches.
-
rootAssetLoader(
String packageName) β AssetLoaderInterface - Creates an asset bundler for a user-defined package.
-
setRuntimeLibraryTag(
String taggedLocation) β void - Tags the runtime materialized library with a diagnostic or origin label.
-
setRuntimeResolver(
RuntimeExecutor resolver) β void - Sets the RuntimeExecutor used to resolve and execute descriptor-backed entities at runtime.
-
synchronized<
T> (Object monitor, T action()) β T -
Runs the given
actionin a critical section, ensuring only one execution at a time permonitorobject. -
synchronizedAsync<
T> (Object monitor, FutureOr< T> action()) β FutureOr<T> -
Runs the given
actionin a critical section, ensuring only one execution at a time permonitorobject. -
tryWith<
T extends Closeable> (T resource, TryWithAction< T> action) β Future<void> - Utility for automatically closing a resource after use.
Typedefs
-
Accumulator<
T, U> = U Function(U, T) - A function used to accumulate values in reduction operations.
- AssetResourceContentDetector = bool Function(Object source)
- A function signature for detecting whether a given source should be treated as content rather than a file path.
- AssetResourceExtensionStrategy = String? Function(Object source)
- A function signature for determining the extension of an AssetResource.
-
AsyncMethodInvocator<
T> = Future< T> Function() - Represents a deferred executable function that performs a method invocation.
- Bool = bool
-
An alias for the built-in
booltype. -
BoolCollection
= List<
Bool> -
A list of boolean values using the
Boolalias. -
BoolSet
= Set<
Bool> -
A set of unique boolean values using the
Boolalias. -
ConditionTester<
T> = bool Function(T value) -
A typedef for a predicate function that tests a condition on a value of type
T. -
Consumer<
T> = void Function(T value) -
A function that consumes a value of type
Twithout returning anything. - CreatedPodHolder = (String, PodDefinition, Object)
- The holder for created pods
-
DataMapper<
T, U> = U Function(T value) -
A function that transforms a value from type
Tto typeU. -
DateTimeCollection
= List<
DateTime> -
A list of
DateTimevalues. -
DateTimeSet
= Set<
DateTime> -
A set of unique
DateTimevalues. -
DurationCollection
= List<
Duration> -
A list of
Durationvalues. -
DurationSet
= Set<
Duration> -
A set of unique
Durationvalues. - ExceptionSupplier = Object Function()
- A function that returns an exception object to be thrown when needed.
- Int = int
- A shorthand alias for an integer value.
-
IntCollection
= List<
Int> -
A list of integers using the
Intalias. -
IntSet
= Set<
Int> -
A set of unique integers using the
Intalias. -
JsonMap
= Map<
String, dynamic> -
A JSON-like structure represented as a
Map<String, dynamic>. -
JsonMapCollection
= List<
JsonMap> - A list of JSON-like maps, useful for handling multiple entities.
-
JsonString
= Map<
String, String> - A map of string keys and string values representing simple string-based JSON data.
-
ObjectFactoryFunction<
T> = FutureOr< ObjectHolder< Function([List<T> >ArgumentValue> ? args]) -
A function that creates an instance of type
T. - PlaceholderResolverFn = String? Function(String placeholderName)
-
PodDefinitionHolder
= (String, PodDefinition, List<
String> ) - Type definition for a pod definition holder tuple.
- PodHolder = (Object, Class)
- A tuple representing a pod and its class.
-
PodInstanceSupplier<
T> = FutureOr< T> Function(PodFactory factory) - Direct compiled instance supplier function for AOT instantiation (zero reflection).
-
PodLifecycleInvoker<
T> = FutureOr< void> Function(T instance) - Direct compiled lifecycle invoker function for AOT @PostConstruct and @PreDestroy (zero reflection).
-
Predicate<
T> = Bool Function(T value) -
A function that takes a value of type
Tand returns a boolean. -
StringCollection
= List<
String> - A list of strings.
-
StringSet
= Set<
String> - A set of unique strings.
-
Supplier<
T> = T Function() -
A function that supplies a value of type
T, typically lazily or on-demand. -
ThrowingSupplier<
T> = T Function() - A functional interface that supplies a value and may throw an exception.
Exceptions / Errors
- ArgumentResolutionException
- Base class for exceptions thrown during argument resolution.
- AssetLoaderException
- An exception thrown when an asset cannot be loaded by the Jetleaf bundler.
- BuildableCacheException
- Exception thrown when a cache deserialization or validation failure occurs during binary cache loading.
- BuildException
- An exception thrown when a build-time or configuration-time failure occurs within the Jetleaf framework.
- CircularDependencyException
- Thrown when a circular dependency is detected within the framework's dependency graph, interceptor ordering, or initialization process.
- ClassNotFoundException
- A runtime exception in Jetleaf thrown when a requested class cannot be found by the runtime provider.
- ComparatorException
- Exception thrown when a comparator is used with a type that is not comparable.
- ConstructorNotFoundException
- Exception thrown when a requested constructor cannot be found or invoked for a given type during resolution.
- ConversionException
- Exception thrown when a type conversion fails in a ConversionService.
- ConversionFailedException
- Exception thrown when an actual type conversion attempt fails.
- ConverterNotFoundException
- Exception thrown when no suitable converter can be found for a given source and target type.
- DartLoadingException
- Exception thrown when Dart file loading fails.
- EndOfStreamException
- Exception thrown when the end of a stream is reached unexpectedly.
- EnvironmentParsingException
- An Exception thrown when an error occurs during environment property parsing.
- FatalPodException
- Base class for fatal pod-related exceptions that indicate unrecoverable errors.
- FewerPositionalArgumentException
- Thrown when a runtime invocation receives fewer positional arguments than the target function or constructor requires.
- FieldAccessException
- Exception thrown when reading a field or getter fails on a given type.
- FieldMutationException
- Exception thrown when writing to a field or setter fails on a given type.
- GenericResolutionException
- Exception thrown when generic type resolution fails during dynamic analysis or reflection-based processing.
- IllegalArgumentException
- Thrown when a method is passed an illegal or inappropriate argument.
- IllegalStateException
- Signals that a method has been invoked at an illegal or inappropriate time.
- ImmaterialClassException
- Thrown when a class exists but cannot be materialized into a concrete ClassDeclaration by Jetleaf.
- InvalidArgumentException
- Exception thrown when an invalid argument is provided.
- InvalidFormatException
- Exception thrown when an invalid format is provided.
- IOException
- Exception thrown when an I/O operation fails.
- LangException
- General exception for language related errors.
- MalformedUrlException
- Thrown to indicate that a malformed URL has occurred.
- MessageSourceException
- An exception that occurs when resolving messages from a MessageSource.
- MethodNotFoundException
- Exception thrown when a requested method cannot be found or invoked on a given type during dynamic resolution.
- MissingRequiredEnvironmentException
- Exception thrown when a required environment variable is not found.
- MissingRequiredNamedParameterException
- Thrown when a required named parameter is missing during runtime method or constructor invocation.
- MissingRequiredPositionalParameterException
- Thrown when a required positional parameter is missing during runtime method or constructor invocation.
- MissingRequiredPropertiesException
- Exception thrown when required properties are not found.
- MorePositionalArgumentException
- Thrown when a runtime invocation receives more positional arguments than the target function or constructor accepts.
- MultipleSourceException
- Exception thrown when multiple class definitions with the same name are found.
- NestedCheckedException
- Abstract base class for checked exceptions that can wrap other exceptions.
- NestedRuntimeException
- Abstract base class for runtime exceptions that can wrap other exceptions.
- NetworkException
- Thrown to indicate an I/O error during network operations.
- NoGuaranteeException
- Exception thrown when a guarantee is not met. Mostly used to behave like NoGuaranteeException
- NoSuchElementException
- Thrown when an operation attempts to access an element that does not exist.
- NoSuchPodDefinitionException
-
Exception thrown when a
PodFactoryis asked for a pod instance by name, and no definition for that pod name exists. - NoUniquePodDefinitionException
- Exception thrown when multiple pod definitions are found for a given type in the application context.
- ParserException
- Exception thrown when parsing fails.
- PlaceholderResolutionException
- Exception thrown when placeholder resolution fails.
- PodCreationException
- Exception thrown when a pod cannot be created.
- PodCreationNotAllowedException
- Exception thrown when a pod creation is not allowed in the current context.
- PodCurrentlyInCreationException
- Exception thrown when a pod is currently in the process of being created.
- PodDefinitionOverrideException
- Exception thrown when a pod definition is overridden.
- PodDefinitionStoreException
- Exception thrown when a pod definition store error occurs.
- PodDefinitionValidationException
- Exception thrown when a pod definition is invalid during validation.
- PodException
- Base exception type for all pod-related errors in Jetleaf.
- PodIsAbstractException
- Exception thrown when attempting to instantiate a pod that is marked as abstract.
- PodIsNotAProviderException
- Exception thrown when a pod is expected to be a PodProvider but is not.
- PodNotOfRequiredTypeException
- Exception thrown when a pod retrieved from the context is not of the expected type.
- PodProviderNotInitializedException
- Exception thrown when attempting to use a PodProvider that hasn't been fully initialized.
- PrivateConstructorInvocationException
- Exception thrown when a developer attempts to invoke a private constructor dynamically, which is not allowed by Jetleaf.
- PrivateFieldAccessException
- Exception thrown when attempting to access a private field or getter/setter on a type during runtime resolution.
- PrivateMethodInvocationException
- Exception thrown when a developer attempts to invoke a private method dynamically, which is not allowed by Jetleaf.
- ReentrantSynchronizedException
- Exception thrown when a synchronized block is reentered from the same zone.
- RuntimeException
- Represents an unchecked runtime exception in Jetleaf.
- RuntimeResolverException
- Base class for all resolver-related exceptions within the Jetleaf resolution and evaluation subsystem.
- ScopeNotActiveException
- Exception thrown when a pod is requested from a scope that is not active.
- SecurityException
- Exception thrown when a security violation occurs.
- StreamClosedException
- Exception thrown when an attempt is made to use a stream that has been closed.
- ThreadInterruptedException
- Exception thrown when an Isolate (thread) is unexpectedly interrupted during execution.
- ThreadSpawnException
- Exception thrown when an Isolate fails to start properly due to issues such as invalid entrypoint, unsupported data, or environment errors.
- Throwable
- Base class for all throwable exceptions in Jetleaf.
- TypeResolutionException
- Exception thrown when type lookup or resolution fails.
- UnexpectedArgumentException
- Thrown when an invocation receives an argument that does not correspond to any declared parameter, usually a named parameter that the target method or constructor does not define.
- UnresolvedTypeInstantiationException
- Exception thrown when Jetleaf is unable to instantiate a class or resolve a constructor because the runtime type is unresolved.
- UnsatisfiedDependencyException
- Exception thrown when a dependency is not satisfied for a pod.
- UnsupportedOperationException
- Thrown to indicate that a requested operation is not supported.
- UnsupportedRuntimeOperationException
- Exception thrown when an operation cannot be performed due to runtime environment limitations.
- UriPathMatchingException
- Exception thrown when a URI or route path fails to match a defined template in a path matcher.