org.openbase.jul.storage.registry

Class AbstractRegistry<KEY,ENTRY extends Identifiable<KEY>,MAP extends Map<KEY,ENTRY>,REGISTRY extends Registry<KEY,ENTRY>,PLUGIN extends RegistryPlugin<KEY,ENTRY,REGISTRY>>

java.lang.Object

org.openbase.jul.pattern.AbstractObservable<T>

org.openbase.jul.pattern.ObservableImpl<Map<KEY,ENTRY>>

org.openbase.jul.storage.registry.AbstractRegistry<KEY,ENTRY,MAP,REGISTRY,PLUGIN>

Type Parameters:

KEY - EntryKey

ENTRY - EntryType

MAP - RegistryEntryMap

REGISTRY - Registry

PLUGIN - RegistryPluginType

All Implemented Interfaces:

NameProvider, Shutdownable, Writable, org.openbase.jul.pattern.Observable<Map<KEY,ENTRY>>, Registry<KEY,ENTRY>

Direct Known Subclasses:

FileSynchronizedRegistryImpl, RegistryImpl, RegistrySandboxImpl, RemoteRegistry

public class AbstractRegistry<KEY,ENTRY extends Identifiable<KEY>,MAP extends Map<KEY,ENTRY>,REGISTRY extends Registry<KEY,ENTRY>,PLUGIN extends RegistryPlugin<KEY,ENTRY,REGISTRY>>
extends org.openbase.jul.pattern.ObservableImpl<Map<KEY,ENTRY>>
implements Registry<KEY,ENTRY>

Author:

Divine Threepwood

Nested Class Summary

Nested classes/interfaces inherited from interface org.openbase.jul.iface.Shutdownable

Shutdownable.ShutdownDeamon

Field Summary

Fields

Modifier and Type	Field and Description
protected boolean	consistent
protected org.slf4j.Logger	logger
protected RegistryPluginPool<KEY,ENTRY,PLUGIN,REGISTRY>	pluginPool
protected RegistrySandbox<KEY,ENTRY,MAP,REGISTRY>	sandbox

Fields inherited from class org.openbase.jul.pattern.ObservableImpl

VALUE_LOCK

Fields inherited from class org.openbase.jul.pattern.AbstractObservable

latestValueHash, observers, unchangedValueFilter

Fields inherited from interface org.openbase.jul.iface.provider.NameProvider

TYPE_FIELD_NAME

Constructor Summary

Constructors

Constructor and Description
AbstractRegistry(MAP entryMap)
AbstractRegistry(MAP entryMap, RegistryPluginPool<KEY,ENTRY,PLUGIN,REGISTRY> pluginPool)

Method Summary

Modifier and Type	Method and Description
void	addDependencyObserver(org.openbase.jul.pattern.Observer<Map<KEY,ENTRY>> observer)
protected void	afterConsistencyCheck() Can be overwritten for further registry actions scheduled after consistency checks.
int	checkConsistency()
void	checkWriteAccess()
void	clear()
boolean	contains(ENTRY entry)
boolean	contains(KEY key)
protected void	finishTransaction()
ENTRY	get(KEY key)
List<ENTRY>	getEntries() Copies all entries into a list.
Map<KEY,ENTRY>	getEntryMap() An unmodifiable map of the current entry map.
Class	getEntryMapClass()
String	getName() Method returns the name of this registry.
void	info(String message) Deprecated. please use method log(String message).
boolean	isBusy()
boolean	isBusyByCurrentThread()
boolean	isConsistent()
protected boolean	isDependingOnConsistentRegistries() If this registry depends on other registries, this method can be used to tell this registry if all depending registries are consistent.
boolean	isEmpty() Return true if this registry does not contain any entries.
boolean	isReadOnly()
boolean	isReady() This method checks if the registry is not handling any tasks or notification and is currently consistent.
boolean	isSandbox()
protected boolean	isWriteLockedByCurrentThread()
ENTRY	load(ENTRY entry)
protected void	lock() Blocks until this registries write lock and the write locks of all registries this one depends on are acquired.
protected void	log(String message) This method can be used to log registry log messages which are only printed for the origin registry.
protected void	log(String message, LogLevel logLevel) This method can be used to log registry log messages which are only printed for the origin registry.
protected void	log(String message, LogLevel logLevel, Throwable throwable) This method can be used to log registry log messages which are only printed for the origin registry.
protected void	notifyObservers()
boolean	recursiveTryLockRegistry(Set<Registry> lockedRegistries) Try to acquire the write lock for this registry and the registries it depends on recursively.
ENTRY	register(ENTRY entry) Method registers the given entry.
void	registerConsistencyHandler(ConsistencyHandler<KEY,ENTRY,MAP,REGISTRY> consistencyHandler)
void	registerDependency(Registry registry) If this registry depends on other registries, this method can be used to tell this registry all depending registries.
void	registerPlugin(PLUGIN plugin) Method can be used to register any compatible registry plugin for this registry.
ENTRY	remove(ENTRY entry)
ENTRY	remove(KEY key)
void	removeAllDependencies() Removal of all registered registry dependencies in the reversed order in which they where added.
void	removeConsistencyHandler(ConsistencyHandler<KEY,ENTRY,MAP,REGISTRY> consistencyHandler)
void	removeDependency(Registry registry) This method allows the removal of a registered registry dependency.
void	removeDependencyObserver(org.openbase.jul.pattern.Observer<Map<KEY,ENTRY>> observer)
void	replaceInternalMap(Map<KEY,ENTRY> map) Replaces the internal registry map by the given one.
void	replaceInternalMap(Map<KEY,ENTRY> map, boolean finishTransaction) Replaces the internal registry map by the given one.
void	setName(String name) Method defines the name of this registry.
protected <S extends AbstractRegistry<KEY,ENTRY,MAP,REGISTRY,PLUGIN> & RegistrySandbox<KEY,ENTRY,MAP,REGISTRY>> void	setupSandbox(S sandbox)
void	shutdown()
int	size() Method returns the amount of registry entries.
ENTRY	superRemove(ENTRY entry)
String	toString()
boolean	tryLockRegistry() Try to acquire the write lock for this registry.
protected void	unlock()
void	unlockRegistry() Unlock the write lock of the registry.
ENTRY	update(ENTRY entry)
protected KEY	verifyID(ENTRY entry)
protected KEY	verifyID(KEY key)

