| Interface | Description |
|---|---|
| __DynamicallyDispatchable |
Interface implemented by all dispatchers so code can be generated to call the dynamic executor regardless of the
dispatcher instance the code is actually working with.
|
| Constants |
Common constants used throughout Spring Loaded.
|
| FileChangeListener |
Call back interface for the FileSystemWatcher.
|
| IsReloadableTypePlugin |
Plugins implementing this interface are allowed to participate in determining whether a type should be made
reloadable.
|
| LoadtimeInstrumentationPlugin |
Plugins that implement this interface are allowed to modify types as they are loaded - this can be necessary
sometimes to ensure, for example, that a particular field is accessible later when a reload event occurs or that some
factory method returns a wrapper rather than the original object it intended to.
|
| Plugin |
Top level interface for Spring-Loaded plugins.
|
| ReloadEventProcessorPlugin |
ReloadEventProcessor Plugins are called when a type is reloading.
|
| UnableToReloadEventProcessorPlugin |
UnableToReloadEventProcessor Plugins are called when a type cannot be reloaded due to an unsupported change.
|
| Class | Description |
|---|---|
| AbstractMember |
Simple implementation of Member which could represent a method, field or constructor.
|
| AnyTypePattern |
Represents '*' type pattern.
|
| Asserts | |
| C | |
| ChildClassLoader |
The ChildClassLoader will load the generated dispatchers and executors which change for each reload.
|
| ClassRenamer |
Modify a class by changing it from one name to another.
|
| ConstantPoolChecker |
Quickly checks the constant pool for class references, it skips everything else as fast as it can.
|
| ConstantPoolChecker2 |
Enables us to check things quickly in the constant pool.
|
| ConstantPoolScanner |
Enables us to check things quickly in the constant pool.
|
| ConstantPoolScanner.References | |
| CurrentLiveVersion |
Captures the information about the reloaded parts of a type that vary each time a new version is loaded.
|
| DispatcherBuilder |
Builder that creates the dispatcher.
|
| EmptyClassVisitor |
Empty implementation that can be subclassed to pick up default implementations of most methods.
|
| ExactTypePattern |
Represents an exact type pattern.
|
| ExecutorBuilder |
The executor embodies the new implementation of the type after it has been reloaded.
|
| FieldDelta |
Encapsulates what has changed about a field on a reload.
|
| FieldMember |
Describes a field, created during TypeDescriptor construction.
|
| FieldReaderWriter |
Able to read or write a particular field in a type.
|
| GlobalConfiguration |
Encapsulates configurable elements - these are set (to values other than the defaults) in TypeRegistry when the
system property springloaded configuration is processed.
|
| IncrementalTypeDescriptor |
This class computes and then encapsulates what has changed between the original form of a type and a newly loaded
version.
|
| InterfaceExtractor |
Extract an interface for a type.
|
| ISMgr |
Every reloadable hierarchy gets an Instance State Manager (ISMgr).
|
| Log |
Minimal support for logging messages, avoids all dependencies it can because it will be loaded very early by the VM
and we don't want to introduce unnecessarily complex classloading.
|
| MethodDelta |
Encapsulates what has changed about a method when it is reloaded, compared to the original form.
|
| MethodInvokerRewriter |
Rewrite method calls and field accesses.
|
| MethodMember |
Representation of a Method.
|
| NameRegistry |
Manages a mapping of names to numbers.
|
| Plugins |
Manages plugin interactions between the user and the agent.
|
| PrefixTypePattern |
Represents a double dotted type pattern.
|
| QuickVisitor |
Can be used to take a quick look in the bytecode for something.
|
| ReflectionFieldReaderWriter |
A FieldReaderWriter implementation that simply uses reflection to set/get the fields.
|
| ReloadableType |
Represents a type that has been processed such that it can be reloaded at runtime.
|
| RTH |
Runtime Helper Class.
|
| SpringLoaded |
API for directly interacting with SpringLoaded.
|
| SSMgr |
Static State Manager.
|
| SystemClassReflectionInvestigator |
This is similar to SystemClassReflectionRewriter but this version just summarizes what it finds, rather than making
any changes.
|
| SystemClassReflectionRewriter |
This is a special rewriter that should be used on system classes that are using reflection.
|
| SystemClassReflectionRewriter.RewriteResult | |
| SystemPropertyConfiguredIsReloadableTypePlugin |
This is not a 'default' plugin, it must be registered by specifying the following on the springloaded option:
"plugins=org.springsource.loaded.SystemPropertyConfiguredIsReloadableTypePlugin".
|
| TypeDelta |
Encapsulates what has changed between two versions of a type - it is used to determine if a reload is possible and
also passed on events related to reloading so that the plugins can tailor their actions based on what prevented
reloading.
|
| TypeDescriptor |
Encapsulates the information about a type relevant to reloading.
|
| TypeDescriptorExtractor |
A type descriptor describes the type, methods, fields, etc - two type descriptors are comparable to discover what has
changed between versions.
|
| TypeDiffComputer |
Compute the differences between two versions of a type as a series of deltas.
|
| TypePattern |
Similar to the AspectJ type pattern model - used for defining reloadable type inclusions/exclusions.
|
| TypeRegistry |
The type registry tracks all reloadable types loaded by a specific class loader.
|
| TypeRegistry.ReloadableTypeNameDecision | |
| TypeRewriter |
Rewrites a class such that it is amenable to reloading.
|
| Utils |
Utility functions for use throughout SpringLoaded
|
| Utils.ReturnType |
| Enum | Description |
|---|---|
| TypeRegistry.CouldBeReloadableDecision | |
| Utils.ReturnType.Kind |
| Exception | Description |
|---|---|
| ReloadException | |
| UnableToLoadClassException |