|
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
public abstract class 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(java.lang.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. |
java.lang.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(java.lang.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-formed
public 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-formed
public 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 java.lang.String toString()
toString in class java.lang.ObjectObject.toString()
|
Eclipse JDT Release 3.1 |
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||