org.pentaho.reporting.libraries.resourceloader

Class ResourceManager

public final class ResourceManager extends Object

The resource manager takes care about the loaded resources, performs caching, if needed and is the central instance when dealing with resources. Resource loading is a two-step process. In the first step, the ResourceLoader accesses the physical storage or network connection to read in the binary data. The loaded ResourceData carries versioning information with it an can be cached indendently from the produced result. Once the loading is complete, a ResourceFactory interprets the binary data and produces a Java-Object from it.

Resources are identified by an Resource-Key and some optional loader parameters (which can be used to parametrize the resource-factories).

Author: Thomas Morgner

See Also: ResourceData ResourceLoader ResourceFactory

Field Summary
static StringBUNDLE_CACHE_PROVIDER_KEY
static StringBUNDLE_LOADER_PREFIX
static StringDATA_CACHE_PROVIDER_KEY
static StringFACTORY_CACHE_PROVIDER_KEY
static StringFACTORY_TYPE_PREFIX
static StringLOADER_PREFIX
Constructor Summary
ResourceManager()
Default Constructor.
ResourceManager(ResourceManagerBackend resourceManagerBackend)
ResourceManager(ResourceManager parent, ResourceManagerBackend backend)
Method Summary
Resourcecreate(ResourceKey key, ResourceKey context, Class target)
Resourcecreate(ResourceKey key, ResourceKey context)
Resourcecreate(ResourceKey key, ResourceKey context, Class[] target)
ResourcecreateDirectly(Object keyValue, Class target)
ResourceKeycreateKey(Object data)
Creates a ResourceKey that carries no Loader-Parameters from the given object.
ResourceKeycreateKey(Object data, Map parameters)
Creates a ResourceKey that carries the given Loader-Parameters contained in the optional map.
ResourceKeyderiveKey(ResourceKey parent, String path)
Derives a new key from the given resource-key.
ResourceKeyderiveKey(ResourceKey parent, String path, Map parameters)
Derives a new key from the given resource-key.
ResourceKeydeserialize(ResourceKey bundleKey, String serializedKey)
Converts a serialized version of a ResourceKey into an actual ResourceKey by locating the proper ResourceLoader that can perform the deserialization.
ResourceManagerBackendgetBackend()
ResourceBundleDataCachegetBundleCache()
ResourceDataCachegetDataCache()
ResourceFactoryCachegetFactoryCache()
ResourceDataload(ResourceKey key)
ResourceDataloadRawData(ResourceKey key)
ResourceBundleDataloadResourceBundle(ResourceKey key)
Tries to find the first resource-bundle-loader that would be able to process the key.
voidregisterBundleDataCache()
voidregisterBundleLoader(ResourceBundleLoader loader)
voidregisterDataCache()
voidregisterDefaultFactories()
voidregisterDefaultLoaders()
voidregisterDefaults()
voidregisterFactory(ResourceFactory factory)
voidregisterFactoryCache()
voidregisterLoader(ResourceLoader loader)
Stringserialize(ResourceKey bundleKey, ResourceKey key)
Creates a String version of the ResourceKey that can be deserialized with the deserialize() method.
voidsetBundleCache(ResourceBundleDataCache bundleCache)
voidsetDataCache(ResourceDataCache dataCache)
voidsetFactoryCache(ResourceFactoryCache factoryCache)
voidshutDown()
URLtoURL(ResourceKey key)
Tries to convert the resource-key into an URL.

Field Detail

BUNDLE_CACHE_PROVIDER_KEY

public static final String BUNDLE_CACHE_PROVIDER_KEY

BUNDLE_LOADER_PREFIX

public static final String BUNDLE_LOADER_PREFIX

DATA_CACHE_PROVIDER_KEY

public static final String DATA_CACHE_PROVIDER_KEY

FACTORY_CACHE_PROVIDER_KEY

public static final String FACTORY_CACHE_PROVIDER_KEY

FACTORY_TYPE_PREFIX

public static final String FACTORY_TYPE_PREFIX

LOADER_PREFIX

public static final String LOADER_PREFIX

Constructor Detail

ResourceManager

public ResourceManager()
Default Constructor.

ResourceManager

public ResourceManager(ResourceManagerBackend resourceManagerBackend)

ResourceManager

public ResourceManager(ResourceManager parent, ResourceManagerBackend backend)

Method Detail

create

public Resource create(ResourceKey key, ResourceKey context, Class target)

create

public Resource create(ResourceKey key, ResourceKey context)

create

