See: Description
Package | Description |
---|---|
org.openidex.search |
The module is useless by itself. It contains an SPI which can be used by modules defining nodes to make the nodes searchable, or to specify how the nodes should be searched, and an API which makes implementation of the SPI easier.
SearchGroup.onStopSearch
Class SearchGroup
now contains method
onStopSearch
, that can be overriden in subclasses
to perform some custom operations that are needed to stop the
search, e.g. terminate internal tasks.
Utils
Class Utils
made public with one public static method
getFileObjectsIterator(SearchInfo si)
. This utility
method returns Iterator
of FileObject
s
for the provided SearchInfo
. This change simplifies
the work with SearchInfo
implementations.
SearchInfo.Files
Added SearchInfo.Files
interface which extends
SearchInfo
interface. It adds method
filesToSearch()
to provide FileObject
s
which should be searched. This change allows to operate FileObject
s
in the search mechanism instead of DataObject
s and
as a result improves search performance.
createCompoundSearchInfo(...)
to class SearchInfoFactory
Compound SearchInfo
is a useful functionality that
has been present in the package since the
SearchInfo
interface had been introduced. It just
was not available from outside the
org.openidex.search
package. This change makes it
available through a public factory method.
SearchInfo
objects contained in Project
s'
lookups are now taken into account by action Find in Projects...
The change is not in the API itself but in the range of its usage.
Before the change, action Find in Projects... did not look
for
SearchInfo
objects – it always searched
projects' SourceGroup
s.
Now the action first checks the
project's Lookup
for presence of a SearchInfo
object. If some
SearchInfo
is present, it is used for the search,
and only if there is no SearchInfo
,
the project's SourceGroup
s are searched.
The SearchInfo API+SPI allows other modules to specify whether and how should nodes they define be searched.
The definition is represented by objects implementing interface
SearchInfo
. To enable searching on a custom node,
a SearchInfo
object must be added to the node's lookup.
In most cases, there is no need to define own class implementing the
interface - one can use factory methods of class
SearchInfoFactory
.
Example:
import org.openide.util.lookup.Lookups; public class MyNode extends AbstractNode { public MyNode(FileObject folder) { super( new MyNodeChildren(folder), Lookups.singleton(SearchInfoFactory.createSearchInfo( folder, true, new FileObjectFilter[] { SearchInfoFactory.VISIBILITY_FILTER }) ); } ... }
One of the factory methods - createSearchInfoBySubnodes(...)
- requires that a reference to the node itself. In this case, it is not
possible to fully define the lookup in the super(...)
statement of the constructor because a reference to the node is not
available until the call of super(...)
returns.
In this case, a special technique must be used:
deprecated-SearchAPI defines interfacesimport org.openide.util.lookup.AbstractLookup; import org.openide.util.lookup.InstanceContent; public class MyNode extends AbstractNode { public MyNode() { this(new InstanceContent()); } public MyNode(InstanceContent ic) { super(new AbstractLookup(ic)); ic.add(SearchInfoFactory.createSearchInfoBySubnodes(this)); } ... }
SearchInfo
, FileObjectFilter
and a factory class SearchInfoFactory
|
|
The sources for the module are in the Apache Git repositories or in the GitHub repositories.
Nothing.
Read more about the implementation in the answers to architecture questions.