Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Programming
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Databases
Mail Systems
openSolaris
Eclipse Documentation
Techotopia.com
Virtuatopia.com

How To Guides
Virtualization
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Windows
Problem Solutions
Privacy Policy

  




 

 


Eclipse Platform
Release 3.5

org.eclipse.core.runtime.spi
Class RegistryStrategy

java.lang.Object
  extended by 
org.eclipse.core.runtime.spi.RegistryStrategy

public class RegistryStrategy
extends Object

This is the basic registry strategy. It describes how the registry does logging, message translation, extra start/stop processing, event scheduling, caching, and debugging.

In this strategy:

  • Logging is done onto System.out;
  • The translation routine assumes that keys are prefixed with '%'/;
  • Caching is enabled and doesn't use state or time stamp validation;
  • Standard Java class loading is used to create executable extensions.

This class can be used without OSGi running.

This class can be overridden and/or instantiated by clients.

Note: This class/interface is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made available at this early stage to solicit feedback from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken (repeatedly) as the API evolves.

Since:
org.eclipse.equinox.registry 3.2

Constructor Summary
RegistryStrategy ( File[] storageDirs, boolean[] cacheReadOnly)
          Constructor for this default registry strategy.
 
Method Summary
 boolean cacheLazyLoading ()
          Specifies if lazy cache loading is used.
 boolean cacheUse ()
          Specifies if the extension registry should use cache to store registry data between invocations.
  Object createExecutableExtension ( RegistryContributor contributor, String className, String overridenContributorName)
          Creates an executable extension.
 boolean debug ()
          Override this method to specify debug requirements to the registry.
 boolean debugRegistryEvents ()
          Override this method to specify debug requirements for the registry event processing.
 long getContainerTimestamp ()
          This method is called as a part of the registry cache validation.
 long getContributionsTimestamp ()
          This method is called as a part of the registry cache validation.
 int getLocationsLength ()
          Returns the number of possible cache locations for this registry.
  File getStorage (int index)
          Returns the possible registry cache location identified by the index.
  SAXParserFactory getXMLParser ()
          Returns the parser used by the registry to parse descriptions of extension points and extensions.
 boolean isCacheReadOnly (int index)
          Returns the read-only status of the registry cache location.
 void log ( IStatus status)
          Override this method to provide customized logging functionality to the registry.
 void onStart ( IExtensionRegistry registry)
          Deprecated. use onStart(IExtensionRegistry, boolean).
 void onStart ( IExtensionRegistry registry, boolean loadedFromCache)
          Override this method to provide additional processing performed when the registry is created and started.
 void onStop ( IExtensionRegistry registry)
          Override this method to provide additional processing to be performed just before the registry is stopped.
static  IStatus processChangeEvent ( Object[] listeners, Map deltas, Object registry)
          This method performs actual processing of the registry change event.
 void scheduleChangeEvent ( Object[] listeners, Map deltas, Object registry)
          Override this method to customize scheduling of an extension registry event.
  String translate ( String key, ResourceBundle resources)
          Translates key using the supplied resource bundle.
 
Methods inherited from class java.lang. Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

RegistryStrategy

public RegistryStrategy(
File[] storageDirs,
                        boolean[] cacheReadOnly)
Constructor for this default registry strategy.

The strategy sequentially checks the array of storage directories to discover the location of the registry cache formed by previous invocations of the extension registry. Once found, the location is used to store registry cache. If this value is null then caching of the registry content is disabled.

The cache read-only array is an array the same length as the storage directory array. It contains boolean values indicating whether or not each storage directory is read-only. If the value at an index is true then the location at the corresponding index in the storage directories array is read-only; if false then the cache location is read-write. The array can be null if the storageDirs parameter is null.

Parameters:
storageDirs - array of file system directories, or null
cacheReadOnly - array of read only attributes, or null
Method Detail

getLocationsLength

