JavaCore extends Plugin

简介: /*******************************************************************************2 * Copyright (c) 2000, 2007 IBM Corporation and others.3 * All rights reserved. This program and the accompanyi
/*******************************************************************************
2  * Copyright (c) 2000, 2007 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Eclipse Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/epl-v10.html
7  *
8  * Contributors:
9  * IBM Corporation - initial API and implementation
10  * IBM Corporation - added the following constants:
11  * COMPILER_PB_DEPRECATION_IN_DEPRECATED_CODE
12  * COMPILER_PB_STATIC_ACCESS_RECEIVER
13  * COMPILER_TASK_TAGS
14  * CORE_CIRCULAR_CLASSPATH
15  * CORE_INCOMPLETE_CLASSPATH
16  * IBM Corporation - added run(IWorkspaceRunnable, IProgressMonitor)
17  * IBM Corporation - added exclusion patterns to source classpath entries
18  * IBM Corporation - added specific output location to source classpath entries
19  * IBM Corporation - added the following constants:
20  * CORE_JAVA_BUILD_CLEAN_OUTPUT_FOLDER
21  * CORE_JAVA_BUILD_RECREATE_MODIFIED_CLASS_FILES_IN_OUTPUT_FOLDER
22  * CLEAN
23  * IBM Corporation - added getClasspathContainerInitializer(String)
24  * IBM Corporation - added the following constants:
25  * CODEASSIST_ARGUMENT_PREFIXES
26  * CODEASSIST_ARGUMENT_SUFFIXES
27  * CODEASSIST_FIELD_PREFIXES
28  * CODEASSIST_FIELD_SUFFIXES
29  * CODEASSIST_LOCAL_PREFIXES
30  * CODEASSIST_LOCAL_SUFFIXES
31  * CODEASSIST_STATIC_FIELD_PREFIXES
32  * CODEASSIST_STATIC_FIELD_SUFFIXES
33  * COMPILER_PB_CHAR_ARRAY_IN_STRING_CONCATENATION
34  * IBM Corporation - added the following constants:
35  * COMPILER_PB_LOCAL_VARIABLE_HIDING
36  * COMPILER_PB_SPECIAL_PARAMETER_HIDING_FIELD
37  * COMPILER_PB_FIELD_HIDING
38  * COMPILER_PB_POSSIBLE_ACCIDENTAL_BOOLEAN_ASSIGNMENT
39  * CORE_INCOMPATIBLE_JDK_LEVEL
40  * VERSION_1_5
41  * COMPILER_PB_EMPTY_STATEMENT
42  * IBM Corporation - added the following constants:
43  * COMPILER_PB_INDIRECT_STATIC_ACCESS
44  * COMPILER_PB_BOOLEAN_METHOD_THROWING_EXCEPTION
45  * COMPILER_PB_UNNECESSARY_CAST
46  * IBM Corporation - added the following constants:
47  * COMPILER_PB_INVALID_JAVADOC
48  * COMPILER_PB_INVALID_JAVADOC_TAGS
49  * COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY
50  * COMPILER_PB_MISSING_JAVADOC_TAGS
51  * COMPILER_PB_MISSING_JAVADOC_TAGS_VISIBILITY
52  * COMPILER_PB_MISSING_JAVADOC_TAGS_OVERRIDING
53  * COMPILER_PB_MISSING_JAVADOC_COMMENTS
54  * COMPILER_PB_MISSING_JAVADOC_COMMENTS_VISIBILITY
55  * COMPILER_PB_MISSING_JAVADOC_COMMENTS_OVERRIDING
56  * COMPILER_PB_DEPRECATION_WHEN_OVERRIDING_DEPRECATED_METHOD
57  * COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING
58  * IBM Corporation - added the following constants:
59  * TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC
60  * IBM Corporation - added the following constants:
61  * COMPILER_PB_FALLTHROUGH_CASE
62  * COMPILER_PB_PARAMETER_ASSIGNMENT
63  * COMPILER_PB_NULL_REFERENCE
64  * IBM Corporation - added the following constants:
65  * CODEASSIST_DEPRECATION_CHECK
66  * IBM Corporation - added the following constants:
67  * COMPILER_PB_POTENTIAL_NULL_REFERENCE
68  * COMPILER_PB_REDUNDANT_NULL_CHECK
69  * IBM Corporation - added the following constants:
70  * COMPILER_PB_UNUSED_PARAMETER_INCLUDE_DOC_COMMENT_REFERENCE
71  *******************************************************************************/
72 package org.eclipse.jdt.core;
73 
74 import java.io.File  JavaDoc;
75 import java.util.ArrayList  JavaDoc;
76 import java.util.HashMap  JavaDoc;
77 import java.util.Hashtable  JavaDoc;
78 import java.util.Map  JavaDoc;
79 
80 import org.eclipse.core.resources.IContainer;
81 import org.eclipse.core.resources.IFile;
82 import org.eclipse.core.resources.IFolder;
83 import org.eclipse.core.resources.IMarker;
84 import org.eclipse.core.resources.IMarkerDelta;
85 import org.eclipse.core.resources.IProject;
86 import org.eclipse.core.resources.IResource;
87 import org.eclipse.core.resources.IResourceChangeEvent;
88 import org.eclipse.core.resources.IResourceChangeListener;
89 import org.eclipse.core.resources.IWorkspace;
90 import org.eclipse.core.resources.IWorkspaceRoot;
91 import org.eclipse.core.resources.IWorkspaceRunnable;
92 import org.eclipse.core.resources.ResourcesPlugin;
93 import org.eclipse.core.runtime.Assert;
94 import org.eclipse.core.runtime.CoreException;
95 import org.eclipse.core.runtime.IConfigurationElement;
96 import org.eclipse.core.runtime.IExtension;
97 import org.eclipse.core.runtime.IExtensionPoint;
98 import org.eclipse.core.runtime.IPath;
99 import org.eclipse.core.runtime.IProgressMonitor;
100 import org.eclipse.core.runtime.OperationCanceledException;
101 import org.eclipse.core.runtime.Platform;
102 import org.eclipse.core.runtime.Plugin;
103 import org.eclipse.core.runtime.QualifiedName;
104 import org.eclipse.core.runtime.SubProgressMonitor;
105 import org.eclipse.core.runtime.jobs.ISchedulingRule;
106 import org.eclipse.jdt.core.compiler.CharOperation;
107 import org.eclipse.jdt.core.search.IJavaSearchConstants;
108 import org.eclipse.jdt.core.search.IJavaSearchScope;
109 import org.eclipse.jdt.core.search.SearchEngine;
110 import org.eclipse.jdt.core.search.SearchPattern;
111 import org.eclipse.jdt.core.search.TypeNameRequestor;
112 import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
113 import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
114 import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
115 import org.eclipse.jdt.internal.core.*;
116 import org.eclipse.jdt.internal.core.builder.JavaBuilder;
117 import org.eclipse.jdt.internal.core.builder.State;
118 import org.eclipse.jdt.internal.core.util.MementoTokenizer;
119 import org.eclipse.jdt.internal.core.util.Messages;
120 import org.eclipse.jdt.internal.core.util.Util;
121 import org.osgi.framework.BundleContext;
122 
123 /**
124  * The plug-in runtime class for the Java model plug-in containing the core
125  * (UI-free) support for Java projects.
126  * <p>
127  * Like all plug-in runtime classes (subclasses of <code>Plugin</code>), this
128  * class is automatically instantiated by the platform when the plug-in gets
129  * activated. Clients must not attempt to instantiate plug-in runtime classes
130  * directly.
131  * </p>
132  * <p>
133  * The single instance of this class can be accessed from any plug-in declaring
134  * the Java model plug-in as a prerequisite via
135  * <code>JavaCore.getJavaCore()</code>. The Java model plug-in will be activated
136  * automatically if not already active.
137  * </p>
138  */
139 public final class JavaCore extends Plugin {
140 
141     private static final IResource[] NO_GENERATED_RESOURCES = new IResource[0];
142 
143     private static Plugin JAVA_CORE_PLUGIN = null;
144     /**
145      * The plug-in identifier of the Java core support
146      * (value <code>"org.eclipse.jdt.core"</code>).
147      */
148     public static final String  JavaDoc PLUGIN_ID = "org.eclipse.jdt.core" ; //$NON-NLS-1$
149 
150     /**
151      * The identifier for the Java builder
152      * (value <code>"org.eclipse.jdt.core.javabuilder"</code>).
153      */
154     public static final String  JavaDoc BUILDER_ID = PLUGIN_ID + ".javabuilder" ; //$NON-NLS-1$
155 
156     /**
157      * The identifier for the Java model
158      * (value <code>"org.eclipse.jdt.core.javamodel"</code>).
159      */
160     public static final String  JavaDoc MODEL_ID = PLUGIN_ID + ".javamodel" ; //$NON-NLS-1$
161 
162     /**
163      * The identifier for the Java nature
164      * (value <code>"org.eclipse.jdt.core.javanature"</code>).
165      * The presence of this nature on a project indicates that it is
166      * Java-capable.
167      *
168      * @see org.eclipse.core.resources.IProject#hasNature(java.lang.String)
169      */
170     public static final String  JavaDoc NATURE_ID = PLUGIN_ID + ".javanature" ; //$NON-NLS-1$
171 
172     /**
173      * Name of the handle id attribute in a Java marker.
174      */
175     protected static final String  JavaDoc ATT_HANDLE_ID =
176         "org.eclipse.jdt.internal.core.JavaModelManager.handleId" ; //$NON-NLS-1$
177 
178     /**
179      * Name of the User Library Container id.
180      * @since 3.0
181      */
182     public static final String  JavaDoc USER_LIBRARY_CONTAINER_ID= "org.eclipse.jdt.USER_LIBRARY"; //$NON-NLS-1$
183 
184     // *************** Possible IDs for configurable options. ********************
185 
186     /**
187      * Possible configurable option ID.
188      * @see #getDefaultOptions()
189      */
190     public static final String  JavaDoc COMPILER_LOCAL_VARIABLE_ATTR = PLUGIN_ID + ".compiler.debug.localVariable"; //$NON-NLS-1$
191 /**
192      * Possible configurable option ID.
193      * @see #getDefaultOptions()
194      */
195     public static final String  JavaDoc COMPILER_LINE_NUMBER_ATTR = PLUGIN_ID + ".compiler.debug.lineNumber"; //$NON-NLS-1$
196 /**
197      * Possible configurable option ID.
198      * @see #getDefaultOptions()
199      */
200     public static final String  JavaDoc COMPILER_SOURCE_FILE_ATTR = PLUGIN_ID + ".compiler.debug.sourceFile"; //$NON-NLS-1$
201 /**
202      * Possible configurable option ID.
203      * @see #getDefaultOptions()
204      */
205     public static final String  JavaDoc COMPILER_CODEGEN_UNUSED_LOCAL = PLUGIN_ID + ".compiler.codegen.unusedLocal"; //$NON-NLS-1$
206 /**
207      * Possible configurable option ID.
208      * @see #getDefaultOptions()
209      */
210     public static final String  JavaDoc COMPILER_CODEGEN_TARGET_PLATFORM = PLUGIN_ID + ".compiler.codegen.targetPlatform"; //$NON-NLS-1$
211 /**
212      * Possible configurable option ID.
213      * @see #getDefaultOptions()
214      * @since 3.0
215      */
216     public static final String  JavaDoc COMPILER_CODEGEN_INLINE_JSR_BYTECODE = PLUGIN_ID + ".compiler.codegen.inlineJsrBytecode"; //$NON-NLS-1$
217 /**
218      * Possible configurable option ID.
219      * @see #getDefaultOptions()
220      * @since 3.0
221      */
222     public static final String  JavaDoc COMPILER_DOC_COMMENT_SUPPORT = PLUGIN_ID + ".compiler.doc.comment.support"; //$NON-NLS-1$
223 /**
224      * Possible configurable option ID.
225      * @see #getDefaultOptions()
226      * @deprecated - discontinued since turning off would violate language specs
227      */
228     public static final String  JavaDoc COMPILER_PB_UNREACHABLE_CODE = PLUGIN_ID + ".compiler.problem.unreachableCode"; //$NON-NLS-1$
229 /**
230      * Possible configurable option ID.
231      * @see #getDefaultOptions()
232      * @deprecated - discontinued since turning off would violate language specs
233      */
234     public static final String  JavaDoc COMPILER_PB_INVALID_IMPORT = PLUGIN_ID + ".compiler.problem.invalidImport"; //$NON-NLS-1$
235 /**
236      * Possible configurable option ID.
237      * @see #getDefaultOptions()
238      */
239     public static final String  JavaDoc COMPILER_PB_OVERRIDING_PACKAGE_DEFAULT_METHOD = PLUGIN_ID + ".compiler.problem.overridingPackageDefaultMethod"; //$NON-NLS-1$
240 /**
241      * Possible configurable option ID.
242      * @see #getDefaultOptions()
243      */
244     public static final String  JavaDoc COMPILER_PB_METHOD_WITH_CONSTRUCTOR_NAME = PLUGIN_ID + ".compiler.problem.methodWithConstructorName"; //$NON-NLS-1$
245 /**
246      * Possible configurable option ID.
247      * @see #getDefaultOptions()
248      */
249     public static final String  JavaDoc COMPILER_PB_DEPRECATION = PLUGIN_ID + ".compiler.problem.deprecation"; //$NON-NLS-1$
250 /**
251      * Possible configurable option ID.
252      * @see #getDefaultOptions()
253      * @since 2.1
254      */
255     public static final String  JavaDoc COMPILER_PB_DEPRECATION_IN_DEPRECATED_CODE = PLUGIN_ID + ".compiler.problem.deprecationInDeprecatedCode"; //$NON-NLS-1$
256 /**
257      * Possible configurable option ID.
258      * @see #getDefaultOptions()
259      * @since 3.0
260      */
261     public static final String  JavaDoc COMPILER_PB_DEPRECATION_WHEN_OVERRIDING_DEPRECATED_METHOD = "org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod"; //$NON-NLS-1$
262 /**
263      * Possible configurable option ID.
264      * @see #getDefaultOptions()
265      */
266     public static final String  JavaDoc COMPILER_PB_HIDDEN_CATCH_BLOCK = PLUGIN_ID + ".compiler.problem.hiddenCatchBlock"; //$NON-NLS-1$
267 /**
268      * Possible configurable option ID.
269      * @see #getDefaultOptions()
270      */
271     public static final String  JavaDoc COMPILER_PB_UNUSED_LOCAL = PLUGIN_ID + ".compiler.problem.unusedLocal"; //$NON-NLS-1$
272 /**
273      * Possible configurable option ID.
274      * @see #getDefaultOptions()
275      */
276     public static final String  JavaDoc COMPILER_PB_UNUSED_PARAMETER = PLUGIN_ID + ".compiler.problem.unusedParameter"; //$NON-NLS-1$
277 /**
278      * Possible configurable option ID.
279      * @see #getDefaultOptions()
280      * @since 2.1
281      */
282     public static final String  JavaDoc COMPILER_PB_UNUSED_PARAMETER_WHEN_IMPLEMENTING_ABSTRACT = PLUGIN_ID + ".compiler.problem.unusedParameterWhenImplementingAbstract"; //$NON-NLS-1$
283 /**
284      * Possible configurable option ID.
285      * @see #getDefaultOptions()
286      * @since 2.1
287      */
288     public static final String  JavaDoc COMPILER_PB_UNUSED_PARAMETER_WHEN_OVERRIDING_CONCRETE = PLUGIN_ID + ".compiler.problem.unusedParameterWhenOverridingConcrete"; //$NON-NLS-1$
289 /**
290      * Possible configurable option ID.
291      * @see #getDefaultOptions()
292      * @since 3.3
293      */
294     public static final String  JavaDoc COMPILER_PB_UNUSED_PARAMETER_INCLUDE_DOC_COMMENT_REFERENCE = PLUGIN_ID + ".compiler.problem.unusedParameterIncludeDocCommentReference"; //$NON-NLS-1$
295 /**
296      * Possible configurable option ID.
297      * @see #getDefaultOptions()
298      * @since 2.0
299      */
300     public static final String  JavaDoc COMPILER_PB_UNUSED_IMPORT = PLUGIN_ID + ".compiler.problem.unusedImport"; //$NON-NLS-1$
301 /**
302      * Possible configurable option ID.
303      * @see #getDefaultOptions()
304      */
305     public static final String  JavaDoc COMPILER_PB_SYNTHETIC_ACCESS_EMULATION = PLUGIN_ID + ".compiler.problem.syntheticAccessEmulation"; //$NON-NLS-1$
306 /**
307      * Possible configurable option ID.
308      * @see #getDefaultOptions()
309      * @since 2.0
310      */
311     public static final String  JavaDoc COMPILER_PB_NON_NLS_STRING_LITERAL = PLUGIN_ID + ".compiler.problem.nonExternalizedStringLiteral"; //$NON-NLS-1$
312 /**
313      * Possible configurable option ID.
314      * @see #getDefaultOptions()
315      * @since 2.0
316      */
317     public static final String  JavaDoc COMPILER_PB_ASSERT_IDENTIFIER = PLUGIN_ID + ".compiler.problem.assertIdentifier"; //$NON-NLS-1$
318 /**
319      * Possible configurable option ID.
320      * @see #getDefaultOptions()
321      * @since 3.1
322      */
323     public static final String  JavaDoc COMPILER_PB_ENUM_IDENTIFIER = PLUGIN_ID + ".compiler.problem.enumIdentifier"; //$NON-NLS-1$
324 /**
325      * Possible configurable option ID.
326      * @see #getDefaultOptions()
327      * @since 2.1
328      */
329     public static final String  JavaDoc COMPILER_PB_STATIC_ACCESS_RECEIVER = PLUGIN_ID + ".compiler.problem.staticAccessReceiver"; //$NON-NLS-1$
330 /**
331      * Possible configurable option ID.
332      * @see #getDefaultOptions()
333      * @since 3.0
334      */
335     public static final String  JavaDoc COMPILER_PB_INDIRECT_STATIC_ACCESS = PLUGIN_ID + ".compiler.problem.indirectStaticAccess"; //$NON-NLS-1$
336 /**
337      * Possible configurable option ID.
338      * @see #getDefaultOptions()
339      * @since 2.1
340      */
341     public static final String  JavaDoc COMPILER_PB_NO_EFFECT_ASSIGNMENT = PLUGIN_ID + ".compiler.problem.noEffectAssignment"; //$NON-NLS-1$
342 /**
343      * Possible configurable option ID.
344      * @see #getDefaultOptions()
345      * @since 2.1
346      */
347     public static final String  JavaDoc COMPILER_PB_INCOMPATIBLE_NON_INHERITED_INTERFACE_METHOD = PLUGIN_ID + ".compiler.problem.incompatibleNonInheritedInterfaceMethod"; //$NON-NLS-1$
348 /**
349      * Possible configurable option ID.
350      * @see #getDefaultOptions()
351      * @since 2.1
352      */
353     public static final String  JavaDoc COMPILER_PB_UNUSED_PRIVATE_MEMBER = PLUGIN_ID + ".compiler.problem.unusedPrivateMember"; //$NON-NLS-1$
354 /**
355      * Possible configurable option ID.
356      * @see #getDefaultOptions()
357      * @since 3.0
358      */
359     public static final String  JavaDoc COMPILER_PB_LOCAL_VARIABLE_HIDING = PLUGIN_ID + ".compiler.problem.localVariableHiding"; //$NON-NLS-1$
360 /**
361      * Possible configurable option ID.
362      * @see #getDefaultOptions()
363      * @since 3.0
364      */
365     public static final String  JavaDoc COMPILER_PB_SPECIAL_PARAMETER_HIDING_FIELD = PLUGIN_ID + ".compiler.problem.specialParameterHidingField"; //$NON-NLS-1$
366 /**
367      * Possible configurable option ID.
368      * @see #getDefaultOptions()
369      * @since 3.0
370      */
371     public static final String  JavaDoc COMPILER_PB_FIELD_HIDING = PLUGIN_ID + ".compiler.problem.fieldHiding"; //$NON-NLS-1$
372 /**
373      * Possible configurable option ID.
374      * @see #getDefaultOptions()
375      * @since 3.1
376      */
377     public static final String  JavaDoc COMPILER_PB_TYPE_PARAMETER_HIDING = PLUGIN_ID + ".compiler.problem.typeParameterHiding"; //$NON-NLS-1$
378 /**
379      * Possible configurable option ID.
380      * @see #getDefaultOptions()
381      * @since 3.0
382      */
383     public static final String  JavaDoc COMPILER_PB_POSSIBLE_ACCIDENTAL_BOOLEAN_ASSIGNMENT = PLUGIN_ID + ".compiler.problem.possibleAccidentalBooleanAssignment"; //$NON-NLS-1$
384 /**
385      * Possible configurable option ID.
386      * @see #getDefaultOptions()
387      * @since 3.2
388      */
389     public static final String  JavaDoc COMPILER_PB_FALLTHROUGH_CASE = PLUGIN_ID + ".compiler.problem.fallthroughCase"; //$NON-NLS-1$
390 /**
391      * Possible configurable option ID.
392      * @see #getDefaultOptions()
393      * @since 3.0
394      */
395     public static final String  JavaDoc COMPILER_PB_EMPTY_STATEMENT = PLUGIN_ID + ".compiler.problem.emptyStatement"; //$NON-NLS-1$
396 /**
397      * Possible configurable option ID.
398      * @see #getDefaultOptions()
399      * @since 3.0
400      */
401     public static final String  JavaDoc COMPILER_PB_BOOLEAN_METHOD_THROWING_EXCEPTION = PLUGIN_ID + ".compiler.problem.booleanMethodThrowingException"; //$NON-NLS-1$
402 /**
403      * Possible configurable option ID.
404      * @see #getDefaultOptions()
405      * @since 3.0
406      */
407     public static final String  JavaDoc COMPILER_PB_UNNECESSARY_TYPE_CHECK = PLUGIN_ID + ".compiler.problem.unnecessaryTypeCheck"; //$NON-NLS-1$
408 /**
409      * Possible configurable option ID.
410      * @see #getDefaultOptions()
411      * @since 3.0
412      */
413     public static final String  JavaDoc COMPILER_PB_UNNECESSARY_ELSE = PLUGIN_ID + ".compiler.problem.unnecessaryElse"; //$NON-NLS-1$
414 /**
415      * Possible configurable option ID.
416      * @see #getDefaultOptions()
417      * @since 3.0
418      */
419     public static final String  JavaDoc COMPILER_PB_UNDOCUMENTED_EMPTY_BLOCK = PLUGIN_ID + ".compiler.problem.undocumentedEmptyBlock"; //$NON-NLS-1$
420 /**
421      * Possible configurable option ID.
422      * @see #getDefaultOptions()
423      * @since 3.0
424      */
425     public static final String  JavaDoc COMPILER_PB_FINALLY_BLOCK_NOT_COMPLETING = PLUGIN_ID + ".compiler.problem.finallyBlockNotCompletingNormally"; //$NON-NLS-1$
426 /**
427      * Possible configurable option ID.
428      * @see #getDefaultOptions()
429      * @since 3.0
430      */
431     public static final String  JavaDoc COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION = PLUGIN_ID + ".compiler.problem.unusedDeclaredThrownException"; //$NON-NLS-1$
432 /**
433      * Possible configurable option ID.
434      * @see #getDefaultOptions()
435      * @since 3.0
436      */
437     public static final String  JavaDoc COMPILER_PB_UNUSED_DECLARED_THROWN_EXCEPTION_WHEN_OVERRIDING = PLUGIN_ID + ".compiler.problem.unusedDeclaredThrownExceptionWhenOverriding"; //$NON-NLS-1$
438 /**
439      * Possible configurable option ID.
440      * @see #getDefaultOptions()
441      * @since 3.0
442      */
443     public static final String  JavaDoc COMPILER_PB_UNQUALIFIED_FIELD_ACCESS = PLUGIN_ID + ".compiler.problem.unqualifiedFieldAccess"; //$NON-NLS-1$
444 /**
445      * Possible configurable option ID.
446      * @see #getDefaultOptions()
447      * @deprecated - got renamed into {@link #COMPILER_PB_UNCHECKED_TYPE_OPERATION}
448      * @since 3.1
449      */
450     public static final String  JavaDoc COMPILER_PB_UNSAFE_TYPE_OPERATION = PLUGIN_ID + ".compiler.problem.uncheckedTypeOperation"; //$NON-NLS-1$
451 /**
452      * Possible configurable option ID.
453      * @see #getDefaultOptions()
454      * @since 3.1
455      */
456     public static final String  JavaDoc COMPILER_PB_UNCHECKED_TYPE_OPERATION = PLUGIN_ID + ".compiler.problem.uncheckedTypeOperation"; //$NON-NLS-1$
457 /**
458      * Possible configurable option ID.
459      * @see #getDefaultOptions()
460      * @since 3.2
461      */
462     public static final String  JavaDoc COMPILER_PB_RAW_TYPE_REFERENCE = PLUGIN_ID + ".compiler.problem.rawTypeReference"; //$NON-NLS-1$
463 /**
464      * Possible configurable option ID.
465      * @see #getDefaultOptions()
466      * @since 3.1
467      */
468     public static final String  JavaDoc COMPILER_PB_FINAL_PARAMETER_BOUND = PLUGIN_ID + ".compiler.problem.finalParameterBound"; //$NON-NLS-1$
469 /**
470      * Possible configurable option ID.
471      * @see #getDefaultOptions()
472      * @since 3.1
473      */
474     public static final String  JavaDoc COMPILER_PB_MISSING_SERIAL_VERSION = PLUGIN_ID + ".compiler.problem.missingSerialVersion"; //$NON-NLS-1$
475 /**
476      * Possible configurable option ID.
477      * @see #getDefaultOptions()
478      * @since 3.1
479      */
480     public static final String  JavaDoc COMPILER_PB_VARARGS_ARGUMENT_NEED_CAST = PLUGIN_ID + ".compiler.problem.varargsArgumentNeedCast"; //$NON-NLS-1$
481 /**
482      * Possible configurable option ID.
483      * @see #getDefaultOptions()
484      * @since 3.1
485      */
486     public static final String  JavaDoc COMPILER_PB_AUTOBOXING = PLUGIN_ID + ".compiler.problem.autoboxing"; //$NON-NLS-1$
487 /**
488      * Possible configurable option ID.
489      * @see #getDefaultOptions()
490      * @since 3.1
491      */
492     public static final String  JavaDoc COMPILER_PB_ANNOTATION_SUPER_INTERFACE = PLUGIN_ID + ".compiler.problem.annotationSuperInterface"; //$NON-NLS-1$
493 /**
494      * Possible configurable option ID.
495      * @see #getDefaultOptions()
496      * @since 3.1
497      */
498     public static final String  JavaDoc COMPILER_PB_MISSING_OVERRIDE_ANNOTATION = PLUGIN_ID + ".compiler.problem.missingOverrideAnnotation"; //$NON-NLS-1$
499 /**
500      * Possible configurable option ID.
501      * @see #getDefaultOptions()
502      * @since 3.1
503      */
504     public static final String  JavaDoc COMPILER_PB_MISSING_DEPRECATED_ANNOTATION = PLUGIN_ID + ".compiler.problem.missingDeprecatedAnnotation"; //$NON-NLS-1$
505 /**
506      * Possible configurable option ID.
507      * @see #getDefaultOptions()
508      * @since 3.1
509      */
510     public static final String  JavaDoc COMPILER_PB_INCOMPLETE_ENUM_SWITCH = PLUGIN_ID + ".compiler.problem.incompleteEnumSwitch"; //$NON-NLS-1$
511 /**
512      * Possible configurable option ID.
513      * @since 3.1
514      * @deprecated use {@link #COMPILER_PB_NULL_REFERENCE} instead
515      */
516     public static final String  JavaDoc COMPILER_PB_INCONSISTENT_NULL_CHECK = PLUGIN_ID + ".compiler.problem.inconsistentNullCheck"; //$NON-NLS-1$
517 /**
518      * Possible configurable option ID.
519      * @see #getDefaultOptions()
520      * @since 3.2
521      */
522     public static final String  JavaDoc COMPILER_PB_UNUSED_LABEL = PLUGIN_ID + ".compiler.problem.unusedLabel"; //$NON-NLS-1$
523 /**
524      * Possible configurable option ID.
525      * @see #getDefaultOptions()
526      * @since 3.0
527      */
528     public static final String  JavaDoc COMPILER_PB_INVALID_JAVADOC = PLUGIN_ID + ".compiler.problem.invalidJavadoc"; //$NON-NLS-1$
529 /**
530      * Possible configurable option ID.
531      * @see #getDefaultOptions()
532      * @since 3.0
533      */
534     public static final String  JavaDoc COMPILER_PB_INVALID_JAVADOC_TAGS = PLUGIN_ID + ".compiler.problem.invalidJavadocTags"; //$NON-NLS-1$
535 /**
536      * Possible configurable option ID.
537      * @see #getDefaultOptions()
538      * @since 3.1
539      */
540     public static final String  JavaDoc COMPILER_PB_INVALID_JAVADOC_TAGS__DEPRECATED_REF = PLUGIN_ID + ".compiler.problem.invalidJavadocTagsDeprecatedRef"; //$NON-NLS-1$
541 /**
542      * Possible configurable option ID.
543      * @see #getDefaultOptions()
544      * @since 3.1
545      */
546     public static final String  JavaDoc COMPILER_PB_INVALID_JAVADOC_TAGS__NOT_VISIBLE_REF = PLUGIN_ID + ".compiler.problem.invalidJavadocTagsNotVisibleRef"; //$NON-NLS-1$
547 /**
548      * Possible configurable option ID.
549      * @see #getDefaultOptions()
550      * @since 3.0
551      */
552     public static final String  JavaDoc COMPILER_PB_INVALID_JAVADOC_TAGS_VISIBILITY = PLUGIN_ID + ".compiler.problem.invalidJavadocTagsVisibility"; //$NON-NLS-1$
553 /**
554      * Possible configurable option ID.
555      * @see #getDefaultOptions()
556      * @since 3.0
557      */
558     public static final String  JavaDoc COMPILER_PB_MISSING_JAVADOC_TAGS = PLUGIN_ID + ".compiler.problem.missingJavadocTags"; //$NON-NLS-1$
559 /**
560      * Possible configurable option ID.
561      * @see #getDefaultOptions()
562      * @since 3.0
563      */
564     public static final String  JavaDoc COMPILER_PB_MISSING_JAVADOC_TAGS_VISIBILITY = PLUGIN_ID + ".compiler.problem.missingJavadocTagsVisibility"; //$NON-NLS-1$
565 /**
566      * Possible configurable option ID.
567      * @see #getDefaultOptions()
568      * @since 3.0
569      */
570     public static final String  JavaDoc COMPILER_PB_MISSING_JAVADOC_TAGS_OVERRIDING = PLUGIN_ID + ".compiler.problem.missingJavadocTagsOverriding"; //$NON-NLS-1$
571 /**
572      * Possible configurable option ID.
573      * @see #getDefaultOptions()
574      * @since 3.0
575      */
576     public static final String  JavaDoc COMPILER_PB_MISSING_JAVADOC_COMMENTS = PLUGIN_ID + ".compiler.problem.missingJavadocComments"; //$NON-NLS-1$
577 /**
578      * Possible configurable option ID.
579      * @see #getDefaultOptions()
580      * @since 3.0
581      */
582     public static final String  JavaDoc COMPILER_PB_MISSING_JAVADOC_COMMENTS_VISIBILITY = PLUGIN_ID + ".compiler.problem.missingJavadocCommentsVisibility"; //$NON-NLS-1$
583 /**
584      * Possible configurable option ID.
585      * @see #getDefaultOptions()
586      * @since 3.0
587      */
588     public static final String  JavaDoc COMPILER_PB_MISSING_JAVADOC_COMMENTS_OVERRIDING = PLUGIN_ID + ".compiler.problem.missingJavadocCommentsOverriding"; //$NON-NLS-1$
589 /**
590      * Possible configurable option ID.
591      * @see #getDefaultOptions()
592      * @since 2.1
593      */
594     public static final String  JavaDoc COMPILER_PB_CHAR_ARRAY_IN_STRING_CONCATENATION = PLUGIN_ID + ".compiler.problem.noImplicitStringConversion"; //$NON-NLS-1$
595 /**
596      * Possible configurable option ID.
597      * @see #getDefaultOptions()
598      * @since 2.0
599      */
600     public static final String  JavaDoc COMPILER_PB_MAX_PER_UNIT = PLUGIN_ID + ".compiler.maxProblemPerUnit"; //$NON-NLS-1$
601 /**
602      * Possible configurable option ID.
603      * @see #getDefaultOptions()
604      * @since 3.2
605      */
606     public static final String  JavaDoc COMPILER_PB_FATAL_OPTIONAL_ERROR = PLUGIN_ID + ".compiler.problem.fatalOptionalError"; //$NON-NLS-1$
607 /**
608      * Possible configurable option ID.
609      * @see #getDefaultOptions()
610      * @since 3.2
611      */
612     public static final String  JavaDoc COMPILER_PB_PARAMETER_ASSIGNMENT = PLUGIN_ID + ".compiler.problem.parameterAssignment"; //$NON-NLS-1$
613 /**
614      * Possible configurable option ID.
615      * @see #getDefaultOptions()
616      * @since 2.0
617      */
618     public static final String  JavaDoc COMPILER_SOURCE = PLUGIN_ID + ".compiler.source"; //$NON-NLS-1$
619 /**
620      * Possible configurable option ID.
621      * @see #getDefaultOptions()
622      * @since 2.0
623      */
624     public static final String  JavaDoc COMPILER_COMPLIANCE = PLUGIN_ID + ".compiler.compliance"; //$NON-NLS-1$
625 /**
626      * Possible configurable option ID.
627      * @see #getDefaultOptions()
628      * @since 2.1
629      */
630     public static final String  JavaDoc COMPILER_TASK_PRIORITIES = PLUGIN_ID + ".compiler.taskPriorities"; //$NON-NLS-1$
631 /**
632      * Possible configurable option value for COMPILER_TASK_PRIORITIES.
633      * @see #getDefaultOptions()
634      * @since 2.1
635      */
636     public static final String  JavaDoc COMPILER_TASK_PRIORITY_HIGH = "HIGH"; //$NON-NLS-1$
637 /**
638      * Possible configurable option value for COMPILER_TASK_PRIORITIES.
639      * @see #getDefaultOptions()
640      * @since 2.1
641      */
642     public static final String  JavaDoc COMPILER_TASK_PRIORITY_LOW = "LOW"; //$NON-NLS-1$
643 /**
644      * Possible configurable option value for COMPILER_TASK_PRIORITIES.
645      * @see #getDefaultOptions()
646      * @since 2.1
647      */
648     public static final String  JavaDoc COMPILER_TASK_PRIORITY_NORMAL = "NORMAL"; //$NON-NLS-1$
649 /**
650      * Possible configurable option ID.
651      * @see #getDefaultOptions()
652      * @since 2.1
653      */
654     public static final String  JavaDoc COMPILER_TASK_TAGS = PLUGIN_ID + ".compiler.taskTags"; //$NON-NLS-1$
655 /**
656      * Possible configurable option ID.
657      * @see #getDefaultOptions()
658      * @since 3.0
659      */
660     public static final String  JavaDoc COMPILER_TASK_CASE_SENSITIVE = PLUGIN_ID + ".compiler.taskCaseSensitive"; //$NON-NLS-1$
661 /**
662      * Possible configurable option ID.
663      * @see #getDefaultOptions()
664      * @since 3.1
665      */
666     public static final String  JavaDoc COMPILER_PB_FORBIDDEN_REFERENCE = PLUGIN_ID + ".compiler.problem.forbiddenReference"; //$NON-NLS-1$
667 /**
668      * Possible configurable option ID.
669      * @see #getDefaultOptions()
670      * @since 3.1
671      */
672     public static final String  JavaDoc COMPILER_PB_DISCOURAGED_REFERENCE = PLUGIN_ID + ".compiler.problem.discouragedReference"; //$NON-NLS-1$
673 /**
674      * Possible configurable option ID.
675      * @see #getDefaultOptions()
676      * @since 3.1
677      */
678     public static final String  JavaDoc COMPILER_PB_SUPPRESS_WARNINGS = PLUGIN_ID + ".compiler.problem.suppressWarnings"; //$NON-NLS-1$
679 /**
680      * Possible configurable option ID.
681      * @see #getDefaultOptions()
682      * @since 3.1
683      */
684     public static final String  JavaDoc COMPILER_PB_UNHANDLED_WARNING_TOKEN = PLUGIN_ID + ".compiler.problem.unhandledWarningToken"; //$NON-NLS-1$
685 /**
686      * Possible configurable option ID.
687      * @see #getDefaultOptions()
688      * @since 3.2
689      */
690     public static final String  JavaDoc COMPILER_PB_NULL_REFERENCE = PLUGIN_ID + ".compiler.problem.nullReference"; //$NON-NLS-1$
691 /**
692      * Possible configurable option ID.
693      * @see #getDefaultOptions()
694      * @since 3.3
695      */
696     public static final String  JavaDoc COMPILER_PB_POTENTIAL_NULL_REFERENCE = PLUGIN_ID + ".compiler.problem.potentialNullReference"; //$NON-NLS-1$
697 /**
698      * Possible configurable option ID.
699      * @see #getDefaultOptions()
700      * @since 3.3
701      */
702     public static final String  JavaDoc COMPILER_PB_REDUNDANT_NULL_CHECK = PLUGIN_ID + ".compiler.problem.redundantNullCheck"; //$NON-NLS-1$
703 /**
704      * Possible configurable option ID.
705      * @see #getDefaultOptions()
706      * @since 3.3
707      */
708     public static final String  JavaDoc COMPILER_PB_OVERRIDING_METHOD_WITHOUT_SUPER_INVOCATION = PLUGIN_ID + ".compiler.problem.overridingMethodWithoutSuperInvocation"; //$NON-NLS-1$
709 /**
710      * Possible configurable option ID.
711      * @see #getDefaultOptions()
712      */
713     public static final String  JavaDoc CORE_JAVA_BUILD_ORDER = PLUGIN_ID + ".computeJavaBuildOrder"; //$NON-NLS-1$
714 /**
715      * Possible configurable option ID.
716      * @see #getDefaultOptions()
717      * @since 2.0
718      */
719     public static final String  JavaDoc CORE_JAVA_BUILD_RESOURCE_COPY_FILTER = PLUGIN_ID + ".builder.resourceCopyExclusionFilter"; //$NON-NLS-1$
720 /**
721      * Possible configurable option ID.
722      * @see #getDefaultOptions()
723      * @since 2.1
724      */
725     public static final String  JavaDoc CORE_JAVA_BUILD_DUPLICATE_RESOURCE = PLUGIN_ID + ".builder.duplicateResourceTask"; //$NON-NLS-1$
726 /**
727      * Possible configurable option ID.
728      * @see #getDefaultOptions()
729      * @since 2.1
730      */
731     public static final String  JavaDoc CORE_JAVA_BUILD_CLEAN_OUTPUT_FOLDER = PLUGIN_ID + ".builder.cleanOutputFolder"; //$NON-NLS-1$
732 /**
733      * Possible configurable option ID.
734      * @see #getDefaultOptions()
735      * @since 3.2
736      */
737     public static final String  JavaDoc CORE_JAVA_BUILD_RECREATE_MODIFIED_CLASS_FILES_IN_OUTPUT_FOLDER = PLUGIN_ID + ".builder.recreateModifiedClassFileInOutputFolder"; //$NON-NLS-1$
738 /**
739      * Possible configurable option ID.
740      * @see #getDefaultOptions()
741      * @since 2.1
742      */
743     public static final String  JavaDoc CORE_INCOMPLETE_CLASSPATH = PLUGIN_ID + ".incompleteClasspath"; //$NON-NLS-1$
744 /**
745      * Possible configurable option ID.
746      * @see #getDefaultOptions()
747      * @since 2.1
748      */
749     public static final String  JavaDoc CORE_CIRCULAR_CLASSPATH = PLUGIN_ID + ".circularClasspath"; //$NON-NLS-1$
750 /**
751      * Possible configurable option ID.
752      * @see #getDefaultOptions()
753      * @since 3.0
754      */
755     public static final String  JavaDoc CORE_INCOMPATIBLE_JDK_LEVEL = PLUGIN_ID + ".incompatibleJDKLevel"; //$NON-NLS-1$
756 /**
757      * Possible configurable option ID.
758      * @see #getDefaultOptions()
759      * @since 2.0
760      */
761     public static final String  JavaDoc CORE_JAVA_BUILD_INVALID_CLASSPATH = PLUGIN_ID + ".builder.invalidClasspath"; //$NON-NLS-1$
762 /**
763      * Possible configurable option ID.
764      * @see #getDefaultOptions()
765      * @since 2.0
766      */
767     public static final String  JavaDoc CORE_ENCODING = PLUGIN_ID + ".encoding"; //$NON-NLS-1$
768 /**
769      * Possible configurable option ID.
770      * @see #getDefaultOptions()
771      * @since 2.1
772      */
773     public static final String  JavaDoc CORE_ENABLE_CLASSPATH_EXCLUSION_PATTERNS = PLUGIN_ID + ".classpath.exclusionPatterns"; //$NON-NLS-1$
774 /**
775      * Possible configurable option ID.
776      * @see #getDefaultOptions()
777      * @since 2.1
778      */
779     public static final String  JavaDoc CORE_ENABLE_CLASSPATH_MULTIPLE_OUTPUT_LOCATIONS = PLUGIN_ID + ".classpath.multipleOutputLocations"; //$NON-NLS-1$
780 /**
781      * Default task tag
782      * @deprecated Use {@link #DEFAULT_TASK_TAGS} instead
783      * @since 2.1
784      */
785     public static final String  JavaDoc DEFAULT_TASK_TAG = "TODO"; //$NON-NLS-1$
786 /**
787      * Default task priority
788      * @deprecated Use {@link #DEFAULT_TASK_PRIORITIES} instead
789      * @since 2.1
790      */
791     public static final String  JavaDoc DEFAULT_TASK_PRIORITY = "NORMAL"; //$NON-NLS-1$
792 /**
793      * Default task tag
794      * @since 3.0
795      */
796     public static final String  JavaDoc DEFAULT_TASK_TAGS = "TODO,FIXME,XXX"; //$NON-NLS-1$
797 /**
798      * Default task priority
799      * @since 3.0
800      */
801     public static final String  JavaDoc DEFAULT_TASK_PRIORITIES = "NORMAL,HIGH,NORMAL"; //$NON-NLS-1$
802 /**
803      * Possible configurable option ID.
804      * @see #getDefaultOptions()
805      * @since 2.0
806      * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_BRACE_POSITION_FOR_ANONYMOUS_TYPE_DECLARATION},
807      * {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_BRACE_POSITION_FOR_BLOCK} ,
808      * {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_BRACE_POSITION_FOR_CONSTRUCTOR_DECLARATION},
809      * {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_BRACE_POSITION_FOR_METHOD_DECLARATION},
810      * {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_BRACE_POSITION_FOR_SWITCH},
811      * {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_BRACE_POSITION_FOR_TYPE_DECLARATION} instead
812      */
813     public static final String  JavaDoc FORMATTER_NEWLINE_OPENING_BRACE = PLUGIN_ID + ".formatter.newline.openingBrace"; //$NON-NLS-1$
814 /**
815      * Possible configurable option ID.
816      * @see #getDefaultOptions()
817      * @since 2.0
818      * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_NEW_LINE_BEFORE_CATCH_IN_TRY_STATEMENT},
819      * {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_NEW_LINE_BEFORE_ELSE_IN_IF_STATEMENT},
820      * {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_NEW_LINE_BEFORE_FINALLY_IN_TRY_STATEMENT},
821      * {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_NEW_LINE_BEFORE_WHILE_IN_DO_STATEMENT} instead.
822      */
823     public static final String  JavaDoc FORMATTER_NEWLINE_CONTROL = PLUGIN_ID + ".formatter.newline.controlStatement"; //$NON-NLS-1$
824 /**
825      * Possible configurable option ID.
826      * @see #getDefaultOptions()
827      * @since 2.0
828      * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_COMPACT_ELSE_IF} instead
829      */
830     public static final String  JavaDoc FORMATTER_NEWLINE_ELSE_IF = PLUGIN_ID + ".formatter.newline.elseIf"; //$NON-NLS-1$
831 /**
832      * Possible configurable option ID.
833      * @see #getDefaultOptions()
834      * @since 2.0
835      * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_NEW_LINE_IN_EMPTY_BLOCK} instead
836      */
837     public static final String  JavaDoc FORMATTER_NEWLINE_EMPTY_BLOCK = PLUGIN_ID + ".formatter.newline.emptyBlock"; //$NON-NLS-1$
838 /**
839      * Possible configurable option ID.
840      * @see #getDefaultOptions()
841      * @since 2.0
842      * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_NUMBER_OF_EMPTY_LINES_TO_PRESERVE} instead
843      */
844     public static final String  JavaDoc FORMATTER_CLEAR_BLANK_LINES = PLUGIN_ID + ".formatter.newline.clearAll"; //$NON-NLS-1$
845 /**
846      * Possible configurable option ID.
847      * @see #getDefaultOptions()
848      * @since 2.0
849      * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_LINE_SPLIT} instead
850      */
851     public static final String  JavaDoc FORMATTER_LINE_SPLIT = PLUGIN_ID + ".formatter.lineSplit"; //$NON-NLS-1$
852 /**
853      * Possible configurable option ID.
854      * @see #getDefaultOptions()
855      * @since 2.0
856      * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_SPACE_BEFORE_ASSIGNMENT_OPERATOR} instead
857      */
858     public static final String  JavaDoc FORMATTER_COMPACT_ASSIGNMENT = PLUGIN_ID + ".formatter.style.assignment"; //$NON-NLS-1$
859 /**
860      * Possible configurable option ID.
861      * @see #getDefaultOptions()
862      * @since 2.0
863      * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_TAB_CHAR}} instead
864      */
865     public static final String  JavaDoc FORMATTER_TAB_CHAR = PLUGIN_ID + ".formatter.tabulation.char"; //$NON-NLS-1$
866 /**
867      * Possible configurable option ID.
868      * @see #getDefaultOptions()
869      * @since 2.0
870      * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_TAB_SIZE} instead
871      */
872     public static final String  JavaDoc FORMATTER_TAB_SIZE = PLUGIN_ID + ".formatter.tabulation.size"; //$NON-NLS-1$
873 /**
874      * Possible configurable option ID
875      * @see #getDefaultOptions()
876      * @since 2.1
877      * @deprecated Use {@link org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants#FORMATTER_INSERT_SPACE_AFTER_CLOSING_PAREN_IN_CAST} instead
878      */
879     public static final String  JavaDoc FORMATTER_SPACE_CASTEXPRESSION = PLUGIN_ID + ".formatter.space.castexpression"; //$NON-NLS-1$
880 /**
881      * Possible configurable option ID.
882      * @see #getDefaultOptions()
883      * @since 2.0
884      */
885     public static final String  JavaDoc CODEASSIST_VISIBILITY_CHECK = PLUGIN_ID + ".codeComplete.visibilityCheck"; //$NON-NLS-1$
886 /**
887      * Possible configurable option ID.
888      * @see #getDefaultOptions()
889      * @since 3.2
890      */
891     public static final String  JavaDoc CODEASSIST_DEPRECATION_CHECK = PLUGIN_ID + ".codeComplete.deprecationCheck"; //$NON-NLS-1$
892 /**
893      * Possible configurable option ID.
894      * @see #getDefaultOptions()
895      * @since 3.2
896      */
897     public static final String  JavaDoc CODEASSIST_CAMEL_CASE_MATCH = PLUGIN_ID + ".codeComplete.camelCaseMatch"; //$NON-NLS-1$
898 /**
899      * Possible configurable option ID.
900      * @see #getDefaultOptions()
901      * @since 2.0
902      */
903     public static final String  JavaDoc CODEASSIST_IMPLICIT_QUALIFICATION = PLUGIN_ID + ".codeComplete.forceImplicitQualification"; //$NON-NLS-1$
904 /**
905      * Possible configurable option ID.
906      * @see #getDefaultOptions()
907      * @since 2.1
908      */
909     public static final String  JavaDoc CODEASSIST_FIELD_PREFIXES = PLUGIN_ID + ".codeComplete.fieldPrefixes"; //$NON-NLS-1$
910 /**
911      * Possible configurable option ID.
912      * @see #getDefaultOptions()
913      * @since 2.1
914      */
915     public static final String  JavaDoc CODEASSIST_STATIC_FIELD_PREFIXES = PLUGIN_ID + ".codeComplete.staticFieldPrefixes"; //$NON-NLS-1$
916 /**
917      * Possible configurable option ID.
918      * @see #getDefaultOptions()
919      * @since 2.1
920      */
921     public static final String  JavaDoc CODEASSIST_LOCAL_PREFIXES = PLUGIN_ID + ".codeComplete.localPrefixes"; //$NON-NLS-1$
922 /**
923      * Possible configurable option ID.
924      * @see #getDefaultOptions()
925      * @since 2.1
926      */
927     public static final String  JavaDoc CODEASSIST_ARGUMENT_PREFIXES = PLUGIN_ID + ".codeComplete.argumentPrefixes"; //$NON-NLS-1$
928 /**
929      * Possible configurable option ID.
930      * @see #getDefaultOptions()
931      * @since 2.1
932      */
933     public static final String  JavaDoc CODEASSIST_FIELD_SUFFIXES = PLUGIN_ID + ".codeComplete.fieldSuffixes"; //$NON-NLS-1$
934 /**
935      * Possible configurable option ID.
936      * @see #getDefaultOptions()
937      * @since 2.1
938      */
939     public static final String  JavaDoc CODEASSIST_STATIC_FIELD_SUFFIXES = PLUGIN_ID + ".codeComplete.staticFieldSuffixes"; //$NON-NLS-1$
940 /**
941      * Possible configurable option ID.
942      * @see #getDefaultOptions()
943      * @since 2.1
944      */
945     public static final String  JavaDoc CODEASSIST_LOCAL_SUFFIXES = PLUGIN_ID + ".codeComplete.localSuffixes"; //$NON-NLS-1$
946 /**
947      * Possible configurable option ID.
948      * @see #getDefaultOptions()
949      * @since 2.1
950      */
951     public static final String  JavaDoc CODEASSIST_ARGUMENT_SUFFIXES = PLUGIN_ID + ".codeComplete.argumentSuffixes"; //$NON-NLS-1$
952 /**
953      * Possible configurable option ID.
954      * @see #getDefaultOptions()
955      * @since 3.1
956      */
957     public static final String  JavaDoc CODEASSIST_FORBIDDEN_REFERENCE_CHECK= PLUGIN_ID + ".codeComplete.forbiddenReferenceCheck"; //$NON-NLS-1$
958 /**
959      * Possible configurable option ID.
960      * @see #getDefaultOptions()
961      * @since 3.1
962      */
963     public static final String  JavaDoc CODEASSIST_DISCOURAGED_REFERENCE_CHECK= PLUGIN_ID + ".codeComplete.discouragedReferenceCheck"; //$NON-NLS-1$
964 /**
965      * Possible configurable option ID.
966      * @see #getDefaultOptions()
967      * @since 3.3
968      */
969     public static final String  JavaDoc CODEASSIST_SUGGEST_STATIC_IMPORTS= PLUGIN_ID + ".codeComplete.suggestStaticImports"; //$NON-NLS-1$
970 /**
971      * Possible configurable option ID.
972      * @see #getDefaultOptions()
973      * @since 3.2
974      */
975     public static final String  JavaDoc TIMEOUT_FOR_PARAMETER_NAME_FROM_ATTACHED_JAVADOC = PLUGIN_ID + ".timeoutForParameterNameFromAttachedJavadoc"; //$NON-NLS-1$
976 
977     /**
978      * Possible configurable option value.
979      * @see #getDefaultOptions()
980      */
981     public static final String  JavaDoc GENERATE = "generate"; //$NON-NLS-1$
982 /**
983      * Possible configurable option value.
984      * @see #getDefaultOptions()
985      */
986     public static final String  JavaDoc DO_NOT_GENERATE = "do not generate"; //$NON-NLS-1$
987 /**
988      * Possible configurable option value.
989      * @see #getDefaultOptions()
990      */
991     public static final String  JavaDoc PRESERVE = "preserve"; //$NON-NLS-1$
992 /**
993      * Possible configurable option value.
994      * @see #getDefaultOptions()
995      */
996     public static final String  JavaDoc OPTIMIZE_OUT = "optimize out"; //$NON-NLS-1$
997 /**
998      * Possible configurable option value.
999      * @see #getDefaultOptions()
1000     */
1001    public static final String  JavaDoc VERSION_1_1 = "1.1"; //$NON-NLS-1$
1002 /**
1003     * Possible configurable option value.
1004     * @see #getDefaultOptions()
1005     */
1006    public static final String  JavaDoc VERSION_1_2 = "1.2"; //$NON-NLS-1$
1007 /**
1008     * Possible configurable option value.
1009     * @see #getDefaultOptions()
1010     * @since 2.0
1011     */
1012    public static final String  JavaDoc VERSION_1_3 = "1.3"; //$NON-NLS-1$
1013 /**
1014     * Possible configurable option value.
1015     * @see #getDefaultOptions()
1016     * @since 2.0
1017     */
1018    public static final String  JavaDoc VERSION_1_4 = "1.4"; //$NON-NLS-1$
1019 /**
1020     * Possible configurable option value.
1021     * @see #getDefaultOptions()
1022     * @since 3.0
1023     */
1024    public static final String  JavaDoc VERSION_1_5 = "1.5"; //$NON-NLS-1$
1025 /**
1026     * Possible configurable option value.
1027     * @see #getDefaultOptions()
1028     * @since 3.2
1029     */
1030    public static final String  JavaDoc VERSION_1_6 = "1.6"; //$NON-NLS-1$
1031 /**
1032     * Possible configurable option value.
1033     * @see #getDefaultOptions()
1034     * @since 3.3
1035     */
1036    public static final String  JavaDoc VERSION_1_7 = "1.7"; //$NON-NLS-1$
1037 /**
1038     * Possible configurable option value.
1039     * @see #getDefaultOptions()
1040     * @since 2.0
1041     */
1042    public static final String  JavaDoc ABORT = "abort"; //$NON-NLS-1$
1043 /**
1044     * Possible configurable option value.
1045     * @see #getDefaultOptions()
1046     */
1047    public static final String  JavaDoc ERROR = "error"; //$NON-NLS-1$
1048 /**
1049     * Possible configurable option value.
1050     * @see #getDefaultOptions()
1051     */
1052    public static final String  JavaDoc WARNING = "warning"; //$NON-NLS-1$
1053 /**
1054     * Possible configurable option value.
1055     * @see #getDefaultOptions()
1056     */
1057    public static final String  JavaDoc IGNORE = "ignore"; //$NON-NLS-1$
1058 /**
1059     * Possible configurable option value.
1060     * @see #getDefaultOptions()
1061     */
1062    public static final String  JavaDoc COMPUTE = "compute"; //$NON-NLS-1$
1063 /**
1064     * Possible configurable option value.
1065     * @see #getDefaultOptions()
1066     * @since 2.0
1067     */
1068    public static final String  JavaDoc INSERT = "insert"; //$NON-NLS-1$
1069 /**
1070     * Possible configurable option value.
1071     * @see #getDefaultOptions()
1072     * @since 2.0
1073     */
1074    public static final String  JavaDoc DO_NOT_INSERT = "do not insert"; //$NON-NLS-1$
1075 /**
1076     * Possible configurable option value.
1077     * @see #getDefaultOptions()
1078     * @since 2.0
1079     */
1080    public static final String  JavaDoc PRESERVE_ONE = "preserve one"; //$NON-NLS-1$
1081 /**
1082     * Possible configurable option value.
1083     * @see #getDefaultOptions()
1084     * @since 2.0
1085     */
1086    public static final String  JavaDoc CLEAR_ALL = "clear all"; //$NON-NLS-1$
1087 /**
1088     * Possible configurable option value.
1089     * @see #getDefaultOptions()
1090     * @since 2.0
1091     */
1092    public static final String  JavaDoc NORMAL = "normal"; //$NON-NLS-1$
1093 /**
1094     * Possible configurable option value.
1095     * @see #getDefaultOptions()
1096     * @since 2.0
1097     */
1098    public static final String  JavaDoc COMPACT = "compact"; //$NON-NLS-1$
1099 /**
1100     * Possible configurable option value.
1101     * @see #getDefaultOptions()
1102     * @since 2.0
1103     */
1104    public static final String  JavaDoc TAB = "tab"; //$NON-NLS-1$
1105 /**
1106     * Possible configurable option value.
1107     * @see #getDefaultOptions()
1108     * @since 2.0
1109     */
1110    public static final String  JavaDoc SPACE = "space"; //$NON-NLS-1$
1111 /**
1112     * Possible configurable option value.
1113     * @see #getDefaultOptions()
1114     * @since 2.0
1115     */
1116    public static final String  JavaDoc ENABLED = "enabled"; //$NON-NLS-1$
1117 /**
1118     * Possible configurable option value.
1119     * @see #getDefaultOptions()
1120     * @since 2.0
1121     */
1122    public static final String  JavaDoc DISABLED = "disabled"; //$NON-NLS-1$
1123 /**
1124     * Possible configurable option value.
1125     * @see #getDefaultOptions()
1126     * @since 2.1
1127     */
1128    public static final String  JavaDoc CLEAN = "clean"; //$NON-NLS-1$
1129 /**
1130     * Possible configurable option value.
1131     * @see #getDefaultOptions()
1132     * @since 3.0
1133     */
1134    public static final String  JavaDoc PUBLIC = "public"; //$NON-NLS-1$
1135 /**
1136     * Possible configurable option value.
1137     * @see #getDefaultOptions()
1138     * @since 3.0
1139     */
1140    public static final String  JavaDoc PROTECTED = "protected"; //$NON-NLS-1$
1141 /**
1142     * Possible configurable option value.
1143     * @see #getDefaultOptions()
1144     * @since 3.0
1145     */
1146    public static final String  JavaDoc DEFAULT = "default"; //$NON-NLS-1$
1147 /**
1148     * Possible configurable option value.
1149     * @see #getDefaultOptions()
1150     * @since 3.0
1151     */
1152    public static final String  JavaDoc PRIVATE = "private"; //$NON-NLS-1$
1153 /**
1154     * Possible configurable option value.
1155     * @see #getDefaultOptions()
1156     * @since 3.1
1157     */
1158    public static final String  JavaDoc NEVER = "never"; //$NON-NLS-1$
1159
1160    /**
1161     * Value of the content-type for Java source files. Use this value to retrieve the Java content type
1162     * from the content type manager, and to add new Java-like extensions to this content type.
1163     *
1164     * @see org.eclipse.core.runtime.content.IContentTypeManager#getContentType(String)
1165     * @see #getJavaLikeExtensions()
1166     * @since 3.2
1167     */
1168    public static final String  JavaDoc JAVA_SOURCE_CONTENT_TYPE = JavaCore.PLUGIN_ID+".javaSource" ; //$NON-NLS-1$
1169
1170    /**
1171     * Creates the Java core plug-in.
1172     * <p>
1173     * The plug-in instance is created automatically by the
1174     * Eclipse platform. Clients must not call.
1175     * </p>
1176     *
1177     * @since 3.0
1178     */
1179    public JavaCore() {
1180        super();
1181        JAVA_CORE_PLUGIN = this;
1182    }
1183
1184    /**
1185     * Adds the given listener for changes to Java elements.
1186     * Has no effect if an identical listener is already registered.
1187     *
1188     * This listener will only be notified during the POST_CHANGE resource change notification
1189     * and any reconcile operation (POST_RECONCILE).
1190     * For finer control of the notification, use <code>addElementChangedListener(IElementChangedListener,int)</code>,
1191     * which allows to specify a different eventMask.
1192     *
1193     * @param listener the listener
1194     * @see ElementChangedEvent
1195     */
1196    public static void addElementChangedListener(IElementChangedListener listener) {
1197        addElementChangedListener(listener, ElementChangedEvent.POST_CHANGE | ElementChangedEvent.POST_RECONCILE);
1198    }
1199
1200    /**
1201     * Adds the given listener for changes to Java elements.
1202     * Has no effect if an identical listener is already registered.
1203     * After completion of this method, the given listener will be registered for exactly
1204     * the specified events. If they were previously registered for other events, they
1205     * will be deregistered.
1206     * <p>
1207     * Once registered, a listener starts receiving notification of changes to
1208     * java elements in the model. The listener continues to receive
1209     * notifications until it is replaced or removed.
1210     * </p>
1211     * <p>
1212     * Listeners can listen for several types of event as defined in <code>ElementChangeEvent</code>.
1213     * Clients are free to register for any number of event types however if they register
1214     * for more than one, it is their responsibility to ensure they correctly handle the
1215     * case where the same java element change shows up in multiple notifications.
1216     * Clients are guaranteed to receive only the events for which they are registered.
1217     * </p>
1218     *
1219     * @param listener the listener
1220     * @param eventMask the bit-wise OR of all event types of interest to the listener
1221     * @see IElementChangedListener
1222     * @see ElementChangedEvent
1223     * @see #removeElementChangedListener(IElementChangedListener)
1224     * @since 2.0
1225     */
1226    public static void addElementChangedListener(IElementChangedListener listener, int eventMask) {
1227        JavaModelManager.getJavaModelManager().deltaState.addElementChangedListener(listener, eventMask);
1228    }
1229
1230    /**
1231     * Configures the given marker attribute map for the given Java element.
1232     * Used for markers, which denote a Java element rather than a resource.
1233     *
1234     * @param attributes the mutable marker attribute map (key type: <code>String</code>,
1235     * value type: <code>String</code>)
1236     * @param element the Java element for which the marker needs to be configured
1237     */
1238    public static void addJavaElementMarkerAttributes(
1239        Map  JavaDoc attributes,
1240        IJavaElement element) {
1241        if (element instanceof IMember)
1242            element = ((IMember) element).getClassFile();
1243        if (attributes != null && element != null)
1244            attributes.put(ATT_HANDLE_ID, element.getHandleIdentifier());
1245    }
1246
1247    private static void addNonJavaResources(Object  JavaDoc[] nonJavaResources,
1248            IContainer container,
1249            int rootPathSegmentCounts,
1250            ArrayList  JavaDoc collector) {
1251        for (int i = 0, max = nonJavaResources.length; i < max; i++) {
1252            Object  JavaDoc nonJavaResource = nonJavaResources[i];
1253            if (nonJavaResource instanceof IFile) {
1254                IFile file = (IFile) nonJavaResource;
1255                IPath path = file.getFullPath().removeFirstSegments(rootPathSegmentCounts);
1256                IResource member = container.findMember(path);
1257                if (member != null && member.exists()) {
1258                    collector.add(member);
1259                }
1260            } else if (nonJavaResource instanceof IFolder) {
1261                IFolder folder = (IFolder) nonJavaResource;
1262                IResource[] members = null;
1263                try {
1264                    members = folder.members();
1265                } catch (CoreException e) {
1266                    // ignore
1267 }
1268                if (members != null) {
1269                    addNonJavaResources(members, container, rootPathSegmentCounts, collector);
1270                }
1271            }
1272        }
1273    }
1274
1275    /**
1276     * Adds the given listener for POST_CHANGE resource change events to the Java core.
1277     * The listener is guaranteed to be notified of the POST_CHANGE resource change event before
1278     * the Java core starts processing the resource change event itself.
1279     * <p>
1280     * Has no effect if an identical listener is already registered.
1281     * </p>
1282     *
1283     * @param listener the listener
1284     * @see #removePreProcessingResourceChangedListener(IResourceChangeListener)
1285     * @since 3.0
1286     * @deprecated use addPreProcessingResourceChangedListener(listener, IResourceChangeEvent.POST_CHANGE) instead
1287     */
1288    public static void addPreProcessingResourceChangedListener(IResourceChangeListener listener) {
1289        addPreProcessingResourceChangedListener(listener, IResourceChangeEvent.POST_CHANGE);
1290    }
1291
1292    /**
1293     * Adds the given listener for resource change events of the given types to the Java core.
1294     * The listener is guaranteed to be notified of the resource change event before
1295     * the Java core starts processing the resource change event itself.
1296     * <p>
1297     * If an identical listener is already registered, the given event types are added to the event types
1298     * of interest to the listener.
1299     * </p>
1300     * <p>
1301     * Supported event types are:
1302     * <ul>
1303     * <li>{@link IResourceChangeEvent#PRE_BUILD}</li>
1304     * <li>{@link IResourceChangeEvent#POST_BUILD}</li>
1305     * <li>{@link IResourceChangeEvent#POST_CHANGE}</li>
1306     * <li>{@link IResourceChangeEvent#PRE_DELETE}</li>
1307     * <li>{@link IResourceChangeEvent#PRE_CLOSE}</li>
1308     * </ul>
1309     * This list may increase in the future.
1310     * </p>
1311     *
1312     * @param listener the listener
1313     * @param eventMask the bit-wise OR of all event types of interest to the
1314     * listener
1315     * @see #removePreProcessingResourceChangedListener(IResourceChangeListener)
1316     * @see IResourceChangeEvent
1317     * @since 3.2
1318     */
1319    public static void addPreProcessingResourceChangedListener(IResourceChangeListener listener, int eventMask) {
1320        JavaModelManager.getJavaModelManager().deltaState.addPreResourceChangedListener(listener, eventMask);
1321    }
1322
1323    /**
1324     * Configures the given marker for the given Java element.
1325     * Used for markers, which denote a Java element rather than a resource.
1326     *
1327     * @param marker the marker to be configured
1328     * @param element the Java element for which the marker needs to be configured
1329     * @exception CoreException if the <code>IMarker.setAttribute</code> on the marker fails
1330     */
1331    public void configureJavaElementMarker(IMarker marker, IJavaElement element)
1332        throws CoreException {
1333        if (element instanceof IMember)
1334            element = ((IMember) element).getClassFile();
1335        if (marker != null && element != null)
1336            marker.setAttribute(ATT_HANDLE_ID, element.getHandleIdentifier());
1337    }
1338
1339    /**
1340     * Returns the Java model element corresponding to the given handle identifier
1341     * generated by <code>IJavaElement.getHandleIdentifier()</code>, or
1342     * <code>null</code> if unable to create the associated element.
1343     *
1344     * @param handleIdentifier the given handle identifier
1345     * @return the Java element corresponding to the handle identifier
1346     */
1347    public static IJavaElement create(String  JavaDoc handleIdentifier) {
1348        return create(handleIdentifier, DefaultWorkingCopyOwner.PRIMARY);
1349    }
1350
1351    /**
1352     * Returns the Java model element corresponding to the given handle identifier
1353     * generated by <code>IJavaElement.getHandleIdentifier()</code>, or
1354     * <code>null</code> if unable to create the associated element.
1355     * If the returned Java element is an <code>ICompilationUnit</code>, its owner
1356     * is the given owner if such a working copy exists, otherwise the compilation unit
1357     * is a primary compilation unit.
1358     *
1359     * @param handleIdentifier the given handle identifier
1360     * @param owner the owner of the returned compilation unit, ignored if the returned
1361     * element is not a compilation unit
1362     * @return the Java element corresponding to the handle identifier
1363     * @since 3.0
1364     */
1365    public static IJavaElement create(String  JavaDoc handleIdentifier, WorkingCopyOwner owner) {
1366        if (handleIdentifier == null) {
1367            return null;
1368        }
1369        MementoTokenizer memento = new MementoTokenizer(handleIdentifier);
1370        JavaModel model = JavaModelManager.getJavaModelManager().getJavaModel();
1371        return model.getHandleFromMemento(memento, owner);
1372    }
1373
1374    /**
1375     * Returns the Java element corresponding to the given file, or
1376     * <code>null</code> if unable to associate the given file
1377     * with a Java element.
1378     *
1379     * <p>The file must be one of:<ul>
1380     * <li>a file with one of the {@link JavaCore#getJavaLikeExtensions()
1381     * Java-like extensions} - the element returned is the corresponding <code>ICompilationUnit</code></li>
1382     * <li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>
1383     * <li>a <code>.jar</code> file - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>
1384     * </ul>
1385     * <p>
1386     * Creating a Java element has the side effect of creating and opening all of the
1387     * element's parents if they are not yet open.
1388     *
1389     * @param file the given file
1390     * @return the Java element corresponding to the given file, or
1391     * <code>null</code> if unable to associate the given file
1392     * with a Java element
1393     */
1394    public static IJavaElement create(IFile file) {
1395        return JavaModelManager.create(file, null/*unknown java project*/);
1396    }
1397    /**
1398     * Returns the package fragment or package fragment root corresponding to the given folder, or
1399     * <code>null</code> if unable to associate the given folder with a Java element.
1400     * <p>
1401     * Note that a package fragment root is returned rather than a default package.
1402     * <p>
1403     * Creating a Java element has the side effect of creating and opening all of the
1404     * element's parents if they are not yet open.
1405     *
1406     * @param folder the given folder
1407     * @return the package fragment or package fragment root corresponding to the given folder, or
1408     * <code>null</code> if unable to associate the given folder with a Java element
1409     */
1410    public static IJavaElement create(IFolder folder) {
1411        return JavaModelManager.create(folder, null/*unknown java project*/);
1412    }
1413    /**
1414     * Returns the Java project corresponding to the given project.
1415     * <p>
1416     * Creating a Java Project has the side effect of creating and opening all of the
1417     * project's parents if they are not yet open.
1418     * <p>
1419     * Note that no check is done at this time on the existence or the java nature of this project.
1420     *
1421     * @param project the given project
1422     * @return the Java project corresponding to the given project, null if the given project is null
1423     */
1424    public static IJavaProject create(IProject project) {
1425        if (project == null) {
1426            return null;
1427        }
1428        JavaModel javaModel = JavaModelManager.getJavaModelManager().getJavaModel();
1429        return javaModel.getJavaProject(project);
1430    }
1431    /**
1432     * Returns the Java element corresponding to the given resource, or
1433     * <code>null</code> if unable to associate the given resource
1434     * with a Java element.
1435     * <p>
1436     * The resource must be one of:<ul>
1437     * <li>a project - the element returned is the corresponding <code>IJavaProject</code></li>
1438     * <li>a file with one of the {@link JavaCore#getJavaLikeExtensions()
1439     * Java-like extensions} - the element returned is the corresponding <code>ICompilationUnit</code></li>
1440     * <li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>
1441     * <li>a <code>.jar</code> file - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>
1442     * <li>a folder - the element returned is the corresponding <code>IPackageFragmentRoot</code>
1443     * or <code>IPackageFragment</code></li>
1444     * <li>the workspace root resource - the element returned is the <code>IJavaModel</code></li>
1445     * </ul>
1446     * <p>
1447     * Creating a Java element has the side effect of creating and opening all of the
1448     * element's parents if they are not yet open.
1449     *
1450     * @param resource the given resource
1451     * @return the Java element corresponding to the given resource, or
1452     * <code>null</code> if unable to associate the given resource
1453     * with a Java element
1454     */
1455    public static IJavaElement create(IResource resource) {
1456        return JavaModelManager.create(resource, null/*unknown java project*/);
1457    }
1458    /**
1459     * Returns the Java element corresponding to the given file, its project being the given
1460     * project. Returns <code>null</code> if unable to associate the given resource
1461     * with a Java element.
1462     *<p>
1463     * The resource must be one of:<ul>
1464     * <li>a project - the element returned is the corresponding <code>IJavaProject</code></li>
1465     * <li>a file with one of the {@link JavaCore#getJavaLikeExtensions()
1466     * Java-like extensions} - the element returned is the corresponding <code>ICompilationUnit</code></li>
1467     * <li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>
1468     * <li>a <code>.jar</code> file - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>
1469     * <li>a folder - the element returned is the corresponding <code>IPackageFragmentRoot</code>
1470     * or <code>IPackageFragment</code></li>
1471     * <li>the workspace root resource - the element returned is the <code>IJavaModel</code></li>
1472     * </ul>
1473     * <p>
1474     * Creating a Java element has the side effect of creating and opening all of the
1475     * element's parents if they are not yet open.
1476     *
1477     * @param resource the given resource
1478     * @return the Java element corresponding to the given file, or
1479     * <code>null</code> if unable to associate the given file
1480     * with a Java element
1481     * @since 3.3
1482     */
1483    public static IJavaElement create(IResource resource, IJavaProject project) {
1484        return JavaModelManager.create(resource, project);
1485    }
1486    /**
1487     * Returns the Java model.
1488     *
1489     * @param root the given root
1490     * @return the Java model, or <code>null</code> if the root is null
1491     */
1492    public static IJavaModel create(IWorkspaceRoot root) {
1493        if (root == null) {
1494            return null;
1495        }
1496        return JavaModelManager.getJavaModelManager().getJavaModel();
1497    }
1498    /**
1499     * Creates and returns a class file element for
1500     * the given <code>.class</code> file. Returns <code>null</code> if unable
1501     * to recognize the class file.
1502     *
1503     * @param file the given <code>.class</code> file
1504     * @return a class file element for the given <code>.class</code> file, or <code>null</code> if unable
1505     * to recognize the class file
1506     */
1507    public static IClassFile createClassFileFrom(IFile file) {
1508        return JavaModelManager.createClassFileFrom(file, null);
1509    }
1510    /**
1511     * Creates and returns a compilation unit element for
1512     * the given source file (i.e. a file with one of the {@link JavaCore#getJavaLikeExtensions()
1513     * Java-like extensions}). Returns <code>null</code> if unable
1514     * to recognize the compilation unit.
1515     *
1516     * @param file the given source file
1517     * @return a compilation unit element for the given source file, or <code>null</code> if unable
1518     * to recognize the compilation unit
1519     */
1520    public static ICompilationUnit createCompilationUnitFrom(IFile file) {
1521        return JavaModelManager.createCompilationUnitFrom(file, null/*unknown java project*/);
1522    }
1523    /**
1524     * Creates and returns a handle for the given JAR file.
1525     * The Java model associated with the JAR's project may be
1526     * created as a side effect.
1527     *
1528     * @param file the given JAR file
1529     * @return a handle for the given JAR file, or <code>null</code> if unable to create a JAR package fragment root.
1530     * (for example, if the JAR file represents a non-Java resource)
1531     */
1532    public static IPackageFragmentRoot createJarPackageFragmentRootFrom(IFile file) {
1533        return JavaModelManager.createJarPackageFragmentRootFrom(file, null/*unknown java project*/);
1534    }
1535
1536    /**
1537     * Answers the project specific value for a given classpath container.
1538     * In case this container path could not be resolved, then will answer <code>null</code>.
1539     * Both the container path and the project context are supposed to be non-null.
1540     * <p>
1541     * The containerPath is a formed by a first ID segment followed with extra segments, which can be
1542     * used as additional hints for resolution. If no container was ever recorded for this container path
1543     * onto this project (using <code>setClasspathContainer</code>, then a
1544     * <code>ClasspathContainerInitializer</code> will be activated if any was registered for this container
1545     * ID onto the extension point "org.eclipse.jdt.core.classpathContainerInitializer".
1546     * <p>
1547     * There is no assumption that the returned container must answer the exact same containerPath
1548     * when requested <code>IClasspathContainer#getPath</code>.
1549     * Indeed, the containerPath is just an indication for resolving it to an actual container object.
1550     * <p>
1551     * Classpath container values are persisted locally to the workspace, but
1552     * are not preserved from a session to another. It is thus highly recommended to register a
1553     * <code>ClasspathContainerInitializer</code> for each referenced container
1554     * (through the extension point "org.eclipse.jdt.core.ClasspathContainerInitializer").
1555     * <p>
1556     * @param containerPath the name of the container, which needs to be resolved
1557     * @param project a specific project in which the container is being resolved
1558     * @return the corresponding classpath container or <code>null</code> if unable to find one.
1559     *
1560     * @exception JavaModelException if an exception occurred while resolving the container, or if the resolved container
1561     * contains illegal entries (contains CPE_CONTAINER entries or null entries).
1562     *
1563     * @see ClasspathContainerInitializer
1564     * @see IClasspathContainer
1565     * @see #setClasspathContainer(IPath, IJavaProject[], IClasspathContainer[], IProgressMonitor)
1566     * @since 2.0
1567     */
1568    public static IClasspathContainer getClasspathContainer(IPath containerPath, IJavaProject project) throws JavaModelException {
1569
1570        JavaModelManager manager = JavaModelManager.getJavaModelManager();
1571        IClasspathContainer container = manager.getClasspathContainer(containerPath, project);
1572        if (container == JavaModelManager.CONTAINER_INITIALIZATION_IN_PROGRESS) {
1573            return manager.getPreviousSessionContainer(containerPath, project);
1574        }
1575        return container;
1576    }
1577
1578    /**
1579     * Helper method finding the classpath container initializer registered for a given classpath container ID
1580     * or <code>null</code> if none was found while iterating over the contributions to extension point to
1581     * the extension point "org.eclipse.jdt.core.classpathContainerInitializer".
1582     * <p>
1583     * A containerID is the first segment of any container path, used to identify the registered container initializer.
1584     * <p>
1585     * @param containerID - a containerID identifying a registered initializer
1586     * @return ClasspathContainerInitializer - the registered classpath container initializer or <code>null</code> if
1587     * none was found.
1588     * @since 2.1
1589     */
1590    public static ClasspathContainerInitializer getClasspathContainerInitializer(String  JavaDoc containerID) {
1591        HashMap  JavaDoc containerInitializersCache = JavaModelManager.getJavaModelManager().containerInitializersCache;
1592        ClasspathContainerInitializer initializer = (ClasspathContainerInitializer) containerInitializersCache.get(containerID);
1593        if (initializer == null) {
1594            initializer = computeClasspathContainerInitializer(containerID);
1595            if (initializer == null)
1596                return null;
1597            containerInitializersCache.put(containerID, initializer);
1598        }
1599        return initializer;
1600    }
1601
1602    private static ClasspathContainerInitializer computeClasspathContainerInitializer(String  JavaDoc containerID) {
1603        Plugin jdtCorePlugin = JavaCore.getPlugin();
1604        if (jdtCorePlugin == null) return null;
1605
1606        IExtensionPoint extension = Platform.getExtensionRegistry().getExtensionPoint(JavaCore.PLUGIN_ID, JavaModelManager.CPCONTAINER_INITIALIZER_EXTPOINT_ID);
1607        if (extension != null) {
1608            IExtension[] extensions = extension.getExtensions();
1609            for(int i = 0; i < extensions.length; i++){
1610                IConfigurationElement [] configElements = extensions[i].getConfigurationElements();
1611                for(int j = 0; j < configElements.length; j++){
1612                    IConfigurationElement configurationElement = configElements[j];
1613                    String  JavaDoc initializerID = configurationElement.getAttribute("id"); //$NON-NLS-1$
1614 if (initializerID != null && initializerID.equals(containerID)){
1615                        if (JavaModelManager.CP_RESOLVE_VERBOSE_ADVANCED)
1616                            verbose_found_container_initializer(containerID, configurationElement);
1617                        try {
1618                            Object  JavaDoc execExt = configurationElement.createExecutableExtension("class"); //$NON-NLS-1$
1619 if (execExt instanceof ClasspathContainerInitializer){
1620                                return (ClasspathContainerInitializer)execExt;
1621                            }
1622                        } catch(CoreException e) {
1623                            // executable extension could not be created: ignore this initializer
1624 if (JavaModelManager.CP_RESOLVE_VERBOSE) {
1625                                verbose_failed_to_instanciate_container_initializer(containerID, configurationElement);
1626                                e.printStackTrace();
1627                            }
1628                        }
1629                    }
1630                }
1631            }
1632        }
1633        return null;
1634    }
1635
1636    private static void verbose_failed_to_instanciate_container_initializer(String  JavaDoc containerID, IConfigurationElement configurationElement) {
1637        Util.verbose(
1638            "CPContainer INIT - failed to instanciate initializer\n" + //$NON-NLS-1$
1639 " container ID: " + containerID + '\n' + //$NON-NLS-1$
1640 " class: " + configurationElement.getAttribute("class"), //$NON-NLS-1$ //$NON-NLS-2$
1641 System.err);
1642    }
1643
1644    private static void verbose_found_container_initializer(String  JavaDoc containerID, IConfigurationElement configurationElement) {
1645        Util.verbose(
1646            "CPContainer INIT - found initializer\n" + //$NON-NLS-1$
1647 " container ID: " + containerID + '\n' + //$NON-NLS-1$
1648 " class: " + configurationElement.getAttribute("class")); //$NON-NLS-1$ //$NON-NLS-2$
1649 }
1650
1651    /**
1652     * Returns the path held in the given classpath variable.
1653     * Returns <code>null</code> if unable to bind.
1654     * <p>
1655     * Classpath variable values are persisted locally to the workspace, and
1656     * are preserved from session to session.
1657     * <p>
1658     * Note that classpath variables can be contributed registered initializers for,
1659     * using the extension point "org.eclipse.jdt.core.classpathVariableInitializer".
1660     * If an initializer is registered for a variable, its persisted value will be ignored:
1661     * its initializer will thus get the opportunity to rebind the variable differently on
1662     * each session.
1663     *
1664     * @param variableName the name of the classpath variable
1665     * @return the path, or <code>null</code> if none
1666     * @see #setClasspathVariable(String, IPath)
1667     */
1668    public static IPath getClasspathVariable(final String  JavaDoc variableName) {
1669
1670        JavaModelManager manager = JavaModelManager.getJavaModelManager();
1671        IPath variablePath = manager.variableGet(variableName);
1672        if (variablePath == JavaModelManager.VARIABLE_INITIALIZATION_IN_PROGRESS){
1673            return manager.getPreviousSessionVariable(variableName);
1674        }
1675
1676        if (variablePath != null) {
1677            if (variablePath == JavaModelManager.CP_ENTRY_IGNORE_PATH)
1678                return null;
1679            return variablePath;
1680        }
1681
1682        // even if persisted value exists, initializer is given priority, only if no initializer is found the persisted value is reused
1683 final ClasspathVariableInitializer initializer = JavaCore.getClasspathVariableInitializer(variableName);
1684        if (initializer != null){
1685            if (JavaModelManager.CP_RESOLVE_VERBOSE)
1686                verbose_triggering_variable_initialization(variableName, initializer);
1687            if (JavaModelManager.CP_RESOLVE_VERBOSE_ADVANCED)
1688                verbose_triggering_variable_initialization_invocation_trace();
1689            manager.variablePut(variableName, JavaModelManager.VARIABLE_INITIALIZATION_IN_PROGRESS); // avoid initialization cycles
1690 boolean ok = false;
1691            try {
1692                // let OperationCanceledException go through
1693 // (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=59363)
1694 initializer.initialize(variableName);
1695
1696                variablePath = manager.variableGet(variableName); // initializer should have performed side-effect
1697 if (variablePath == JavaModelManager.VARIABLE_INITIALIZATION_IN_PROGRESS) return null; // break cycle (initializer did not init or reentering call)
1698 if (JavaModelManager.CP_RESOLVE_VERBOSE_ADVANCED)
1699                    verbose_variable_value_after_initialization(variableName, variablePath);
1700                manager.variablesWithInitializer.add(variableName);
1701                ok = true;
1702            } catch (RuntimeException  JavaDoc e) {
1703                if (JavaModelManager.CP_RESOLVE_VERBOSE)
1704                    e.printStackTrace();
1705                throw e;
1706            } catch (Error  JavaDoc e) {
1707                if (JavaModelManager.CP_RESOLVE_VERBOSE)
1708                    e.printStackTrace();
1709                throw e;
1710            } finally {
1711                if (!ok) JavaModelManager.getJavaModelManager().variablePut(variableName, null); // flush cache
1712 }
1713        } else {
1714            if (JavaModelManager.CP_RESOLVE_VERBOSE_ADVANCED)
1715                verbose_no_variable_initializer_found(variableName);
1716        }
1717        return variablePath;
1718    }
1719
1720    private static void verbose_no_variable_initializer_found(String  JavaDoc variableName) {
1721        Util.verbose(
1722            "CPVariable INIT - no initializer found\n" + //$NON-NLS-1$
1723 " variable: " + variableName); //$NON-NLS-1$
1724 }
1725
1726    private static void verbose_variable_value_after_initialization(String  JavaDoc variableName, IPath variablePath) {
1727        Util.verbose(
1728            "CPVariable INIT - after initialization\n" + //$NON-NLS-1$
1729 " variable: " + variableName +'\n' + //$NON-NLS-1$
1730 " variable path: " + variablePath); //$NON-NLS-1$
1731 }
1732
1733    private static void verbose_triggering_variable_initialization(String  JavaDoc variableName, ClasspathVariableInitializer initializer) {
1734        Util.verbose(
1735            "CPVariable INIT - triggering initialization\n" + //$NON-NLS-1$
1736 " variable: " + variableName + '\n' + //$NON-NLS-1$
1737 " initializer: " + initializer); //$NON-NLS-1$
1738 }
1739
1740    private static void verbose_triggering_variable_initialization_invocation_trace() {
1741        Util.verbose(
1742            "CPVariable INIT - triggering initialization\n" + //$NON-NLS-1$
1743 " invocation trace:"); //$NON-NLS-1$
1744 new Exception  JavaDoc("<Fake exception>").printStackTrace(System.out); //$NON-NLS-1$
1745 }
1746
1747    /**
1748     * Returns deprecation message of a given classpath variable.
1749     *
1750     * @param variableName
1751     * @return A string if the classpath variable is deprecated, <code>null</code> otherwise.
1752     * @since 3.3
1753     */
1754    public static String  JavaDoc getClasspathVariableDeprecationMessage(String  JavaDoc variableName) {
1755        return (String  JavaDoc) JavaModelManager.getJavaModelManager().deprecatedVariables.get(variableName);
1756    }
1757
1758    /**
1759     * Helper method finding the classpath variable initializer registered for a given classpath variable name
1760     * or <code>null</code> if none was found while iterating over the contributions to extension point to
1761     * the extension point "org.eclipse.jdt.core.classpathVariableInitializer".
1762     * <p>
1763     * @param variable the given variable
1764     * @return ClasspathVariableInitializer - the registered classpath variable initializer or <code>null</code> if
1765     * none was found.
1766     * @since 2.1
1767     */
1768    public static ClasspathVariableInitializer getClasspathVariableInitializer(String  JavaDoc variable){
1769
1770        Plugin jdtCorePlugin = JavaCore.getPlugin();
1771        if (jdtCorePlugin == null) return null;
1772
1773        IExtensionPoint extension = Platform.getExtensionRegistry().getExtensionPoint(JavaCore.PLUGIN_ID, JavaModelManager.CPVARIABLE_INITIALIZER_EXTPOINT_ID);
1774        if (extension != null) {
1775            IExtension[] extensions = extension.getExtensions();
1776            for(int i = 0; i < extensions.length; i++){
1777                IConfigurationElement [] configElements = extensions[i].getConfigurationElements();
1778                for(int j = 0; j < configElements.length; j++){
1779                    IConfigurationElement configElement = configElements[j];
1780                    try {
1781                        String  JavaDoc varAttribute = configElement.getAttribute("variable"); //$NON-NLS-1$
1782 if (variable.equals(varAttribute)) {
1783                            if (JavaModelManager.CP_RESOLVE_VERBOSE_ADVANCED)
1784                                verbose_found_variable_initializer(variable, configElement);
1785                            Object  JavaDoc execExt = configElement.createExecutableExtension("class"); //$NON-NLS-1$
1786 if (execExt instanceof ClasspathVariableInitializer){
1787                                ClasspathVariableInitializer initializer = (ClasspathVariableInitializer)execExt;
1788                                String  JavaDoc deprecatedAttribute = configElement.getAttribute("deprecated"); //$NON-NLS-1$
1789 if (deprecatedAttribute != null) {
1790                                    JavaModelManager.getJavaModelManager().deprecatedVariables.put(variable, deprecatedAttribute);
1791                                }
1792                                String  JavaDoc readOnlyAttribute = configElement.getAttribute("readOnly"); //$NON-NLS-1$
1793 if (JavaModelManager.TRUE.equals(readOnlyAttribute)) {
1794                                    JavaModelManager.getJavaModelManager().readOnlyVariables.add(variable);
1795                                }
1796                                return initializer;
1797                            }
1798                        }
1799                    } catch(CoreException e){
1800                        // executable extension could not be created: ignore this initializer
1801 if (JavaModelManager.CP_RESOLVE_VERBOSE) {
1802                            verbose_failed_to_instanciate_variable_initializer(variable, configElement);
1803                            e.printStackTrace();
1804                        }
1805                    }
1806                }
1807            }
1808        }
1809        return null;
1810    }
1811
1812    private static void verbose_failed_to_instanciate_variable_initializer(String  JavaDoc variable, IConfigurationElement configElement) {
1813        Util.verbose(
1814            "CPContainer INIT - failed to instanciate initializer\n" + //$NON-NLS-1$
1815 " variable: " + variable + '\n' + //$NON-NLS-1$
1816 " class: " + configElement.getAttribute("class"), //$NON-NLS-1$ //$NON-NLS-2$
1817 System.err);
1818    }
1819
1820    private static void verbose_found_variable_initializer(String  JavaDoc variable, IConfigurationElement configElement) {
1821        Util.verbose(
1822            "CPVariable INIT - found initializer\n" + //$NON-NLS-1$
1823 " variable: " + variable + '\n' + //$NON-NLS-1$
1824 " class: " + configElement.getAttribute("class")); //$NON-NLS-1$ //$NON-NLS-2$
1825 }
1826
1827    /**
1828     * Returns the names of all known classpath variables.
1829     * <p>
1830     * Classpath variable values are persisted locally to the workspace, and
1831     * are preserved from session to session.
1832     * <p>
1833     *
1834     * @return the list of classpath variable names
1835     * @see #setClasspathVariable(String, IPath)
1836     */
1837    public static String  JavaDoc[] getClasspathVariableNames() {
1838        return JavaModelManager.getJavaModelManager().variableNames();
1839    }
1840
1841    /**
1842     * Returns a table of all known configurable options with their default values.
1843     * These options allow to configure the behaviour of the underlying components.
1844     * The client may safely use the result as a template that they can modify and
1845     * then pass to <code>setOptions</code>.
1846     *
1847     * Helper constants have been defined on JavaCore for each of the option ID and
1848     * their possible constant values.
1849     *
1850     * Note: more options might be added in further releases.
1851     * <pre>
1852     * RECOGNIZED OPTIONS:
1853     *
1854     * COMPILER / Setting Compliance Level
1855     * Select the compliance level for the compiler. In "1.3" mode, source and target settings
1856     * should not go beyond "1.3" level.
1857     * - option id: "org.eclipse.jdt.core.compiler.compliance"
1858     * - possible values: { "1.3", "1.4", "1.5", "1.6", "1.7" }
1859     * - default: "1.4"
1860     *
1861     * COMPILER / Setting Source Compatibility Mode
1862     * Specify whether which source level compatibility is used. From 1.4 on, 'assert' is a keyword
1863     * reserved for assertion support. Also note, than when toggling to 1.4 mode, the target VM
1864     * level should be set to "1.4" and the compliance mode should be "1.4".
1865     * Source level 1.5 is necessary to enable generics, autoboxing, covariance, annotations, enumerations
1866     * enhanced for loop, static imports and varargs. Once toggled, the target VM level should be set to "1.5"
1867     * and the compliance mode should be "1.5".
1868     * Source level 1.6 is necessary to enable the computation of stack map tables. Once toggled, the target
1869     * VM level should be set to "1.6" and the compliance mode should be "1.6".
1870     * Once the source level 1.7 is toggled, the target VM level should be set to "1.7" and the compliance mode
1871     * should be "1.7".
1872     * - option id: "org.eclipse.jdt.core.compiler.source"
1873     * - possible values: { "1.3", "1.4", "1.5", "1.6", "1.7" }
1874     * - default: "1.3"
1875     *
1876     * COMPILER / Defining Target Java Platform
1877     * For binary compatibility reason, .class files can be tagged to with certain VM versions and later.
1878     * Note that "1.4" target requires to toggle compliance mode to "1.4", "1.5" target requires
1879     * to toggle compliance mode to "1.5", "1.6" target requires to toggle compliance mode to "1.6" and
1880     * "1.7" target requires to toggle compliance mode to "1.7".
1881     * - option id: "org.eclipse.jdt.core.compiler.codegen.targetPlatform"
1882     * - possible values: { "1.1", "1.2", "1.3", "1.4", "1.5", "1.6", "1.7" }
1883     * - default: "1.2"
1884     *
1885     * COMPILER / Generating Local Variable Debug Attribute
1886     * When generated, this attribute will enable local variable names
1887     * to be displayed in debugger, only in place where variables are
1888     * definitely assigned (.class file is then bigger)
1889     * - option id: "org.eclipse.jdt.core.compiler.debug.localVariable"
1890     * - possible values: { "generate", "do not generate" }
1891     * - default: "generate"
1892     *
1893     * COMPILER / Generating Line Number Debug Attribute
1894     * When generated, this attribute will enable source code highlighting in debugger
1895     * (.class file is then bigger).
1896     * - option id: "org.eclipse.jdt.core.compiler.debug.lineNumber"
1897     * - possible values: { "generate", "do not generate" }
1898     * - default: "generate"
1899     *
1900     * COMPILER / Generating Source Debug Attribute
1901     * When generated, this attribute will enable the debugger to present the
1902     * corresponding source code.
1903     * - option id: "org.eclipse.jdt.core.compiler.debug.sourceFile"
1904     * - possible values: { "generate", "do not generate" }
1905     * - default: "generate"
1906     *
1907     * COMPILER / Preserving Unused Local Variables
1908     * Unless requested to preserve unused local variables (that is, never read), the
1909     * compiler will optimize them out, potentially altering debugging
1910     * - option id: "org.eclipse.jdt.core.compiler.codegen.unusedLocal"
1911     * - possible values: { "preserve", "optimize out" }
1912     * - default: "preserve"
1913     *
1914     * COMPILER / Inline JSR Bytecode Instruction
1915     * When enabled, the compiler will no longer generate JSR instructions, but rather inline corresponding
1916     * subroutine code sequences (mostly corresponding to try finally blocks). The generated code will thus
1917     * get bigger, but will load faster on virtual machines since the verification process is then much simpler.
1918     * This mode is anticipating support for the Java Specification Request 202.
1919     * Note that JSR inlining is optional only for target platform lesser than 1.5. From 1.5 on, the JSR
1920     * inlining is mandatory (also see related setting "org.eclipse.jdt.core.compiler.codegen.targetPlatform").
1921     * - option id: "org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode"
1922     * - possible values: { "enabled", "disabled" }
1923     * - default: "disabled"
1924     *
1925     * COMPILER / Javadoc Comment Support
1926     * When this support is disabled, the compiler will ignore all javadoc problems options settings
1927     * and will not report any javadoc problem. It will also not find any reference in javadoc comment and
1928     * DOM AST Javadoc node will be only a flat text instead of having structured tag elements.
1929     * - option id: "org.eclipse.jdt.core.compiler.doc.comment.support"
1930     * - possible values: { "enabled", "disabled" }
1931     * - default: "enabled"
1932     *
1933     * COMPILER / Reporting Attempt to Override Package-Default Method
1934     * A package default method is not visible in a different package, and thus
1935     * cannot be overridden. When enabling this option, the compiler will signal
1936     * such scenarii either as an error or a warning.
1937     * - option id: "org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod"
1938     * - possible values: { "error", "warning", "ignore" }
1939     * - default: "warning"
1940     *
1941     * COMPILER / Reporting Method With Constructor Name
1942     * Naming a method with a constructor name is generally considered poor
1943     * style programming. When enabling this option, the compiler will signal such
1944     * scenarii either as an error or a warning.
1945     * - option id: "org.eclipse.jdt.core.compiler.problem.methodWithConstructorName"
1946     * - possible values: { "error", "warning", "ignore" }
1947     * - default: "warning"
1948     *
1949     * COMPILER / Reporting Deprecation
1950     * When enabled, the compiler will signal use of deprecated API either as an
1951     * error or a warning.
1952     * - option id: "org.eclipse.jdt.core.compiler.problem.deprecation"
1953     * - possible values: { "error", "warning", "ignore" }
1954     * - default: "warning"
1955     *
1956     * COMPILER / Reporting Deprecation Inside Deprecated Code
1957     * When enabled, the compiler will signal use of deprecated API inside deprecated code.
1958     * The severity of the problem is controlled with option "org.eclipse.jdt.core.compiler.problem.deprecation".
1959     * - option id: "org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode"
1960     * - possible values: { "enabled", "disabled" }
1961     * - default: "disabled"
1962     *
1963     * COMPILER / Reporting Deprecation When Overriding Deprecated Method
1964     * When enabled, the compiler will signal the declaration of a method overriding a deprecated one.
1965     * The severity of the problem is controlled with option "org.eclipse.jdt.core.compiler.problem.deprecation".
1966     * - option id: "org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod"
1967     * - possible values: { "enabled", "disabled" }
1968     * - default: "disabled"
1969     *
1970     * COMPILER / Reporting Hidden Catch Block
1971     * Locally to a try statement, some catch blocks may hide others . For example,
1972     * try { throw new java.io.CharConversionException();
1973     * } catch (java.io.CharConversionException e) {
1974     * } catch (java.io.IOException e) {}.
1975     * When enabling this option, the compiler will issue an error or a warning for hidden
1976     * catch blocks corresponding to checked exceptions
1977     * - option id: "org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock"
1978     * - possible values: { "error", "warning", "ignore" }
1979     * - default: "warning"
1980     *
1981     * COMPILER / Reporting Unused Local
1982     * When enabled, the compiler will issue an error or a warning for unused local
1983     * variables (that is, variables never read from)
1984     * - option id: "org.eclipse.jdt.core.compiler.problem.unusedLocal"
1985     * - possible values: { "error", "warning", "ignore" }
1986     * - default: "ignore"
1987     *
1988     * COMPILER / Reporting Unused Parameter
1989     * When enabled, the compiler will issue an error or a warning for unused method
1990     * parameters (that is, parameters never read from)
1991     * - option id: "org.eclipse.jdt.core.compiler.problem.unusedParameter"
1992     * - possible values: { "error", "warning", "ignore" }
1993     * - default: "ignore"
1994     *
1995     * COMPILER / Reporting Unused Parameter if Implementing Abstract Method
1996     * When enabled, the compiler will signal unused parameters in abstract method implementations.
1997     * The severity of the problem is controlled with option "org.eclipse.jdt.core.compiler.problem.unusedParameter".
1998     * - option id: "org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract"
1999     * - possible values: { "enabled", "disabled" }
2000     * - default: "disabled"
2001     *
2002     * COMPILER / Reporting Unused Parameter if Overriding Concrete Method
2003     * When enabled, the compiler will signal unused parameters in methods overriding concrete ones.
2004     * The severity of the problem is controlled with option "org.eclipse.jdt.core.compiler.problem.unusedParameter".
2005     * - option id: "org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete"
2006     * - possible values: { "enabled", "disabled" }
2007     * - default: "disabled"
2008     *
2009     * COMPILER / Consider Reference in Doc Comment for Unused Parameter Check
2010     * When enabled, the compiler will consider doc comment references to parameters (i.e. @param clauses) for the unused
2011     * parameter check. Thus, documented parameters will be considered as mandated as per doc contract.
2012     * The severity of the unused parameter problem is controlled with option "org.eclipse.jdt.core.compiler.problem.unusedParameter".
2013     * Note: this option has no effect until the doc comment support is enabled according to the 
2014     * option "org.eclipse.jdt.core.compiler.doc.comment.support".
2015     * - option id: "org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocReference"
2016     * - possible values: { "enabled", "disabled" }
2017     * - default: "enabled"
2018     *
2019     * COMPILER / Reporting Unused Import
2020     * When enabled, the compiler will issue an error or a warning for unused import
2021     * reference
2022     * - option id: "org.eclipse.jdt.core.compiler.problem.unusedImport"
2023     * - possible values: { "error", "warning", "ignore" }
2024     * - default: "warning"
2025     *
2026     * COMPILER / Reporting Unused Private Members
2027     * When enabled, the compiler will issue an error or a warning whenever a private
2028     * method or field is declared but never used within the same unit.
2029     * - option id: "org.eclipse.jdt.core.compiler.problem.unusedPrivateMember"
2030     * - possible values: { "error", "warning", "ignore" }
2031     * - default: "ignore"
2032     *
2033     * COMPILER / Reporting Assignment with no Effect
2034     * When enabled, the compiler will issue an error or a warning whenever an assignment
2035     * has no effect (e.g 'x = x').
2036     * - option id: "org.eclipse.jdt.core.compiler.problem.noEffectAssignment"
2037     * - possible values: { "error", "warning", "ignore" }
2038     * - default: "warning"
2039     *
2040     * COMPILER / Reporting Empty Statements and Unnecessary Semicolons
2041     * When enabled, the compiler will issue an error or a warning if an empty statement or a
2042     * unnecessary semicolon is encountered.
2043     * - option id: "org.eclipse.jdt.core.compiler.problem.emptyStatement"
2044     * - possible values: { "error", "warning", "ignore" }
2045     * - default: "ignore"
2046     *
2047     * COMPILER / Reporting Unnecessary Type Check
2048     * When enabled, the compiler will issue an error or a warning when a cast or an instanceof operation
2049     * is unnecessary.
2050     * - option id: "org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck"
2051     * - possible values: { "error", "warning", "ignore" }
2052     * - default: "ignore"
2053     *
2054     * COMPILER / Reporting Unnecessary Else
2055     * When enabled, the compiler will issue an error or a warning when a statement is unnecessarily
2056     * nested within an else clause (in situation where then clause is not completing normally).
2057     * - option id: "org.eclipse.jdt.core.compiler.problem.unnecessaryElse"
2058     * - possible values: { "error", "warning", "ignore" }
2059     * - default: "ignore"
2060     *
2061     * COMPILER / Reporting Synthetic Access Emulation
2062     * When enabled, the compiler will issue an error or a warning whenever it emulates
2063     * access to a non-accessible member of an enclosing type. Such access can have
2064     * performance implications.
2065     * - option id: "org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation"
2066     * - possible values: { "error", "warning", "ignore" }
2067     * - default: "ignore"
2068     *
2069     * COMPILER / Reporting Non-Externalized String Literal
2070     * When enabled, the compiler will issue an error or a warning for non externalized
2071     * String literal (that is, not tagged with //$NON-NLS-<n>$).
2072     * - option id: "org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral"
2073     * - possible values: { "error", "warning", "ignore" }
2074     * - default: "ignore"
2075     *
2076     * COMPILER / Reporting Usage of 'assert' Identifier
2077     * When enabled, the compiler will issue an error or a warning whenever 'assert' is
2078     * used as an identifier (reserved keyword in 1.4)
2079     * - option id: "org.eclipse.jdt.core.compiler.problem.assertIdentifier"
2080     * - possible values: { "error", "warning", "ignore" }
2081     * - default: "warning"
2082     *
2083     * COMPILER / Reporting Usage of 'enum' Identifier
2084     * When enabled, the compiler will issue an error or a warning whenever 'enum' is
2085     * used as an identifier (reserved keyword in 1.5)
2086     * - option id: "org.eclipse.jdt.core.compiler.problem.enumIdentifier"
2087     * - possible values: { "error", "warning", "ignore" }
2088     * - default: "warning"
2089     *
2090     * COMPILER / Reporting Non-Static Reference to a Static Member
2091     * When enabled, the compiler will issue an error or a warning whenever a static field
2092     * or method is accessed with an expression receiver. A reference to a static member should
2093     * be qualified with a type name.
2094     * - option id: "org.eclipse.jdt.core.compiler.problem.staticAccessReceiver"
2095     * - possible values: { "error", "warning", "ignore" }
2096     * - default: "warning"
2097     *
2098     * COMPILER / Reporting Indirect Reference to a Static Member
2099     * When enabled, the compiler will issue an error or a warning whenever a static field
2100     * or method is accessed in an indirect way. A reference to a static member should
2101     * preferably be qualified with its declaring type name.
2102     * - option id: "org.eclipse.jdt.core.compiler.problem.indirectStaticAccess"
2103     * - possible values: { "error", "warning", "ignore" }
2104     * - default: "ignore"
2105     *
2106     * COMPILER / Reporting Interface Method not Compatible with non-Inherited Methods
2107     * When enabled, the compiler will issue an error or a warning whenever an interface
2108     * defines a method incompatible with a non-inherited Object method. Until this conflict
2109     * is resolved, such an interface cannot be implemented, For example,
2110     * interface I {
2111     * int clone();
2112     * }
2113     * - option id: "org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod"
2114     * - possible values: { "error", "warning", "ignore" }
2115     * - default: "warning"
2116     *
2117     * COMPILER / Reporting Usage of char[] Expressions in String Concatenations
2118     * When enabled, the compiler will issue an error or a warning whenever a char[] expression
2119     * is used in String concatenations (for example, "hello" + new char[]{'w','o','r','l','d'}).
2120     * - option id: "org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion"
2121     * - possible values: { "error", "warning", "ignore" }
2122     * - default: "warning"
2123     *
2124     * COMPILER / Reporting Local Variable Declaration Hiding another Variable
2125     * When enabled, the compiler will issue an error or a warning whenever a local variable
2126     * declaration is hiding some field or local variable (either locally, inherited or defined in enclosing type).
2127     * - option id: "org.eclipse.jdt.core.compiler.problem.localVariableHiding"
2128     * - possible values: { "error", "warning", "ignore" }
2129     * - default: "ignore"
2130     *
2131     * COMPILER / Reporting Field Declaration Hiding another Variable
2132     * When enabled, the compiler will issue an error or a warning whenever a field
2133     * declaration is hiding some field or local variable (either locally, inherited or defined in enclosing type).
2134     * - option id: "org.eclipse.jdt.core.compiler.problem.fieldHiding"
2135     * - possible values: { "error", "warning", "ignore" }
2136     * - default: "ignore"
2137     *
2138     * COMPILER / Reporting Special Parameter Hiding another Field
2139     * When enabled, the compiler will signal cases where a constructor or setter method parameter declaration
2140     * is hiding some field (either locally, inherited or defined in enclosing type).
2141     * The severity of the problem is controlled with option "org.eclipse.jdt.core.compiler.problem.localVariableHiding".
2142     * - option id: "org.eclipse.jdt.core.compiler.problem.specialParameterHidingField"
2143     * - possible values: { "enabled", "disabled" }
2144     * - default: "disabled"
2145     *
2146     * COMPILER / Reporting Type Declaration Hiding another Type
2147     * When enabled, the compiler will issue an error or a warning in situations where a type parameter
2148     * declaration is hiding some type, when a nested type is hiding some type parameter, or when
2149     * a nested type is hiding another nested type defined in same unit.
2150     * - option id: "org.eclipse.jdt.core.compiler.problem.typeParameterHiding"
2151     * - possible values: { "error", "warning", "ignore" }
2152     * - default: "warning"
2153     *
2154     * COMPILER / Reporting Possible Accidental Boolean Assignment
2155     * When enabled, the compiler will issue an error or a warning if a boolean assignment is acting as the condition
2156     * of a control statement (where it probably was meant to be a boolean comparison).
2157     * - option id: "org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment"
2158     * - possible values: { "error", "warning", "ignore" }
2159     * - default: "ignore"
2160     *
2161     * COMPILER / Reporting Undocumented Empty Block
2162     * When enabled, the compiler will issue an error or a warning when an empty block is detected and it is not
2163     * documented with any comment.
2164     * - option id: "org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock"
2165     * - possible values: { "error", "warning", "ignore" }
2166     * - default: "ignore"
2167     *
2168     * COMPILER / Reporting Finally Blocks Not Completing Normally
2169     * When enabled, the compiler will issue an error or a warning when a finally block does not complete normally.
2170     * - option id: "org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally"
2171     * - possible values: { "error", "warning", "ignore" }
2172     * - default: "warning"
2173     *
2174     * COMPILER / Reporting Unused Declared Thrown Exception
2175     * When enabled, the compiler will issue an error or a warning when a method or a constructor is declaring a
2176     * thrown checked exception, but never actually raises it in its body.
2177     * - option id: "org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException"
2178     * - possible values: { "error", "warning", "ignore" }
2179     * - default: "ignore"
2180     *
2181     * COMPILER / Reporting Unused Declared Thrown Exception in Overridind Method
2182     * When disabled, the compiler will not include overriding methods in its diagnosis for unused declared
2183     * thrown exceptions.
2184     * <br>
2185     * The severity of the problem is controlled with option "org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException".
2186     * - option id: "org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding"
2187     * - possible values: { "enabled", "disabled" }
2188     * - default: "disabled"
2189     *
2190     * COMPILER / Reporting Unqualified Access to Field
2191     * When enabled, the compiler will issue an error or a warning when a field is access without any qualification.
2192     * In order to improve code readability, it should be qualified, e.g. 'x' should rather be written 'this.x'.
2193     * - option id: "org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess"
2194     * - possible values: { "error", "warning", "ignore" }
2195     * - default: "ignore"
2196     *
2197     * COMPILER / Reporting Unchecked Type Operation
2198     * When enabled, the compiler will issue an error or a warning whenever an operation involves generic types, and potentially
2199     * invalidates type safety since involving raw types (e.g. invoking #foo(X<String>) with arguments (X)).
2200     * - option id: "org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation"
2201     * - possible values: { "error", "warning", "ignore" }
2202     * - default: "warning"
2203     *
2204     * COMPILER / Reporting Raw Type Reference
2205     * When enabled, the compiler will issue an error or a warning when detecting references to raw types. Raw types are
2206     * discouraged, and are intended to help interfacing with legacy code. In the future, the language specification may
2207     * reject raw references to generic types.
2208     * - option id: "org.eclipse.jdt.core.compiler.problem.rawTypeReference"
2209     * - possible values: { "error", "warning", "ignore" }
2210     * - default: "warning"
2211     *
2212     * COMPILER / Reporting final Bound for Type Parameter
2213     * When enabled, the compiler will issue an error or a warning whenever a generic type parameter is associated with a
2214     * bound corresponding to a final type; since final types cannot be further extended, the parameter is pretty useless.
2215     * - option id: "org.eclipse.jdt.core.compiler.problem.finalParameterBound"
2216     * - possible values: { "error", "warning", "ignore" }
2217     * - default: "warning"
2218     *
2219     * COMPILER / Reporting Missing Declaration of serialVersionUID Field on Serializable Class
2220     * When enabled, the compiler will issue an error or a warning whenever a serializable class is missing a local declaration
2221     * of a serialVersionUID field. This field must be declared as static final and be of type long.
2222     * - option id: "org.eclipse.jdt.core.compiler.problem.missingSerialVersion"
2223     * - possible values: { "error", "warning", "ignore" }
2224     * - default: "warning"
2225     *
2226     * COMPILER / Reporting Varargs Argument Needing a Cast in Method/Constructor Invocation
2227     * When enabled, the compiler will issue an error or a warning whenever a varargs arguments should be cast
2228     * when passed to a method/constructor invocation. (e.g. Class.getMethod(String name, Class ... args )
2229     * invoked with arguments ("foo", null)).
2230     * - option id: "org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast"
2231     * - possible values: { "error", "warning", "ignore" }
2232     * - default: "warning"
2233     *
2234     * COMPILER / Reporting Null Dereference
2235     * When enabled, the compiler will issue an error or a warning whenever a
2236     * variable that is statically known to hold a null value is used to
2237     * access a field or method.
2238     *
2239     * - option id: "org.eclipse.jdt.core.compiler.problem.nullReference"
2240     * - possible values: { "error", "warning", "ignore" }
2241     * - default: "ignore"
2242     *
2243     * COMPILER / Reporting Potential Null Dereference
2244     * When enabled, the compiler will issue an error or a warning whenever a
2245     * variable that has formerly been tested against null but is not (no more)
2246     * statically known to hold a non-null value is used to access a field or
2247     * method.
2248     *
2249     * - option id: "org.eclipse.jdt.core.compiler.problem.potentialNullReference"
2250     * - possible values: { "error", "warning", "ignore" }
2251     * - default: "ignore"
2252     *
2253     * COMPILER / Reporting Redundant Null Check
2254     * When enabled, the compiler will issue an error or a warning whenever a
2255     * variable that is statically known to hold a null or a non-null value
2256     * is tested against null.
2257     *
2258     * - option id: "org.eclipse.jdt.core.compiler.problem.redundantNullCheck"
2259     * - possible values: { "error", "warning", "ignore" }
2260     * - default: "ignore"
2261     *
2262     * COMPILER / Reporting Use of Annotation Type as Super Interface
2263     * When enabled, the compiler will issue an error or a warning whenever an annotation type is used
2264     * as a super-interface. Though legal, this is discouraged.
2265     * - option id: "org.eclipse.jdt.core.compiler.problem.annotationSuperInterface"
2266     * - possible values: { "error", "warning", "ignore" }
2267     * - default: "warning"
2268     *
2269     * COMPILER / Reporting Missing @Override Annotation
2270     * When enabled, the compiler will issue an error or a warning whenever encountering a method
2271     * declaration which overrides a superclass method but has no @Override annotation.
2272     * - option id: "org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation"
2273     * - possible values: { "error", "warning", "ignore" }
2274     * - default: "ignore"
2275     *
2276     * COMPILER / Reporting Missing @Deprecated Annotation
2277     * When enabled, the compiler will issue an error or a warning whenever encountering a declaration
2278     * carrying a @deprecated doc tag but having no corresponding @Deprecated annotation.
2279     * - option id: "org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation"
2280     * - possible values: { "error", "warning", "ignore" }
2281     * - default: "ignore"
2282     *
2283     * COMPILER / Reporting Incomplete Enum Switch
2284     * When enabled, the compiler will issue an error or a warning whenever
2285     * an enum constant has no corresponding case label in an enum switch
2286     * statement.
2287     * - option id: "org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch"
2288     * - possible values: { "error", "warning", "ignore" }
2289     * - default: "ignore"
2290     *
2291     * COMPILER / Reporting Boxing/Unboxing Conversion
2292     * When enabled, the compiler will issue an error or a warning whenever a boxing or an unboxing
2293     * conversion is performed.
2294     * - option id: "org.eclipse.jdt.core.compiler.problem.autoboxing"
2295     * - possible values: { "error", "warning", "ignore" }
2296     * - default: "ignore"
2297     *
2298     * COMPILER / Reporting Invalid Javadoc Comment
2299     * This is the generic control for the severity of Javadoc problems.
2300     * When enabled, the compiler will issue an error or a warning for a problem in Javadoc.
2301     * - option id: "org.eclipse.jdt.core.compiler.problem.invalidJavadoc"
2302     * - possible values: { "error", "warning", "ignore" }
2303     * - default: "ignore"
2304     *
2305     * COMPILER / Visibility Level For Invalid Javadoc Tags
2306     * Set the minimum visibility level for Javadoc tag problems. Below this level problems will be ignored.
2307     * - option id: "org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility"
2308     * - possible values: { "public", "protected", "default", "private" }
2309     * - default: "public"
2310     *
2311     * COMPILER / Reporting Invalid Javadoc Tags
2312     * When enabled, the compiler will signal unbound or unexpected reference tags in Javadoc.
2313     * A 'throws' tag referencing an undeclared exception would be considered as unexpected.
2314     * <br>Note that this diagnosis can be enabled based on the visibility of the construct associated with the Javadoc;
2315     * also see the setting "org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility".
2316     * <br>
2317     * The severity of the problem is controlled with option "org.eclipse.jdt.core.compiler.problem.invalidJavadoc".
2318     * - option id: "org.eclipse.jdt.core.compiler.problem.invalidJavadocTags"
2319     * - possible values: { "disabled", "enabled" }
2320     * - default: "disabled"
2321     *
2322     * COMPILER / Reporting Invalid Javadoc Tags with Deprecated References
2323     * Specify whether the compiler will report deprecated references used in Javadoc tags.
2324     * <br>Note that this diagnosis can be enabled based on the visibility of the construct associated with the Javadoc;
2325     * also see the setting "org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility".
2326     * - option id: "org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef"
2327     * - possible values: { "enabled", "disabled" }
2328     * - default: "disabled"
2329     *
2330     * COMPILER / Reporting Invalid Javadoc Tags with Not Visible References
2331     * Specify whether the compiler will report non-visible references used in Javadoc tags.
2332     * <br>Note that this diagnosis can be enabled based on the visibility of the construct associated with the Javadoc;
2333     * also see the setting "org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility".
2334     * - option id: "org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef"
2335     * - possible values: { "enabled", "disabled" }
2336     * - default: "disabled"
2337     *
2338     * COMPILER / Reporting Missing Javadoc Tags
2339     * This is the generic control for the severity of Javadoc missing tag problems.
2340     * When enabled, the compiler will issue an error or a warning when tags are missing in Javadoc comments.
2341     * <br>Note that this diagnosis can be enabled based on the visibility of the construct associated with the Javadoc;
2342     * also see the setting "org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility".
2343     * <br>
2344     * - option id: "org.eclipse.jdt.core.compiler.problem.missingJavadocTags"
2345     * - possible values: { "error", "warning", "ignore" }
2346     * - default: "ignore"
2347     *
2348     * COMPILER / Visibility Level For Missing Javadoc Tags
2349     * Set the minimum visibility level for Javadoc missing tag problems. Below this level problems will be ignored.
2350     * - option id: "org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility"
2351     * - possible values: { "public", "protected", "default", "private" }
2352     * - default: "public"
2353     *
2354     * COMPILER / Reporting Missing Javadoc Tags on Overriding Methods
2355     * Specify whether the compiler will verify overriding methods in order to report Javadoc missing tag problems.
2356     * - option id: "org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding"
2357     * - possible values: { "enabled", "disabled" }
2358     * - default: "disabled"
2359     *
2360     * COMPILER / Reporting Missing Javadoc Comments
2361     * This is the generic control for the severity of missing Javadoc comment problems.
2362     * When enabled, the compiler will issue an error or a warning when Javadoc comments are missing.
2363     * <br>Note that this diagnosis can be enabled based on the visibility of the construct associated with the expected Javadoc;
2364     * also see the setting "org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility".
2365     * <br>
2366     * - option id: "org.eclipse.jdt.core.compiler.problem.missingJavadocComments"
2367     * - possible values: { "error", "warning", "ignore" }
2368     * - default: "ignore"
2369     *
2370     * COMPILER / Visibility Level For Missing Javadoc Comments
2371     * Set the minimum visibility level for missing Javadoc problems. Below this level problems will be ignored.
2372     * - option id: "org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility"
2373     * - possible values: { "public", "protected", "default", "private" }
2374     * - default: "public"
2375     *
2376     * COMPILER / Reporting Missing Javadoc Comments on Overriding Methods
2377     * Specify whether the compiler will verify overriding methods in order to report missing Javadoc comment problems.
2378     * - option id: "org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding"
2379     * - possible values: { "enabled", "disabled" }
2380     * - default: "disabled"
2381     *
2382     * COMPILER / Maximum Number of Problems Reported per Compilation Unit
2383     * Specify the maximum number of problems reported on each compilation unit.
2384     * - option id: "org.eclipse.jdt.core.compiler.maxProblemPerUnit"
2385     * - possible values: "<n>" where <n> is zero or a positive integer (if zero then all problems are reported).
2386     * - default: "100"
2387     *
2388     * COMPILER / Treating Optional Error as Fatal
2389     * When enabled, optional errors (i.e. optional problems which severity is set to "error") will be treated as standard
2390     * compiler errors, yielding problem methods/types preventing from running offending code until the issue got resolved.
2391     * When disabled, optional errors are only considered as warnings, still carrying an error indication to make them more
2392     * severe. Note that by default, errors are fatal, whether they are optional or not.
2393     * - option id: "org.eclipse.jdt.core.compiler.problem.fatalOptionalError"
2394     * - possible values: { "enabled", "disabled" }
2395     * - default: "enabled"
2396     *
2397     * COMPILER / Defining the Automatic Task Tags
2398     * When the tag list is not empty, the compiler will issue a task marker whenever it encounters
2399     * one of the corresponding tags inside any comment in Java source code.
2400     * Generated task messages will start with the tag, and range until the next line separator,
2401     * comment ending, or tag.
2402     * When a given line of code bears multiple tags, each tag will be reported separately.
2403     * Moreover, a tag immediately followed by another tag will be reported using the contents of the
2404     * next non-empty tag of the line, if any.
2405     * Note that tasks messages are trimmed. If a tag is starting with a letter or digit, then it cannot be leaded by
2406     * another letter or digit to be recognized ("fooToDo" will not be recognized as a task for tag "ToDo", but "foo#ToDo"
2407     * will be detected for either tag "ToDo" or "#ToDo"). Respectively, a tag ending with a letter or digit cannot be followed
2408     * by a letter or digit to be recognized ("ToDofoo" will not be recognized as a task for tag "ToDo", but "ToDo:foo" will
2409     * be detected either for tag "ToDo" or "ToDo:").
2410     * - option id: "org.eclipse.jdt.core.compiler.taskTags"
2411     * - possible values: { "<tag>[,<tag>]*" } where <tag> is a String without any wild-card or leading/trailing spaces
2412     * - default: "TODO,FIXME,XXX"
2413     *
2414     * COMPILER / Defining the Automatic Task Priorities
2415     * In parallel with the Automatic Task Tags, this list defines the priorities (high, normal or low)
2416     * of the task markers issued by the compiler.
2417     * If the default is specified, the priority of each task marker is "NORMAL".
2418     * - option id: "org.eclipse.jdt.core.compiler.taskPriorities"
2419     * - possible values: { "<priority>[,<priority>]*" } where <priority> is one of "HIGH", "NORMAL" or "LOW"
2420     * - default: "NORMAL,HIGH,NORMAL"
2421     *
2422     * COMPILER / Determining whether task tags are case-sensitive
2423     * When enabled, task tags are considered in a case-sensitive way.
2424     * - option id: "org.eclipse.jdt.core.compiler.taskCaseSensitive"
2425     * - possible values: { "enabled", "disabled" }
2426     * - default: "enabled"
2427     *
2428     * COMPILER / Reporting Forbidden Reference to Type with Restricted Access
2429     * When enabled, the compiler will issue an error or a warning when referring to a type that is non accessible, as defined according
2430     * to the access rule specifications.
2431     * - option id: "org.eclipse.jdt.core.compiler.problem.forbiddenReference"
2432     * - possible values: { "error", "warning", "ignore" }
2433     * - default: "warning"
2434     *
2435     * COMPILER / Reporting Discouraged Reference to Type with Restricted Access
2436     * When enabled, the compiler will issue an error or a warning when referring to a type with discouraged access, as defined according
2437     * to the access rule specifications.
2438     * - option id: "org.eclipse.jdt.core.compiler.problem.discouragedReference"
2439     * - possible values: { "error", "warning", "ignore" }
2440     * - default: "warning"
2441     *
2442     * COMPILER / Determining Effect of @SuppressWarnings
2443     * When enabled, the @SuppressWarnings annotation can be used to suppress some compiler warnings.
2444     * When disabled, all @SupressWarnings annotations are ignored; i.e., warnings are reported.
2445     * - option id: "org.eclipse.jdt.core.compiler.problem.suppressWarnings"
2446     * - possible values: { "enabled", "disabled" }
2447     * - default: "enabled"
2448     *
2449     * COMPILER / Reporting Unhandled Warning Token for @SuppressWarnings
2450     * When enabled, the compiler will issue an error or a warning when encountering a token
2451     * it cannot handle inside a @SuppressWarnings annotation.
2452     * - option id: "org.eclipse.jdt.core.compiler.problem.unhandledWarningToken"
2453     * - possible values: { "error", "warning", "ignore" }
2454     * - default: "warning"
2455     *
2456     * COMPILER / Reporting Unreferenced Label
2457     * When enabled, the compiler will issue an error or a warning when encountering a labeled statement which label
2458     * is never explicitly referenced. A label is considered to be referenced if its name explicitly appears behind a break
2459     * or continue statement; for instance the following label would be considered unreferenced; LABEL: { break; }
2460     * - option id: "org.eclipse.jdt.core.compiler.problem.unusedLabel"
2461     * - possible values: { "error", "warning", "ignore" }
2462     * - default: "warning"
2463     *
2464     * COMPILER / Reporting Parameter Assignment
2465     * When enabled, the compiler will issue an error or a warning if a parameter is
2466     * assigned to.
2467     * - option id: "org.eclipse.jdt.core.compiler.problem.parameterAssignment"
2468     * - possible values: { "error", "warning", "ignore" }
2469     * - default: "ignore"
2470     *
2471     * COMPILER / Reporting Switch Fall-Through Case
2472     * When enabled, the compiler will issue an error or a warning if a case may be
2473     * entered by falling through previous case. Empty cases are allowed.
2474     * - option id: "org.eclipse.jdt.core.compiler.problem.fallthroughCase"
2475     * - possible values: { "error", "warning", "ignore" }
2476     * - default: "ignore"
2477     *
2478     * COMPILER / Reporting Overriding method that doesn't call the super method invocation
2479     * When enabled, the compiler will issue an error or a warning if a method is overriding a method without calling
2480     * the super invocation.
2481     * - option id: "org.eclipse.jdt.core.compiler.problem.overridingMethodWithoutSuperInvocation"
2482     * - possible values: { "error", "warning", "ignore" }
2483     * - default: "ignore"
2484     *
2485     * BUILDER / Specifying Filters for Resource Copying Control
2486     * Allow to specify some filters to control the resource copy process.
2487     * - option id: "org.eclipse.jdt.core.builder.resourceCopyExclusionFilter"
2488     * - possible values: { "<name>[,<name>]* } where <name> is a file name pattern (* and ? wild-cards allowed)
2489     * or the name of a folder which ends with '/'
2490     * - default: ""
2491     *
2492     * BUILDER / Abort if Invalid Classpath
2493     * Allow to toggle the builder to abort if the classpath is invalid
2494     * - option id: "org.eclipse.jdt.core.builder.invalidClasspath"
2495     * - possible values: { "abort", "ignore" }
2496     * - default: "abort"
2497     *
2498     * BUILDER / Cleaning Output Folder(s)
2499     * Indicate whether the JavaBuilder is allowed to clean the output folders
2500     * when performing full build operations.
2501     * - option id: "org.eclipse.jdt.core.builder.cleanOutputFolder"
2502     * - possible values: { "clean", "ignore" }
2503     * - default: "clean"
2504     *
2505     * BUILDER / Recreate Modified class files in Output Folder
2506     * Indicate whether the JavaBuilder should check for any changes to .class files
2507     * in the output folders while performing incremental build operations. If changes
2508     * are detected to managed .class files, then a full build is performed, otherwise
2509     * the changes are left as is. Tools further altering generated .class files, like optimizers,
2510     * should ensure this option remains set in its default state of ignore.
2511     * - option id: "org.eclipse.jdt.core.builder.recreateModifiedClassFileInOutputFolder"
2512     * - possible values: { "enabled", "ignore" }
2513     * - default: "ignore"
2514     *
2515     * BUILDER / Reporting Duplicate Resources
2516     * Indicate the severity of the problem reported when more than one occurrence
2517     * of a resource is to be copied into the output location.
2518     * - option id: "org.eclipse.jdt.core.builder.duplicateResourceTask"
2519     * - possible values: { "error", "warning" }
2520     * - default: "warning"
2521     *
2522     * JAVACORE / Computing Project Build Order
2523     * Indicate whether JavaCore should enforce the project build order to be based on
2524     * the classpath prerequisite chain. When requesting to compute, this takes over
2525     * the platform default order (based on project references).
2526     * - option id: "org.eclipse.jdt.core.computeJavaBuildOrder"
2527     * - possible values: { "compute", "ignore" }
2528     * - default: "ignore"
2529     *
2530     * JAVACORE / Default Source Encoding Format
2531     * Get the default encoding format of source files. This value is
2532     * immutable and preset to the result of ResourcesPlugin.getEncoding().
2533     * It is offered as a convenience shortcut only.
2534     * - option id: "org.eclipse.jdt.core.encoding"
2535     * - value: <immutable, platform default value>
2536     *
2537     * JAVACORE / Reporting Incomplete Classpath
2538     * Indicate the severity of the problem reported when an entry on the classpath does not exist,
2539     * is not legite or is not visible (for example, a referenced project is closed).
2540     * - option id: "org.eclipse.jdt.core.incompleteClasspath"
2541     * - possible values: { "error", "warning"}
2542     * - default: "error"
2543     *
2544     * JAVACORE / Reporting Classpath Cycle
2545     * Indicate the severity of the problem reported when a project is involved in a cycle.
2546     * - option id: "org.eclipse.jdt.core.circularClasspath"
2547     * - possible values: { "error", "warning" }
2548     * - default: "error"
2549     *
2550     * JAVACORE / Reporting Incompatible JDK Level for Required Binaries
2551     * Indicate the severity of the problem reported when a project prerequisites another project
2552     * or library with an incompatible target JDK level (e.g. project targeting 1.1 vm, but compiled against 1.4 libraries).
2553     * - option id: "org.eclipse.jdt.core.incompatibleJDKLevel"
2554     * - possible values: { "error", "warning", "ignore" }
2555     * - default: "ignore"
2556     *
2557     * JAVACORE / Enabling Usage of Classpath Exclusion Patterns
2558     * When disabled, no entry on a project classpath can be associated with
2559     * an exclusion pattern.
2560     * - option id: "org.eclipse.jdt.core.classpath.exclusionPatterns"
2561     * - possible values: { "enabled", "disabled" }
2562     * - default: "enabled"
2563     *
2564     * JAVACORE / Enabling Usage of Classpath Multiple Output Locations
2565     * When disabled, no entry on a project classpath can be associated with
2566     * a specific output location, preventing thus usage of multiple output locations.
2567     * - option id: "org.eclipse.jdt.core.classpath.multipleOutputLocations"
2568     * - possible values: { "enabled", "disabled" }
2569     * - default: "enabled"
2570     *
2571     * JAVACORE / Set the timeout value for retrieving the method's parameter names from javadoc
2572     * Timeout in milliseconds to retrieve the method's parameter names from javadoc.
2573     * If the value is 0, the parameter names are not fetched and the raw names are returned.
2574     * - option id: "org.eclipse.jdt.core.timeoutForParameterNameFromAttachedJavadoc"
2575     * - possible values: "<n>", where n is an integer greater than or equal to 0
2576     * - default: "50"
2577     *
2578     * DEPRECATED SEE DefaultCodeFormatterOptions: FORMATTER / Inserting New Line Before Opening Brace
2579     * When Insert, a new line is inserted before an opening brace, otherwise nothing
2580     * is inserted
2581     * - option id: "org.eclipse.jdt.core.formatter.newline.openingBrace"
2582     * - possible values: { "insert", "do not insert" }
2583     * - default: "do not insert"
2584     *
2585     * DEPRECATED SEE DefaultCodeFormatterOptions: FORMATTER / Inserting New Line Inside Control Statement
2586     * When Insert, a new line is inserted between } and following else, catch, finally
2587     * - option id: "org.eclipse.jdt.core.formatter.newline.controlStatement"
2588     * - possible values: { "insert", "do not insert" }
2589     * - default: "do not insert"
2590     *
2591     * DEPRECATED SEE DefaultCodeFormatterOptions: Clearing Blank Lines
2592     * When Clear all, all blank lines are removed. When Preserve one, only one is kept
2593     * and all others removed.
2594     * - option id: "org.eclipse.jdt.core.formatter.newline.clearAll"
2595     * - possible values: { "clear all", "preserve one" }
2596     * - default: "preserve one"
2597     *
2598     * DEPRECATED SEE DefaultCodeFormatterOptions: Inserting New Line Between Else/If
2599     * When Insert, a blank line is inserted between an else and an if when they are
2600     * contiguous. When choosing to not insert, else-if will be kept on the same
2601     * line when possible.
2602     * - option id: "org.eclipse.jdt.core.formatter.newline.elseIf"
2603     * - possible values: { "insert", "do not insert" }
2604     * - default: "do not insert"
2605     *
2606     * DEPRECATED SEE DefaultCodeFormatterOptions: Inserting New Line In Empty Block
2607     * When insert, a line break is inserted between contiguous { and }, if } is not followed
2608     * by a keyword.
2609     * - option id: "org.eclipse.jdt.core.formatter.newline.emptyBlock"
2610     * - possible values: { "insert", "do not insert" }
2611     * - default: "insert"
2612     *
2613     * DEPRECATED SEE DefaultCodeFormatterOptions: Splitting Lines Exceeding Length
2614     * Enable splitting of long lines (exceeding the configurable length). Length of 0 will
2615     * disable line splitting
2616     * - option id: "org.eclipse.jdt.core.formatter.lineSplit"
2617     * - possible values: "<n>", where n is zero or a positive integer
2618     * - default: "80"
2619     *
2620     * DEPRECATED SEE DefaultCodeFormatterOptions: Compacting Assignment
2621     * Assignments can be formatted asymmetrically, for example 'int x= 2;', when Normal, a space
2622     * is inserted before the assignment operator
2623     * - option id: "org.eclipse.jdt.core.formatter.style.assignment"
2624     * - possible values: { "compact", "normal" }
2625     * - default: "normal"
2626     *
2627     * DEPRECATED SEE DefaultCodeFormatterOptions: Defining Indentation Character
2628     * Either choose to indent with tab characters or spaces
2629     * - option id: "org.eclipse.jdt.core.formatter.tabulation.char"
2630     * - possible values: { "tab", "space" }
2631     * - default: "tab"
2632     *
2633     * DEPRECATED SEE DefaultCodeFormatterOptions: Defining Space Indentation Length
2634     * When using spaces, set the amount of space characters to use for each
2635     * indentation mark.
2636     * - option id: "org.eclipse.jdt.core.formatter.tabulation.size"
2637     * - possible values: "<n>", where n is a positive integer
2638     * - default: "4"
2639     *
2640     * DEPRECATED SEE DefaultCodeFormatterOptions: Inserting space in cast expression
2641     * When Insert, a space is added between the type and the expression in a cast expression.
2642     * - option id: "org.eclipse.jdt.core.formatter.space.castexpression"
2643     * - possible values: { "insert", "do not insert" }
2644     * - default: "insert"
2645     *
2646     * CODEASSIST / Activate Visibility Sensitive Completion
2647     * When active, completion doesn't show that you can not see
2648     * (for example, you can not see private methods of a super class).
2649     * - option id: "org.eclipse.jdt.core.codeComplete.visibilityCheck"
2650     * - possible values: { "enabled", "disabled" }
2651     * - default: "disabled"
2652     *
2653     * CODEASSIST / Activate Deprecation Sensitive Completion
2654     * When enabled, completion doesn't propose deprecated members and types.
2655     * - option id: "org.eclipse.jdt.core.codeComplete.deprecationCheck"
2656     * - possible values: { "enabled", "disabled" }
2657     * - default: "disabled"
2658     *
2659     * CODEASSIST / Automatic Qualification of Implicit Members
2660     * When active, completion automatically qualifies completion on implicit
2661     * field references and message expressions.
2662     * - option id: "org.eclipse.jdt.core.codeComplete.forceImplicitQualification"
2663     * - possible values: { "enabled", "disabled" }
2664     * - default: "disabled"
2665     *
2666     * CODEASSIST / Define the Prefixes for Field Name
2667     * When the prefixes is non empty, completion for field name will begin with
2668     * one of the proposed prefixes.
2669     * - option id: "org.eclipse.jdt.core.codeComplete.fieldPrefixes"
2670     * - possible values: { "<prefix>[,<prefix>]*" } where <prefix> is a String without any wild-card
2671     * - default: ""
2672     *
2673     * CODEASSIST / Define the Prefixes for Static Field Name
2674     * When the prefixes is non empty, completion for static field name will begin with
2675     * one of the proposed prefixes.
2676     * - option id: "org.eclipse.jdt.core.codeComplete.staticFieldPrefixes"
2677     * - possible values: { "<prefix>[,<prefix>]*" } where <prefix> is a String without any wild-card
2678     * - default: ""
2679     *
2680     * CODEASSIST / Define the Prefixes for Local Variable Name
2681     * When the prefixes is non empty, completion for local variable name will begin with
2682     * one of the proposed prefixes.
2683     * - option id: "org.eclipse.jdt.core.codeComplete.localPrefixes"
2684     * - possible values: { "<prefix>[,<prefix>]*" } where <prefix> is a String without any wild-card
2685     * - default: ""
2686     *
2687     * CODEASSIST / Define the Prefixes for Argument Name
2688     * When the prefixes is non empty, completion for argument name will begin with
2689     * one of the proposed prefixes.
2690     * - option id: "org.eclipse.jdt.core.codeComplete.argumentPrefixes"
2691     * - possible values: { "<prefix>[,<prefix>]*" } where <prefix> is a String without any wild-card
2692     * - default: ""
2693     *
2694     * CODEASSIST / Define the Suffixes for Field Name
2695     * When the suffixes is non empty, completion for field name will end with
2696     * one of the proposed suffixes.
2697     * - option id: "org.eclipse.jdt.core.codeComplete.fieldSuffixes"
2698     * - possible values: { "<suffix>[,<suffix>]*" } where <suffix> is a String without any wild-card
2699     * - default: ""
2700     *
2701     * CODEASSIST / Define the Suffixes for Static Field Name
2702     * When the suffixes is non empty, completion for static field name will end with
2703     * one of the proposed suffixes.
2704     * - option id: "org.eclipse.jdt.core.codeComplete.staticFieldSuffixes"
2705     * - possible values: { "<suffix>[,<suffix>]*" } where <suffix> is a String without any wild-card
2706     * - default: ""
2707     *
2708     * CODEASSIST / Define the Suffixes for Local Variable Name
2709     * When the suffixes is non empty, completion for local variable name will end with
2710     * one of the proposed suffixes.
2711     * - option id: "org.eclipse.jdt.core.codeComplete.localSuffixes"
2712     * - possible values: { "<suffix>[,<suffix>]*" } where <suffix> is a String without any wild-card
2713     * - default: ""
2714     *
2715     * CODEASSIST / Define the Suffixes for Argument Name
2716     * When the suffixes is non empty, completion for argument name will end with
2717     * one of the proposed suffixes.
2718     * - option id: "org.eclipse.jdt.core.codeComplete.argumentSuffixes"
2719     * - possible values: { "<suffix>[,<suffix>]*" } where <suffix> is a String without any wild-card
2720     * - default: ""
2721     *
2722     * CODEASSIST / Activate Forbidden Reference Sensitive Completion
2723     * When enabled, completion doesn't propose elements which match a
2724     * forbidden reference rule.
2725     * - option id: "org.eclipse.jdt.core.codeComplete.forbiddenReferenceCheck"
2726     * - possible values: { "enabled", "disabled" }
2727     * - default: "enabled"
2728     *
2729     * CODEASSIST / Activate Discouraged Reference Sensitive Completion
2730     * When enabled, completion doesn't propose elements which match a
2731     * discouraged reference rule.
2732     * - option id: "org.eclipse.jdt.core.codeComplete.discouragedReferenceCheck"
2733     * - possible values: { "enabled", "disabled" }
2734     * - default: "disabled"
2735     *
2736     * CODEASSIST / Activate Camel Case Sensitive Completion
2737     * When enabled, completion shows proposals whose name match the CamelCase
2738     * pattern.
2739     * - option id: "org.eclipse.jdt.core.codeComplete.camelCaseMatch"
2740     * - possible values: { "enabled", "disabled" }
2741     * - default: "enabled"
2742     *
2743     * CODEASSIST / Activate Suggestion of Static Import
2744     * When enabled, completion proposals can contain static import
2745     * pattern.
2746     * - option id: "org.eclipse.jdt.core.codeComplete.suggestStaticImports"
2747     * - possible values: { "enabled", "disabled" }
2748     * - default: "enabled"
2749     * </pre>
2750     */
2751    public static Hashtable  JavaDoc getDefaultOptions(){
2752        return JavaModelManager.getJavaModelManager().getDefaultOptions();
2753    }
2754
2755    /**
2756     * Returns the workspace root default charset encoding.
2757     *
2758     * @return the name of the default charset encoding for workspace root.
2759     * @see IContainer#getDefaultCharset()
2760     * @see ResourcesPlugin#getEncoding()
2761     * @since 3.0
2762     */
2763    public static String  JavaDoc getEncoding() {
2764        // Verify that workspace is not shutting down (see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=60687)
2765 IWorkspace workspace = ResourcesPlugin.getWorkspace();
2766        if (workspace != null) {
2767            try {
2768                return workspace.getRoot().getDefaultCharset();
2769            } catch (CoreException e) {
2770                // fails silently and return plugin global encoding if core exception occurs
2771 }
2772        }
2773        return ResourcesPlugin.getEncoding();
2774    }
2775
2776    /**
2777     * Returns an array that contains the resources generated by the Java builder when building the
2778     * compilation units contained in the given region.
2779     * <p>The contents of the array is accurate only if the elements of the given region have been built.</p>
2780     * <p>The given region can contain instances of:</p>
2781     * <ul>
2782     * <li><code>org.eclipse.jdt.core.ICompilationUnit</code></li>
2783     * <li><code>org.eclipse.jdt.core.IPackageFragment</code></li>
2784     * <li><code>org.eclipse.jdt.core.IPackageFragmentRoot</code></li>
2785     * <li><code>org.eclipse.jdt.core.IJavaProject</code></li>
2786     * </ul>
2787     * <p>All other types of <code>org.eclipse.jdt.core.IJavaElement</code> are ignored.</p>
2788     *
2789     * @param region the given region
2790     * @param includesNonJavaResources a flag that indicates if non-java resources should be included
2791     *
2792     * @return an array that contains the resources generated by the Java builder when building the
2793     * compilation units contained in the given region, an empty array if none
2794     * @exception IllegalArgumentException if the given region is <code>null</code>
2795     * @since 3.3
2796     */
2797    public static IResource[] getGeneratedResources(IRegion region, boolean includesNonJavaResources) {
2798        if (region == null) throw new IllegalArgumentException  JavaDoc("region cannot be null"); //$NON-NLS-1$
2799 IJavaElement[] elements = region.getElements();
2800        HashMap  JavaDoc projectsStates = new HashMap  JavaDoc();
2801        ArrayList  JavaDoc collector = new ArrayList  JavaDoc();
2802        for (int i = 0, max = elements.length; i < max; i++) {
2803            // collect all the java project
2804 IJavaElement element = elements[i];
2805            IJavaProject javaProject = element.getJavaProject();
2806            IProject project = javaProject.getProject();
2807            State state = null;
2808            State currentState = (State) projectsStates.get(project);
2809            if (currentState != null) {
2810                state = currentState;
2811            } else {
2812                state = (State) JavaModelManager.getJavaModelManager().getLastBuiltState(project, null);
2813                if (state != null) {
2814                    projectsStates.put(project, state);
2815                }
2816            }
2817            if (state == null) continue;
2818            if (element.getElementType() == IJavaElement.JAVA_PROJECT) {
2819                IPackageFragmentRoot[] roots = null;
2820                try {
2821                    roots = javaProject.getPackageFragmentRoots();
2822                } catch (JavaModelException e) {
2823                    // ignore
2824 }
2825                if (roots == null) continue;
2826                IRegion region2 = JavaCore.newRegion();
2827                for (int j = 0; j < roots.length; j++) {
2828                    region2.add(roots[j]);
2829                }
2830                IResource[] res = getGeneratedResources(region2, includesNonJavaResources);
2831                for (int j = 0, max2 = res.length; j < max2; j++) {
2832                    collector.add(res[j]);
2833                }
2834                continue;
2835            }
2836            IPath outputLocation = null;
2837            try {
2838                outputLocation = javaProject.getOutputLocation();
2839            } catch (JavaModelException e) {
2840                // ignore
2841 }
2842            IJavaElement root = element;
2843            while (root != null && root.getElementType() != IJavaElement.PACKAGE_FRAGMENT_ROOT) {
2844                root = root.getParent();
2845            }
2846            if (root == null) continue;
2847            IPackageFragmentRoot packageFragmentRoot = (IPackageFragmentRoot) root;
2848            int rootPathSegmentCounts = packageFragmentRoot.getPath().segmentCount();
2849            try {
2850                IClasspathEntry entry = packageFragmentRoot.getRawClasspathEntry();
2851                IPath entryOutputLocation = entry.getOutputLocation();
2852                if (entryOutputLocation != null) {
2853                    outputLocation = entryOutputLocation;
2854                }
2855            } catch (JavaModelException e) {
2856                e.printStackTrace();
2857            }
2858            if (outputLocation == null) continue;
2859            IContainer container = (IContainer) project.getWorkspace().getRoot().findMember(outputLocation);
2860            switch(element.getElementType()) {
2861                case IJavaElement.COMPILATION_UNIT :
2862                    // get the .class files generated when this element was built
2863 ICompilationUnit unit = (ICompilationUnit) element;
2864                    getGeneratedResource(unit, container, state, rootPathSegmentCounts, collector);
2865                    break;
2866                case IJavaElement.PACKAGE_FRAGMENT :
2867                    // collect all the .class files generated when all the units in this package were built
2868 IPackageFragment fragment = (IPackageFragment) element;
2869                    ICompilationUnit[] compilationUnits = null;
2870                    try {
2871                        compilationUnits = fragment.getCompilationUnits();
2872                    } catch (JavaModelException e) {
2873                        // ignore
2874 }
2875                    if (compilationUnits == null) continue;
2876                    for (int j = 0, max2 = compilationUnits.length; j < max2; j++) {
2877                        getGeneratedResource(compilationUnits[j], container, state, rootPathSegmentCounts, collector);
2878                    }
2879                    if (includesNonJavaResources) {
2880                        // retrieve all non-java resources from the output location using the package fragment path
2881 Object  JavaDoc[] nonJavaResources = null;
2882                        try {
2883                            nonJavaResources = fragment.getNonJavaResources();
2884                        } catch (JavaModelException e) {
2885                            // ignore
2886 }
2887                        if (nonJavaResources != null) {
2888                            addNonJavaResources(nonJavaResources, container, rootPathSegmentCounts, collector);
2889                        }
2890                    }
2891                    break;
2892                case IJavaElement.PACKAGE_FRAGMENT_ROOT :
2893                    // collect all the .class files generated when all the units in this package were built
2894 IPackageFragmentRoot fragmentRoot = (IPackageFragmentRoot) element;
2895                    if (fragmentRoot.isArchive()) continue;
2896                    IJavaElement[] children = null;
2897                    try {
2898                        children = fragmentRoot.getChildren();
2899                    } catch (JavaModelException e) {
2900                        // ignore
2901 }
2902                    if (children == null) continue;
2903                    for (int j = 0, max2 = children.length; j < max2; j++) {
2904                        fragment = (IPackageFragment) children[j];
2905                        ICompilationUnit[] units = null;
2906                        try {
2907                            units = fragment.getCompilationUnits();
2908                        } catch (JavaModelException e) {
2909                            // ignore
2910 }
2911                        if (units == null) continue;
2912                        for (int n = 0, max3 = units.length; n < max3; n++) {
2913                            getGeneratedResource(units[n], container, state, rootPathSegmentCounts, collector);
2914                        }
2915                        if (includesNonJavaResources) {
2916                            // retrieve all non-java resources from the output location using the package fragment path
2917 Object  JavaDoc[] nonJavaResources = null;
2918                            try {
2919                                nonJavaResources = fragment.getNonJavaResources();
2920                            } catch (JavaModelException e) {
2921                                // ignore
2922 }
2923                            if (nonJavaResources != null) {
2924                                addNonJavaResources(nonJavaResources, container, rootPathSegmentCounts, collector);
2925                            }
2926                        }
2927                    }
2928                    break;
2929            }
2930        }
2931        int size = collector.size();
2932        if (size != 0) {
2933            IResource[] result = new IResource[size];
2934            collector.toArray(result);
2935            return result;
2936        }
2937        return NO_GENERATED_RESOURCES;
2938    }
2939
2940    private static void getGeneratedResource(ICompilationUnit unit,
2941            IContainer container,
2942            State state,
2943            int rootPathSegmentCounts,
2944            ArrayList  JavaDoc collector) {
2945        IResource resource = unit.getResource();
2946        char[][] typeNames = state.getDefinedTypeNamesFor(resource.getProjectRelativePath().toString());
2947        if (typeNames != null) {
2948            IPath path = unit.getPath().removeFirstSegments(rootPathSegmentCounts).removeLastSegments(1);
2949            for (int j = 0, max2 = typeNames.length; j < max2; j++) {
2950                IPath localPath = path.append(new String  JavaDoc(typeNames[j]) + ".class"); //$NON-NLS-1$
2951 IResource member = container.findMember(localPath);
2952                if (member != null && member.exists()) {
2953                    collector.add(member);
2954                }
2955            }
2956        } else {
2957            IPath path = unit.getPath().removeFirstSegments(rootPathSegmentCounts).removeLastSegments(1);
2958            path = path.append(Util.getNameWithoutJavaLikeExtension(unit.getElementName()) + ".class"); //$NON-NLS-1$
2959 IResource member = container.findMember(path);
2960            if (member != null && member.exists()) {
2961                collector.add(member);
2962            }
2963        }
2964    }
2965
2966    /**
2967     * Returns the single instance of the Java core plug-in runtime class.
2968     * Equivalent to <code>(JavaCore) getPlugin()</code>.
2969     *
2970     * @return the single instance of the Java core plug-in runtime class
2971     */
2972    public static JavaCore getJavaCore() {
2973        return (JavaCore) getPlugin();
2974    }
2975
2976    /**
2977     * Returns the list of known Java-like extensions.
2978     * Java like extension are defined in the {@link org.eclipse.core.runtime.Platform#getContentTypeManager()
2979     * content type manager} for the {@link #JAVA_SOURCE_CONTENT_TYPE}.
2980     * Note that a Java-like extension doesn't include the leading dot ('.').
2981     * Also note that the "java" extension is always defined as a Java-like extension.
2982     *
2983     * @return the list of known Java-like extensions.
2984     * @since 3.2
2985     */
2986    public static String  JavaDoc[] getJavaLikeExtensions() {
2987        return CharOperation.toStrings(Util.getJavaLikeExtensions());
2988    }
2989
2990    /**
2991     * Helper method for returning one option value only. Equivalent to <code>(String)JavaCore.getOptions().get(optionName)</code>
2992     * Note that it may answer <code>null</code> if this option does not exist.
2993     * <p>
2994     * For a complete description of the configurable options, see <code>getDefaultOptions</code>.
2995     * </p>
2996     *
2997     * @param optionName the name of an option
2998     * @return the String value of a given option
2999     * @see JavaCore#getDefaultOptions()
3000     * @see JavaCorePreferenceInitializer for changing default settings
3001     * @since 2.0
3002     */
3003    public static String  JavaDoc getOption(String  JavaDoc optionName) {
3004        return JavaModelManager.getJavaModelManager().getOption(optionName);
3005    }
3006
3007    /**
3008     * Returns the table of the current options. Initially, all options have their default values,
3009     * and this method returns a table that includes all known options.
3010     * <p>For a complete description of the configurable options, see <code>getDefaultOptions</code>.</p>
3011     * <p>Returns a default set of options even if the platform is not running.</p>
3012     *
3013     * @return table of current settings of all options
3014     * (key type: <code>String</code>; value type: <code>String</code>)
3015     * @see #getDefaultOptions()
3016     * @see JavaCorePreferenceInitializer for changing default settings
3017     */
3018    public static Hashtable  JavaDoc getOptions() {
3019        return JavaModelManager.getJavaModelManager().getOptions();
3020    }
3021
3022    /**
3023     * Returns the single instance of the Java core plug-in runtime class.
3024     *
3025     * @return the single instance of the Java core plug-in runtime class
3026     */
3027    public static Plugin getPlugin() {
3028        return JAVA_CORE_PLUGIN;
3029    }
3030
3031    /**
3032     * This is a helper method, which returns the resolved classpath entry denoted
3033     * by a given entry (if it is a variable entry). It is obtained by resolving the variable
3034     * reference in the first segment. Returns <code>null</code> if unable to resolve using
3035     * the following algorithm:
3036     * <ul>
3037     * <li> if variable segment cannot be resolved, returns <code>null</code></li>
3038     * <li> finds a project, JAR or binary folder in the workspace at the resolved path location</li>
3039     * <li> if none finds an external JAR file or folder outside the workspace at the resolved path location </li>
3040     * <li> if none returns <code>null</code></li>
3041     * </ul>
3042     * <p>
3043     * Variable source attachment path and root path are also resolved and recorded in the resulting classpath entry.
3044     * <p>
3045     * NOTE: This helper method does not handle classpath containers, for which should rather be used
3046     * <code>JavaCore#getClasspathContainer(IPath, IJavaProject)</code>.
3047     * <p>
3048     *
3049     * @param entry the given variable entry
3050     * @return the resolved library or project classpath entry, or <code>null</code>
3051     * if the given variable entry could not be resolved to a valid classpath entry
3052     */
3053    public static IClasspathEntry getResolvedClasspathEntry(IClasspathEntry entry) {
3054
3055        if (entry.getEntryKind() != IClasspathEntry.CPE_VARIABLE)
3056            return entry;
3057
3058        IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
3059        IPath resolvedPath = JavaCore.getResolvedVariablePath(entry.getPath());
3060        if (resolvedPath == null)
3061            return null;
3062
3063        Object  JavaDoc target = JavaModel.getTarget(workspaceRoot, resolvedPath, false);
3064        if (target == null)
3065            return null;
3066
3067        // inside the workspace
3068 if (target instanceof IResource) {
3069            IResource resolvedResource = (IResource) target;
3070            switch (resolvedResource.getType()) {
3071
3072                case IResource.PROJECT :
3073                    // internal project
3074 return JavaCore.newProjectEntry(
3075                            resolvedPath,
3076                            entry.getAccessRules(),
3077                            entry.combineAccessRules(),
3078                            entry.getExtraAttributes(),
3079                            entry.isExported());
3080                case IResource.FILE :
3081                    if (org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(resolvedResource.getName())) {
3082                        // internal binary archive
3083 return JavaCore.newLibraryEntry(
3084                                resolvedPath,
3085                                getResolvedVariablePath(entry.getSourceAttachmentPath()),
3086                                getResolvedVariablePath(entry.getSourceAttachmentRootPath()),
3087                                entry.getAccessRules(),
3088                                entry.getExtraAttributes(),
3089                                entry.isExported());
3090                    }
3091                    break;
3092
3093                case IResource.FOLDER :
3094                    // internal binary folder
3095 return JavaCore.newLibraryEntry(
3096                            resolvedPath,
3097                            getResolvedVariablePath(entry.getSourceAttachmentPath()),
3098                            getResolvedVariablePath(entry.getSourceAttachmentRootPath()),
3099                            entry.getAccessRules(),
3100                            entry.getExtraAttributes(),
3101                            entry.isExported());
3102            }
3103        }
3104        // outside the workspace
3105 if (target instanceof File  JavaDoc) {
3106            File  JavaDoc externalFile = JavaModel.getFile(target);
3107            if (externalFile != null) {
3108                String  JavaDoc fileName = externalFile.getName().toLowerCase();
3109                if (fileName.endsWith(SuffixConstants.SUFFIX_STRING_jar) || fileName.endsWith(SuffixConstants.SUFFIX_STRING_zip)) {
3110                    // external binary archive
3111 return JavaCore.newLibraryEntry(
3112                            resolvedPath,
3113                            getResolvedVariablePath(entry.getSourceAttachmentPath()),
3114                            getResolvedVariablePath(entry.getSourceAttachmentRootPath()),
3115                            entry.getAccessRules(),
3116                            entry.getExtraAttributes(),
3117                            entry.isExported());
3118                }
3119            } else { // external binary folder
3120 if (resolvedPath.isAbsolute()){
3121                    return JavaCore.newLibraryEntry(
3122                            resolvedPath,
3123                            getResolvedVariablePath(entry.getSourceAttachmentPath()),
3124                            getResolvedVariablePath(entry.getSourceAttachmentRootPath()),
3125                            entry.getAccessRules(),
3126                            entry.getExtraAttributes(),
3127                            entry.isExported());
3128                }
3129            }
3130        }
3131        return null;
3132    }
3133
3134
3135    /**
3136     * Resolve a variable path (helper method).
3137     *
3138     * @param variablePath the given variable path
3139     * @return the resolved variable path or <code>null</code> if none
3140     */
3141    public static IPath getResolvedVariablePath(IPath variablePath) {
3142
3143        if (variablePath == null)
3144            return null;
3145        int count = variablePath.segmentCount();
3146        if (count == 0)
3147            return null;
3148
3149        // lookup variable
3150 String  JavaDoc variableName = variablePath.segment(0);
3151        IPath resolvedPath = JavaCore.getClasspathVariable(variableName);
3152        if (resolvedPath == null)
3153            return null;
3154
3155        // append path suffix
3156 if (count > 1) {
3157            resolvedPath = resolvedPath.append(variablePath.removeFirstSegments(1));
3158        }
3159        return resolvedPath;
3160    }
3161
3162    /**
3163     * Answers the shared working copies currently registered for this buffer factory.
3164     * Working copies can be shared by several clients using the same buffer factory,see
3165     * <code>IWorkingCopy.getSharedWorkingCopy</code>.
3166     *
3167     * @param factory the given buffer factory
3168     * @return the list of shared working copies for a given buffer factory
3169     * @since 2.0
3170     * @deprecated Use {@link #getWorkingCopies(WorkingCopyOwner)} instead
3171     */
3172    public static IWorkingCopy[] getSharedWorkingCopies(IBufferFactory factory){
3173
3174        // if factory is null, default factory must be used
3175 if (factory == null) factory = BufferManager.getDefaultBufferManager().getDefaultBufferFactory();
3176
3177        return getWorkingCopies(BufferFactoryWrapper.create(factory));
3178    }
3179
3180    /**
3181     * Returns the names of all defined user libraries. The corresponding classpath container path
3182     * is the name appended to the USER_LIBRARY_CONTAINER_ID.
3183     * @return Return an array containing the names of all known user defined.
3184     * @since 3.0
3185     */
3186    public static String  JavaDoc[] getUserLibraryNames() {
3187         return JavaModelManager.getUserLibraryManager().getUserLibraryNames();
3188    }
3189
3190    /**
3191     * Returns the working copies that have the given owner.
3192     * Only compilation units in working copy mode are returned.
3193     * If the owner is <code>null</code>, primary working copies are returned.
3194     *
3195     * @param owner the given working copy owner or <code>null</code> for primary working copy owner
3196     * @return the list of working copies for a given owner
3197     * @since 3.0
3198     */
3199    public static ICompilationUnit[] getWorkingCopies(WorkingCopyOwner owner){
3200
3201        JavaModelManager manager = JavaModelManager.getJavaModelManager();
3202        if (owner == null) owner = DefaultWorkingCopyOwner.PRIMARY;
3203        ICompilationUnit[] result = manager.getWorkingCopies(owner, false/*don't add primary WCs*/);
3204        if (result == null) return JavaModelManager.NO_WORKING_COPY;
3205        return result;
3206    }
3207
3208    /**
3209     * Initializes JavaCore internal structures to allow subsequent operations (such
3210     * as the ones that need a resolved classpath) to run full speed. A client may
3211     * choose to call this method in a background thread early after the workspace
3212     * has started so that the initialization is transparent to the user.
3213     * <p>
3214     * However calling this method is optional. Services will lazily perform
3215     * initialization when invoked. This is only a way to reduce initialization
3216     * overhead on user actions, if it can be performed before at some
3217     * appropriate moment.
3218     * </p><p>
3219     * This initialization runs accross all Java projects in the workspace. Thus the
3220     * workspace root scheduling rule is used during this operation.
3221     * </p><p>
3222     * This method may return before the initialization is complete. The
3223     * initialization will then continue in a background thread.
3224     * </p><p>
3225     * This method can be called concurrently.
3226     * </p>
3227     *
3228     * @param monitor a progress monitor, or <code>null</code> if progress
3229     * reporting and cancellation are not desired
3230     * @exception CoreException if the initialization fails,
3231     * the status of the exception indicates the reason of the failure
3232     * @since 3.1
3233     */
3234    public static void initializeAfterLoad(IProgressMonitor monitor) throws CoreException {
3235        try {
3236            if (monitor != null) monitor.beginTask(Messages.javamodel_initialization, 100);
3237
3238            // initialize all containers and variables
3239 JavaModelManager manager = JavaModelManager.getJavaModelManager();
3240            try {
3241                if (monitor != null) {
3242                    monitor.subTask(Messages.javamodel_configuring_classpath_containers);
3243                    manager.batchContainerInitializationsProgress.set(new SubProgressMonitor(monitor, 50)); // 50% of the time is spent in initializing containers and variables
3244 }
3245                
3246                // all classpaths in the workspace are going to be resolved, ensure that containers are initialized in one batch
3247 manager.batchContainerInitializations = true; 
3248                
3249                // avoid leaking source attachment properties (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=183413)
3250 IJavaProject[] projects = manager.getJavaModel().getJavaProjects();
3251                for (int i = 0, length = projects.length; i < length; i++) {
3252                    IClasspathEntry[] classpath;
3253                    try {
3254                        classpath = ((JavaProject) projects[i]).getResolvedClasspath();
3255                    } catch (JavaModelException e) {
3256                        // project no longer exist: ignore
3257 continue;
3258                    }
3259                    if (classpath != null) {
3260                        for (int j = 0, length2 = classpath.length; j < length2; j++) {
3261                            IClasspathEntry entry = classpath[j];
3262                            if (entry.getSourceAttachmentPath() != null)
3263                                Util.setSourceAttachmentProperty(entry.getPath(), null);
3264                            // else source might have been attached by IPackageFragmentRoot#attachSource(...), we keep it
3265 }
3266                    }
3267                }
3268                
3269                // initialize delta state
3270 manager.deltaState.rootsAreStale = true; // in case it was already initialized before we cleaned up the source attachment proprties
3271 manager.deltaState.initializeRoots();
3272            } finally {
3273                manager.batchContainerInitializationsProgress.set(null);
3274            }
3275
3276            // dummy query for waiting until the indexes are ready
3277 SearchEngine engine = new SearchEngine();
3278            IJavaSearchScope scope = SearchEngine.createWorkspaceScope();
3279            try {
3280                if (monitor != null)
3281                    monitor.subTask(Messages.javamodel_configuring_searchengine);
3282                engine.searchAllTypeNames(
3283                    null,
3284                    SearchPattern.R_EXACT_MATCH,
3285                    "!@$#!@".toCharArray(), //$NON-NLS-1$
3286 SearchPattern.R_PATTERN_MATCH | SearchPattern.R_CASE_SENSITIVE,
3287                    IJavaSearchConstants.CLASS,
3288                    scope,
3289                    new TypeNameRequestor() {
3290                        public void acceptType(
3291                            int modifiers,
3292                            char[] packageName,
3293                            char[] simpleTypeName,
3294                            char[][] enclosingTypeNames,
3295                            String  JavaDoc path) {
3296                            // no type to accept
3297 }
3298                    },
3299                    // will not activate index query caches if indexes are not ready, since it would take to long
3300 // to wait until indexes are fully rebuild
3301 IJavaSearchConstants.CANCEL_IF_NOT_READY_TO_SEARCH,
3302                    monitor == null ? null : new SubProgressMonitor(monitor, 49) // 49% of the time is spent in the dummy search
3303 );
3304            } catch (JavaModelException e) {
3305                // /search failed: ignore
3306 } catch (OperationCanceledException e) {
3307                if (monitor != null && monitor.isCanceled())
3308                    throw e;
3309                // else indexes were not ready: catch the exception so that jars are still refreshed
3310 }
3311
3312            // check if the build state version number has changed since last session
3313 // (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=98969)
3314 if (monitor != null)
3315                monitor.subTask(Messages.javamodel_getting_build_state_number);
3316            QualifiedName qName = new QualifiedName(JavaCore.PLUGIN_ID, "stateVersionNumber"); //$NON-NLS-1$
3317 IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
3318            String  JavaDoc versionNumber = null;
3319            try {
3320                versionNumber = root.getPersistentProperty(qName);
3321            } catch (CoreException e) {
3322                // could not read version number: consider it is new
3323 }
3324            final JavaModel model = manager.getJavaModel();
3325            String  JavaDoc newVersionNumber = Byte.toString(State.VERSION);
3326            if (!newVersionNumber.equals(versionNumber)) {
3327                // build state version number has changed: touch every projects to force a rebuild
3328 if (JavaBuilder.DEBUG)
3329                    System.out.println("Build state version number has changed"); //$NON-NLS-1$
3330 IWorkspaceRunnable runnable = new IWorkspaceRunnable() {
3331                    public void run(IProgressMonitor progressMonitor2) throws CoreException {
3332                        IJavaProject[] projects = null;
3333                        try {
3334                            projects = model.getJavaProjects();
3335                        } catch (JavaModelException e) {
3336                            // could not get Java projects: ignore
3337 }
3338                        if (projects != null) {
3339                            for (int i = 0, length = projects.length; i < length; i++) {
3340                                IJavaProject project = projects[i];
3341                                try {
3342                                    if (JavaBuilder.DEBUG)
3343                                        System.out.println("Touching " + project.getElementName()); //$NON-NLS-1$
3344 project.getProject().touch(progressMonitor2);
3345                                } catch (CoreException e) {
3346                                    // could not touch this project: ignore
3347 }
3348                            }
3349                        }
3350                    }
3351                };
3352                if (monitor != null)
3353                    monitor.subTask(Messages.javamodel_building_after_upgrade);
3354                try {
3355                    ResourcesPlugin.getWorkspace().run(runnable, monitor);
3356                } catch (CoreException e) {
3357                    // could not touch all projects
3358 }
3359                try {
3360                    root.setPersistentProperty(qName, newVersionNumber);
3361                } catch (CoreException e) {
3362                    Util.log(e, "Could not persist build state version number"); //$NON-NLS-1$
3363 }
3364            }
3365
3366            // ensure external jars are refreshed (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=93668)
3367 try {
3368                if (monitor != null)
3369                    monitor.subTask(Messages.javamodel_refreshing_external_jars);
3370                model.refreshExternalArchives(
3371                    null/*refresh all projects*/,
3372                    monitor == null ? null : new SubProgressMonitor(monitor, 1) // 1% of the time is spent in jar refresh
3373 );
3374            } catch (JavaModelException e) {
3375                // refreshing failed: ignore
3376 }
3377            
3378        } finally {
3379            if (monitor != null) monitor.done();
3380        }
3381    }
3382
3383    /**
3384     * Returns whether a given classpath variable is read-only or not.
3385     *
3386     * @param variableName
3387     * @return <code>true</code> if the classpath variable is read-only,
3388     * <code>false</code> otherwise.
3389     * @since 3.3
3390     */
3391    public static boolean isClasspathVariableReadOnly(String  JavaDoc variableName) {
3392        return JavaModelManager.getJavaModelManager().readOnlyVariables.contains(variableName);
3393    }
3394
3395    /**
3396     * Returns whether the given file name's extension is a Java-like extension.
3397     *
3398     * @return whether the given file name's extension is a Java-like extension
3399     * @see #getJavaLikeExtensions()
3400     * @since 3.2
3401     */
3402    public static boolean isJavaLikeFileName(String  JavaDoc fileName) {
3403        return Util.isJavaLikeFileName(fileName);
3404    }
3405
3406    /**
3407     * Returns whether the given marker references the given Java element.
3408     * Used for markers, which denote a Java element rather than a resource.
3409     *
3410     * @param element the element
3411     * @param marker the marker
3412     * @return <code>true</code> if the marker references the element, false otherwise
3413     * @exception CoreException if the <code>IMarker.getAttribute</code> on the marker fails
3414     */
3415    public static boolean isReferencedBy(IJavaElement element, IMarker marker) throws CoreException {
3416
3417        // only match units or classfiles
3418 if (element instanceof IMember){
3419            IMember member = (IMember) element;
3420            if (member.isBinary()){
3421                element = member.getClassFile();
3422            } else {
3423                element = member.getCompilationUnit();
3424            }
3425        }
3426        if (element == null) return false;
3427        if (marker == null) return false;
3428
3429        String  JavaDoc markerHandleId = (String  JavaDoc)marker.getAttribute(ATT_HANDLE_ID);
3430        if (markerHandleId == null) return false;
3431
3432        IJavaElement markerElement = JavaCore.create(markerHandleId);
3433        while (true){
3434            if (element.equals(markerElement)) return true; // external elements may still be equal with different handleIDs.
3435
3436            // cycle through enclosing types in case marker is associated with a classfile (15568)
3437 if (markerElement instanceof IClassFile){
3438                IType enclosingType = ((IClassFile)markerElement).getType().getDeclaringType();
3439                if (enclosingType != null){
3440                    markerElement = enclosingType.getClassFile(); // retry with immediate enclosing classfile
3441 continue;
3442                }
3443            }
3444            break;
3445        }
3446        return false;
3447    }
3448
3449    /**
3450     * Returns whether the given marker delta references the given Java element.
3451     * Used for markers deltas, which denote a Java element rather than a resource.
3452     *
3453     * @param element the element
3454     * @param markerDelta the marker delta
3455     * @return <code>true</code> if the marker delta references the element
3456     * @exception CoreException if the <code>IMarkerDelta.getAttribute</code> on the marker delta fails
3457     */
3458    public static boolean isReferencedBy(IJavaElement element, IMarkerDelta markerDelta) throws CoreException {
3459
3460        // only match units or classfiles
3461 if (element instanceof IMember){
3462            IMember member = (IMember) element;
3463            if (member.isBinary()){
3464                element = member.getClassFile();
3465            } else {
3466                element = member.getCompilationUnit();
3467            }
3468        }
3469        if (element == null) return false;
3470        if (markerDelta == null) return false;
3471
3472        String  JavaDoc markerDeltarHandleId = (String  JavaDoc)markerDelta.getAttribute(ATT_HANDLE_ID);
3473        if (markerDeltarHandleId == null) return false;
3474
3475        IJavaElement markerElement = JavaCore.create(markerDeltarHandleId);
3476        while (true){
3477            if (element.equals(markerElement)) return true; // external elements may still be equal with different handleIDs.
3478
3479            // cycle through enclosing types in case marker is associated with a classfile (15568)
3480 if (markerElement instanceof IClassFile){
3481                IType enclosingType = ((IClassFile)markerElement).getType().getDeclaringType();
3482                if (enclosingType != null){
3483                    markerElement = enclosingType.getClassFile(); // retry with immediate enclosing classfile
3484 continue;
3485                }
3486            }
3487            break;
3488        }
3489        return false;
3490    }
3491
3492    /**
3493     * Creates and returns a new access rule with the given file pattern and kind.
3494     * <p>
3495     * The rule kind is one of {@link IAccessRule#K_ACCESSIBLE}, {@link IAccessRule#K_DISCOURAGED},
3496     * or {@link IAccessRule#K_NON_ACCESSIBLE}, optionally combined with {@link IAccessRule#IGNORE_IF_BETTER},
3497     * e..g. <code>IAccessRule.K_NON_ACCESSIBLE | IAccessRule.IGNORE_IF_BETTER</code>.
3498     * </p>
3499     *
3500     * @param filePattern the file pattern this access rule should match
3501     * @param kind one of {@link IAccessRule#K_ACCESSIBLE}, {@link IAccessRule#K_DISCOURAGED},
3502     * or {@link IAccessRule#K_NON_ACCESSIBLE}, optionally combined with
3503     * {@link IAccessRule#IGNORE_IF_BETTER}
3504     * @return a new access rule
3505     * @since 3.1
3506     */
3507    public static IAccessRule newAccessRule(IPath filePattern, int kind) {
3508        return new ClasspathAccessRule(filePattern, kind);
3509    }
3510
3511    /**
3512     * Creates and returns a new classpath attribute with the given name and the given value.
3513     *
3514     * @return a new classpath attribute
3515     * @since 3.1
3516     */
3517    public static IClasspathAttribute newClasspathAttribute(String  JavaDoc name, String  JavaDoc value) {
3518        return new ClasspathAttribute(name, value);
3519    }
3520
3521    /**
3522     * Creates and returns a new classpath entry of kind <code>CPE_CONTAINER</code>
3523     * for the given path. This method is fully equivalent to calling
3524     * {@link #newContainerEntry(IPath, IAccessRule[], IClasspathAttribute[], boolean)
3525     * newContainerEntry(containerPath, new IAccessRule[0], new IClasspathAttribute[0], false)}.
3526     * <p>
3527     * @param containerPath the path identifying the container, it must be formed of two
3528     * segments
3529     * @return a new container classpath entry
3530     *
3531     * @see JavaCore#getClasspathContainer(IPath, IJavaProject)
3532     * @since 2.0
3533     */
3534    public static IClasspathEntry newContainerEntry(IPath containerPath) {
3535        return newContainerEntry(
3536        containerPath,
3537        ClasspathEntry.NO_ACCESS_RULES,
3538        ClasspathEntry.NO_EXTRA_ATTRIBUTES,
3539        false/*not exported*/);
3540    }
3541
3542    /**
3543     * Creates and returns a new classpath entry of kind <code>CPE_CONTAINER</code>
3544     * for the given path. This method is fully equivalent to calling
3545     * {@link #newContainerEntry(IPath, IAccessRule[], IClasspathAttribute[], boolean)
3546     * newContainerEntry(containerPath, new IAccessRule[0], new IClasspathAttribute[0], isExported)}.
3547     *
3548     * @param containerPath the path identifying the container, it must be formed of at least
3549     * one segment (ID+hints)
3550     * @param isExported a boolean indicating whether this entry is contributed to dependent
3551     * projects in addition to the output location
3552     * @return a new container classpath entry
3553     *
3554     * @see JavaCore#getClasspathContainer(IPath, IJavaProject)
3555     * @see JavaCore#setClasspathContainer(IPath, IJavaProject[], IClasspathContainer[], IProgressMonitor)
3556     * @since 2.0
3557     */
3558    public static IClasspathEntry newContainerEntry(IPath containerPath, boolean isExported) {
3559        return newContainerEntry(
3560            containerPath,
3561            ClasspathEntry.NO_ACCESS_RULES,
3562            ClasspathEntry.NO_EXTRA_ATTRIBUTES,
3563            isExported);
3564    }
3565
3566    /**
3567     * Creates and returns a new classpath entry of kind <code>CPE_CONTAINER</code>
3568     * for the given path. The path of the container will be used during resolution so as to map this
3569     * container entry to a set of other classpath entries the container is acting for.
3570     * <p>
3571     * A container entry allows to express indirect references to a set of libraries, projects and variable entries,
3572     * which can be interpreted differently for each Java project where it is used.
3573     * A classpath container entry can be resolved using <code>JavaCore.getResolvedClasspathContainer</code>,
3574     * and updated with <code>JavaCore.classpathContainerChanged</code>
3575     * <p>
3576     * A container is exclusively resolved by a <code>ClasspathContainerInitializer</code> registered onto the
3577     * extension point "org.eclipse.jdt.core.classpathContainerInitializer".
3578     * <p>
3579     * A container path must be formed of at least one segment, where: <ul>
3580     * <li> the first segment is a unique ID identifying the target container, there must be a container initializer registered
3581     * onto this ID through the extension point "org.eclipse.jdt.core.classpathContainerInitializer". </li>
3582     * <li> the remaining segments will be passed onto the initializer, and can be used as additional
3583     * hints during the initialization phase. </li>
3584     * </ul>
3585     * <p>
3586     * Example of an ClasspathContainerInitializer for a classpath container denoting a default JDK container:
3587     * <pre>
3588     * containerEntry = JavaCore.newContainerEntry(new Path("MyProvidedJDK/default"));
3589     *
3590     * <extension
3591     * point="org.eclipse.jdt.core.classpathContainerInitializer">
3592     * <containerInitializer
3593     * id="MyProvidedJDK"
3594     * class="com.example.MyInitializer"/>
3595     * </pre>
3596     * <p>
3597     * The access rules determine the set of accessible source and class files
3598     * in the container. If the list of access rules is empty, then all files
3599     * in this container are accessible.
3600     * See {@link IAccessRule} for a detailed description of access
3601     * rules. Note that if an entry defined by the container defines access rules,
3602     * then these access rules are combined with the given access rules.
3603     * The given access rules are considered first, then the entry's access rules are
3604     * considered.
3605     * </p>
3606     * <p>
3607     * The <code>extraAttributes</code> list contains name/value pairs that must be persisted with
3608     * this entry. If no extra attributes are provided, an empty array must be passed in.<br>
3609     * Note that this list should not contain any duplicate name.
3610     * </p>
3611     * <p>
3612     * The <code>isExported</code> flag indicates whether this entry is contributed to dependent
3613     * projects. If not exported, dependent projects will not see any of the classes from this entry.
3614     * If exported, dependent projects will concatenate the accessible files patterns of this entry with the
3615     * accessible files patterns of the projects, and they will concatenate the non accessible files patterns of this entry
3616     * with the non accessible files patterns of the project.
3617     * </p>
3618     * <p>
3619     * Note that this operation does not attempt to validate classpath containers
3620     * or access the resources at the given paths.
3621     * </p>
3622     *
3623     * @param containerPath the path identifying the container, it must be formed of at least
3624     * one segment (ID+hints)
3625     * @param accessRules the possibly empty list of access rules for this entry
3626     * @param extraAttributes the possibly empty list of extra attributes to persist with this entry
3627     * @param isExported a boolean indicating whether this entry is contributed to dependent
3628     * projects in addition to the output location
3629     * @return a new container classpath entry
3630     *
3631     * @see JavaCore#getClasspathContainer(IPath, IJavaProject)
3632     * @see JavaCore#setClasspathContainer(IPath, IJavaProject[], IClasspathContainer[], IProgressMonitor)
3633     * @see JavaCore#newContainerEntry(IPath, boolean)
3634     * @see JavaCore#newAccessRule(IPath, int)
3635     * @since 3.1
3636     */
3637    public static IClasspathEntry newContainerEntry(
3638            IPath containerPath,
3639            IAccessRule[] accessRules,
3640            IClasspathAttribute[] extraAttributes,
3641            boolean isExported) {
3642
3643        if (containerPath == null) {
3644            Assert.isTrue(false, "Container path cannot be null"); //$NON-NLS-1$
3645 } else if (containerPath.segmentCount() < 1) {
3646            Assert.isTrue(
3647                false,
3648                "Illegal classpath container path: \'" + containerPath.makeRelative().toString() + "\', must have at least one segment (containerID+hints)"); //$NON-NLS-1$//$NON-NLS-2$
3649 }
3650        return new ClasspathEntry(
3651            IPackageFragmentRoot.K_SOURCE,
3652            IClasspathEntry.CPE_CONTAINER,
3653            containerPath,
3654            ClasspathEntry.INCLUDE_ALL, // inclusion patterns
3655 ClasspathEntry.EXCLUDE_NONE, // exclusion patterns
3656 null, // source attachment
3657 null, // source attachment root
3658 null, // specific output folder
3659 isExported,
3660            accessRules,
3661            true, // combine access rules
3662 extraAttributes);
3663    }
3664
3665    /**
3666     * Creates and returns a type hierarchy for all types in the given
3667     * region, considering subtypes within that region and considering types in the
3668     * working copies with the given owner.
3669     * In other words, the owner's working copies will take
3670     * precedence over their original compilation units in the workspace.
3671     * <p>
3672     * Note that if a working copy is empty, it will be as if the original compilation
3673     * unit had been deleted.
3674     * <p>
3675     *
3676     * @param monitor the given progress monitor
3677     * @param region the given region
3678     * @param owner the owner of working copies that take precedence over their original compilation units,
3679     * or <code>null</code> if the primary working copy owner should be used
3680     * @exception JavaModelException if an element in the region does not exist or if an
3681     * exception occurs while accessing its corresponding resource
3682     * @exception IllegalArgumentException if region is <code>null</code>
3683     * @return a type hierarchy for all types in the given
3684     * region, considering subtypes within that region
3685     * @since 3.1
3686     */
3687    public static ITypeHierarchy newTypeHierarchy(IRegion region, WorkingCopyOwner owner, IProgressMonitor monitor) throws JavaModelException {
3688        if (region == null) {
3689            throw new IllegalArgumentException  JavaDoc(Messages.hierarchy_nullRegion);
3690        }
3691        ICompilationUnit[] workingCopies = JavaModelManager.getJavaModelManager().getWorkingCopies(owner, true/*add primary working copies*/);
3692        CreateTypeHierarchyOperation op =
3693            new CreateTypeHierarchyOperation(region, workingCopies, null, true/*compute subtypes*/);
3694        op.runOperation(monitor);
3695        return op.getResult();
3696    }
3697
3698    /**
3699     * Creates and returns a new non-exported classpath entry of kind <code>CPE_LIBRARY</code> for the
3700     * JAR or folder identified by the given absolute path. This specifies that all package fragments
3701     * within the root will have children of type <code>IClassFile</code>.
3702     * This method is fully equivalent to calling
3703     * {@link #newLibraryEntry(IPath, IPath, IPath, IAccessRule[], IClasspathAttribute[], boolean)
3704     * newLibraryEntry(path, sourceAttachmentPath, sourceAttachmentRootPath, new IAccessRule[0], new IClasspathAttribute[0], false)}.
3705     *
3706     * @param path the absolute path of the binary archive
3707     * @param sourceAttachmentPath the absolute path of the corresponding source archive or folder,
3708     * or <code>null</code> if none. Note, since 3.0, an empty path is allowed to denote no source attachment.
3709     * and will be automatically converted to <code>null</code>.
3710     * @param sourceAttachmentRootPath the location of the root of the source files within the source archive or folder
3711     * or <code>null</code> if this location should be automatically detected.
3712     * @return a new library classpath entry
3713     */
3714    public static IClasspathEntry newLibraryEntry(
3715        IPath path,
3716        IPath sourceAttachmentPath,
3717        IPath sourceAttachmentRootPath) {
3718
3719        return newLibraryEntry(
3720            path,
3721            sourceAttachmentPath,
3722            sourceAttachmentRootPath,
3723            ClasspathEntry.NO_ACCESS_RULES,
3724            ClasspathEntry.NO_EXTRA_ATTRIBUTES,
3725            false/*not exported*/);
3726    }
3727
3728    /**
3729     * Creates and returns a new classpath entry of kind <code>CPE_LIBRARY</code> for the JAR or folder
3730     * identified by the given absolute path. This specifies that all package fragments within the root
3731     * will have children of type <code>IClassFile</code>.
3732     * This method is fully equivalent to calling
3733     * {@link #newLibraryEntry(IPath, IPath, IPath, IAccessRule[], IClasspathAttribute[], boolean)
3734     * newLibraryEntry(path, sourceAttachmentPath, sourceAttachmentRootPath, new IAccessRule[0], new IClasspathAttribute[0], isExported)}.
3735     *
3736     * @param path the absolute path of the binary archive
3737     * @param sourceAttachmentPath the absolute path of the corresponding source archive or folder,
3738     * or <code>null</code> if none. Note, since 3.0, an empty path is allowed to denote no source attachment.
3739     * and will be automatically converted to <code>null</code>.
3740     * @param sourceAttachmentRootPath the location of the root of the source files within the source archive or folder
3741     * or <code>null</code> if this location should be automatically detected.
3742     * @param isExported indicates whether this entry is contributed to dependent
3743     * projects in addition to the output location
3744     * @return a new library classpath entry
3745     * @since 2.0
3746     */
3747    public static IClasspathEntry newLibraryEntry(
3748        IPath path,
3749        IPath sourceAttachmentPath,
3750        IPath sourceAttachmentRootPath,
3751        boolean isExported) {
3752
3753        return newLibraryEntry(
3754            path,
3755            sourceAttachmentPath,
3756            sourceAttachmentRootPath,
3757            ClasspathEntry.NO_ACCESS_RULES,
3758            ClasspathEntry.NO_EXTRA_ATTRIBUTES,
3759            isExported);
3760    }
3761
3762    /**
3763     * Creates and returns a new classpath entry of kind <code>CPE_LIBRARY</code> for the JAR or folder
3764     * identified by the given absolute path. This specifies that all package fragments within the root
3765     * will have children of type <code>IClassFile</code>.
3766     * <p>
3767     * A library entry is used to denote a prerequisite JAR or root folder containing binaries.
3768     * The target JAR can either be defined internally to the workspace (absolute path relative
3769     * to the workspace root) or externally to the workspace (absolute path in the file system).
3770     * The target root folder can only be defined internally to the workspace (absolute path relative
3771     * to the workspace root). To use a binary folder external to the workspace, it must first be
3772     * linked (see IFolder#createLink(...)).
3773     * <p>
3774     * e.g. Here are some examples of binary path usage<ul>
3775     * <li><code> "c:\jdk1.2.2\jre\lib\rt.jar" </code> - reference to an external JAR on Windows</li>
3776     * <li><code> "/Project/someLib.jar" </code> - reference to an internal JAR on Windows or Linux</li>
3777     * <li><code> "/Project/classes/" </code> - reference to an internal binary folder on Windows or Linux</li>
3778     * </ul>
3779     * Note that on non-Windows platform, a path <code>"/some/lib.jar"</code> is ambiguous.
3780     * It can be a path to an external JAR (its file system path being <code>"/some/lib.jar"</code>)
3781     * or it can be a path to an internal JAR (<code>"some"</code> being a project in the workspace).
3782     * Such an ambiguity is solved when the classpath entry is used (e.g. in {@link IJavaProject#getPackageFragmentRoots()}).
3783     * If the resource <code>"lib.jar"</code> exists in project <code>"some"</code>, then it is considered an
3784     * internal JAR. Otherwise it is an external JAR.
3785     * <p>Also note that this operation does not attempt to validate or access the
3786     * resources at the given paths.
3787     * </p><p>
3788     * The access rules determine the set of accessible class files
3789     * in the library. If the list of access rules is empty then all files
3790     * in this library are accessible.
3791     * See {@link IAccessRule} for a detailed description of access
3792     * rules.
3793     * </p>
3794     * <p>
3795     * The <code>extraAttributes</code> list contains name/value pairs that must be persisted with
3796     * this entry. If no extra attributes are provided, an empty array must be passed in.<br>
3797     * Note that this list should not contain any duplicate name.
3798     * </p>
3799     * <p>
3800     * The <code>isExported</code> flag indicates whether this entry is contributed to dependent
3801     * projects. If not exported, dependent projects will not see any of the classes from this entry.
3802     * If exported, dependent projects will concatenate the accessible files patterns of this entry with the
3803     * accessible files patterns of the projects, and they will concatenate the non accessible files patterns of this entry
3804     * with the non accessible files patterns of the project.
3805     * </p>
3806     *
3807     * @param path the absolute path of the binary archive
3808     * @param sourceAttachmentPath the absolute path of the corresponding source archive or folder,
3809     * or <code>null</code> if none. Note, since 3.0, an empty path is allowed to denote no source attachment.
3810     * and will be automatically converted to <code>null</code>.
3811     * @param sourceAttachmentRootPath the location of the root of the source files within the source archive or folder
3812     * or <code>null</code> if this location should be automatically detected.
3813     * @param accessRules the possibly empty list of access rules for this entry
3814     * @param extraAttributes the possibly empty list of extra attributes to persist with this entry
3815     * @param isExported indicates whether this entry is contributed to dependent
3816     * projects in addition to the output location
3817     * @return a new library classpath entry
3818     * @since 3.1
3819     */
3820    public static IClasspathEntry newLibraryEntry(
3821            IPath path,
3822            IPath sourceAttachmentPath,
3823            IPath sourceAttachmentRootPath,
3824            IAccessRule[] accessRules,
3825            IClasspathAttribute[] extraAttributes,
3826            boolean isExported) {
3827
3828        if (path == null) Assert.isTrue(false, "Library path cannot be null"); //$NON-NLS-1$
3829 if (!path.isAbsolute()) Assert.isTrue(false, "Path for IClasspathEntry must be absolute"); //$NON-NLS-1$
3830 if (sourceAttachmentPath != null) {
3831            if (sourceAttachmentPath.isEmpty()) {
3832                sourceAttachmentPath = null; // treat empty path as none
3833 } else if (!sourceAttachmentPath.isAbsolute()) {
3834                Assert.isTrue(false, "Source attachment path '" //$NON-NLS-1$
3835 + sourceAttachmentPath
3836                        + "' for IClasspathEntry must be absolute"); //$NON-NLS-1$
3837 }
3838        }
3839        return new ClasspathEntry(
3840            IPackageFragmentRoot.K_BINARY,
3841            IClasspathEntry.CPE_LIBRARY,
3842            JavaProject.canonicalizedPath(path),
3843            ClasspathEntry.INCLUDE_ALL, // inclusion patterns
3844 ClasspathEntry.EXCLUDE_NONE, // exclusion patterns
3845 sourceAttachmentPath,
3846            sourceAttachmentRootPath,
3847            null, // specific output folder
3848 isExported,
3849            accessRules,
3850            false, // no access rules to combine
3851 extraAttributes);
3852    }
3853
3854    /**
3855     * Creates and returns a new non-exported classpath entry of kind <code>CPE_PROJECT</code>
3856     * for the project identified by the given absolute path.
3857     * This method is fully equivalent to calling
3858     * {@link #newProjectEntry(IPath, IAccessRule[], boolean, IClasspathAttribute[], boolean)
3859     * newProjectEntry(path, new IAccessRule[0], true, new IClasspathAttribute[0], false)}.
3860     *
3861     * @param path the absolute path of the binary archive
3862     * @return a new project classpath entry
3863     */
3864    public static IClasspathEntry newProjectEntry(IPath path) {
3865        return newProjectEntry(path, false);
3866    }
3867
3868    /**
3869     * Creates and returns a new classpath entry of kind <code>CPE_PROJECT</code>
3870     * for the project identified by the given absolute path.
3871     * This method is fully equivalent to calling
3872     * {@link #newProjectEntry(IPath, IAccessRule[], boolean, IClasspathAttribute[], boolean)
3873     * newProjectEntry(path, new IAccessRule[0], true, new IClasspathAttribute[0], isExported)}.
3874     *
3875     * @param path the absolute path of the prerequisite project
3876     * @param isExported indicates whether this entry is contributed to dependent
3877     * projects in addition to the output location
3878     * @return a new project classpath entry
3879     * @since 2.0
3880     */
3881    public static IClasspathEntry newProjectEntry(IPath path, boolean isExported) {
3882
3883        if (!path.isAbsolute()) Assert.isTrue(false, "Path for IClasspathEntry must be absolute"); //$NON-NLS-1$
3884
3885        return newProjectEntry(
3886            path,
3887            ClasspathEntry.NO_ACCESS_RULES,
3888            true,
3889            ClasspathEntry.NO_EXTRA_ATTRIBUTES,
3890            isExported);
3891    }
3892
3893    /**
3894     * Creates and returns a new classpath entry of kind <code>CPE_PROJECT</code>
3895     * for the project identified by the given absolute path.
3896     * <p>
3897     * A project entry is used to denote a prerequisite project on a classpath.
3898     * The referenced project will be contributed as a whole, either as sources (in the Java Model, it
3899     * contributes all its package fragment roots) or as binaries (when building, it contributes its
3900     * whole output location).
3901     * </p>
3902     * <p>
3903     * A project reference allows to indirect through another project, independently from its internal layout.
3904     * </p><p>
3905     * The prerequisite project is referred to using an absolute path relative to the workspace root.
3906     * </p>
3907     * <p>
3908     * The access rules determine the set of accessible class files
3909     * in the project. If the list of access rules is empty then all files
3910     * in this project are accessible.
3911     * See {@link IAccessRule} for a detailed description of access rules.
3912     * </p>
3913     * <p>
3914     * The <code>combineAccessRules</code> flag indicates whether access rules of one (or more)
3915     * exported entry of the project should be combined with the given access rules. If they should
3916     * be combined, the given access rules are considered first, then the entry's access rules are
3917     * considered.
3918     * </p>
3919     * <p>
3920     * The <code>extraAttributes</code> list contains name/value pairs that must be persisted with
3921     * this entry. If no extra attributes are provided, an empty array must be passed in.<br>
3922     * Note that this list should not contain any duplicate name.
3923     * </p>
3924     * <p>
3925     * The <code>isExported</code> flag indicates whether this entry is contributed to dependent
3926     * projects. If not exported, dependent projects will not see any of the classes from this entry.
3927     * If exported, dependent projects will concatenate the accessible files patterns of this entry with the
3928     * accessible files patterns of the projects, and they will concatenate the non accessible files patterns of this entry
3929     * with the non accessible files patterns of the project.
3930     * </p>
3931     *
3932     * @param path the absolute path of the prerequisite project
3933     * @param accessRules the possibly empty list of access rules for this entry
3934     * @param combineAccessRules whether the access rules of the project's exported entries should be combined with the given access rules
3935     * @param extraAttributes the possibly empty list of extra attributes to persist with this entry
3936     * @param isExported indicates whether this entry is contributed to dependent
3937     * projects in addition to the output location
3938     * @return a new project classpath entry
3939     * @since 3.1
3940     */
3941    public static IClasspathEntry newProjectEntry(
3942            IPath path,
3943            IAccessRule[] accessRules,
3944            boolean combineAccessRules,
3945            IClasspathAttribute[] extraAttributes,
3946            boolean isExported) {
3947
3948        if (!path.isAbsolute()) Assert.isTrue(false, "Path for IClasspathEntry must be absolute"); //$NON-NLS-1$
3949
3950        return new ClasspathEntry(
3951            IPackageFragmentRoot.K_SOURCE,
3952            IClasspathEntry.CPE_PROJECT,
3953            path,
3954            ClasspathEntry.INCLUDE_ALL, // inclusion patterns
3955 ClasspathEntry.EXCLUDE_NONE, // exclusion patterns
3956 null, // source attachment
3957 null, // source attachment root
3958 null, // specific output folder
3959 isExported,
3960            accessRules,
3961            combineAccessRules,
3962            extraAttributes);
3963    }
3964
3965    /**
3966     * Returns a new empty region.
3967     *
3968     * @return a new empty region
3969     */
3970    public static IRegion newRegion() {
3971        return new Region();
3972    }
3973
3974    /**
3975     * Creates and returns a new classpath entry of kind <code>CPE_SOURCE</code>
3976     * for all files in the project's source folder identified by the given
3977     * absolute workspace-relative path.
3978     * <p>
3979     * The convenience method is fully equivalent to:
3980     * <pre>
3981     * newSourceEntry(path, new IPath[] {}, new IPath[] {}, null);
3982     * </pre>
3983     * </p>
3984     *
3985     * @param path the absolute workspace-relative path of a source folder
3986     * @return a new source classpath entry
3987     * @see #newSourceEntry(IPath, IPath[], IPath[], IPath)
3988     */
3989    public static IClasspathEntry newSourceEntry(IPath path) {
3990
3991        return newSourceEntry(path, ClasspathEntry.INCLUDE_ALL, ClasspathEntry.EXCLUDE_NONE, null /*output location*/);
3992    }
3993
3994    /**
3995     * Creates and returns a new classpath entry of kind <code>CPE_SOURCE</code>
3996     * for the project's source folder identified by the given absolute
3997     * workspace-relative path but excluding all source files with paths
3998     * matching any of the given patterns.
3999     * <p>
4000     * The convenience method is fully equivalent to:
4001     * <pre>
4002     * newSourceEntry(path, new IPath[] {}, exclusionPatterns, null);
4003     * </pre>
4004     * </p>
4005     *
4006     * @param path the absolute workspace-relative path of a source folder
4007     * @param exclusionPatterns the possibly empty list of exclusion patterns
4008     * represented as relative paths
4009     * @return a new source classpath entry
4010     * @see #newSourceEntry(IPath, IPath[], IPath[], IPath)
4011     * @since 2.1
4012     */
4013    public static IClasspathEntry newSourceEntry(IPath path, IPath[] exclusionPatterns) {
4014
4015        return newSourceEntry(path, ClasspathEntry.INCLUDE_ALL, exclusionPatterns, null /*output location*/);
4016    }
4017
4018    /**
4019     * Creates and returns a new classpath entry of kind <code>CPE_SOURCE</code>
4020     * for the project's source folder identified by the given absolute
4021     * workspace-relative path but excluding all source files with paths
4022     * matching any of the given patterns, and associated with a specific output location
4023     * (that is, ".class" files are not going to the project default output location).
4024     * <p>
4025     * The convenience method is fully equivalent to:
4026     * <pre>
4027     * newSourceEntry(path, new IPath[] {}, exclusionPatterns, specificOutputLocation);
4028     * </pre>
4029     * </p>
4030     *
4031     * @param path the absolute workspace-relative path of a source folder
4032     * @param exclusionPatterns the possibly empty list of exclusion patterns
4033     * represented as relative paths
4034     * @param specificOutputLocation the specific output location for this source entry (<code>null</code> if using project default ouput location)
4035     * @return a new source classpath entry
4036     * @see #newSourceEntry(IPath, IPath[], IPath[], IPath)
4037     * @since 2.1
4038     */
4039    public static IClasspathEntry newSourceEntry(IPath path, IPath[] exclusionPatterns, IPath specificOutputLocation) {
4040
4041        return newSourceEntry(path, ClasspathEntry.INCLUDE_ALL, exclusionPatterns, specificOutputLocation);
4042    }
4043
4044    /**
4045     * Creates and returns a new classpath entry of kind <code>CPE_SOURCE</code>
4046     * for the project's source folder identified by the given absolute
4047     * workspace-relative path but excluding all source files with paths
4048     * matching any of the given patterns, and associated with a specific output location
4049     * (that is, ".class" files are not going to the project default output location).
4050     * <p>
4051     * The convenience method is fully equivalent to:
4052     * <pre>
4053     * newSourceEntry(path, new IPath[] {}, exclusionPatterns, specificOutputLocation, new IClasspathAttribute[] {});
4054     * </pre>
4055     * </p>
4056     *
4057     * @param path the absolute workspace-relative path of a source folder
4058     * @param inclusionPatterns the possibly empty list of inclusion patterns
4059     * represented as relative paths
4060     * @param exclusionPatterns the possibly empty list of exclusion patterns
4061     * represented as relative paths
4062     * @param specificOutputLocation the specific output location for this source entry (<code>null</code> if using project default ouput location)
4063     * @return a new source classpath entry
4064     * @see #newSourceEntry(IPath, IPath[], IPath[], IPath, IClasspathAttribute[])
4065     * @since 3.0
4066     */
4067    public static IClasspathEntry newSourceEntry(IPath path, IPath[] inclusionPatterns, IPath[] exclusionPatterns, IPath specificOutputLocation) {
4068        return newSourceEntry(path, inclusionPatterns, exclusionPatterns, specificOutputLocation, ClasspathEntry.NO_EXTRA_ATTRIBUTES);
4069    }
4070
4071    /**
4072     * Creates and returns a new classpath entry of kind <code>CPE_SOURCE</code>
4073     * for the project's source folder identified by the given absolute
4074     * workspace-relative path using the given inclusion and exclusion patterns
4075     * to determine which source files are included, and the given output path
4076     * to control the output location of generated files.
4077     * <p>
4078     * The source folder is referred to using an absolute path relative to the
4079     * workspace root, e.g. <code>/Project/src</code>. A project's source
4080     * folders are located with that project. That is, a source classpath
4081     * entry specifying the path <code>/P1/src</code> is only usable for
4082     * project <code>P1</code>.
4083     * </p>
4084     * <p>
4085     * The inclusion patterns determines the initial set of source files that
4086     * are to be included; the exclusion patterns are then used to reduce this
4087     * set. When no inclusion patterns are specified, the initial file set
4088     * includes all relevent files in the resource tree rooted at the source
4089     * entry's path. On the other hand, specifying one or more inclusion
4090     * patterns means that all <b>and only</b> files matching at least one of
4091     * the specified patterns are to be included. If exclusion patterns are
4092     * specified, the initial set of files is then reduced by eliminating files
4093     * matched by at least one of the exclusion patterns. Inclusion and
4094     * exclusion patterns look like relative file paths with wildcards and are
4095     * interpreted relative to the source entry's path. File patterns are
4096     * case-sensitive can contain '**', '*' or '?' wildcards (see
4097     * {@link IClasspathEntry#getExclusionPatterns()} for the full description
4098     * of their syntax and semantics). The resulting set of files are included
4099     * in the corresponding package fragment root; all package fragments within
4100     * the root will have children of type <code>ICompilationUnit</code>.
4101     * </p>
4102     * <p>
4103     * For example, if the source folder path is
4104     * <code>/Project/src</code>, there are no inclusion filters, and the
4105     * exclusion pattern is
4106     * <code>com/xyz/tests/**</code>, then source files
4107     * like <code>/Project/src/com/xyz/Foo.java</code>
4108     * and <code>/Project/src/com/xyz/utils/Bar.java</code> would be included,
4109     * whereas <code>/Project/src/com/xyz/tests/T1.java</code>
4110     * and <code>/Project/src/com/xyz/tests/quick/T2.java</code> would be
4111     * excluded.
4112     * </p>
4113     * <p>
4114     * Additionally, a source entry can be associated with a specific output location.
4115     * By doing so, the Java builder will ensure that the generated ".class" files will
4116     * be issued inside this output location, as opposed to be generated into the
4117     * project default output location (when output location is <code>null</code>).
4118     * Note that multiple source entries may target the same output location.
4119     * The output location is referred to using an absolute path relative to the
4120     * workspace root, e.g. <code>"/Project/bin"</code>, it must be located inside
4121     * the same project as the source folder.
4122     * </p>
4123     * <p>
4124     * Also note that all sources/binaries inside a project are contributed as
4125     * a whole through a project entry
4126     * (see <code>JavaCore.newProjectEntry</code>). Particular source entries
4127     * cannot be selectively exported.
4128     * </p>
4129     * <p>
4130     * The <code>extraAttributes</code> list contains name/value pairs that must be persisted with
4131     * this entry. If no extra attributes are provided, an empty array must be passed in.<br>
4132     * Note that this list should not contain any duplicate name.
4133     * </p>
4134     *
4135     * @param path the absolute workspace-relative path of a source folder
4136     * @param inclusionPatterns the possibly empty list of inclusion patterns
4137     * represented as relative paths
4138     * @param exclusionPatterns the possibly empty list of exclusion patterns
4139     * represented as relative paths
4140     * @param specificOutputLocation the specific output location for this source entry (<code>null</code> if using project default ouput location)
4141     * @param extraAttributes the possibly empty list of extra attributes to persist with this entry
4142     * @return a new source classpath entry with the given exclusion patterns
4143     * @see IClasspathEntry#getInclusionPatterns()
4144     * @see IClasspathEntry#getExclusionPatterns()
4145     * @see IClasspathEntry#getOutputLocation()
4146     * @since 3.1
4147     */
4148    public static IClasspathEntry newSourceEntry(IPath path, IPath[] inclusionPatterns, IPath[] exclusionPatterns, IPath specificOutputLocation, IClasspathAttribute[] extraAttributes) {
4149
4150        if (path == null) Assert.isTrue(false, "Source path cannot be null"); //$NON-NLS-1$
4151 if (!path.isAbsolute()) Assert.isTrue(false, "Path for IClasspathEntry must be absolute"); //$NON-NLS-1$
4152 if (exclusionPatterns == null) Assert.isTrue(false, "Exclusion pattern set cannot be null"); //$NON-NLS-1$
4153 if (inclusionPatterns == null) Assert.isTrue(false, "Inclusion pattern set cannot be null"); //$NON-NLS-1$
4154
4155        return new ClasspathEntry(
4156            IPackageFragmentRoot.K_SOURCE,
4157            IClasspathEntry.CPE_SOURCE,
4158            path,
4159            inclusionPatterns,
4160            exclusionPatterns,
4161            null, // source attachment
4162 null, // source attachment root
4163 specificOutputLocation, // custom output location
4164 false,
4165            null,
4166            false, // no access rules to combine
4167 extraAttributes);
4168    }
4169
4170    /**
4171     * Creates and returns a new non-exported classpath entry of kind <code>CPE_VARIABLE</code>
4172     * for the given path. This method is fully equivalent to calling
4173     * {@link #newVariableEntry(IPath, IPath, IPath, IAccessRule[], IClasspathAttribute[], boolean)
4174     * newVariableEntry(variablePath, variableSourceAttachmentPath, sourceAttachmentRootPath, new IAccessRule[0], new IClasspathAttribute[0], false)}.
4175     *
4176     * @param variablePath the path of the binary archive; first segment is the
4177     * name of a classpath variable
4178     * @param variableSourceAttachmentPath the path of the corresponding source archive,
4179     * or <code>null</code> if none; if present, the first segment is the
4180     * name of a classpath variable (not necessarily the same variable
4181     * as the one that begins <code>variablePath</code>)
4182     * @param sourceAttachmentRootPath the location of the root of the source files within the source archive
4183     * or <code>null</code> if <code>variableSourceAttachmentPath</code> is also <code>null</code>
4184     * @return a new library classpath entry
4185     */
4186    public static IClasspathEntry newVariableEntry(
4187        IPath variablePath,
4188        IPath variableSourceAttachmentPath,
4189        IPath sourceAttachmentRootPath) {
4190
4191        return newVariableEntry(variablePath, variableSourceAttachmentPath, sourceAttachmentRootPath, false);
4192    }
4193
4194    /**
4195     * Creates and returns a new classpath entry of kind <code>CPE_VARIABLE</code>
4196     * for the given path. This method is fully equivalent to calling
4197     * {@link #newVariableEntry(IPath, IPath, IPath, IAccessRule[], IClasspathAttribute[], boolean)
4198     * newVariableEntry(variablePath, variableSourceAttachmentPath, sourceAttachmentRootPath, new IAccessRule[0], new IClasspathAttribute[0], isExported)}.
4199     *
4200     * @param variablePath the path of the binary archive; first segment is the
4201     * name of a classpath variable
4202     * @param variableSourceAttachmentPath the path of the corresponding source archive,
4203     * or <code>null</code> if none; if present, the first segment is the
4204     * name of a classpath variable (not necessarily the same variable
4205     * as the one that begins <code>variablePath</code>)
4206     * @param variableSourceAttachmentRootPath the location of the root of the source files within the source archive
4207     * or <code>null</code> if <code>variableSourceAttachmentPath</code> is also <code>null</code>
4208     * @param isExported indicates whether this entry is contributed to dependent
4209     * projects in addition to the output location
4210     * @return a new variable classpath entry
4211     * @since 2.0
4212     */
4213    public static IClasspathEntry newVariableEntry(
4214            IPath variablePath,
4215            IPath variableSourceAttachmentPath,
4216            IPath variableSourceAttachmentRootPath,
4217            boolean isExported) {
4218
4219        return newVariableEntry(
4220            variablePath,
4221            variableSourceAttachmentPath,
4222            variableSourceAttachmentRootPath,
4223            ClasspathEntry.NO_ACCESS_RULES,
4224            ClasspathEntry.NO_EXTRA_ATTRIBUTES,
4225            isExported);
4226    }
4227
4228    /**
4229     * Creates and returns a new classpath entry of kind <code>CPE_VARIABLE</code>
4230     * for the given path. The first segment of the path is the name of a classpath variable.
4231     * The trailing segments of the path will be appended to resolved variable path.
4232     * <p>
4233     * A variable entry allows to express indirect references on a classpath to other projects or libraries,
4234     * depending on what the classpath variable is referring.
4235     * <p>
4236     * It is possible to register an automatic initializer (<code>ClasspathVariableInitializer</code>),
4237     * which will be invoked through the extension point "org.eclipse.jdt.core.classpathVariableInitializer".
4238     * After resolution, a classpath variable entry may either correspond to a project or a library entry.
4239     * <p>
4240     * e.g. Here are some examples of variable path usage<ul>
4241     * <li> "JDTCORE" where variable <code>JDTCORE</code> is
4242     * bound to "c:/jars/jdtcore.jar". The resolved classpath entry is denoting the library "c:\jars\jdtcore.jar"</li>
4243     * <li> "JDTCORE" where variable <code>JDTCORE</code> is
4244     * bound to "/Project_JDTCORE". The resolved classpath entry is denoting the project "/Project_JDTCORE"</li>
4245     * <li> "PLUGINS/com.example/example.jar" where variable <code>PLUGINS</code>
4246     * is bound to "c:/eclipse/plugins". The resolved classpath entry is denoting the library "c:\eclipse\plugins\com.example\example.jar"</li>
4247     * </ul>
4248     * <p>
4249     * The access rules determine the set of accessible class files
4250     * in the project or library. If the list of access rules is empty then all files
4251     * in this project or library are accessible.
4252     * See {@link IAccessRule} for a detailed description of access rules.
4253     * </p>
4254     * <p>
4255     * The <code>extraAttributes</code> list contains name/value pairs that must be persisted with
4256     * this entry. If no extra attributes are provided, an empty array must be passed in.<br>
4257     * Note that this list should not contain any duplicate name.
4258     * </p>
4259     * <p>
4260     * The <code>isExported</code> flag indicates whether this entry is contributed to dependent
4261     * projects. If not exported, dependent projects will not see any of the classes from this entry.
4262     * If exported, dependent projects will concatenate the accessible files patterns of this entry with the
4263     * accessible files patterns of the projects, and they will concatenate the non accessible files patterns of this entry
4264     * with the non accessible files patterns of the project.
4265     * </p>
4266     * <p>
4267     * Note that this operation does not attempt to validate classpath variables
4268     * or access the resources at the given paths.
4269     * </p>
4270     *
4271     * @param variablePath the path of the binary archive; first segment is the
4272     * name of a classpath variable
4273     * @param variableSourceAttachmentPath the path of the corresponding source archive,
4274     * or <code>null</code> if none; if present, the first segment is the
4275     * name of a classpath variable (not necessarily the same variable
4276     * as the one that begins <code>variablePath</code>)
4277     * @param variableSourceAttachmentRootPath the location of the root of the source files within the source archive
4278     * or <code>null</code> if <code>variableSourceAttachmentPath</code> is also <code>null</code>
4279     * @param accessRules the possibly empty list of access rules for this entry
4280     * @param extraAttributes the possibly empty list of extra attributes to persist with this entry
4281     * @param isExported indicates whether this entry is contributed to dependent
4282     * projects in addition to the output location
4283     * @return a new variable classpath entry
4284     * @since 3.1
4285     */
4286    public static IClasspathEntry newVariableEntry(
4287            IPath variablePath,
4288            IPath variableSourceAttachmentPath,
4289            IPath variableSourceAttachmentRootPath,
4290            IAccessRule[] accessRules,
4291            IClasspathAttribute[] extraAttributes,
4292            boolean isExported) {
4293
4294        if (variablePath == null) Assert.isTrue(false, "Variable path cannot be null"); //$NON-NLS-1$
4295 if (variablePath.segmentCount() < 1) {
4296            Assert.isTrue(
4297                false,
4298                "Illegal classpath variable path: \'" + variablePath.makeRelative().toString() + "\', must have at least one segment"); //$NON-NLS-1$//$NON-NLS-2$
4299 }
4300
4301        return new ClasspathEntry(
4302            IPackageFragmentRoot.K_SOURCE,
4303            IClasspathEntry.CPE_VARIABLE,
4304            variablePath,
4305            ClasspathEntry.INCLUDE_ALL, // inclusion patterns
4306 ClasspathEntry.EXCLUDE_NONE, // exclusion patterns
4307 variableSourceAttachmentPath, // source attachment
4308 variableSourceAttachmentRootPath, // source attachment root
4309 null, // specific output folder
4310 isExported,
4311            accessRules,
4312            false, // no access rules to combine
4313 extraAttributes);
4314    }
4315    /**
4316     * Removed the given classpath variable. Does nothing if no value was
4317     * set for this classpath variable.
4318     * <p>
4319     * This functionality cannot be used while the resource tree is locked.
4320     * <p>
4321     * Classpath variable values are persisted locally to the workspace, and
4322     * are preserved from session to session.
4323     * <p>
4324     *
4325     * @param variableName the name of the classpath variable
4326     * @see #setClasspathVariable(String, IPath)
4327     *
4328     * @deprecated Use {@link #removeClasspathVariable(String, IProgressMonitor)} instead
4329     */
4330    public static void removeClasspathVariable(String  JavaDoc variableName) {
4331        removeClasspathVariable(variableName, null);
4332    }
4333
4334    /**
4335     * Removed the given classpath variable. Does nothing if no value was
4336     * set for this classpath variable.
4337     * <p>
4338     * This functionality cannot be used while the resource tree is locked.
4339     * <p>
4340     * Classpath variable values are persisted locally to the workspace, and
4341     * are preserved from session to session.
4342     * <p>
4343     *
4344     * @param variableName the name of the classpath variable
4345     * @param monitor the progress monitor to report progress
4346     * @see #setClasspathVariable(String, IPath)
4347     */
4348    public static void removeClasspathVariable(String  JavaDoc variableName, IProgressMonitor monitor) {
4349        try {
4350            SetVariablesOperation operation = new SetVariablesOperation(new String  JavaDoc[]{ variableName}, new IPath[]{ null }, true/*update preferences*/);
4351            operation.runOperation(monitor);
4352        } catch (JavaModelException e) {
4353            Util.log(e, "Exception while removing variable " + variableName); //$NON-NLS-1$
4354 }
4355    }
4356
4357    /**
4358     * Removes the given element changed listener.
4359     * Has no affect if an identical listener is not registered.
4360     *
4361     * @param listener the listener
4362     */
4363    public static void removeElementChangedListener(IElementChangedListener listener) {
4364        JavaModelManager.getJavaModelManager().deltaState.removeElementChangedListener(listener);
4365    }
4366
4367    /**
4368     * Removes the file extension from the given file name, if it has a Java-like file
4369     * extension. Otherwise the file name itself is returned.
4370     * Note this removes the dot ('.') before the extension as well.
4371     *
4372     * @param fileName the name of a file
4373     * @return the fileName without the Java-like extension
4374     * @since 3.2
4375     */
4376    public static String  JavaDoc removeJavaLikeExtension(String  JavaDoc fileName) {
4377        return Util.getNameWithoutJavaLikeExtension(fileName);
4378    }
4379
4380    /**
4381     * Removes the given pre-processing resource changed listener.
4382     * <p>
4383     * Has no affect if an identical listener is not registered.
4384     *
4385     * @param listener the listener
4386     * @since 3.0
4387     */
4388    public static void removePreProcessingResourceChangedListener(IResourceChangeListener listener) {
4389        JavaModelManager.getJavaModelManager().deltaState.removePreResourceChangedListener(listener);
4390    }
4391
4392
4393
4394    /**
4395     * Runs the given action as an atomic Java model operation.
4396     * <p>
4397     * After running a method that modifies java elements,
4398     * registered listeners receive after-the-fact notification of
4399     * what just transpired, in the form of a element changed event.
4400     * This method allows clients to call a number of
4401     * methods that modify java elements and only have element
4402     * changed event notifications reported at the end of the entire
4403     * batch.
4404     * </p>
4405     * <p>
4406     * If this method is called outside the dynamic scope of another such
4407     * call, this method runs the action and then reports a single
4408     * element changed event describing the net effect of all changes
4409     * done to java elements by the action.
4410     * </p>
4411     * <p>
4412     * If this method is called in the dynamic scope of another such
4413     * call, this method simply runs the action.
4414     * </p>
4415     *
4416     * @param action the action to perform
4417     * @param monitor a progress monitor, or <code>null</code> if progress
4418     * reporting and cancellation are not desired
4419     * @exception CoreException if the operation failed.
4420     * @since 2.1
4421     */
4422    public static void run(IWorkspaceRunnable action, IProgressMonitor monitor) throws CoreException {
4423        run(action, ResourcesPlugin.getWorkspace().getRoot(), monitor);
4424    }
4425    /**
4426     * Runs the given action as an atomic Java model operation.
4427     * <p>
4428     * After running a method that modifies java elements,
4429     * registered listeners receive after-the-fact notification of
4430     * what just transpired, in the form of a element changed event.
4431     * This method allows clients to call a number of
4432     * methods that modify java elements and only have element
4433     * changed event notifications reported at the end of the entire
4434     * batch.
4435     * </p>
4436     * <p>
4437     * If this method is called outside the dynamic scope of another such
4438     * call, this method runs the action and then reports a single
4439     * element changed event describing the net effect of all changes
4440     * done to java elements by the action.
4441     * </p>
4442     * <p>
4443     * If this method is called in the dynamic scope of another such
4444     * call, this method simply runs the action.
4445     * </p>
4446     * <p>
4447     * The supplied scheduling rule is used to determine whether this operation can be
4448     * run simultaneously with workspace changes in other threads. See
4449     * <code>IWorkspace.run(...)</code> for more details.
4450     * </p>
4451     *
4452     * @param action the action to perform
4453     * @param rule the scheduling rule to use when running this operation, or
4454     * <code>null</code> if there are no scheduling restrictions for this operation.
4455     * @param monitor a progress monitor, or <code>null</code> if progress
4456     * reporting and cancellation are not desired
4457     * @exception CoreException if the operation failed.
4458     * @since 3.0
4459     */
4460    public static void run(IWorkspaceRunnable action, ISchedulingRule rule, IProgressMonitor monitor) throws CoreException {
4461        IWorkspace workspace = ResourcesPlugin.getWorkspace();
4462        if (workspace.isTreeLocked()) {
4463            new BatchOperation(action).run(monitor);
4464        } else {
4465            // use IWorkspace.run(...) to ensure that a build will be done in autobuild mode
4466 workspace.run(new BatchOperation(action), rule, IWorkspace.AVOID_UPDATE, monitor);
4467        }
4468    }
4469    /**
4470     * Bind a container reference path to some actual containers (<code>IClasspathContainer</code>).
4471     * This API must be invoked whenever changes in container need to be reflected onto the JavaModel.
4472     * Containers can have distinct values in different projects, therefore this API considers a
4473     * set of projects with their respective containers.
4474     * <p>
4475     * <code>containerPath</code> is the path under which these values can be referenced through
4476     * container classpath entries (<code>IClasspathEntry#CPE_CONTAINER</code>). A container path
4477     * is formed by a first ID segment followed with extra segments, which can be used as additional hints
4478     * for the resolution. The container ID is used to identify a <code>ClasspathContainerInitializer</code>
4479     * registered on the extension point "org.eclipse.jdt.core.classpathContainerInitializer".
4480     * <p>
4481     * There is no assumption that each individual container value passed in argument
4482     * (<code>respectiveContainers</code>) must answer the exact same path when requested
4483     * <code>IClasspathContainer#getPath</code>.
4484     * Indeed, the containerPath is just an indication for resolving it to an actual container object. It can be
4485     * delegated to a <code>ClasspathContainerInitializer</code>, which can be activated through the extension
4486     * point "org.eclipse.jdt.core.ClasspathContainerInitializer").
4487     * <p>
4488     * In reaction to changing container values, the JavaModel will be updated to reflect the new
4489     * state of the updated container. A combined Java element delta will be notified to describe the corresponding
4490     * classpath changes resulting from the container update. This operation is batched, and automatically eliminates
4491     * unnecessary updates (new container is same as old one). This operation acquires a lock on the workspace's root.
4492     * <p>
4493     * This functionality cannot be used while the workspace is locked, since
4494     * it may create/remove some resource markers.
4495     * <p>
4496     * Classpath container values are persisted locally to the workspace, but
4497     * are not preserved from a session to another. It is thus highly recommended to register a
4498     * <code>ClasspathContainerInitializer</code> for each referenced container
4499     * (through the extension point "org.eclipse.jdt.core.ClasspathContainerInitializer").
4500     * <p>
4501     * Note: setting a container to <code>null</code> will cause it to be lazily resolved again whenever
4502     * its value is required. In particular, this will cause a registered initializer to be invoked
4503     * again.
4504     * <p>
4505     * @param containerPath - the name of the container reference, which is being updated
4506     * @param affectedProjects - the set of projects for which this container is being bound
4507     * @param respectiveContainers - the set of respective containers for the affected projects
4508     * @param monitor a monitor to report progress
4509     * @throws JavaModelException
4510     * @see ClasspathContainerInitializer
4511     * @see #getClasspathContainer(IPath, IJavaProject)
4512     * @see IClasspathContainer
4513     * @since 2.0
4514     */
4515    public static void setClasspathContainer(IPath containerPath, IJavaProject[] affectedProjects, IClasspathContainer[] respectiveContainers, IProgressMonitor monitor) throws JavaModelException {
4516        if (affectedProjects.length != respectiveContainers.length)
4517            Assert.isTrue(false, "Projects and containers collections should have the same size"); //$NON-NLS-1$
4518 SetContainerOperation operation = new SetContainerOperation(containerPath, affectedProjects, respectiveContainers);
4519        operation.runOperation(monitor);
4520    }
4521
4522    /**
4523     * Sets the value of the given classpath variable.
4524     * The path must have at least one segment.
4525     * <p>
4526     * This functionality cannot be used while the resource tree is locked.
4527     * <p>
4528     * Classpath variable values are persisted locally to the workspace, and
4529     * are preserved from session to session.
4530     * <p>
4531     *
4532     * @param variableName the name of the classpath variable
4533     * @param path the path
4534     * @throws JavaModelException
4535     * @see #getClasspathVariable(String)
4536     *
4537     * @deprecated Use {@link #setClasspathVariable(String, IPath, IProgressMonitor)} instead
4538     */
4539    public static void setClasspathVariable(String  JavaDoc variableName, IPath path)
4540        throws JavaModelException {
4541
4542        setClasspathVariable(variableName, path, null);
4543    }
4544
4545    /**
4546     * Sets the value of the given classpath variable.
4547     * The path must not be null.
4548     * <p>
4549     * This functionality cannot be used while the resource tree is locked.
4550     * <p>
4551     * Classpath variable values are persisted locally to the workspace, and
4552     * are preserved from session to session.
4553     * <p>
4554     * Updating a variable with the same value has no effect.
4555     *
4556     * @param variableName the name of the classpath variable
4557     * @param path the path
4558     * @param monitor a monitor to report progress
4559     * @throws JavaModelException
4560     * @see #getClasspathVariable(String)
4561     */
4562    public static void setClasspathVariable(
4563        String  JavaDoc variableName,
4564        IPath path,
4565        IProgressMonitor monitor)
4566        throws JavaModelException {
4567
4568        if (path == null) Assert.isTrue(false, "Variable path cannot be null"); //$NON-NLS-1$
4569 setClasspathVariables(new String  JavaDoc[]{variableName}, new IPath[]{ path }, monitor);
4570    }
4571
4572    /**
4573     * Sets the values of all the given classpath variables at once.
4574     * Null paths can be used to request corresponding variable removal.
4575     * <p>
4576     * A combined Java element delta will be notified to describe the corresponding
4577     * classpath changes resulting from the variables update. This operation is batched,
4578     * and automatically eliminates unnecessary updates (new variable is same as old one).
4579     * This operation acquires a lock on the workspace's root.
4580     * <p>
4581     * This functionality cannot be used while the workspace is locked, since
4582     * it may create/remove some resource markers.
4583     * <p>
4584     * Classpath variable values are persisted locally to the workspace, and
4585     * are preserved from session to session.
4586     * <p>
4587     * Updating a variable with the same value has no effect.
4588     *
4589     * @param variableNames an array of names for the updated classpath variables
4590     * @param paths an array of path updates for the modified classpath variables (null
4591     * meaning that the corresponding value will be removed
4592     * @param monitor a monitor to report progress
4593     * @throws JavaModelException
4594     * @see #getClasspathVariable(String)
4595     * @since 2.0
4596     */
4597    public static void setClasspathVariables(
4598        String  JavaDoc[] variableNames,
4599        IPath[] paths,
4600        IProgressMonitor monitor)
4601        throws JavaModelException {
4602
4603        if (variableNames.length != paths.length) Assert.isTrue(false, "Variable names and paths collections should have the same size"); //$NON-NLS-1$
4604 SetVariablesOperation operation = new SetVariablesOperation(variableNames, paths, true/*update preferences*/);
4605        operation.runOperation(monitor);
4606    }
4607
4608    /**
4609     * Sets the default's compiler options inside the given options map according
4610     * to the given compliance.
4611     *
4612     * <p>The given compliance must be one of the compliance supported by the compiler.
4613     * See {@link #getDefaultOptions()} for a list of compliance values.</p>
4614     *
4615     * <p>The list of modified options is:</p>
4616     * <ul>
4617     * <li>{@link #COMPILER_CODEGEN_TARGET_PLATFORM}</li>
4618     * <li>{@link #COMPILER_SOURCE}</li>
4619     * <li>{@link #COMPILER_COMPLIANCE}</li>
4620     * <li>{@link #COMPILER_PB_ASSERT_IDENTIFIER}</li>
4621     * <li>{@link #COMPILER_PB_ENUM_IDENTIFIER}</li>
4622     * </ul>
4623     *
4624     * <p>If the given compliance is unknown, the given map is unmodified.</p>
4625     *
4626     * @param compliance the given compliance
4627     * @param options the given options map
4628     * @since 3.3
4629     */
4630    public static void setComplianceOptions(String  JavaDoc compliance, Map  JavaDoc options) {
4631        switch((int) (CompilerOptions.versionToJdkLevel(compliance) >>> 16)) {
4632            case ClassFileConstants.MAJOR_VERSION_1_3:
4633                options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_3);
4634                options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_3);
4635                options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_1);
4636                options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.IGNORE);
4637                options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.IGNORE);
4638                break;
4639            case ClassFileConstants.MAJOR_VERSION_1_4:
4640                options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_4);
4641                options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_3);
4642                options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_2);
4643                options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.WARNING);
4644                options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.WARNING);
4645                break;
4646            case ClassFileConstants.MAJOR_VERSION_1_5:
4647                options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_5);
4648                options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_5);
4649                options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_5);
4650                options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.ERROR);
4651                options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.ERROR);
4652                options.put(JavaCore.COMPILER_CODEGEN_INLINE_JSR_BYTECODE, JavaCore.ENABLED);
4653                break;
4654            case ClassFileConstants.MAJOR_VERSION_1_6:
4655                options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_6);
4656                options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_6);
4657                options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_6);
4658                options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.ERROR);
4659                options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.ERROR);
4660                options.put(JavaCore.COMPILER_CODEGEN_INLINE_JSR_BYTECODE, JavaCore.ENABLED);
4661                break;
4662            case ClassFileConstants.MAJOR_VERSION_1_7:
4663                options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_7);
4664                options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_7);
4665                options.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_7);
4666                options.put(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.ERROR);
4667                options.put(JavaCore.COMPILER_PB_ENUM_IDENTIFIER, JavaCore.ERROR);
4668                options.put(JavaCore.COMPILER_CODEGEN_INLINE_JSR_BYTECODE, JavaCore.ENABLED);
4669        }
4670    }
4671
4672    /**
4673     * Sets the current table of options. All and only the options explicitly
4674     * included in the given table are remembered; all previous option settings
4675     * are forgotten, including ones not explicitly mentioned.
4676     * <p>
4677     * For a complete description of the configurable options, see
4678     * <code>getDefaultOptions</code>.
4679     * </p>
4680     *
4681     * @param newOptions
4682     * the new options (key type: <code>String</code>; value type:
4683     * <code>String</code>), or <code>null</code> to reset all
4684     * options to their default values
4685     * @see JavaCore#getDefaultOptions()
4686     * @see JavaCorePreferenceInitializer for changing default settings
4687     */
4688    public static void setOptions(Hashtable  JavaDoc newOptions) {
4689        JavaModelManager.getJavaModelManager().setOptions(newOptions);
4690    }
4691
4692    /* (non-Javadoc)
4693     * Shutdown the JavaCore plug-in.
4694     * <p>
4695     * De-registers the JavaModelManager as a resource changed listener and save participant.
4696     * <p>
4697     * @see org.eclipse.core.runtime.Plugin#stop(BundleContext)
4698     */
4699    public void stop(BundleContext context) throws Exception  JavaDoc {
4700        try {
4701            JavaModelManager.getJavaModelManager().shutdown();
4702        } finally {
4703            // ensure we call super.stop as the last thing
4704 super.stop(context);
4705        }
4706    }
4707
4708    /* (non-Javadoc)
4709     * Startup the JavaCore plug-in.
4710     * <p>
4711     * Registers the JavaModelManager as a resource changed listener and save participant.
4712     * Starts the background indexing, and restore saved classpath variable values.
4713     * <p>
4714     * @throws Exception
4715     * @see org.eclipse.core.runtime.Plugin#start(BundleContext)
4716     */
4717    public void start(BundleContext context) throws Exception  JavaDoc {
4718        super.start(context);
4719        JavaModelManager.getJavaModelManager().startup();
4720    }
4721}

