lang library
Core Language Architecture: Metaprogramming Runtime, Reflection & System Topologies
A highly optimized reflection, metaprogramming, and asset resolution subsystem.
Classes
- AbsolutePathValidator
- Validates that a URI contains an absolute path (starting with '/').
-
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.
- AllowedDomainsValidator
- Validates that a URI's host matches one of the allowed domains.
- Annotation
- Provides reflective access to annotations applied to declarations.
- 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.
- 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.
-
ArrayList<
E> - A resizable array implementation similar to Java's ArrayList.
- 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:
- Author
- Annotation to describe the author of a declaration.
- 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.
- BigInteger
- A wrapper class for arbitrary precision integers.
- 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.
- 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.
- 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.
-
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.
- 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.
-
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. - 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.
- ConstructorDeclaration
-
Represents a constructor of a Dart class, including its parameters,
modifiers (
const,factory), and the ability to create new instances. - Currency
- Abstract base class for currency operations following ISO 4217 standards.
- DateTimeFormatter
- A formatter and parser for date-time objects based on patterns, similar to Java's DateTimeFormatter.
- Declaration
- A named, typed declaration representing a concrete program element.
- 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.
- Double
- A wrapper class for double that provides Java-like functionality and methods.
- DoubleStream
-
A sequence of primitive
double-valued elements supporting sequential and parallel aggregate operations. - Dynamic
- Abstract base class representing a dynamic or unconstrained type within the Jetleaf type system.
- EntityDeclaration
- A uniquely identifiable declaration representing a runtime entity.
- 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.
- EnumValue
- Represents a single value within an enum type, providing full reflective access to its metadata, declaration details, and runtime behavior.
- 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.
- 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.
- 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.
- Flushable
- An object that can be flushed.
- 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.
-
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.
-
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. - 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.
- 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.
- IntStream
-
A sequence of primitive
int-valued elements supporting sequential and parallel aggregate operations. - 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.
- LanguageRange
- Represents a language range as defined in RFC 4647.
- LibraryDeclaration
- Represents a Dart library declaration within Jetleafโs reflection and generation system.
- LinkDeclaration
- Abstract base class for type references in reflection systems.
-
LinkedList<
E> -
A custom implementation of a doubly linked list that implements the standard
List<E>interface. -
LinkedQueue<
E> - A queue implementation using a linked list structure, mimicking Java's LinkedList as Queue.
-
LinkedStack<
E> - A stack implementation using a linked list structure, mimicking Java's LinkedList as Stack.
-
ListChange<
T> -
Represents a change in a
List. - LocalDate
- Represents a calendar date without time or timezone.
- LocalDateTime
- A date-time object without a timezone, composed of a LocalDate and LocalTime.
- Locale
- A representation of a locale, consisting of a language code and optional country and variant codes.
-
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.
- Long
- A wrapper class for large integers that provides Java-like functionality.
-
MapChange<
K, V> -
Represents a change in a
Map. - 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.
- Method
- Provides reflective access to class method metadata and invocation capabilities.
- MethodDeclaration
- Represents a method declaration in a Dart class, extension, mixin, or top-level scope.
- 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. -
NamedLocalThread<
T> - A specialized LocalThread that includes a descriptive name for better debugging and identification.
- 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.
- NoSpacesValidator
- Validates that a URI string doesn't contain any spaces.
- Null
- A minimal placeholder class representing a null-like object.
- 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.
-
Obs<
T> - A reactive wrapper for values, lists, or maps.
- ObsEvent
- A base class representing an event in an observable system.
-
Optional<
T> - A container object which may or may not contain a non-null value.
- 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.
- 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.
- PermissionManager
- Abstract interface for elements that can have protection domains.
- 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.
- 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.
- 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.
- 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.
- RegexUtils
- A collection of commonly used regular expressions, provided as constants.
- Resolved
- An annotation used to mark classes for which AOT-compatible runtime resolvers should be generated.
- 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://").
- SecureSchemeValidator
- Validates that a URI uses a secure scheme (https or wss by default).
- Short
- A wrapper class for int representing a 16-bit signed integer.
-
SimpleProvider<
T> - Simple, immutable implementation of Provider that always returns a pre-defined, constant value.
- 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.
- 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.
-
Stack<
E> - A last-in-first-out (LIFO) stack implementation, mimicking Java's Stack.
- 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.
-
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.
- 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.
-
SuppliedNamedLocalThread<
T> - A NamedLocalThread that provides an initial value using a Supplier function.
- 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. -
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. - 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}). - 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.
-
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.
- Writer
- Abstract class for writing to character streams.
- ZonedDateTime
- Represents a date-time with timezone information.
- ZoneId
- Represents a time zone identifier, abstracting the concept of region-based or offset-based zone IDs (e.g., 'UTC', 'America/New_York').
Enums
- DomainPermission
- Enumeration of reflection-based permissions for secure access to class metadata, fields, methods, constructors, and annotations within a container or framework.
- ListChangeType
-
Represents the type of change that occurs in a
List. - MapChangeType
-
Represents the type of change that occurs in a
Map. - TypeKind
- Enumerates the different kinds of Dart types recognized by Jetleafโs reflection and type resolution system.
Mixins
- 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
- 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
-
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.
- 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. -
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.
-
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.
- 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.
- EndOfStreamException
- Exception thrown when the end of a stream is reached unexpectedly.
- 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.
- MethodNotFoundException
- Exception thrown when a requested method cannot be found or invoked on a given type during dynamic resolution.
- 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.
- 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.
- 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.
- 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.
- 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.