public abstract class SearchPattern
extends org.eclipse.wst.jsdt.internal.core.search.matching.InternalSearchPattern
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.wst.jsdt.core.IJavaScriptElement, int)
,
Provisional API: This class/interface is part of an interim API that is still under development and expected to
change significantly before reaching stability. It is being made available at this early stage to solicit feedback
from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
(repeatedly) as the API evolves.
Modifier and Type | Field and Description |
---|---|
static int |
R_CAMELCASE_MATCH
Match rule: The search pattern contains a Camel Case expression.
|
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 ('*' or '?').
|
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 and Description |
---|
SearchPattern(int matchRule)
Creates a search pattern with the rule to apply for matching index keys.
|
Modifier and Type | Method and Description |
---|---|
static boolean |
camelCaseMatch(java.lang.String pattern,
int patternStart,
int patternEnd,
java.lang.String name,
int nameStart,
int nameEnd)
Answers true if a sub-pattern matches the subpart of the given name using CamelCase rules, or false otherwise.
|
static boolean |
camelCaseMatch(java.lang.String pattern,
java.lang.String name)
Answers true if the pattern matches the given name using CamelCase rules, or false otherwise.
|
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(IJavaScriptElement element,
int limitTo)
Returns a search pattern based on a given JavaScript element.
|
static SearchPattern |
createPattern(IJavaScriptElement element,
int limitTo,
int matchRule)
Returns a search pattern based on a given JavaScript 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.
|
static boolean |
isPatternMatch(java.lang.String pattern)
Returns whether the given pattern is a pattern case or not.
|
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.
|
static boolean |
matchesQualificationPattern(char[] thisQualifiedName,
char[] otherQualifiedName,
boolean isCaseSensitive)
Returns whether this pattern's prefix qualifier matches the other patterns qualified name.
|
java.lang.String |
toString() |
static int |
validateMatchRule(java.lang.String stringPattern,
int matchRule)
Validate compatibility between given string pattern and match rule.
|
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
public static final int R_CAMELCASE_MATCH
NPE
type string pattern will match
NullPointerException
and NpPermissionException
types,NuPoEx
type string pattern will only match
NullPointerException
type.for a detailed explanation
of Camel Case matching.
Can be combined to {@link #R_PREFIX_MATCH} match rule. For example,
when prefix match rule is combined with Camel Case match rule,
"nPE"
pattern will match nPException
.
Match rule {@link #R_PATTERN_MATCH} may also be combined but both rules
will not be used simultaneously as they are mutually exclusive.
Used match rule depends on whether string pattern contains specific pattern
characters (e.g. '*' or '?') or not. If it does, then only Pattern match rule
will be used, otherwise only Camel Case match will be used.
For example, with "NPE"
string pattern, search will only use
Camel Case match rule, but with N*P*E*
string pattern, it will
use only Pattern match rule.
,
Constant Field Valuespublic SearchPattern(int matchRule)
matchRule
- one of R_EXACT_MATCH
, R_PREFIX_MATCH
, R_PATTERN_MATCH
,
R_REGEXP_MATCH
, R_CAMELCASE_MATCH
combined with one of following 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.public static final boolean camelCaseMatch(java.lang.String pattern, java.lang.String name)
pattern = "NPE" name = NullPointerException / NoPermissionException result => true
pattern = "NuPoEx" name = NullPointerException result => true
pattern = "npe" name = NullPointerException result => false
pattern
- the given patternname
- the given nameImplementation has been entirely copied from this method except for array lengthes
which were obviously replaced with calls to {@link String#length()}.
public static final boolean camelCaseMatch(java.lang.String pattern, int patternStart, int patternEnd, java.lang.String name, int nameStart, int nameEnd)
pattern = "NPE" patternStart = 0 patternEnd = 3 name = NullPointerException nameStart = 0 nameEnd = 20 result => true
pattern = "NPE" patternStart = 0 patternEnd = 3 name = NoPermissionException nameStart = 0 nameEnd = 21 result => true
pattern = "NuPoEx" patternStart = 0 patternEnd = 6 name = NullPointerException nameStart = 0 nameEnd = 20 result => true
pattern = "NuPoEx" patternStart = 0 patternEnd = 6 name = NoPermissionException nameStart = 0 nameEnd = 21 result => false
pattern = "npe" patternStart = 0 patternEnd = 3 name = NullPointerException nameStart = 0 nameEnd = 20 result => false
pattern
- the given patternpatternStart
- the start index of the pattern, inclusivepatternEnd
- the end index of the pattern, exclusivename
- the given namenameStart
- the start index of the name, inclusivenameEnd
- the end index of the name, exclusiveImplementation has been entirely copied from this method except for array lengthes
which were obviously replaced with calls to {@link String#length()} and
for array direct access which were replaced with calls to {@link String#charAt(int)}.
public static SearchPattern createAndPattern(SearchPattern leftPattern, SearchPattern rightPattern)
leftPattern
- the left patternrightPattern
- the right patternpublic static SearchPattern createOrPattern(SearchPattern leftPattern, SearchPattern rightPattern)
leftPattern
- the left patternrightPattern
- the right patternpublic 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
IJavaScriptSearchConstants.CLASS
: only look for classesIJavaScriptSearchConstants#INTERFACE
: only look for interfacesIJavaScriptSearchConstants.ENUM
: only look for enumerationIJavaScriptSearchConstants#ANNOTATION_TYPE
: only look for annotation typeIJavaScriptSearchConstants#CLASS_AND_ENUM
: only look for classes and enumerationsIJavaScriptSearchConstants#CLASS_AND_INTERFACE
: only look for classes and interfacesIJavaScriptSearchConstants.TYPE
: look for all types (ie. classes, interfaces, enum and annotation types)IJavaScriptSearchConstants.FIELD
: look for fieldsIJavaScriptSearchConstants.METHOD
: look for methodsIJavaScriptSearchConstants.CONSTRUCTOR
: look for constructorsIJavaScriptSearchConstants.PACKAGE
: look for packageslimitTo
- determines the nature of the expected matches
IJavaScriptSearchConstants.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.IJavaScriptSearchConstants.IGNORE_DECLARING_TYPE
and
IJavaScriptSearchConstants.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.
IJavaScriptSearchConstants.REFERENCES
: will search references to the given element.IJavaScriptSearchConstants.ALL_OCCURRENCES
: will search for either declarations or
references as specified above.
IJavaScriptSearchConstants.IMPLEMENTORS
: for types, will find all types
which directly implement/extend a given interface.
Note that types may be only classes or only interfaces if IJavaScriptSearchConstants.CLASS
or
IJavaScriptSearchConstants#INTERFACE
is respectively used instead of IJavaScriptSearchConstants.TYPE
.
matchRule
- one of R_EXACT_MATCH
, R_PREFIX_MATCH
, R_PATTERN_MATCH
,
R_REGEXP_MATCH
, R_CAMELCASE_MATCH
combined with one of following 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(IJavaScriptElement element, int limitTo)
R_ERASURE_MATCH
matches.
If other kind of generic matches (ie. R_EXACT_MATCH
or R_EQUIVALENT_MATCH
)
are expected, createPattern(IJavaScriptElement, int, int)
method need to be used instead with
the explicit match rule specified.
element
- the JavaScript element the search pattern is based onlimitTo
- determines the nature of the expected matches
IJavaScriptSearchConstants.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:
IJavaScriptSearchConstants.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
IJavaScriptSearchConstants.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
IJavaScriptSearchConstants.REFERENCES
: will search references to the given element.IJavaScriptSearchConstants.ALL_OCCURRENCES
: will search for either declarations or
references as specified above.
IJavaScriptSearchConstants.IMPLEMENTORS
: for types, will find all types
which directly implement/extend a given interface.
null
if the given element is ill-formedpublic static SearchPattern createPattern(IJavaScriptElement element, int limitTo, int matchRule)
element
- the JavaScript element the search pattern is based onlimitTo
- determines the nature of the expected matches
IJavaScriptSearchConstants.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:
IJavaScriptSearchConstants.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
IJavaScriptSearchConstants.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
IJavaScriptSearchConstants.REFERENCES
: will search references to the given element.IJavaScriptSearchConstants.ALL_OCCURRENCES
: will search for either declarations or
references as specified above.
IJavaScriptSearchConstants.IMPLEMENTORS
: for types, will find all types
which directly implement/extend a given interface.
matchRule
- one of R_EXACT_MATCH
, R_PREFIX_MATCH
, R_PATTERN_MATCH
,
R_REGEXP_MATCH
, R_CAMELCASE_MATCH
combined with one of following 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 keypublic 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 namepublic static boolean matchesQualificationPattern(char[] thisQualifiedName, char[] otherQualifiedName, boolean isCaseSensitive)
Returns whether this pattern's prefix qualifier matches the other patterns qualified name. This pattern's qualifier must have a match rule of pattern match for a match to occur.
thisQualifiedName
- this qualifier pattern to inspectotherQualifiedName
- other qualifier pattern to inspectisCaseSensitive
- whether this qualifier pattern is case sensitivepublic static int validateMatchRule(java.lang.String stringPattern, int matchRule)
R_PATTERN_MATCH
without any '*' or '?' in string pattern:
pattern match bit is unset,
R_PATTERN_MATCH
and R_PREFIX_MATCH
bits simultaneously set:
prefix match bit is unset,
R_PATTERN_MATCH
and R_CAMELCASE_MATCH
bits simultaneously set:
camel case match bit is unset,
R_CAMELCASE_MATCH
with invalid combination of uppercase and lowercase characters:
camel case match bit is unset and replaced with prefix match pattern,
R_CAMELCASE_MATCH
combined with R_PREFIX_MATCH
and R_CASE_SENSITIVE
bits is reduced to only R_CAMELCASE_MATCH
as Camel Case search is already prefix and case sensitive,
R_REGEXP_MATCH
with any other match mode bit set,
stringPattern
- The string patternmatchRule
- The match rulepublic static boolean isPatternMatch(java.lang.String pattern)
pattern
- the pattern to inspectpublic java.lang.String toString()
toString
in class java.lang.Object
Object.toString()
Copyright (c) IBM Corp. and others 2000, 2010. All Rights Reserved.