public final int getLocationsLength()
Returns the number of possible cache locations for this registry.

Returns:
number of possible cache locations for this registry

getStorage

public final 
File getStorage(int index)
Returns the possible registry cache location identified by the index.

Parameters:
index - index of the possible registry location
Returns:
potential registry cache location

isCacheReadOnly

public final boolean isCacheReadOnly(int index)
Returns the read-only status of the registry cache location.

Parameters:
index - the index of the possible registry location
Returns:
true if the location is read only and false if the location is read/write

log

public void log(
IStatus status)
Override this method to provide customized logging functionality to the registry. The method adds a log entry based on the supplied status.

This method writes a message to System.out in the following format:

 [Error|Warning|Log]: Main error message
 [Error|Warning|Log]: Child error message 1
        ...
 [Error|Warning|Log]: Child error message N
 

Parameters:
status - the status to log

translate

public 
String translate(
String key,
                        
ResourceBundle resources)
Translates key using the supplied resource bundle. The resource bundle is optional and might be null.

The default translation routine assumes that keys are prefixed with '%'. If no resource bundle is present, the key itself (without leading '%') is returned. There is no decoding for the leading '%%'.

Parameters:
key - message key to be translated
resources - resource bundle, or null
Returns:
the translated string, must not be null

onStart

public void onStart(
IExtensionRegistry registry)
Deprecated. use onStart(IExtensionRegistry, boolean).

Override this method to provide additional processing performed when the registry is created and started. Overrides should call super.onStart() at the beginning of the processing.

NOTE: Avoid placing duplicate functionality in this method and onStart(IExtensionRegistry, boolean) as both methods will be called on the registry startup.

Parameters:
registry - the extension registry being started

onStart

public void onStart(
IExtensionRegistry registry,
                    boolean loadedFromCache)
Override this method to provide additional processing performed when the registry is created and started. Overrides should call super.onStart() at the beginning of the processing.

Parameters:
registry - the extension registry being started
loadedFromCache - true is registry contents was loaded from cache when the registry was created
Since:
3.4

onStop

public void onStop(
IExtensionRegistry registry)
Override this method to provide additional processing to be performed just before the registry is stopped. Overrides should call super.onStop() at the end of the processing.

Parameters:
registry - the extension registry being stopped

createExecutableExtension

public 
Object createExecutableExtension(
RegistryContributor contributor,
                                        
String className,
                                        
String overridenContributorName)
                                 throws 
CoreException
Creates an executable extension. Override this method to supply an alternative processing for the creation of executable extensions.

This method receives the contributor of the executable extension and, possibly, an optional contributor name if specified by the executable extension. The overridden contributor name might be null.

In this implementation registry attempts to instantiate the class specified via the class name (must not be null) using standard Java reflection mechanism. This method assumes that such class has a default constructor with no arguments.

Parameters:
contributor - the contributor of this executable extension
className - the name of the class to be instantiated
overridenContributorName - the contributor to be used, or null if not specified
Returns:
the object created, or null
Throws:
CoreException - if there was a problem creating the executable extension
See Also:
IConfigurationElement.createExecutableExtension(String), IExecutableExtension

scheduleChangeEvent

public void scheduleChangeEvent(
Object[] listeners,
                                
Map deltas,
                                
Object registry)
Override this method to customize scheduling of an extension registry event. Note that this method must make the following call to actually process the event:


        RegistryStrategy.processChangeEvent(listeners, deltas, registry);
 

In the default implementation, the method registry events are executed in a queue on a separate thread (i.e. asynchronously, sequentially).

Parameters:
listeners - the list of active listeners (thread safe); may not be null
deltas - the registry deltas (thread safe); may not be null
registry - the extension registry (NOT thread safe); may not be null

processChangeEvent

public static final 
IStatus processChangeEvent(
Object[] listeners,
                                               
Map deltas,
                                               
Object registry)
This method performs actual processing of the registry change event. It should only be used by overrides of the RegistryStrategy.scheduleChangeEvent. It will return null if an unexpected registry type was encountered.

