net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/core/search/IJavaSearchConstants.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2004 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11 package net.sourceforge.phpdt.core.search;
  12
  13 // import net.sourceforge.phpdt.internal.core.search.processing.*;
  14
  15 /**
  16  * <p>
  17  * This interface defines the constants used by the search engine.
  18  * </p>
  19  * <p>
  20  * This interface declares constants only; it is not intended to be implemented.
  21  * </p>
  22  *
  23  * @see org.eclipse.jdt.core.search.SearchEngine
  24  */
  25 public interface IJavaSearchConstants {
  26
  27         /**
  28          * The nature of searched element or the nature of match in unknown.
  29          */
  30         int UNKNOWN = -1;
  31
  32         /* Nature of searched element */
  33
  34         /**
  35          * The searched element is a type.
  36          */
  37         int TYPE = 0;
  38
  39         /**
  40          * The searched element is a method.
  41          */
  42         int METHOD = 1;
  43
  44         /**
  45          * The searched element is a package.
  46          */
  47         int PACKAGE = 2;
  48
  49         /**
  50          * The searched element is a constructor.
  51          */
  52         int CONSTRUCTOR = 3;
  53
  54         /**
  55          * The searched element is a field.
  56          */
  57         int FIELD = 4;
  58
  59         /**
  60          * The searched element is a class. More selective than using TYPE
  61          */
  62         int CLASS = 5;
  63
  64         /**
  65          * The searched element is an interface. More selective than using TYPE
  66          */
  67         int INTERFACE = 6;
  68
  69         /* Nature of match */
  70
  71         /**
  72          * The search result is a declaration. Can be used in conjunction with any
  73          * of the nature of searched elements so as to better narrow down the
  74          * search.
  75          */
  76         int DECLARATIONS = 0;
  77
  78         /**
  79          * The search result is a type that implements an interface. Used in
  80          * conjunction with either TYPE or CLASS or INTERFACE, it will respectively
  81          * search for any type implementing/extending an interface, or rather
  82          * exclusively search for classes implementing an interface, or interfaces
  83          * extending an interface.
  84          */
  85         int IMPLEMENTORS = 1;
  86
  87         /**
  88          * The search result is a reference. Can be used in conjunction with any of
  89          * the nature of searched elements so as to better narrow down the search.
  90          * References can contain implementers since they are more generic kind of
  91          * matches.
  92          */
  93         int REFERENCES = 2;
  94
  95         /**
  96          * The search result is a declaration, a reference, or an implementer of an
  97          * interface. Can be used in conjunction with any of the nature of searched
  98          * elements so as to better narrow down the search.
  99          */
 100         int ALL_OCCURRENCES = 3;
 101
 102         /**
 103          * When searching for field matches, it will exclusively find read accesses,
 104          * as opposed to write accesses. Note that some expressions are considered
 105          * both as field read/write accesses: for example, x++; x+= 1;
 106          *
 107          * @since 2.0
 108          */
 109         int READ_ACCESSES = 4;
 110
 111         /**
 112          * When searching for field matches, it will exclusively find write
 113          * accesses, as opposed to read accesses. Note that some expressions are
 114          * considered both as field read/write accesses: for example, x++; x+= 1;
 115          *
 116          * @since 2.0
 117          */
 118         int WRITE_ACCESSES = 5;
 119
 120         /* Syntactic match modes */
 121
 122         /**
 123          * The search pattern matches exactly the search result, that is, the source
 124          * of the search result equals the search pattern.
 125          *
 126          * @deprecated Use {@link SearchPattern#R_EXACT_MATCH} instead.
 127          */
 128         int EXACT_MATCH = 0;
 129
 130         /**
 131          * The search pattern is a prefix of the search result.
 132          *
 133          * @deprecated Use {@link SearchPattern#R_PREFIX_MATCH} instead.
 134          */
 135         int PREFIX_MATCH = 1;
 136
 137         /**
 138          * The search pattern contains one or more wild cards ('*') where a
 139          * wild-card can replace 0 or more characters in the search result.
 140          *
 141          * @deprecated Use {@link SearchPattern#R_PATTERN_MATCH} instead.
 142          */
 143         int PATTERN_MATCH = 2;
 144
 145         /* Case sensitivity */
 146
 147         /**
 148          * The search pattern matches the search result only if cases are the same.
 149          *
 150          * @deprecated Use the methods that take the matchMode with
 151          *             {@link SearchPattern#R_CASE_SENSITIVE} as a matchRule
 152          *             instead.
 153          */
 154         boolean CASE_SENSITIVE = true;
 155
 156         /**
 157          * The search pattern ignores cases in the search result.
 158          *
 159          * @deprecated Use the methods that take the matchMode without
 160          *             {@link SearchPattern#R_CASE_SENSITIVE} as a matchRule
 161          *             instead.
 162          */
 163         boolean CASE_INSENSITIVE = false;
 164
 165         /* Waiting policies */
 166
 167         /**
 168          * The search operation starts immediately, even if the underlying indexer
 169          * has not finished indexing the workspace. Results will more likely not
 170          * contain all the matches.
 171          */
 172         // int FORCE_IMMEDIATE_SEARCH = IJob.ForceImmediate;
 173         /**
 174          * The search operation throws an
 175          * <code>org.eclipse.core.runtime.OperationCanceledException</code> if the
 176          * underlying indexer has not finished indexing the workspace.
 177          */
 178         // int CANCEL_IF_NOT_READY_TO_SEARCH = IJob.CancelIfNotReady;
 179         /**
 180          * The search operation waits for the underlying indexer to finish indexing
 181          * the workspace before starting the search.
 182          */
 183         // int WAIT_UNTIL_READY_TO_SEARCH = IJob.WaitUntilReady;
 184
 185 }