FinderFactory.GenericBwdFinder (Editor Library) - NetBeans API Javadoc (Current Development Version)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

org.netbeans.modules.editor.lib/1 1.14.0 3

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.netbeans.editor
Class FinderFactory.GenericBwdFinder

java.lang.Object
  org.netbeans.editor.FinderFactory.AbstractFinder
      org.netbeans.editor.FinderFactory.GenericBwdFinder

All Implemented Interfaces:: Finder

Direct Known Subclasses:: FinderFactory.AcceptorBwdFinder, FinderFactory.CharArrayBwdFinder, FinderFactory.CharBwdFinder, FinderFactory.NonWhiteBwdFinder, FinderFactory.PreviousWordBwdFinder, FinderFactory.StringBwdFinder, FinderFactory.WhiteBwdFinder, FinderFactory.WholeWordsBwdFinder

Enclosing class:: FinderFactory

public abstract static class FinderFactory.GenericBwdFinder
extends FinderFactory.AbstractFinder
extends FinderFactory.AbstractFinder

Generic backward finder that simplifies the search process.

Field Summary

Fields inherited from class org.netbeans.editor.FinderFactory.AbstractFinder

found

Constructor Summary

FinderFactory.GenericBwdFinder()


Method Summary

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.

Methods inherited from class org.netbeans.editor.FinderFactory.AbstractFinder

isFound, reset

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Fields inherited from class org.netbeans.editor.FinderFactory.AbstractFinder
`found`

Constructor Summary
`FinderFactory.GenericBwdFinder()`

Method Summary
`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.

Methods inherited from class org.netbeans.editor.FinderFactory.AbstractFinder
`isFound, reset`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

FinderFactory.GenericBwdFinder

public FinderFactory.GenericBwdFinder()

Method Detail

find

public final int find(int bufferStartPos,
                      char[] buffer,
                      int offset1,
                      int offset2,
                      int reqPos,
                      int limitPos)

Description copied from interface: Finder

This is the most important function in finder. It can be called several times if the whole search area doesn't fit in the cache buffer. Usual forward search should look like this:


   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.

Parameters:: bufferStartPos - begining position of the buffer (not search area).; buffer - buffer with chars to be searched; offset1 - 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.
Returns:: in case the string was found, 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.

scan

protected abstract int scan(char ch,
                            boolean lastChar)

This function decides if it found a desired string or not. The function receives currently searched character and flag if it's the last one that is searched or not.

Returns:: if the function decides that it found a desired string it sets 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.