org.eclipse.jdt/org.eclipse.jdt.core/3.20.0 : org/eclipse/jdt/core/search/SearchMatch.java

SearchMatch
http://www.eclipse.org/jdt: Java Development Tools Core (Eclipse Foundation)
Eclipse Public License - v 2.0
Copyright (c) 2000, 2009 IBM Corporation and others.
This program and the accompanying materials
are made available under the terms of the Eclipse Public License 2.0
which accompanies this distribution, and is available at
https://www.eclipse.org/legal/epl-2.0/
SPDX-License-Identifier: EPL-2.0
Contributors:
    IBM Corporation - initial API and implementation
/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.core.search;

import org.eclipse.core.resources.IResource;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.internal.core.JavaElement;

A search match represents the result of a search query.
Search matches may be accurate (A_ACCURATE) or they might be
merely potential matches (A_INACCURATE). The latter occurs when
a compile-time problem prevents the search engine from completely resolving
the match.

This class is intended to be instantiated and subclassed by clients.

See Also: search.search(SearchPattern, SearchParticipant[], IJavaSearchScope, SearchRequestor, IProgressMonitor)
Since: 3.0/**
 * A search match represents the result of a search query.
 *
 * Search matches may be accurate (<code>A_ACCURATE</code>) or they might be
 * merely potential matches (<code>A_INACCURATE</code>). The latter occurs when
 * a compile-time problem prevents the search engine from completely resolving
 * the match.
 * <p>
 * This class is intended to be instantiated and subclassed by clients.
 * </p>
 *
 * @see SearchEngine#search(SearchPattern, SearchParticipant[], IJavaSearchScope, SearchRequestor, org.eclipse.core.runtime.IProgressMonitor)
 * @since 3.0
 */
public class SearchMatch {

	The search result corresponds an exact match of the search pattern.
See Also: getAccuracy()/**
	 * The search result corresponds an exact match of the search pattern.
	 *
	 * @see #getAccuracy()
	 */
	public static final int A_ACCURATE = 0;

	The search result is potentially a match for the search pattern,
but the search engine is unable to fully check it (for example, because
there are errors in the code or the classpath are not correctly set).
See Also: getAccuracy()/**
	 * The search result is potentially a match for the search pattern,
	 * but the search engine is unable to fully check it (for example, because
	 * there are errors in the code or the classpath are not correctly set).
	 *
	 * @see #getAccuracy()
	 */
	public static final int A_INACCURATE = 1;

	private Object element;
	private int length;
	private int offset;

	private int accuracy;
	private SearchParticipant participant;
	private IResource resource;

	private boolean insideDocComment = false;

	// store the rule used while reporting the match
	private final static int ALL_GENERIC_FLAVORS = SearchPattern.R_FULL_MATCH |
								SearchPattern.R_EQUIVALENT_MATCH |
								SearchPattern.R_ERASURE_MATCH;
	private int rule = ALL_GENERIC_FLAVORS;

	// store other necessary information
	private boolean raw = false;
	private boolean implicit = false;

	Creates a new search match.

Note that isInsideDocComment() defaults to false.

Params: element – the element that encloses or corresponds to the match,
or null if none
accuracy – one of A_ACCURATE or A_INACCURATE
offset – the offset the match starts at, or -1 if unknown
length – the length of the match, or -1 if unknown
participant – the search participant that created the match
resource – the resource of the element, or null if none/**
	 * Creates a new search match.
	 * <p>
	 * Note that <code>isInsideDocComment()</code> defaults to false.
	 * </p>
	 *
	 * @param element the element that encloses or corresponds to the match,
	 * or <code>null</code> if none
	 * @param accuracy one of {@link #A_ACCURATE} or {@link #A_INACCURATE}
	 * @param offset the offset the match starts at, or -1 if unknown
	 * @param length the length of the match, or -1 if unknown
	 * @param participant the search participant that created the match
	 * @param resource the resource of the element, or <code>null</code> if none
	 */
	public SearchMatch(
			IJavaElement element,
			int accuracy,
			int offset,
			int length,
			SearchParticipant participant,
			IResource resource) {
		this.element = element;
		this.offset = offset;
		this.length = length;
		this.accuracy = accuracy & A_INACCURATE;
		if (accuracy > A_INACCURATE) {
			int genericFlavors = accuracy & ALL_GENERIC_FLAVORS;
			if (genericFlavors > 0) {
				this.rule &= ~ALL_GENERIC_FLAVORS; // reset generic flavors
			}
			this.rule |= accuracy & ~A_INACCURATE; // accuracy may have also some rule information
		}
		this.participant = participant;
		this.resource = resource;
	}