Read more: http://kickjava.com/src/org/eclipse/jdt/core/JavaCore.java.htm#ixzz2tkFaV0QY

目录
相关文章
|
6天前
使用EventBus 3.0 报 Subscriber class com.example.test.MainActivity and its super classes have no public methods with the @Subscribe annotation
使用EventBus 3.0 报 Subscriber class com.example.test.MainActivity and its super classes have no public methods with the @Subscribe annotation
13 5
|
IDE 开发工具
Error:No such property: GradleVersion for class: JetGradlePlugin问题处理
Error:No such property: GradleVersion for class: JetGradlePlugin问题处理
Error:No such property: GradleVersion for class: JetGradlePlugin问题处理
|
Java 数据库 Android开发
在添加greendao 的plugin 出现?:Could not initialize class com.android.sdklib.repository
在添加greendao 的plugin 出现?:Could not initialize class com.android.sdklib.repository
259 1
在添加greendao 的plugin 出现?:Could not initialize class com.android.sdklib.repository
|
Java
SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Class path contains multiple SLF4J bindings
140 0
|
Java 数据库连接 mybatis
Lombok - Does lombok @Builder allow extends
Lombok - Does lombok @Builder allow extends
424 0
【Junit 报错】Test class should have exactly one public zero-argument constructor和Test class can only have one constructor
错误1: 1 java.lang.Exception: Test class should have exactly one public zero-argument constructor 2 at org.
6058 0
|
分布式计算 Hadoop Java
SLF4J: Class path contains multiple SLF4J bindings.解决方案
SLF4J: Class path contains multiple SLF4J bindings.解决方案
553 0
SLF4J: Class path contains multiple SLF4J bindings.解决方案
|
JavaScript
vue npm run build打包报错:Class extends value undefined is not a constructor or null
vue npm run build打包报错:Class extends value undefined is not a constructor or null
790 0
vue npm run build打包报错:Class extends value undefined is not a constructor or null
[Hyperf]Entry “xxxInterface“ cannot be resolved: the class is not instantiable
[Hyperf]Entry “xxxInterface“ cannot be resolved: the class is not instantiable
417 0
[Hyperf]Entry “xxxInterface“ cannot be resolved: the class is not instantiable
ant build里如何指定classpath
ant build里如何指定classpath
101 0
ant build里如何指定classpath

热门文章

最新文章