SuperKeyedRegistry (Nuxeo 2021.64.6 API Documentation)

java.lang.Object
- org.nuxeo.ecm.automation.core.impl.SuperKeyedRegistry<K,V>

Direct Known Subclasses:

AdapterKeyedRegistry, ClassKeyedRegistry
```
public abstract class SuperKeyedRegistry<K,V>
extends Object
```
A registry which is inheriting values from super keys. The super key relation is defined by the derived classes by overriding getSuperKeys(Object) method. The registry is thread safe and is optimized for lookups. A concurrent cache is dynamically updated when a value is retrieved from a super entry. The cache is removed each time a modification is made on the registry using put(Object, Object) or remove(Object) methods. Thus, for maximum performance you need to avoid modifying the registry after lookups were done: at application startup build the registry, at runtime perform lookups, at shutdown remove entries. The root key is passed in the constructor and is used to stop looking in super entries.

Author:

Bogdan Stefanescu

Field Summary

Fields
Modifier and Type Field Description

protected ConcurrentMap<K,Object> lookup
the cache map used for lookups.

protected Map<K,V> registry

Constructor Summary

Constructors
Constructor Description

SuperKeyedRegistry()

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`flushCache()`
`V`	`get(K key)`
`protected abstract List<K>`	`getSuperKeys(K key)`
`protected boolean`	`isCachingEnabled(K key)`	Override this in order to disable caching some specific keys.
`protected abstract boolean`	`isRoot(K key)`
`void`	`put(K key, V value)`
`V`	`remove(K key)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- registry
```
protected Map<K,V> registry
```
- lookup
```
protected volatile ConcurrentMap<K,Object> lookup
```
  the cache map used for lookups. Object is used for the value to be able to insert NULL values.

Constructor Detail
- SuperKeyedRegistry
```
public SuperKeyedRegistry()
```

Method Detail

put

public void put(K key,
                V value)

remove
```
public V remove(K key)
```

flushCache
```
public void flushCache()
```

isRoot

protected abstract boolean isRoot(K key)

getSuperKeys

protected abstract List<K> getSuperKeys(K key)

isCachingEnabled
```
protected boolean isCachingEnabled(K key)
```
Override this in order to disable caching some specific keys. For example when using java classes as keys you may want to avoid caching proxy classes. The default is to return true. (cache is enabled)

get
```
public V get(K key)
```