Package org.springsource.loaded

Interface Summary

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 Summary

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.
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.
TypeRewriter	Rewrites a class such that it is amenable to reloading.
Utils	Utility functions for use throughout SpringLoaded
Utils.ReturnType

Enum Summary

Enum	Description
Utils.ReturnType.Kind

Exception Summary

Exception	Description
ReloadException
UnableToLoadClassException