public class WordMatch extends FinderFactory.AbstractFinder implements PropertyChangeListener
found
Constructor and Description |
---|
WordMatch(EditorUI editorUI)
Construct new word match over given view manager
|
Modifier and Type | Method and Description |
---|---|
void |
clear()
Clear word matching, so that it forgots the remembered
matching words.
|
int |
find(int bufferStartPos,
char[] buffer,
int offset1,
int offset2,
int reqPos,
int limitPos)
This is the most important function in finder.
|
String |
getMatchWord(int startPos,
boolean forward)
Find next matching word and replace it on current cursor position
|
String |
getPreviousWord() |
void |
propertyChange(PropertyChangeEvent evt) |
void |
reset()
Reset this finder before each search
|
String |
toString() |
isFound
public WordMatch(EditorUI editorUI)
public void propertyChange(PropertyChangeEvent evt)
propertyChange
in interface PropertyChangeListener
public void clear()
public void reset()
reset
in interface Finder
reset
in class FinderFactory.AbstractFinder
public String getMatchWord(int startPos, boolean forward)
forward
- in which direction should the search be donepublic String getPreviousWord()
public int find(int bufferStartPos, char[] buffer, int offset1, int offset2, int reqPos, int limitPos)
Finder
int offset = reqPos - bufferStartPos;
while (offset < offset2) {
if (buffer[offset]-meets-condition) {
set-found-flag
return offset + bufferStartPos;
}
offset++;
}
return offset + bufferStartPos;
Bakward search follows:
int offset = reqPos - bufferStartPos
while (offset >= offset1) {
if (buffer[offset]-meets-condition) {
set-found-flag
return offset + bufferStartPos;
}
offset--;
}
return offset + bufferStartPos;
Caution! Nothing can be written to the data comming in buffer to
find()
method because of performance reasons
these are primary document data, not a copy.
Buffer is always guaranteed to have at least one char - it is
char standing at reqPos. However there can be calls to find()
when there will be only that one character, so find()
must
must be prepared for this.
Unlike calling DocCache.find()
the offset1 < offset2 even
for backward searches.find
in interface Finder
bufferStartPos
- begining position of the buffer (not search area).buffer
- buffer with chars to be searchedoffset1
- offset of begining of searchable area in buffer.
No searching below this offset can be performed.offset2
- offset of end of searchable area in buffer.
No searching beyond this offset can be performed.reqPos
- required position. Initially it is the begining
search position requested by caller. In subsequent calls
it is the same value as returned from previous call
to find()
method.limitPos
- is filled with position beyond which search cannot go.
(i.e. forward: pos < limitPos and backward: pos >= limitPos)
Some finders i.e. finder that tries to find some word with
whole-words-only flag turned on can benefit
from this information. If the searched word is at the very end of
the document the finder wouldn't normally find it as it would request
the next buffer even when the whole word was matched because the finder
needs to find white space to know the word ended there. However this
would be beyond the search area so EOT exception would be raised.
To correctly manage this situation finder must care for limitPos.
When it sees the word and knows this is the last text in document
it signals that it found the word.find()
method returns the position (not offset) where the string starts
(and must also set some flag resulting to that isFound()
method will return true).
If the string was not yet found, the function should return
position (not offset) where the next search should continue. If this
position is greater or equal than limit position
(lower than limit position for backward search),
searching will stop resulting in -1 as returned position.
The position returned will be passed as reqPos
in next
call to find()
method.