	Returns the accuracy of this search match.
Returns: one of A_ACCURATE or A_INACCURATE/**
	 * Returns the accuracy of this search match.
	 *
	 * @return one of {@link #A_ACCURATE} or {@link #A_INACCURATE}
	 */
	public final int getAccuracy() {
		return this.accuracy;
	}

	Returns the element of this search match.
In case of a reference match, this is the inner-most enclosing element of the reference.
In case of a declaration match, this is the declaration.
Returns: the element of the search match, or null if none/**
	 * Returns the element of this search match.
	 * In case of a reference match, this is the inner-most enclosing element of the reference.
	 * In case of a declaration match, this is the declaration.
	 *
	 * @return the element of the search match, or <code>null</code> if none
	 */
	public final Object getElement() {
		return this.element;
	}

	Returns the length of this search match.
Returns: the length of this search match, or -1 if unknown/**
	 * Returns the length of this search match.
	 *
	 * @return the length of this search match, or -1 if unknown
	 */
	public final int getLength() {
		return this.length;
	}

	Returns the offset of this search match.
Returns: the offset of this search match, or -1 if unknown/**
	 * Returns the offset of this search match.
	 *
	 * @return the offset of this search match, or -1 if unknown
	 */
	public final int getOffset() {
		return this.offset;
	}

	Returns the search participant which issued this search match.
Returns: the participant which issued this search match/**
	 * Returns the search participant which issued this search match.
	 *
	 * @return the participant which issued this search match
	 */
	public final SearchParticipant getParticipant() {
		return this.participant;
	}

	Returns the resource containing this search match.
Returns: the resource of the match, or null if none/**
	 * Returns the resource containing this search match.
	 *
	 * @return the resource of the match, or <code>null</code> if none
	 */
	public final IResource getResource() {
		return this.resource;
	}

	Returns the rule used while creating the match.
Returns: one of SearchPattern.R_FULL_MATCH, SearchPattern.R_EQUIVALENT_MATCH or SearchPattern.R_ERASURE_MATCH
Since: 3.1/**
	 * Returns the rule used while creating the match.
	 *
	 * @return one of {@link SearchPattern#R_FULL_MATCH}, {@link SearchPattern#R_EQUIVALENT_MATCH}
	 * 	or {@link SearchPattern#R_ERASURE_MATCH}
	 * @since 3.1
	 */
	public final int getRule() {
		return this.rule;
	}

	Returns whether match element is compatible with searched pattern or not.
Note that equivalent matches are also erasure ones.
Returns: true if match element is compatible
				false otherwise
Since: 3.1/**
	 * Returns whether match element is compatible with searched pattern or not.
	 * Note that equivalent matches are also erasure ones.
	 *
	 * @return <code>true</code> if match element is compatible
	 * 				<code>false</code> otherwise
	 * @since 3.1
	 */
	public final boolean isEquivalent() {
		return isErasure() && (this.rule & SearchPattern.R_EQUIVALENT_MATCH) != 0;
	}

	Returns whether match element only has same erasure than searched pattern or not.
Note that this is always true for both generic and non-generic element as soon
as the accuracy is accurate.
Returns: true if match element has same erasure
				false otherwise
Since: 3.1/**
	 * Returns whether match element only has same erasure than searched pattern or not.
	 * Note that this is always true for both generic and non-generic element as soon
	 * as the accuracy is accurate.
	 *
	 * @return <code>true</code> if match element has same erasure
	 * 				<code>false</code> otherwise
	 * @since 3.1
	 */
	public final boolean isErasure() {
		return (this.rule & SearchPattern.R_ERASURE_MATCH) != 0;
	}

