org.openbase.jul.storage.registry

Class MockRegistrySandbox<KEY,ENTRY extends Identifiable<KEY>,MAP extends Map<KEY,ENTRY>,R extends Registry<KEY,ENTRY>>

java.lang.Object

org.openbase.jul.storage.registry.MockRegistrySandbox<KEY,ENTRY,MAP,R>

Type Parameters:

KEY -

ENTRY -

MAP -

R -

All Implemented Interfaces:

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

public class MockRegistrySandbox<KEY,ENTRY extends Identifiable<KEY>,MAP extends Map<KEY,ENTRY>,R extends Registry<KEY,ENTRY>>
extends Object
implements RegistrySandbox<KEY,ENTRY,MAP,R>

Author:

Divine Threepwood

Nested Class Summary

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

Shutdownable.ShutdownDeamon

Field Summary

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

TYPE_FIELD_NAME

Constructor Summary

Constructors

Constructor and Description
MockRegistrySandbox(Registry<KEY,ENTRY> registry)

Method Summary

Modifier and Type	Method and Description
void	addDependencyObserver(org.openbase.jul.pattern.Observer<Map<KEY,ENTRY>> observer)
void	addObserver(org.openbase.jul.pattern.Observer<Map<KEY,ENTRY>> observer)
void	checkWriteAccess()
void	clear()
boolean	contains(ENTRY entry)
boolean	contains(KEY key)
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.
String	getName() Method returns the name of this registry.
Map<KEY,ENTRY>	getValue()
Future<Map<KEY,ENTRY>>	getValueFuture()
boolean	isConsistent()
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()
boolean	isValueAvailable()
ENTRY	load(ENTRY entry)
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,R> consistencyHandler)
ENTRY	remove(ENTRY entry)
ENTRY	remove(KEY entry)
void	removeConsistencyHandler(ConsistencyHandler<KEY,ENTRY,MAP,R> consistencyHandler)
void	removeDependencyObserver(org.openbase.jul.pattern.Observer<Map<KEY,ENTRY>> observer)
void	removeObserver(org.openbase.jul.pattern.Observer<Map<KEY,ENTRY>> observer)
void	replaceInternalMap(Map<KEY,ENTRY> map)
void	shutdown()
int	size() Method returns the amount of registry entries.
void	sync(MAP map)
String	toString()
boolean	tryLockRegistry() Try to acquire the write lock for this registry.
void	unlockRegistry() Unlock the write lock of the registry.
ENTRY	update(ENTRY entry)
void	waitForValue(long timeout, TimeUnit timeUnit)

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

getLatestValue, waitForValue

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

registerShutdownHook, registerShutdownHook

Constructor Detail

MockRegistrySandbox

public MockRegistrySandbox(Registry<KEY,ENTRY> registry)

Method Detail

toString

public String toString()

Overrides:

toString in class Object

register

public ENTRY register(ENTRY entry)
               throws CouldNotPerformException

Description copied from interface: Registry

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.

update

public ENTRY update(ENTRY entry)
             throws CouldNotPerformException

Specified by:

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

Throws:

CouldNotPerformException

sync

public void sync(MAP map)

Specified by:

sync in interface RegistrySandbox<KEY,ENTRY extends Identifiable<KEY>,MAP extends Map<KEY,ENTRY>,R extends Registry<KEY,ENTRY>>

registerConsistencyHandler

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

Specified by:

registerConsistencyHandler in interface RegistrySandbox<KEY,ENTRY extends Identifiable<KEY>,MAP extends Map<KEY,ENTRY>,R extends Registry<KEY,ENTRY>>

Throws:

CouldNotPerformException

removeConsistencyHandler

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

Specified by:

removeConsistencyHandler in interface RegistrySandbox<KEY,ENTRY extends Identifiable<KEY>,MAP extends Map<KEY,ENTRY>,R extends Registry<KEY,ENTRY>>

Throws:

CouldNotPerformException

remove