Methods inherited from class org.openbase.jul.pattern.ObservableImpl

applyValueUpdate, getValue, getValueFuture, isValueAvailable, waitForValue

Methods inherited from class org.openbase.jul.pattern.AbstractObservable

addObserver, isNotificationInProgess, notifyObservers, notifyObservers, removeObserver, setExecutorService, setHashGenerator, waitUntilNotificationIsFinished

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.openbase.jul.storage.registry.Registry

get, isEmtpy

Methods inherited from interface org.openbase.jul.iface.Writable

isWritable

Methods inherited from interface org.openbase.jul.pattern.Observable

addObserver, getLatestValue, getValue, getValueFuture, isValueAvailable, removeObserver, waitForValue, waitForValue

Methods inherited from interface org.openbase.jul.iface.Shutdownable

registerShutdownHook, registerShutdownHook

Field Detail

logger

protected final org.slf4j.Logger logger

pluginPool

protected final RegistryPluginPool<KEY,ENTRY extends Identifiable<KEY>,PLUGIN extends RegistryPlugin<KEY,ENTRY,REGISTRY>,REGISTRY extends Registry<KEY,ENTRY>> pluginPool

sandbox

protected RegistrySandbox<KEY,ENTRY extends Identifiable<KEY>,MAP extends Map<KEY,ENTRY>,REGISTRY extends Registry<KEY,ENTRY>> sandbox

consistent

protected boolean consistent

Constructor Detail

AbstractRegistry

public AbstractRegistry(MAP entryMap)
                 throws InstantiationException

Throws:

InstantiationException

AbstractRegistry

public AbstractRegistry(MAP entryMap,
                        RegistryPluginPool<KEY,ENTRY,PLUGIN,REGISTRY> pluginPool)
                 throws InstantiationException

Throws:

InstantiationException

Method Detail

setupSandbox

protected <S extends AbstractRegistry<KEY,ENTRY,MAP,REGISTRY,PLUGIN> & RegistrySandbox<KEY,ENTRY,MAP,REGISTRY>> void setupSandbox(S sandbox)
                                                                                                                           throws CouldNotPerformException

Throws:

CouldNotPerformException

register

public ENTRY register(ENTRY entry)
               throws CouldNotPerformException

Method registers the given entry.

Specified by:

register in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

Parameters:

entry - the new entry to register which is not yet included in the registry

Returns:

the registered entry updated by all consistency checks this registry provides.

Throws:

CouldNotPerformException - is thrown if the given entry is not valid, already registered or something else went wrong during the registration.

load

public ENTRY load(ENTRY entry)
           throws CouldNotPerformException

Throws:

CouldNotPerformException

update

public ENTRY update(ENTRY entry)
             throws CouldNotPerformException

Specified by:

update in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

Parameters:

entry -

Returns:

Throws:

CouldNotPerformException

remove

public ENTRY remove(KEY key)
             throws CouldNotPerformException

Specified by:

remove in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

Parameters:

key -

Returns:

Throws:

CouldNotPerformException

remove

public ENTRY remove(ENTRY entry)
             throws CouldNotPerformException

Specified by:

remove in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

Parameters:

entry -

Returns:

Throws:

CouldNotPerformException

superRemove