	Returns whether element matches exactly searched pattern or not.
Note that exact matches are also erasure and equivalent ones.
Returns: true if match is exact
				false otherwise
Since: 3.1/**
	 * Returns whether element matches exactly searched pattern or not.
	 * Note that exact matches are also erasure and equivalent ones.
	 *
	 * @return <code>true</code> if match is exact
	 * 				<code>false</code> otherwise
	 * @since 3.1
	 */
	public final boolean isExact() {
		return isEquivalent() && (this.rule & SearchPattern.R_FULL_MATCH) != 0;
	}

	Returns whether the associated element is implicit or not.
Note that this piece of information is currently only implemented
for implicit member pair value in annotation.
Returns: true if this match is associated to an implicit
element and false otherwise
Since: 3.1/**
	 * Returns whether the associated element is implicit or not.
	 *
	 * Note that this piece of information is currently only implemented
	 * for implicit member pair value in annotation.
	 *
	 * @return <code>true</code> if this match is associated to an implicit
	 * element and <code>false</code> otherwise
	 * @since 3.1
	 */
	public final boolean isImplicit() {
		return this.implicit;
	}

	Returns whether the associated element is a raw type/method or not.
Returns: true if this match is associated to a raw
type or method and false otherwise
Since: 3.1/**
	 * Returns whether the associated element is a raw type/method or not.
	 *
	 * @return <code>true</code> if this match is associated to a raw
	 * type or method and <code>false</code> otherwise
	 * @since 3.1
	 */
	public final boolean isRaw() {
		return this.raw;
	}

	Returns whether this search match is inside a doc comment of a Java
source file.
Returns: true if this search match is inside a doc
comment, and false otherwise/**
	 * Returns whether this search match is inside a doc comment of a Java
	 * source file.
	 *
	 * @return <code>true</code> if this search match is inside a doc
	 * comment, and <code>false</code> otherwise
	 */
	public final boolean isInsideDocComment() {
		// default is outside a doc comment
		return this.insideDocComment;
	}

	Sets the accuracy of this match.
Params: accuracy – one of A_ACCURATE or A_INACCURATE/**
	 * Sets the accuracy of this match.
	 *
	 * @param accuracy one of {@link #A_ACCURATE} or {@link #A_INACCURATE}
	 */
	public final void setAccuracy (int accuracy) {
		this.accuracy = accuracy;
	}

	Sets the element of this search match.
Params: element – the element that encloses or corresponds to the match,
or null if none/**
	 * Sets the element of this search match.
	 *
	 * @param element the element that encloses or corresponds to the match,
	 * or <code>null</code> if none
	 */
	public final void setElement (Object element) {
		this.element = element;
	}

	Sets whether this search match is inside a doc comment of a Java
source file.
Params: insideDoc – true if this search match is inside a doc
comment, and false otherwise/**
	 * Sets whether this search match is inside a doc comment of a Java
	 * source file.
	 *
	 * @param insideDoc <code>true</code> if this search match is inside a doc
	 * comment, and <code>false</code> otherwise
	 */
	public final void setInsideDocComment (boolean insideDoc) {
		this.insideDocComment = insideDoc;
	}

	Sets whether the associated element is implicit or not.
Typically, this is the case when match is on an implicit constructor
or an implicit member pair value in annotation.
Params: implicit – true if this match is associated to an implicit
element and false otherwise
Since: 3.1/**
	 * Sets whether the associated element is implicit or not.
	 * Typically, this is the case when match is on an implicit constructor
	 * or an implicit member pair value in annotation.
	 *
	 * @param implicit <code>true</code> if this match is associated to an implicit
	 * element and <code>false</code> otherwise
	 * @since 3.1
	 */
	public final void setImplicit(boolean implicit) {
		this.implicit = implicit;
	}

	Sets the length of this search match.
Params: length – the length of the match, or -1 if unknown/**
	 * Sets the length of this search match.
	 *
	 * @param length the length of the match, or -1 if unknown
	 */
	public final void setLength(int length) {
		this.length = length;
	}

	Sets the offset of this search match.
Params: offset – the offset the match starts at, or -1 if unknown/**
	 * Sets the offset of this search match.
	 *
	 * @param offset the offset the match starts at, or -1 if unknown
	 */
	public final void setOffset(int offset) {
		this.offset = offset;
	}