public ENTRY remove(ENTRY entry)
             throws CouldNotPerformException

Specified by:

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

Throws:

CouldNotPerformException

remove

public ENTRY remove(KEY entry)
             throws CouldNotPerformException

Specified by:

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

Throws:

CouldNotPerformException

get

public ENTRY get(KEY key)
          throws CouldNotPerformException

Specified by:

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

Throws:

CouldNotPerformException

getEntries

public List<ENTRY> getEntries()

Description copied from interface: Registry

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

contains

public boolean contains(ENTRY entry)
                 throws CouldNotPerformException

Specified by:

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

Throws:

CouldNotPerformException

contains

public boolean contains(KEY key)
                 throws CouldNotPerformException

Specified by:

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

Throws:

CouldNotPerformException

clear

public void clear()
           throws CouldNotPerformException

Specified by:

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

Throws:

CouldNotPerformException

checkWriteAccess

public void checkWriteAccess()
                      throws RejectedException

Specified by:

checkWriteAccess in interface Writable

Throws:

RejectedException

isReadOnly

public boolean isReadOnly()

Specified by:

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

replaceInternalMap

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

Specified by:

replaceInternalMap in interface RegistrySandbox<KEY,ENTRY extends Identifiable<KEY>,MAP extends Map<KEY,ENTRY>,R extends Registry<KEY,ENTRY>>

size

public int size()

Description copied from interface: Registry

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.

getName

public String getName()

Description copied from interface: Registry

Method returns the name of this registry.

Specified by:

getName in interface NameProvider

Specified by:

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

Returns:

the name as string.

load

public ENTRY load(ENTRY entry)
           throws CouldNotPerformException

Specified by:

load in interface RegistrySandbox<KEY,ENTRY extends Identifiable<KEY>,MAP extends Map<KEY,ENTRY>,R extends Registry<KEY,ENTRY>>

Throws:

CouldNotPerformException

isConsistent

public boolean isConsistent()

Specified by:

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

addObserver

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

Specified by:

addObserver in interface org.openbase.jul.pattern.Observable<Map<KEY,ENTRY extends Identifiable<KEY>>>

removeObserver

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

Specified by:

removeObserver in interface org.openbase.jul.pattern.Observable<Map<KEY,ENTRY extends Identifiable<KEY>>>

getValue

public Map<KEY,ENTRY> getValue()
                        throws NotAvailableException

Specified by:

getValue in interface org.openbase.jul.pattern.Observable<Map<KEY,ENTRY extends Identifiable<KEY>>>

Throws:

NotAvailableException

isValueAvailable

public boolean isValueAvailable()

Specified by:

isValueAvailable in interface org.openbase.jul.pattern.Observable<Map<KEY,ENTRY extends Identifiable<KEY>>>

shutdown

public void shutdown()

Specified by:

shutdown in interface Shutdownable

isSandbox

public boolean isSandbox()

Specified by:

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

isEmpty

public boolean isEmpty()

Description copied from interface: Registry

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.

isReady

public boolean isReady()

Description copied from interface: Registry

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.

waitForValue

public void waitForValue(long timeout,
                         TimeUnit timeUnit)
                  throws NotAvailableException,
                         InterruptedException

Specified by:

waitForValue in interface org.openbase.jul.pattern.Observable<Map<KEY,ENTRY extends Identifiable<KEY>>>

Throws:

NotAvailableException

InterruptedException

tryLockRegistry

public boolean tryLockRegistry()
                        throws RejectedException

Description copied from interface: Registry

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.

unlockRegistry

public void unlockRegistry()

Description copied from interface: Registry

Unlock the write lock of the registry.

Specified by:

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

getValueFuture

public Future<Map<KEY,ENTRY>> getValueFuture()

Specified by:

getValueFuture in interface org.openbase.jul.pattern.Observable<Map<KEY,ENTRY extends Identifiable<KEY>>>

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

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>>

recursiveTryLockRegistry

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

Description copied from interface: Registry

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.