Provides interfaces and classes for defining
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:
- 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.
- 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.
- 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.
AbstractTransformerand implement one of the three interfaces listed above. Finally, create another class that implements either
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
Tunableannotation on the get method to allow clients of your code to adjust the parameters using
TunableSetterwithout 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
E>A convenience base class for Transformers.A convenience base class for ValidatableTransformers.CompositeFilter<C, E>Determines how a
CompositeFiltercombines the results of its contained
E>A transformer that transforms its input one element at a time and pushes the results into the given sink.A factory for creating
E>A transformer that decides whether to accept or reject elements.FilterFactory<C, E>A factory for creating
E>A transformer that takes its input altogether, transforms it, and pushes the results into the given sink.A factory for creating
E>A chain of
Transformers with a user-defined name.SubFilterTransformer<C,
Transformerthat contains a
CompositeFilterthat 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
Transformerfactories.Listens for changes to
Transformerparameters.Collects the results of a transformation.TransformerSource<C,
E>Provides a sequence of elements from a context.A marker interface that can be added to any
Transformerto indicate that the transformer may be invalid in certain contexts.A warning message that will appear in the UI when a Transformer is invalid.