public ENTRY superRemove(ENTRY entry)
                  throws CouldNotPerformException

Throws:

CouldNotPerformException

get

public ENTRY get(KEY key)
          throws CouldNotPerformException

Specified by:

get in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

Parameters:

key -

Returns:

Throws:

CouldNotPerformException

getEntries

public List<ENTRY> getEntries()
                       throws CouldNotPerformException

Copies all entries into a list.

Specified by:

getEntries in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

Returns:

a list with all values of the entry map

Throws:

CouldNotPerformException - if something fails

getEntryMap

public Map<KEY,ENTRY> getEntryMap()

Description copied from interface: Registry

An unmodifiable map of the current entry map.

Specified by:

getEntryMap in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

Returns:

the current entry map of the registry but unmodifiable

size

public int size()

Method returns the amount of registry entries.

Specified by:

size in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

Returns:

the count of entries as integer.

isEmpty

public boolean isEmpty()

Return true if this registry does not contain any entries.

Specified by:

isEmpty in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

Returns:

is true if the registry is empty.

contains

public boolean contains(ENTRY entry)
                 throws CouldNotPerformException

Specified by:

contains in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

Parameters:

entry -

Returns:

Throws:

CouldNotPerformException

contains

public boolean contains(KEY key)
                 throws CouldNotPerformException

Specified by:

contains in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

Parameters:

key -

Returns:

Throws:

CouldNotPerformException

clear

public void clear()
           throws CouldNotPerformException

Specified by:

clear in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

Throws:

CouldNotPerformException

replaceInternalMap

public void replaceInternalMap(Map<KEY,ENTRY> map)
                        throws CouldNotPerformException

Replaces the internal registry map by the given one.

Use with care!

Parameters:

map -

Throws:

CouldNotPerformException

getEntryMapClass

public Class getEntryMapClass()

replaceInternalMap

public void replaceInternalMap(Map<KEY,ENTRY> map,
                               boolean finishTransaction)
                        throws CouldNotPerformException

Replaces the internal registry map by the given one.

Use with care!

Parameters:

map -

finishTransaction - is true the registry transaction will be verified.

Throws:

CouldNotPerformException

checkWriteAccess

public void checkWriteAccess()
                      throws RejectedException

Specified by:

checkWriteAccess in interface Writable

Throws:

RejectedException

isDependingOnConsistentRegistries

protected boolean isDependingOnConsistentRegistries()

If this registry depends on other registries, this method can be used to tell this registry if all depending registries are consistent.

Returns:

The method returns should return false if at least one depending registry is not consistent!

registerDependency

public void registerDependency(Registry registry)
                        throws CouldNotPerformException

If this registry depends on other registries, this method can be used to tell this registry all depending registries. For instance this is used to switch to read only mode in case one depending registry is not consistent. Consistency checks are skipped as well if at least one depending registry is not consistent.

Parameters:

registry - the dependency of these registry.

Throws:

CouldNotPerformException

removeDependency

public void removeDependency(Registry registry)
                      throws CouldNotPerformException

This method allows the removal of a registered registry dependency.

Parameters:

registry - the dependency to remove.

Throws:

CouldNotPerformException

removeAllDependencies

public void removeAllDependencies()

Removal of all registered registry dependencies in the reversed order in which they where added.

isReadOnly

public boolean isReadOnly()

Specified by:

isReadOnly in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

Returns:

notifyObservers

protected final void notifyObservers()

verifyID

protected KEY verifyID(ENTRY entry)
                throws VerificationFailedException

Throws:

VerificationFailedException

verifyID

protected KEY verifyID(KEY key)
                throws VerificationFailedException

Throws:

VerificationFailedException

registerConsistencyHandler

public void registerConsistencyHandler(ConsistencyHandler<KEY,ENTRY,MAP,REGISTRY> consistencyHandler)
                                throws CouldNotPerformException

Throws:

CouldNotPerformException

removeConsistencyHandler

public void removeConsistencyHandler(ConsistencyHandler<KEY,ENTRY,MAP,REGISTRY> consistencyHandler)
                              throws CouldNotPerformException

Throws:

CouldNotPerformException

checkConsistency

public final int checkConsistency()
                           throws CouldNotPerformException

Throws:

CouldNotPerformException

afterConsistencyCheck

protected void afterConsistencyCheck()
                              throws CouldNotPerformException

Can be overwritten for further registry actions scheduled after consistency checks.

Don't forgett to pass-througt the call to the super class. (super.afterConsistencyCheck())

Throws:

CouldNotPerformException - is thrown if any plugin afterConsistencyCheck fails.

finishTransaction

protected void finishTransaction()
                          throws CouldNotPerformException

Throws:

CouldNotPerformException

isConsistent

public boolean isConsistent()

Specified by:

isConsistent in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

Returns:

isReady

public boolean isReady()

