public abstract class ContributionFragmentRegistry<T> extends Object
#contributionUpdated(String, Object)
each time you need to store or
remove a contribution. Note that contribution objects that are registered by
your implementation must not be modified. You can see them as
immutable objects - otherwise your local changes will be lost at the next
update event.
To use it you should extends this abstract implementation and implement the abstract methods.
The implementation registry doesn't need to be thread safe since it will be called from synchronized methods.
Also, the contribution object
A simple implementation is:
public class MyRegistry extends ContributionFragmentRegistry<MyContribution> { public Map<String, MyContribution> registry = new HAshMap<String, MyContribution>(); public String getContributionId(MyContribution contrib) { return contrib.getId(); } public void contributionUpdated(String id, MyContribution contrib, MyContribution origContrib) { registry.put(id, contrib); } public void contributionRemoved(String id, MyContribution origContrib) { registry.remove(id); } public MyContribution clone(MyContribution contrib) { MyContribution clone = new MyContribution(contrib.getId()); clone.setSomeProperty(contrib.getSomeProperty()); ... return clone; } public void merge(MyContribution src, MyContribution dst) { dst.setSomeProperty(src.getSomeProperty()); ... } }Since 5.5, if the registry does not support merging of resources, you can just override the method
isSupportingMerge()
and return false, so
that merge(Object, Object)
and Object.clone()
are never called.SimpleContributionRegistry
Modifier and Type | Class and Description |
---|---|
static class |
ContributionFragmentRegistry.Fragment<T> |
static class |
ContributionFragmentRegistry.FragmentList<T> |
Constructor and Description |
---|
ContributionFragmentRegistry() |
Modifier and Type | Method and Description |
---|---|
void |
addContribution(T contrib)
Add a new contribution.
|
abstract T |
clone(T orig)
CLone the given contribution object
|
abstract void |
contributionRemoved(String id,
T origContrib)
All the fragments in the contribution was removed.
|
abstract void |
contributionUpdated(String id,
T contrib,
T newOrigContrib)
Adds or updates a contribution.
|
abstract String |
getContributionId(T contrib)
Returns the contribution ID given the contribution object
|
ContributionFragmentRegistry.FragmentList<T>[] |
getFragments()
Get an array of all contribution fragments
|
boolean |
isSupportingMerge()
Returns true if merge is supported.
|
abstract void |
merge(T src,
T dst)
Merge 'src' into 'dst'.
|
void |
removeContribution(T contrib)
Remove a contribution.
|
void |
removeContribution(T contrib,
boolean useEqualsMethod)
Remove a contribution.
|
public abstract String getContributionId(T contrib)
contrib
- public abstract void contributionUpdated(String id, T contrib, T newOrigContrib)
If the contribution doesn't yet exists then it will be added, otherwise the value will be updated. If the given value is null the existing contribution must be removed.
The second parameter is the contribution that should be updated when
merging, as well as stored and used. This usually represents a clone of
the original contribution or a merge of multiple contribution fragments.
Modifications on this object at application level will be lost on next
contributionUpdated(String, Object, Object)
call on the same
object id: modifications should be done in the
merge(Object, Object)
method.
The last parameter is the new contribution object, unchanged (original) which was neither cloned nor merged. This object should never be modified at application level, because it will be used each time a subsequent merge is done. Also, it never should be stored.
id
- - the id of the contribution that needs to be updatedcontrib
- the updated contribution object thatnewOrigContrib
- - the new, unchanged (original) contribution
fragment that triggered the update.public abstract void contributionRemoved(String id, T origContrib)
The first parameter is the contribution ID that should be remove and the second parameter the original contribution fragment that as unregistered causing the contribution to be removed.
id
- origContrib
- public abstract T clone(T orig)
object
- public abstract void merge(T src, T dst)
src
- the object to copy over the 'dst' objectdst
- this object is modifiedpublic boolean isSupportingMerge()
Hook method to be overridden if merge logics behind Object.clone()
and
merge(Object, Object)
cannot be implemented.
public void addContribution(T contrib)
contrib
- public void removeContribution(T contrib)
Uses standard equality to check for old objects (useEqualsMethod == false).
contrib
- removeContribution(Object, boolean)
public void removeContribution(T contrib, boolean useEqualsMethod)
Equality can be controlled from here.
Contributions come from the runtime that keeps exact instances, so using equality usually makes it possible to remove the exact instance that was contributed by this component (without needing to reference the component name for instance). But when unit-testing, or when registrating contributions that do not come directly from the runtime, regirties need to use the equals method defined on each contribution.
contrib
- the contrib to removeuseEqualsMethod
- a boolean stating that old contributions should
be checked using the equals method instead ofpublic ContributionFragmentRegistry.FragmentList<T>[] getFragments()
Copyright © 2013 Nuxeo SA. All Rights Reserved.