	Sets the participant of this match.
Params: participant – the search participant that created this match/**
	 * Sets the participant of this match.
	 *
	 * @param participant the search participant that created this match
	 */
	public final void setParticipant (SearchParticipant participant) {
		this.participant = participant;
	}

	Sets the resource of this match.
Params: resource – the resource of the match, or null if none/**
	 * Sets the resource of this match.
	 *
	 * @param resource the resource of the match, or <code>null</code> if none
	 */
	public final void setResource (IResource resource) {
		this.resource = resource;
	}

	Set the rule used while reporting the match.
Params: rule – one of SearchPattern.R_FULL_MATCH, SearchPattern.R_EQUIVALENT_MATCH or SearchPattern.R_ERASURE_MATCH
Since: 3.1/**
	 * Set the rule used while reporting the match.
	 *
	 * @param rule one of {@link SearchPattern#R_FULL_MATCH}, {@link SearchPattern#R_EQUIVALENT_MATCH}
	 * 	or {@link SearchPattern#R_ERASURE_MATCH}
	 * @since 3.1
	 */
	public final void setRule(int rule) {
		this.rule = rule;
	}

	Set whether the associated element is a raw type/method or not.
Params: raw – true if this search match is associated to a raw
type or method and false otherwise
Since: 3.1/**
	 * Set whether the associated element is a raw type/method or not.
	 *
	 * @param raw <code>true</code> if this search match is associated to a raw
	 * type or method and <code>false</code> otherwise
	 * @since 3.1
	 */
	public final void setRaw(boolean raw) {
		this.raw = raw;
	}

	@Override
	public String toString() {
		StringBuffer buffer = new StringBuffer();
		buffer.append("Search match"); //$NON-NLS-1$
		buffer.append("\n  accuracy="); //$NON-NLS-1$
		buffer.append(this.accuracy == A_ACCURATE ? "ACCURATE" : "INACCURATE"); //$NON-NLS-1$ //$NON-NLS-2$
		buffer.append("\n  rule="); //$NON-NLS-1$
		if ((this.rule & SearchPattern.R_FULL_MATCH) != 0) {
			buffer.append("EXACT"); //$NON-NLS-1$
		} else if ((this.rule & SearchPattern.R_EQUIVALENT_MATCH) != 0) {
			buffer.append("EQUIVALENT"); //$NON-NLS-1$
		} else if ((this.rule & SearchPattern.R_ERASURE_MATCH) != 0) {
			buffer.append("ERASURE"); //$NON-NLS-1$
		}
		buffer.append("\n  raw="); //$NON-NLS-1$
		buffer.append(this.raw);
		buffer.append("\n  offset="); //$NON-NLS-1$
		buffer.append(this.offset);
		buffer.append("\n  length="); //$NON-NLS-1$
		buffer.append(this.length);
		if (this.element != null) {
			buffer.append("\n  element="); //$NON-NLS-1$
			buffer.append(((JavaElement)getElement()).toStringWithAncestors());
		}
		buffer.append("\n"); //$NON-NLS-1$
		return buffer.toString();
	}
}
See Also:	search.search(SearchPattern, SearchParticipant[], IJavaSearchScope, SearchRequestor, IProgressMonitor)
Since:	3.0
Returns:	one of `SearchPattern.R_FULL_MATCH`, `SearchPattern.R_EQUIVALENT_MATCH` or `SearchPattern.R_ERASURE_MATCH`
Since:	3.1
Returns:	`true` if match element is compatible `false` otherwise
Since:	3.1
Returns:	`true` if match element has same erasure `false` otherwise
Since:	3.1
Returns:	`true` if this match is associated to an implicit element and `false` otherwise
Since:	3.1
Returns:	`true` if this match is associated to a raw type or method and `false` otherwise
Since:	3.1
Params:	implicit – `true` if this match is associated to an implicit element and `false` otherwise
Since:	3.1
Params:	rule – one of `SearchPattern.R_FULL_MATCH`, `SearchPattern.R_EQUIVALENT_MATCH` or `SearchPattern.R_ERASURE_MATCH`
Since:	3.1
Params:	raw – `true` if this search match is associated to a raw type or method and `false` otherwise
Since:	3.1
/

org.eclipse.jdt/ org.eclipse.jdt.core/ 3.20.0/ org/eclipse/jdt/core/search/SearchMatch.java