public Resource create(ResourceKey key, ResourceKey context, Class[] target)

createDirectly

public Resource createDirectly(Object keyValue, Class target)

createKey

public ResourceKey createKey(Object data)
Creates a ResourceKey that carries no Loader-Parameters from the given object.

Parameters: data the key-data

Returns: the generated resource-key, never null.

Throws: ResourceKeyCreationException if the key-creation failed.

createKey

public ResourceKey createKey(Object data, Map parameters)
Creates a ResourceKey that carries the given Loader-Parameters contained in the optional map.

Parameters: data the key-data parameters an optional map of parameters.

Returns: the generated resource-key, never null.

Throws: ResourceKeyCreationException if the key-creation failed.

deriveKey

public ResourceKey deriveKey(ResourceKey parent, String path)
Derives a new key from the given resource-key. Only keys for a hierarchical storage system (like file-systems or URLs) can have derived keys. Since LibLoader 0.3.0 only hierarchical keys can be derived. For that, the deriving path must be given as String.

Before trying to derive the key, the system tries to interpret the path as absolute key-value.

Parameters: parent the parent key, must never be null path the relative path, that is used to derive the key.

Returns: the derived key.

Throws: ResourceKeyCreationException if deriving the key failed.

deriveKey

public ResourceKey deriveKey(ResourceKey parent, String path, Map parameters)
Derives a new key from the given resource-key. Only keys for a hierarchical storage system (like file-systems or URLs) can have derived keys. Since LibLoader 0.3.0 only hierarchical keys can be derived. For that, the deriving path must be given as String.

The optional parameter-map will be applied to the derived key after the parent's parameters have been copied to the new key.

Before trying to derive the key, the system tries to interpret the path as absolute key-value.

Parameters: parent the parent key, or null to interpret the path as absolute key. path the relative path, that is used to derive the key. parameters a optional map containing resource-key parameters.

Returns: the derived key.

Throws: ResourceKeyCreationException if deriving the key failed.

deserialize

public ResourceKey deserialize(ResourceKey bundleKey, String serializedKey)
Converts a serialized version of a ResourceKey into an actual ResourceKey by locating the proper ResourceLoader that can perform the deserialization.

Parameters: serializedKey the String serialized key to be deserialized

Returns: the ResourceKey that has been deserialized

Throws: ResourceKeyCreationException indicates an error trying to create the ResourceKey from the deserialized version

getBackend

public ResourceManagerBackend getBackend()

getBundleCache

public ResourceBundleDataCache getBundleCache()

getDataCache

public ResourceDataCache getDataCache()

getFactoryCache

public ResourceFactoryCache getFactoryCache()

load

public ResourceData load(ResourceKey key)

loadRawData

public ResourceData loadRawData(ResourceKey key)

loadResourceBundle

public ResourceBundleData loadResourceBundle(ResourceKey key)
Tries to find the first resource-bundle-loader that would be able to process the key.

Parameters: key the resource-key.

Returns: the resourceloader for that key, or null, if no resource-loader is able to process the key.

Throws: ResourceLoadingException if an error occured.

registerBundleDataCache

public void registerBundleDataCache()

registerBundleLoader

public void registerBundleLoader(ResourceBundleLoader loader)

registerDataCache

public void registerDataCache()

registerDefaultFactories

public void registerDefaultFactories()

registerDefaultLoaders

public void registerDefaultLoaders()

registerDefaults

public void registerDefaults()

registerFactory

public void registerFactory(ResourceFactory factory)

registerFactoryCache

public void registerFactoryCache()

registerLoader

public void registerLoader(ResourceLoader loader)

serialize

public String serialize(ResourceKey bundleKey, ResourceKey key)
Creates a String version of the ResourceKey that can be deserialized with the deserialize() method.

Parameters: bundleKey the key to the bundle containing the resource, or null if no bundle exists. key the key to be serialized

Throws: ResourceException indicates an error trying to serialize the key NullPointerException indicates the supplied key is null

setBundleCache

public void setBundleCache(ResourceBundleDataCache bundleCache)

setDataCache

public void setDataCache(ResourceDataCache dataCache)

setFactoryCache

public void setFactoryCache(ResourceFactoryCache factoryCache)

shutDown

public void shutDown()

toURL

public URL toURL(ResourceKey key)
Tries to convert the resource-key into an URL. Not all resource-keys have an URL representation. This method exists to make it easier to connect LibLoader to other resource-loading frameworks.

Parameters: key the resource-key

Returns: the URL for the key, or null if there is no such key.