This method checks if the registry is not handling any tasks or notification and is currently consistent.

Specified by:

isReady in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

Returns:

Returns true if this registry is consistent and not busy.

shutdown

public void shutdown()

Specified by:

shutdown in interface Shutdownable

Overrides:

shutdown in class org.openbase.jul.pattern.AbstractObservable<Map<KEY,ENTRY extends Identifiable<KEY>>>

registerPlugin

public void registerPlugin(PLUGIN plugin)
                    throws CouldNotPerformException,
                           InterruptedException

Method can be used to register any compatible registry plugin for this registry.

Parameters:

plugin - the plugin to register.

Throws:

CouldNotPerformException - is thrown in case the plugin could not be registered.

InterruptedException - is thrown if the thread is externally interrupted.

getName

public String getName()

Method returns the name of this registry. In case the name was never set for this registry the simple class name of the registry class is returned instead.

Specified by:

getName in interface NameProvider

Specified by:

getName in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

Returns:

the name of the registry.

setName

public void setName(String name)

Method defines the name of this registry.

Parameters:

name -

isSandbox

public boolean isSandbox()

Specified by:

isSandbox in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

Returns:

log

protected void log(String message)

This method can be used to log registry log messages which are only printed for the origin registry. Info messages of a sandbox instance are redirected to the debug channel.

Parameters:

message - the info message to print as string.

log

protected void log(String message,
                   LogLevel logLevel,
                   Throwable throwable)

This method can be used to log registry log messages which are only printed for the origin registry. Info messages of a sandbox instance are redirected to the debug channel.

Parameters:

message - the info message to print as string.

logLevel - the log level to log the message.

throwable - the cause of the message.

log

protected void log(String message,
                   LogLevel logLevel)

This method can be used to log registry log messages which are only printed for the origin registry. Info messages of a sandbox instance are redirected to the debug channel.

Parameters:

message - the info message to print as string.

logLevel - the log level to log the message.

info

@Deprecated
public void info(String message)

Deprecated. please use method log(String message).

This method can be used to log registry info messages which are only printed for the origin registry. Info messages of a sandbox instance are redirected to the debug channel.

Parameters:

message - the info message to print as string.

toString

public String toString()

Overrides:

toString in class org.openbase.jul.pattern.AbstractObservable<Map<KEY,ENTRY extends Identifiable<KEY>>>

Returns:

lock

protected void lock()
             throws CouldNotPerformException

Blocks until this registries write lock and the write locks of all registries this one depends on are acquired.

Throws:

CouldNotPerformException - Is thrown if the process gets interrupted. Additionally the interrupt flag is restored.

isBusy

public boolean isBusy()

isBusyByCurrentThread

public boolean isBusyByCurrentThread()

unlock

protected void unlock()

isWriteLockedByCurrentThread

protected boolean isWriteLockedByCurrentThread()

tryLockRegistry

public boolean tryLockRegistry()
                        throws RejectedException

Try to acquire the write lock for this registry. If this method returns true then this thread now holds the write lock for this registry. If it returns false then the lock could not currently be acquired.

Specified by:

tryLockRegistry in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

Returns:

If the lock could be acquired.

Throws:

RejectedException - If the registry does not support to be locked externally which is for example the case for remote registries.

recursiveTryLockRegistry

public boolean recursiveTryLockRegistry(Set<Registry> lockedRegistries)
                                 throws RejectedException

Try to acquire the write lock for this registry and the registries it depends on recursively. This method returns true if all locks could be acquired and false if at least one lock could not be acquired. In any case the set lockedRegistries contains any locked registry afterwards. So if the method returns false any registry inside this set should be unlocked before trying it again to prevent dead locks. Additionally this method should only be performed while already holding the write lock for the registry. Else it can happen that a thread that tries to recursively lock the same registry by using the same set as another thread thinks that he acquired it even though the other thread is currently in the process of acquiring it.

Specified by:

recursiveTryLockRegistry in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

Parameters:

lockedRegistries - Set of already locked registries. Should be given empty to this method and will contain all locked registries afterwards.

Returns:

If all registries could be locked.

Throws:

RejectedException - If the registry does not support to be locked externally which is for example the case for remote registries.

unlockRegistry

public void unlockRegistry()

Unlock the write lock of the registry.

Specified by:

unlockRegistry in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

addDependencyObserver

public void addDependencyObserver(org.openbase.jul.pattern.Observer<Map<KEY,ENTRY>> observer)

Specified by:

addDependencyObserver in interface Registry<KEY,ENTRY extends Identifiable<KEY>>

removeDependencyObserver

public void removeDependencyObserver(org.openbase.jul.pattern.Observer<Map<KEY,ENTRY>> observer)

Specified by:

removeDependencyObserver in interface Registry<KEY,ENTRY extends Identifiable<KEY>>