Package org.cytoscape.filter.model

Provides interfaces and classes for defining Transformers and Filters. Transformations can be applied to a stream of elements typically provided by a TransformerSource. The output of a transformation is collected into a TransformerSink. There are three main types of Transformers, listed in order of increasing generality:

Filter

This transformer narrows an element stream by deciding whether or not the element makes it to the sink. The binary nature of this transformation allows users to compose multiple filters together into a CompositeFilter, which combines their result using Boolean logic. In the Cytoscape GUI, these transformers appear in the "Filter" section of the "Select" tab.

ElementTransformer

This transformer takes a single element from a specific context as input and decides what elements from that same context make it to the sink. These may or may not include the original element. In the Cytoscape GUI, these transformers appear in the "Chain" section of the "Select" tab.

HolisticTransformer

This transformer takes multiple elements from a specific context as input and decides what elements from that same context make it to the sink. These may or may not include the original element. In the Cytoscape GUI, these transformers appear in the "Chain" section of the "Select" tab.

To define a custom Transformer, extend AbstractTransformer and implement one of the three interfaces listed above. Finally, create another class that implements either FilterFactory, ElementTransformerFactory, or HolisticTransformerFactory, which creates instances of your custom transformer. Finally, register that factory as an OSGi service. If your transformer is parameterized, declare the parameters as get/set method pairs. Use the Tunable annotation on the get method to allow clients of your code to adjust the parameters using TunableSetter without having to expose any API. When the set method is called, your implementation should notify all registered TransformerListeners of the change in parameters (e.g. by calling AbstractTransformer.notifyListeners(). To define a user interface for your transformer, see the view package.

Interface Summary

Interface	Description
CompositeFilter<C,E>	A Filter that computes the set-union or set-intersection of the Filters it contains.
ElementTransformer<C,E>	A transformer that transforms its input one element at a time and pushes the results into the given sink.
ElementTransformerFactory<C,E>	A factory for creating ElementTransformers.
Filter<C,E>	A transformer that decides whether to accept or reject elements.
FilterFactory<C,E>	A factory for creating Filters.
HolisticTransformer<C,E>	A transformer that takes its input altogether, transforms it, and pushes the results into the given sink.
HolisticTransformerFactory<C,E>	A factory for creating HolisticTransformers.
NamedTransformer<C,E>	A chain of Transformers with a user-defined name.
SubFilterTransformer<C,E>	A Transformer that contains a CompositeFilter that it uses to filter its output.
Transformer<C,E>	Transforms a stream of elements from a particular context.
TransformerFactory<C,E>	The base interface for all Transformer factories.
TransformerListener	Listens for changes to Transformer parameters.
TransformerSink<T>	Collects the results of a transformation.
TransformerSource<C,E>	Provides a sequence of elements from a context.
ValidatableTransformer<C,E>	A marker interface that can be added to any Transformer to indicate that the transformer may be invalid in certain contexts.

Class Summary

Class	Description
AbstractTransformer<C,E>	A convenience base class for Transformers.
ValidationWarning	A warning message that will appear in the UI when a Transformer is invalid.

Enum Summary

Enum	Description
CompositeFilter.Type	Determines how a CompositeFilter combines the results of its contained Filters.