public abstract static class FinderFactory.GenericBwdFinder extends FinderFactory.AbstractFinder
found| Constructor and Description |
|---|
GenericBwdFinder() |
| Modifier and Type | Method and Description |
|---|---|
int |
find(int bufferStartPos,
char[] buffer,
int offset1,
int offset2,
int reqPos,
int limitPos)
This is the most important function in finder.
|
protected abstract int |
scan(char ch,
boolean lastChar)
This function decides if it found a desired string or not.
|
isFound, resetpublic final 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.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.protected abstract int scan(char ch,
boolean lastChar)
found = true and returns
how many characters back the searched string begins in backward
direction (0 stands for current character). It is usually 0 as the
finder usually decides after the last required character but it's
not always the case e.g. for whole-words-only search it can be 1 or so.
If the string is not yet found it returns how many characters it should go
in backward direction (in this case it would usually be -1).
The next searched character will be that one requested.