Parameters:
listeners - the list of active listeners; may not be null
deltas - the extension registry deltas; may not be null
registry - the extension registry; may not be null
Returns:
status of the operation or null

debug

public boolean debug()
Override this method to specify debug requirements to the registry. In the default implementation this method returns false indicating that debug functionality is turned off.

Note that in a general case the extension registry plug-in doesn't depend on OSGI and therefore cannot use Eclipse .options files to discover debug options.

Returns:
true if debug logging and validation should be performed and false otherwise

debugRegistryEvents

public boolean debugRegistryEvents()
Override this method to specify debug requirements for the registry event processing. In the default implementation this method returns false indicating that debug of the registry events is turned off.

Note that in a general case the extension registry plug-in doesn't depend on OSGI and therefore cannot use Eclipse .options files to discover debug options.

Returns:
true if debug logging and validation of the registry events should be performed and false otherwise

cacheUse

public boolean cacheUse()
Specifies if the extension registry should use cache to store registry data between invocations.

The default implementation enables caching returning true.

Returns:
true if the cache should be used and false otherwise

cacheLazyLoading

public boolean cacheLazyLoading()
Specifies if lazy cache loading is used.

The default implementation specifies that lazy cache loading is going to be used and therefore returns true.

Returns:
true if lazy cache loading is used and false otherwise

getContainerTimestamp

public long getContainerTimestamp()
This method is called as a part of the registry cache validation. The cache is valid on the registry startup if the pair {container time stamp, contributors time stamp} supplied by the registry strategy is the same as the {container time stamp, contributors time stamp} stored in the registry cache. The goal of the validation is to be able to catch modifications made to the original data contributed into the registry and not reflected in the registry cache.

The method produces a number that corresponds to the current state of the data stored by the container. Increment the stamp if the data stored in the container has been updated so that the data cached by the registry is no longer valid. For instance, in Eclipse addition or removal of a bundle results in the number returned by this method being incremented. As a result, if a bundle that contributed plugin.xml into the extension registry was modified, the state doesn't match the state stored in the registry cache. In this case the cache content becomes invalid and the registry needs to be re-created from the original data.

Generally, treat this number as a hash code for the data stored in the registry. It stays the same as long as the registry content is not changing. It becomes a different number as the registry content gets modified.

Return 0 to indicate that state verification is not required.

Returns:
number indicating state of the application data

getContributionsTimestamp

public long getContributionsTimestamp()
This method is called as a part of the registry cache validation. The method calculates a number describing the time when the originating contributions (i.e., plugin.xml files in case of the Eclipse registry) were last modified.

The value returned by the method is compared with the timestamp tracked by the registry. If contributions changed since they have been added to the registry (i.e., plugin.xml file was modified since the last run), the value of the getContributionsTimestamp() will change and no longer will be the same as the value tracked by the registry. In this case the cache is considered to be invalid and the registry is going to be re-populated form scratch.

(The word "timestamp" is used very loosely here. In this context, "timestamp" is more likely to be a hash value aggregating a number of actual timestamps from the contributions.)

This method may return 0 to indicate that no time stamp verification is required.

Returns:
a value corresponding to the last mofification time of contributions contained in the registry

getXMLParser

public 
SAXParserFactory getXMLParser()
Returns the parser used by the registry to parse descriptions of extension points and extensions. This method must not return null.

Returns:
this strategy's parser
See Also:
IExtensionRegistry.addContribution(java.io.InputStream, IContributor, boolean, String, ResourceBundle, Object)

Eclipse Platform
Release 3.5

Guidelines for using Eclipse APIs.

Copyright (c) Eclipse contributors and others 2000, 2008. All rights reserved.


 
 
  Published under the terms of the Eclipse Public License Version 1.0 ("EPL") Design by Interspire