|
Eclipse JDT Release 3.1 |
|||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectorg.eclipse.jdt.internal.core.search.matching.InternalSearchPattern
org.eclipse.jdt.core.search.SearchPattern
A search pattern defines how search results are found. Use SearchPattern.createPattern
to create a search pattern.
Search patterns are used during the search phase to decode index entries that were added during the indexing phase
(see SearchDocument.addIndexEntry(char[], char[])
). When an index is queried, the
index categories and keys to consider are retrieved from the search pattern using getIndexCategories()
and
getIndexKey()
, as well as the match rule (see getMatchRule()
). A blank pattern is
then created (see getBlankPattern()
). This blank pattern is used as a record as follows.
For each index entry in the given index categories and that starts with the given key, the blank pattern is fed using
decodeIndexKey(char[])
. The original pattern is then asked if it matches the decoded key using
matchesDecodedKey(SearchPattern)
. If it matches, a search doument is created for this index entry
using SearchParticipant.getDocument(String)
.
This class is intended to be subclassed by clients. A default behavior is provided for each of the methods above, that clients can ovveride if they wish.
createPattern(org.eclipse.jdt.core.IJavaElement, int)
,
createPattern(String, int, int, int)
Field Summary | |
---|---|
static int |
R_CASE_SENSITIVE
Match rule: The search pattern matches the search result only if cases are the same. |
static int |
R_EQUIVALENT_MATCH
Match rule: The search pattern matches search results as raw/parameterized types/methods with equivalent type parameters. |
static int |
R_ERASURE_MATCH
Match rule: The search pattern matches search results as raw/parameterized types/methods with same erasure. |
static int |
R_EXACT_MATCH
Match rule: The search pattern matches exactly the search result, that is, the source of the search result equals the search pattern. |
static int |
R_FULL_MATCH
Match rule: The search pattern matches exactly the search result, that is, the source of the search result equals the search pattern. |
static int |
R_PATTERN_MATCH
Match rule: The search pattern contains one or more wild cards ('*') where a wild-card can replace 0 or more characters in the search result. |
static int |
R_PREFIX_MATCH
Match rule: The search pattern is a prefix of the search result. |
static int |
R_REGEXP_MATCH
Match rule: The search pattern contains a regular expression. |
Constructor Summary | |
---|---|
SearchPattern(int matchRule)
Creates a search pattern with the rule to apply for matching index keys. |
Method Summary | |
---|---|
static SearchPattern |
createAndPattern(SearchPattern leftPattern,
SearchPattern rightPattern)
Returns a search pattern that combines the given two patterns into an "and" pattern. |
static SearchPattern |
createOrPattern(SearchPattern leftPattern,
SearchPattern rightPattern)
Returns a search pattern that combines the given two patterns into an "or" pattern. |
static SearchPattern |
createPattern(IJavaElement element,
int limitTo)
Returns a search pattern based on a given Java element. |
static SearchPattern |
createPattern(IJavaElement element,
int limitTo,
int matchRule)
Returns a search pattern based on a given Java element. |
static SearchPattern |
createPattern(String stringPattern,
int searchFor,
int limitTo,
int matchRule)
Returns a search pattern based on a given string pattern. |
void |
decodeIndexKey(char[] key)
Decode the given index key in this pattern. |
abstract SearchPattern |
getBlankPattern()
Returns a blank pattern that can be used as a record to decode an index key. |
char[][] |
getIndexCategories()
Returns an array of index categories to consider for this index query. |
char[] |
getIndexKey()
Returns a key to find in relevant index categories, if null then all index entries are matched. |
int |
getMatchRule()
Returns the rule to apply for matching index keys. |
boolean |
matchesDecodedKey(SearchPattern decodedPattern)
Returns whether this pattern matches the given pattern (representing a decoded index key). |
boolean |
matchesName(char[] pattern,
char[] name)
Returns whether the given name matches the given pattern. |
String |
toString()
|
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
Field Detail |
public static final int R_EXACT_MATCH
public static final int R_PREFIX_MATCH
public static final int R_PATTERN_MATCH
public static final int R_REGEXP_MATCH
public static final int R_CASE_SENSITIVE
R_EXACT_MATCH
| R_CASE_SENSITIVE
public static final int R_ERASURE_MATCH
List<Exception>
List<Object>
<T>foo(T t)
<Exception>foo(new Exception())
<Object>foo(new Object())
R_CASE_SENSITIVE
| R_ERASURE_MATCH
This rule is not activated by default, so raw types or parameterized types with same erasure will not be found
for pattern List<String>,
Note that with this pattern, the match selection will be only on the erasure even for parameterized types.
public static final int R_EQUIVALENT_MATCH
List<Exception>
List<? extends Throwable>
List<? super RuntimeException>
List<?>
<T>foo(T t)
<Exception>foo(new Exception())
<? extends Throwable>foo(new Exception())
<? super RuntimeException>foo(new Exception())
foo(new Exception())
R_CASE_SENSITIVE
| R_EQUIVALENT_MATCH
This rule is not activated by default, so raw types or equivalent parameterized types will not be found
for pattern List<String>,
This mode is overridden by R_ERASURE_MATCH
as erasure matches obviously include equivalent ones.
That means that pattern with rule set to R_EQUIVALENT_MATCH
| R_ERASURE_MATCH
will return same results than rule only set with R_ERASURE_MATCH
.
public static final int R_FULL_MATCH
Constructor Detail |
public SearchPattern(int matchRule)
matchRule
- one of R_EXACT_MATCH
, R_PREFIX_MATCH
, R_PATTERN_MATCH
,
R_REGEXP_MATCH
combined with one of follwing values: R_CASE_SENSITIVE
, R_ERASURE_MATCH
or R_EQUIVALENT_MATCH
.
e.g. R_EXACT_MATCH
| R_CASE_SENSITIVE
if an exact and case sensitive match is requested,
R_PREFIX_MATCH
if a prefix non case sensitive match is requested or R_EXACT_MATCH
| R_ERASURE_MATCH
if a non case sensitive and erasure match is requested.R_ERASURE_MATCH
or R_EQUIVALENT_MATCH
have no effect
on non-generic types/methods search.Method Detail |
public static SearchPattern createAndPattern(SearchPattern leftPattern, SearchPattern rightPattern)
leftPattern
- the left patternrightPattern
- the right pattern
public static SearchPattern createOrPattern(SearchPattern leftPattern, SearchPattern rightPattern)
leftPattern
- the left patternrightPattern
- the right pattern
public static SearchPattern createPattern(String stringPattern, int searchFor, int limitTo, int matchRule)
Object
:
createSearchPattern("Object", TYPE, REFERENCES, false);
Object()
constructor:
createSearchPattern("java.lang.Object()", CONSTRUCTOR, REFERENCES, true);
java.lang.Runnable
:
createSearchPattern("java.lang.Runnable", TYPE, IMPLEMENTORS, true);
stringPattern
- the given patternsearchFor
- determines the nature of the searched elements
IJavaSearchConstants.CLASS
: only look for classesIJavaSearchConstants.INTERFACE
: only look for interfacesIJavaSearchConstants.ENUM
: only look for enumerationIJavaSearchConstants.ANNOTATION_TYPE
: only look for annotation typeIJavaSearchConstants.CLASS_AND_ENUM
: only look for classes and enumerationsIJavaSearchConstants.CLASS_AND_INTERFACE
: only look for classes and interfacesIJavaSearchConstants.TYPE
: look for all types (ie. classes, interfaces, enum and annotation types)IJavaSearchConstants.FIELD
: look for fieldsIJavaSearchConstants.METHOD
: look for methodsIJavaSearchConstants.CONSTRUCTOR
: look for constructorsIJavaSearchConstants.PACKAGE
: look for packageslimitTo
- determines the nature of the expected matches
IJavaSearchConstants.DECLARATIONS
: will search declarations matching
with the corresponding element. In case the element is a method, declarations of matching
methods in subtypes will also be found, allowing to find declarations of abstract methods, etc.IJavaSearchConstants.IGNORE_DECLARING_TYPE
and
IJavaSearchConstants.IGNORE_RETURN_TYPE
are ignored for string patterns.
This is due to the fact that client may omit to define them in string pattern to have same behavior.
IJavaSearchConstants.REFERENCES
: will search references to the given element.IJavaSearchConstants.ALL_OCCURRENCES
: will search for either declarations or
references as specified above.
IJavaSearchConstants.IMPLEMENTORS
: for interface, will find all types
which implements a given interface.
matchRule
- one of R_EXACT_MATCH
, R_PREFIX_MATCH
, R_PATTERN_MATCH
,
R_REGEXP_MATCH
combined with one of follwing values: R_CASE_SENSITIVE
, R_ERASURE_MATCH
or R_EQUIVALENT_MATCH
.
e.g. R_EXACT_MATCH
| R_CASE_SENSITIVE
if an exact and case sensitive match is requested,
R_PREFIX_MATCH
if a prefix non case sensitive match is requested or R_EXACT_MATCH
| R_ERASURE_MATCH
if a non case sensitive and erasure match is requested.R_ERASURE_MATCH
or R_EQUIVALENT_MATCH
have no effect
on non-generic types/methods search.null
if the string pattern is ill-formedpublic static SearchPattern createPattern(IJavaElement element, int limitTo)
element
- the Java element the search pattern is based onlimitTo
- determines the nature of the expected matches
IJavaSearchConstants.DECLARATIONS
: will search declarations matching
with the corresponding element. In case the element is a method, declarations of matching
methods in subtypes will also be found, allowing to find declarations of abstract methods, etc.
Some additional flags may be specified while searching declaration:
IJavaSearchConstants.IGNORE_DECLARING_TYPE
: declaring type will be ignored
during the search.class A { A method() { return null; } } class B extends A { B method() { return null; } } class C { A method() { return null; } }search for
method
declaration with this flag
will return 2 matches: in A and in C
IJavaSearchConstants.IGNORE_RETURN_TYPE
: return type will be ignored
during the search.method
declaration with this flag
will return 2 matches: in A and in B.
method
declaration
with these 2 flags will return 3 matches: in A, in B and in C
IJavaSearchConstants.REFERENCES
: will search references to the given element.IJavaSearchConstants.ALL_OCCURRENCES
: will search for either declarations or
references as specified above.
IJavaSearchConstants.IMPLEMENTORS
: for interface, will find all types
which implements a given interface.
null
if the given element is ill-formedpublic static SearchPattern createPattern(IJavaElement element, int limitTo, int matchRule)
element
- the Java element the search pattern is based onlimitTo
- determines the nature of the expected matches
IJavaSearchConstants.DECLARATIONS
: will search declarations matching
with the corresponding element. In case the element is a method, declarations of matching
methods in subtypes will also be found, allowing to find declarations of abstract methods, etc.
Some additional flags may be specified while searching declaration:
IJavaSearchConstants.IGNORE_DECLARING_TYPE
: declaring type will be ignored
during the search.class A { A method() { return null; } } class B extends A { B method() { return null; } } class C { A method() { return null; } }search for
method
declaration with this flag
will return 2 matches: in A and in C
IJavaSearchConstants.IGNORE_RETURN_TYPE
: return type will be ignored
during the search.method
declaration with this flag
will return 2 matches: in A and in B.
method
declaration
with these 2 flags will return 3 matches: in A, in B and in C
IJavaSearchConstants.REFERENCES
: will search references to the given element.IJavaSearchConstants.ALL_OCCURRENCES
: will search for either declarations or
references as specified above.
IJavaSearchConstants.IMPLEMENTORS
: for interface, will find all types
which implements a given interface.
matchRule
- one of R_EXACT_MATCH
, R_PREFIX_MATCH
, R_PATTERN_MATCH
,
R_REGEXP_MATCH
combined with one of follwing values: R_CASE_SENSITIVE
, R_ERASURE_MATCH
or R_EQUIVALENT_MATCH
.
e.g. R_EXACT_MATCH
| R_CASE_SENSITIVE
if an exact and case sensitive match is requested,
R_PREFIX_MATCH
if a prefix non case sensitive match is requested or R_EXACT_MATCH
|R_ERASURE_MATCH
if a non case sensitive and erasure match is requested.R_ERASURE_MATCH
or R_EQUIVALENT_MATCH
have no effect on non-generic types
or methods search.null
if the given element is ill-formedpublic void decodeIndexKey(char[] key)
matchesDecodedKey(SearchPattern)
to find out if the corresponding index entry
should be considered.
This method should be re-implemented in subclasses that need to decode an index key.
key
- the given index keypublic abstract SearchPattern getBlankPattern()
Implementors of this method should return a new search pattern that is going to be used to decode index keys.
decodeIndexKey(char[])
public char[] getIndexKey()
This method should be re-implemented in subclasses that need to narrow down the index query.
null
if all index entries are matched.public char[][] getIndexCategories()
This method should be re-implemented in subclasses that need to narrow down the index query.
public final int getMatchRule()
public boolean matchesDecodedKey(SearchPattern decodedPattern)
This method should be re-implemented in subclasses that need to narrow down the index query.
decodedPattern
- a pattern representing a decoded index key
public boolean matchesName(char[] pattern, char[] name)
This method should be re-implemented in subclasses that need to define how a name matches a pattern.
pattern
- the given pattern, or null
to represent "*"name
- the given name
public String toString()
Object.toString()
|
Eclipse JDT Release 3.1 |
|||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |