|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
public interface ProjectionContext
Interface that defines the projection between original features and projected features.
Note: Implementing this interface is not trivial. It is assumed that if you are implementing this, you are a power user or developer. All method documentation is aimed at those groups, not users.
This interface directly specifies a core set of methods that a ProjectionContext implementation must provide. These are needed to allow ProjectedFeatureHolder to connect to the context and for projected features to be implemented on top of the context.
All of these methods are implemented by @link ReparentContext, and it would be unwise to try to implement them again independently, but it's a free world and this is, after all, an interface. Some of the methods have contracts that are a little tricky to implement without some thought.
The methods projectFeature() and revertFeature() should be used as your exclusive means for converting features between the two views. If you have some utility method that produces projections, it /must/ be exclusively invoked from projectFeature(). Likewise, although it is tempting to cast the projected feature to Projection, and then to call getProjectedFeature(), this will break the encapsulation of the context. The only method that should do this cast is revertFeature().
Projection methods are used by the projection engine to map projected and unprojected feature properties. They are not declared directly in this interface, but should be supplied by implementations. They will be picked up by the projection engine using introspection, and connected to projected feature instances by run-time code generation.
So that the projection methods can be found, they should all follow the
same template. If a feature interface has a property foo
of
type Bar
, then the feature interface will have the two methods:
The projection engine will be looking for a pair of methods in the context
named:
public void setFoo(Bar bar)
public Bar getFoo()
public Bar projectFoo(Bar bar);
public Bar revertFoo(Bar bar);
If these methods are found, then the projected feature will have get/set
methods that resemble:
If these methods are not found, then the projected feature will have get/set
methods that resembl:
public void setFoo(Bar bar) {
getViewedFeature().setFoo(getContext().revertFoo(bar));
}
public Bar getFoo() {
return getContext().projectFoo(getViewedFeature().getFoo());
}
public void setFoo(Bar bar) {
getViewedFeature().setFoo(bar);
}
public Bar getFoo() {
return getContext().getViewedFeature().getFoo();
}
Only those methods defined by the interface of the unprojected feature will be mapped accross. So, if the context provides projectors for the strand property but the feature is not a stranded feature, it's projection will not have a strand property.
origLoc
to your new
location yourLoc
, be sure to make sure the decorations match.
The easiest way to do this is return
origLoc.newInstance(yourLoc)
.Method Summary | |
---|---|
void |
addChangeListener(Feature projFeat,
ChangeListener cl,
ChangeType ct)
Add a ChangeListener to a projected feature. |
Feature |
createFeature(Feature.Template projTempl)
Create a projected feature with properties matching the template. |
Feature |
createFeature(Feature projParent,
Feature.Template projTempl)
Create a new projected feature. |
FeatureHolder |
getParent(Feature projFeat)
|
Sequence |
getSequence(Feature projFeat)
Get the sequence for a feature. |
FeatureHolder |
getUnprojectedFeatures()
Get the features before projection. |
FeatureHolder |
projectChildFeatures(Feature feature,
FeatureHolder parent)
Project all features that are children of feature so that they become children of parent. |
Feature |
projectFeature(Feature feat)
Project a single feature. |
FeatureHolder |
projectFeatures(FeatureHolder features)
Project all of the features in a FeatureHolder. |
FeatureFilter |
projectFilter(FeatureFilter filt)
Transform a filter on unprojected features so that it applies to projected features. |
void |
removeChangeListener(Feature projFeat,
ChangeListener cl,
ChangeType ct)
Remove a ChangeListener from a projected feature. |
void |
removeFeature(Feature dyingChild)
Remove the dying child. |
void |
removeFeature(Feature projParent,
Feature dyingChild)
Remove the dying child. |
Feature |
revertFeature(Feature projFeat)
Unproject a feature. |
FeatureFilter |
revertFilter(FeatureFilter filt)
Transform a filter on projected features so that it applies to unprojected features. |
Method Detail |
---|
FeatureHolder getUnprojectedFeatures()
If you are projecting all the features in some feature holder, that is what this method should return.
FeatureHolder getParent(Feature projFeat)
Sequence getSequence(Feature projFeat)
This will be the return value of projFeat.getParent()
.
projFeat
- the projected Feature
Feature projectFeature(Feature feat)
feat
- the Feature to project
FeatureHolder projectFeatures(FeatureHolder features)
Warning: The results of calling this method for features that are not in getUnprojectedFeatures() is not specified by this API, but it is reasonable to assume that bad things will happen.
features
- the FeatureHolder containing the features to project
Feature revertFeature(Feature projFeat)
This is the inverse opperation to @link projectFeature().
Note: The result of calling this method for a feature that is not projected through this context is not specified by this API, but it is reasonable to assume that bad things will happen.
projFeat
- the Feature to un-project
FeatureFilter projectFilter(FeatureFilter filt)
filt
- the FeatureFilter to transform
FeatureFilter revertFilter(FeatureFilter filt)
filt
- the FeatureFilter to transform
FeatureHolder projectChildFeatures(Feature feature, FeatureHolder parent)
feature
- the Feature to project all children ofparent
- the new parent feature holder
Feature createFeature(Feature.Template projTempl) throws BioException, ChangeVetoException
You will probably implement this by delegating to the unprojected feature holder. It is imperative that the template properties are unprojected first so that when the newly created feature is projected, the properties match up.
Not every projection context has fully reversible semantics. Use your discression and come up with a reasonable plan that causes least supprise to the user.
projTempl
- the Feature.Template to instantiate
BioException
- if there was a problem instantiating the template
ChangeVetoException
- if the feature creation was vetoedvoid removeFeature(Feature dyingChild) throws BioException, ChangeVetoException
dyingChild
- a projected feature to remove
BioException
- if there is an error removing the feature
ChangeVetoException
- if the removal of the feature was vetoedFeature createFeature(Feature projParent, Feature.Template projTempl) throws BioException, ChangeVetoException
See the notes for @link createFeature(Feature.Template) for implementation advice.
projParent
- the parent for the newly created featureprojTempl
- the Feature.Template specifying the new feature
BioException
- if there was a problem creating the feature
ChangeVetoException
- if the creation of the feature was vetoedvoid removeFeature(Feature projParent, Feature dyingChild) throws ChangeVetoException, BioException
projParent
- the projected parent FeaturedyingChild
- the child Feature to remove
ChangeVetoException
- if the removal of the feature was vetoed
BioException
void addChangeListener(Feature projFeat, ChangeListener cl, ChangeType ct)
projFeat
- the projected Feature to add the listener forcl
- the ChangeListener to addct
- the ChangeType to register it forvoid removeChangeListener(Feature projFeat, ChangeListener cl, ChangeType ct)
projFeat
- the projected Feature to remove the listener forcl
- the ChangeListener to removect
- the ChangeType it is registered for
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |