612ff560ac4a966bb21955f975a2b24eaca5d94b
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / core / IJavaProject.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2003 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  *     IBM Corporation - added getOption(String, boolean), getOptions(boolean) and setOptions(Map)
11  *     IBM Corporation - deprecated getPackageFragmentRoots(IClasspathEntry) and 
12  *                               added findPackageFragmentRoots(IClasspathEntry)
13  *     IBM Corporation - added isOnClasspath(IResource)
14  *******************************************************************************/
15 package net.sourceforge.phpdt.core;
16
17 import org.eclipse.core.resources.IProject;
18
19
20 /**
21  * A Java project represents a view of a project resource in terms of Java 
22  * elements such as package fragments, types, methods and fields.
23  * A project may contain several package roots, which contain package fragments. 
24  * A package root corresponds to an underlying folder or JAR.
25  * <p>
26  * Each Java project has a classpath, defining which folders contain source code and
27  * where required libraries are located. Each Java project also has an output location,
28  * defining where the builder writes <code>.class</code> files. A project that
29  * references packages in another project can access the packages by including
30  * the required project in a classpath entry. The Java model will present the
31  * source elements in the required project; when building, the compiler will use
32  * the corresponding generated class files from the required project's output
33  * location(s)). The classpath format is a sequence of classpath entries
34  * describing the location and contents of package fragment roots.
35  * </p>
36  * Java project elements need to be opened before they can be navigated or manipulated.
37  * The children of a Java project are the package fragment roots that are 
38  * defined by the classpath and contained in this project (in other words, it
39  * does not include package fragment roots for other projects).
40  * </p>
41  * <p>
42  * This interface is not intended to be implemented by clients. An instance
43  * of one of these handles can be created via 
44  * <code>JavaCore.create(project)</code>.
45  * </p>
46  *
47  * @see JavaCore#create(org.eclipse.core.resources.IProject)
48  * @see IClasspathEntry
49  */
50 public interface IJavaProject extends IParent, IJavaElement, IOpenable {
51
52         /**
53          * Returns the <code>IJavaElement</code> corresponding to the given
54          * classpath-relative path, or <code>null</code> if no such 
55          * <code>IJavaElement</code> is found. The result is one of an
56          * <code>ICompilationUnit</code>, <code>IClassFile</code>, or
57          * <code>IPackageFragment</code>. 
58          * <p>
59          * When looking for a package fragment, there might be several potential
60          * matches; only one of them is returned.
61          *
62          * <p>For example, the path "java/lang/Object.java", would result in the
63          * <code>ICompilationUnit</code> or <code>IClassFile</code> corresponding to
64          * "java.lang.Object". The path "java/lang" would result in the
65          * <code>IPackageFragment</code> for "java.lang".
66          * @param path the given classpath-relative path
67          * @exception JavaModelException if the given path is <code>null</code>
68          *  or absolute
69          * @return the <code>IJavaElement</code> corresponding to the given
70          * classpath-relative path, or <code>null</code> if no such 
71          * <code>IJavaElement</code> is found
72          */
73 //      IJavaElement findElement(IPath path) throws JavaModelException;
74
75         /**
76          * Returns the first existing package fragment on this project's classpath
77          * whose path matches the given (absolute) path, or <code>null</code> if none
78          * exist.
79          * The path can be:
80          *      - internal to the workbench: "/Project/src"
81          *  - external to the workbench: "c:/jdk/classes.zip/java/lang"
82          * @param path the given absolute path
83          * @exception JavaModelException if this element does not exist or if an
84          *              exception occurs while accessing its corresponding resource
85          * @return the first existing package fragment on this project's classpath
86          * whose path matches the given (absolute) path, or <code>null</code> if none
87          * exist
88          */
89 //      IPackageFragment findPackageFragment(IPath path) throws JavaModelException;
90
91         /**
92          * Returns the existing package fragment root on this project's classpath
93          * whose path matches the given (absolute) path, or <code>null</code> if
94          * one does not exist.
95          * The path can be:
96          *      - internal to the workbench: "/Compiler/src"
97          *      - external to the workbench: "c:/jdk/classes.zip"
98          * @param path the given absolute path
99          * @exception JavaModelException if this element does not exist or if an
100          *              exception occurs while accessing its corresponding resource
101          * @return the existing package fragment root on this project's classpath
102          * whose path matches the given (absolute) path, or <code>null</code> if
103          * one does not exist
104          */
105 //      IPackageFragmentRoot findPackageFragmentRoot(IPath path)
106 //              throws JavaModelException;
107         /**
108          * Returns the existing package fragment roots identified by the given entry.
109          * Note that a classpath entry that refers to another project may
110          * have more than one root (if that project has more than on root
111          * containing source), and classpath entries within the current
112          * project identify a single root.
113          * <p>
114          * If the classpath entry denotes a variable, it will be resolved and return
115          * the roots of the target entry (empty if not resolvable).
116          * <p>
117          * If the classpath entry denotes a container, it will be resolved and return
118          * the roots corresponding to the set of container entries (empty if not resolvable).
119          * 
120          * @param entry the given entry
121          * @return the existing package fragment roots identified by the given entry
122          * @see IClasspathContainer
123          * @since 2.1
124          */
125 //      IPackageFragmentRoot[] findPackageFragmentRoots(IClasspathEntry entry);
126         /**
127          * Returns the first type found following this project's classpath 
128          * with the given fully qualified name or <code>null</code> if none is found.
129          * The fully qualified name is a dot-separated name. For example,
130          * a class B defined as a member type of a class A in package x.y should have a 
131          * the fully qualified name "x.y.A.B".
132          * 
133          * Note that in order to be found, a type name (or its toplevel enclosing
134          * type name) must match its corresponding compilation unit name. As a 
135          * consequence, secondary types cannot be found using this functionality.
136          * Secondary types can however be explicitely accessed through their enclosing
137          * unit or found by the <code>SearchEngine</code>.
138          * 
139          * @param fullyQualifiedName the given fully qualified name
140          * @exception JavaModelException if this element does not exist or if an
141          *              exception occurs while accessing its corresponding resource
142          * @return the first type found following this project's classpath 
143          * with the given fully qualified name or <code>null</code> if none is found
144          * @see IType#getFullyQualifiedName(char)
145          * @since 2.0
146          */
147 //      IType findType(String fullyQualifiedName) throws JavaModelException;
148         /**
149          * Returns the first type found following this project's classpath 
150          * with the given package name and type qualified name
151          * or <code>null</code> if none is found.
152          * The package name is a dot-separated name.
153          * The type qualified name is also a dot-separated name. For example,
154          * a class B defined as a member type of a class A should have the 
155          * type qualified name "A.B".
156          * 
157          * Note that in order to be found, a type name (or its toplevel enclosing
158          * type name) must match its corresponding compilation unit name. As a 
159          * consequence, secondary types cannot be found using this functionality.
160          * Secondary types can however be explicitely accessed through their enclosing
161          * unit or found by the <code>SearchEngine</code>.
162          * 
163          * @param packageName the given package name
164          * @param typeQualifiedName the given type qualified name
165          * @exception JavaModelException if this element does not exist or if an
166          *              exception occurs while accessing its corresponding resource
167          * @return the first type found following this project's classpath 
168          * with the given package name and type qualified name
169          * or <code>null</code> if none is found
170          * @see IType#getTypeQualifiedName(char)
171
172          * @since 2.0
173          */
174 //      IType findType(String packageName, String typeQualifiedName) throws JavaModelException;
175
176         /**
177          * Returns all of the existing package fragment roots that exist
178          * on the classpath, in the order they are defined by the classpath.
179          *
180          * @return all of the existing package fragment roots that exist
181          * on the classpath
182          * @exception JavaModelException if this element does not exist or if an
183          *              exception occurs while accessing its corresponding resource
184          */
185 //      IPackageFragmentRoot[] getAllPackageFragmentRoots() throws JavaModelException;
186
187         /**
188          * Returns an array of non-Java resources directly contained in this project.
189          * It does not transitively answer non-Java resources contained in folders;
190          * these would have to be explicitly iterated over.
191          * <p>
192          * Non-Java resources includes other files and folders located in the
193          * project not accounted for by any of it source or binary package fragment
194          * roots. If the project is a source folder itself, resources excluded from the
195          * corresponding source classpath entry by one or more exclusion patterns
196          * are considered non-Java resources and will appear in the result
197          * (possibly in a folder)
198          * </p>
199          * 
200          * @return an array of non-Java resources directly contained in this project
201          * @exception JavaModelException if this element does not exist or if an
202          *              exception occurs while accessing its corresponding resource
203          */
204 //      Object[] getNonJavaResources() throws JavaModelException;
205
206         /**
207          * Helper method for returning one option value only. Equivalent to <code>(String)this.getOptions(inheritJavaCoreOptions).get(optionName)</code>
208          * Note that it may answer <code>null</code> if this option does not exist, or if there is no custom value for it.
209          * <p>
210          * For a complete description of the configurable options, see <code>JavaCore#getDefaultOptions</code>.
211          * </p>
212          * 
213          * @param optionName the name of an option
214          * @param inheritJavaCoreOptions - boolean indicating whether JavaCore options should be inherited as well
215          * @return the String value of a given option
216          * @see JavaCore#getDefaultOptions
217          * @since 2.1
218          */
219 //      String getOption(String optionName, boolean inheritJavaCoreOptions);
220         
221         /**
222          * Returns the table of the current custom options for this project. Projects remember their custom options,
223          * in other words, only the options different from the the JavaCore global options for the workspace.
224          * A boolean argument allows to directly merge the project options with global ones from <code>JavaCore</code>.
225          * <p>
226          * For a complete description of the configurable options, see <code>JavaCore#getDefaultOptions</code>.
227          * </p>
228          * 
229          * @param inheritJavaCoreOptions - boolean indicating whether JavaCore options should be inherited as well
230          * @return table of current settings of all options 
231          *   (key type: <code>String</code>; value type: <code>String</code>)
232          * @see JavaCore#getDefaultOptions
233          * @since 2.1
234          */
235 //      Map getOptions(boolean inheritJavaCoreOptions);
236
237         /**
238          * Returns the default output location for this project as a workspace-
239          * relative absolute path.
240          * <p>
241          * The default output location is where class files are ordinarily generated
242          * (and resource files, copied). Each source classpath entry can also
243          * specify an output location for the generated class files (and copied
244          * resource files) corresponding to compilation units under that source
245          * folder. This makes it possible to arrange generated class files for
246          * different source folders in different output folders, and not
247          * necessarily the default output folder. This means that the generated
248          * class files for the project may end up scattered across several folders,
249          * rather than all in the default output folder (which is more standard).
250          * </p>
251          * 
252          * @return the workspace-relative absolute path of the default output folder
253          * @exception JavaModelException if this element does not exist
254          * @see #setOutputLocation
255          * @see IClasspathEntry#getOutputLocation
256          */
257 //      IPath getOutputLocation() throws JavaModelException;
258
259         /**
260          * Returns a package fragment root for the JAR at the specified file system path.
261          * This is a handle-only method.  The underlying <code>java.io.File</code>
262          * may or may not exist. No resource is associated with this local JAR
263          * package fragment root.
264          * 
265          * @param jarPath the jars's file system path
266          * @return a package fragment root for the JAR at the specified file system path
267          */
268 //      IPackageFragmentRoot getPackageFragmentRoot(String jarPath);
269
270         /**
271          * Returns a package fragment root for the given resource, which
272          * must either be a folder representing the top of a package hierarchy,
273          * or a <code>.jar</code> or <code>.zip</code> file.
274          * This is a handle-only method.  The underlying resource may or may not exist. 
275          * 
276          * @param resource the given resource
277          * @return a package fragment root for the given resource, which
278          * must either be a folder representing the top of a package hierarchy,
279          * or a <code>.jar</code> or <code>.zip</code> file
280          */
281 //      IPackageFragmentRoot getPackageFragmentRoot(IResource resource);
282
283         /**
284          * Returns all of the  package fragment roots contained in this
285          * project, identified on this project's resolved classpath. The result
286          * does not include package fragment roots in other projects referenced
287          * on this project's classpath.
288          *
289          * <p>NOTE: This is equivalent to <code>getChildren()</code>.
290          *
291          * @return all of the  package fragment roots contained in this
292          * project, identified on this project's resolved classpath
293          * @exception JavaModelException if this element does not exist or if an
294          *              exception occurs while accessing its corresponding resource
295          */
296 //      IPackageFragmentRoot[] getPackageFragmentRoots() throws JavaModelException;
297
298         /**
299          * Returns the existing package fragment roots identified by the given entry.
300          * Note that a classpath entry that refers to another project may
301          * have more than one root (if that project has more than on root
302          * containing source), and classpath entries within the current
303          * project identify a single root.
304          * <p>
305          * If the classpath entry denotes a variable, it will be resolved and return
306          * the roots of the target entry (empty if not resolvable).
307          * <p>
308          * If the classpath entry denotes a container, it will be resolved and return
309          * the roots corresponding to the set of container entries (empty if not resolvable).
310          * 
311          * @param entry the given entry
312          * @return the existing package fragment roots identified by the given entry
313          * @see IClasspathContainer
314          * @deprecated Use IJavaProject#findPackageFragmentRoots instead
315          */
316 //      IPackageFragmentRoot[] getPackageFragmentRoots(IClasspathEntry entry);
317
318         /**
319          * Returns all package fragments in all package fragment roots contained
320          * in this project. This is a convenience method.
321          *
322          * Note that the package fragment roots corresponds to the resolved
323          * classpath of the project.
324          *
325          * @return all package fragments in all package fragment roots contained
326          * in this project
327          * @exception JavaModelException if this element does not exist or if an
328          *              exception occurs while accessing its corresponding resource
329          */
330 //      IPackageFragment[] getPackageFragments() throws JavaModelException;
331
332         /**
333          * Returns the <code>IProject</code> on which this <code>IJavaProject</code>
334          * was created. This is handle-only method.
335          * 
336          * @return the <code>IProject</code> on which this <code>IJavaProject</code>
337          * was created
338          */
339         IProject getProject();
340
341         /**
342          * Returns the raw classpath for the project, as a list of classpath entries. This corresponds to the exact set
343          * of entries which were assigned using <code>setRawClasspath</code>, in particular such a classpath may contain
344          * classpath variable entries. Classpath variable entries can be resolved individually (see <code>JavaCore#getClasspathVariable</code>),
345          * or the full classpath can be resolved at once using the helper method <code>getResolvedClasspath</code>.
346          * <p>
347          * A classpath variable provides an indirection level for better sharing a classpath. As an example, it allows
348          * a classpath to no longer refer directly to external JARs located in some user specific location. The classpath
349          * can simply refer to some variables defining the proper locations of these external JARs.
350          *  <p>
351          * Note that in case the project isn't yet opened, the classpath will directly be read from the associated <tt>.classpath</tt> file.
352          * <p>
353          * 
354          * @return the raw classpath for the project, as a list of classpath entries
355          * @exception JavaModelException if this element does not exist or if an
356          *              exception occurs while accessing its corresponding resource
357          * @see IClasspathEntry
358          */
359 //      IClasspathEntry[] getRawClasspath() throws JavaModelException;
360
361         /**
362          * Returns the names of the projects that are directly required by this
363          * project. A project is required if it is in its classpath.
364          * <p>
365          * The project names are returned in the order they appear on the classpath.
366          *
367          * @return the names of the projects that are directly required by this
368          * project in classpath order
369          * @exception JavaModelException if this element does not exist or if an
370          *              exception occurs while accessing its corresponding resource
371          */
372 //      String[] getRequiredProjectNames() throws JavaModelException;
373
374         /**
375          * This is a helper method returning the resolved classpath for the project
376          * as a list of simple (non-variable, non-container) classpath entries.
377          * All classpath variable and classpath container entries in the project's
378          * raw classpath will be replaced by the simple classpath entries they
379          * resolve to.
380          * <p>
381          * The resulting resolved classpath is accurate for the given point in time.
382          * If the project's raw classpath is later modified, or if classpath
383          * variables are changed, the resolved classpath can become out of date.
384          * Because of this, hanging on resolved classpath is not recommended.
385          * </p>
386          * 
387          * @param ignoreUnresolvedEntry indicates how to handle unresolvable
388          * variables and containers; <code>true</code> indicates that missing
389          * variables and unresolvable classpath containers should be silently
390          * ignored, and that the resulting list should consist only of the
391          * entries that could be successfully resolved; <code>false</code> indicates
392          * that a <code>JavaModelException</code> should be thrown for the first
393          * unresolved variable or container
394          * @return the resolved classpath for the project as a list of simple 
395          * classpath entries, where all classpath variable and container entries
396          * have been resolved and substituted with their final target entries
397          * @exception JavaModelException in one of the corresponding situation:
398          * <ul>
399          *    <li>this element does not exist</li>
400          *    <li>an exception occurs while accessing its corresponding resource</li>
401          *    <li>a classpath variable or classpath container was not resolvable
402          *    and <code>ignoreUnresolvedEntry</code> is <code>false</code>.</li>
403          * </ul>
404          * @see IClasspathEntry
405          */
406 //      IClasspathEntry[] getResolvedClasspath(boolean ignoreUnresolvedEntry)
407 //           throws JavaModelException;
408
409         /**
410          * Returns whether this project has been built at least once and thus whether it has a build state.
411          * @return true if this project has been built at least once, false otherwise
412          */
413 //      boolean hasBuildState();
414
415         /**
416          * Returns whether setting this project's classpath to the given classpath entries
417          * would result in a cycle.
418          *
419          * If the set of entries contains some variables, those are resolved in order to determine
420          * cycles.
421          * 
422          * @param entries the given classpath entries
423          * @return true if the given classpath entries would result in a cycle, false otherwise
424          */
425 //      boolean hasClasspathCycle(IClasspathEntry[] entries);
426         /**
427          * Returns whether the given element is on the classpath of this project, 
428          * that is, referenced from a classpath entry and not explicitly excluded
429          * using an exclusion pattern. 
430          * 
431          * @param element the given element
432          * @return <code>true</code> if the given element is on the classpath of
433          * this project, <code>false</code> otherwise
434          * @see IClasspathEntry#getExclusionPatterns
435          * @since 2.0
436          */
437 //      boolean isOnClasspath(IJavaElement element);
438         /**
439          * Returns whether the given resource is on the classpath of this project,
440          * that is, referenced from a classpath entry and not explicitly excluded
441          * using an exclusion pattern.
442          * 
443          * @param element the given element
444          * @return <code>true</code> if the given resource is on the classpath of
445          * this project, <code>false</code> otherwise
446          * @see IClasspathEntry#getExclusionPatterns
447          * @since 2.1
448          */
449 //      boolean isOnClasspath(IResource resource);
450
451         /**
452          * Creates a new evaluation context.
453          * @return a new evaluation context.
454          */
455 //      IEvaluationContext newEvaluationContext();
456
457         /**
458          * Creates and returns a type hierarchy for all types in the given
459          * region, considering subtypes within that region.
460          *
461          * @param monitor the given progress monitor
462          * @param region the given region
463          * @exception JavaModelException if this element does not exist or if an
464          *              exception occurs while accessing its corresponding resource
465          * @exception IllegalArgumentException if region is <code>null</code>
466          * @return a type hierarchy for all types in the given
467          * region, considering subtypes within that region
468          */
469 //      ITypeHierarchy newTypeHierarchy(IRegion region, IProgressMonitor monitor)
470 //              throws JavaModelException;
471
472         /**
473          * Creates and returns a type hierarchy for the given type considering
474          * subtypes in the specified region.
475          * 
476          * @param monitor the given monitor
477          * @param region the given region
478          * @param type the given type
479          * 
480          * @exception JavaModelException if this element does not exist or if an
481          *              exception occurs while accessing its corresponding resource
482          *
483          * @exception IllegalArgumentException if type or region is <code>null</code>
484          * @return a type hierarchy for the given type considering
485          * subtypes in the specified region
486          */
487 //      ITypeHierarchy newTypeHierarchy(
488 //              IType type,
489 //              IRegion region,
490 //              IProgressMonitor monitor)
491 //              throws JavaModelException;
492
493         /**
494          * Sets the project custom options. All and only the options explicitly included in the given table 
495          * are remembered; all previous option settings are forgotten, including ones not explicitly
496          * mentioned.
497          * <p>
498          * For a complete description of the configurable options, see <code>JavaCore#getDefaultOptions</code>.
499          * </p>
500          * 
501          * @param newOptions the new options (key type: <code>String</code>; value type: <code>String</code>),
502          *   or <code>null</code> to flush all custom options (clients will automatically get the global JavaCore options).
503          * @see JavaCore#getDefaultOptions
504          * @since 2.1
505          */
506 //      void setOptions(Map newOptions);
507
508         /**
509          * Sets the default output location of this project to the location
510          * described by the given workspace-relative absolute path.
511          * <p>
512          * The default output location is where class files are ordinarily generated
513          * (and resource files, copied). Each source classpath entries can also
514          * specify an output location for the generated class files (and copied
515          * resource files) corresponding to compilation units under that source
516          * folder. This makes it possible to arrange that generated class files for
517          * different source folders to end up in different output folders, and not
518          * necessarily the default output folder. This means that the generated
519          * class files for the project may end up scattered across several folders,
520          * rather than all in the default output folder (which is more standard).
521          * </p>
522          * 
523          * @param path the workspace-relative absolute path of the default output
524          * folder
525          * @param monitor the progress monitor
526          * 
527          * @exception JavaModelException if the classpath could not be set. Reasons include:
528          * <ul>
529          *  <li> This Java element does not exist (ELEMENT_DOES_NOT_EXIST)</li>
530          *  <li> The path refers to a location not contained in this project (<code>PATH_OUTSIDE_PROJECT</code>)
531          *  <li> The path is not an absolute path (<code>RELATIVE_PATH</code>)
532          *  <li> The path is nested inside a package fragment root of this project (<code>INVALID_PATH</code>)
533          *  <li> The output location is being modified during resource change event notification (CORE_EXCEPTION)        
534          * </ul>
535          * @see #getOutputLocation
536      * @see IClasspathEntry#getOutputLocation
537          */
538 //      void setOutputLocation(IPath path, IProgressMonitor monitor)
539 //              throws JavaModelException;
540
541         /**
542          * Sets the classpath of this project using a list of classpath entries. In particular such a classpath may contain
543          * classpath variable entries. Classpath variable entries can be resolved individually (see <code>JavaCore#getClasspathVariable</code>),
544          * or the full classpath can be resolved at once using the helper method <code>getResolvedClasspath</code>.
545          * <p>
546          * A classpath variable provides an indirection level for better sharing a classpath. As an example, it allows
547          * a classpath to no longer refer directly to external JARs located in some user specific location. The classpath
548          * can simply refer to some variables defining the proper locations of these external JARs.
549          * <p>
550          * Setting the classpath to <code>null</code> specifies a default classpath
551          * (the project root). Setting the classpath to an empty array specifies an
552          * empty classpath.
553          * <p>
554          * If a cycle is detected while setting this classpath, an error marker will be added
555          * to the project closing the cycle.
556          * To avoid this problem, use <code>hasClasspathCycle(IClasspathEntry[] entries)</code>
557          * before setting the classpath.
558          *
559          * @param entries a list of classpath entries
560          * @param monitor the given progress monitor
561          * @exception JavaModelException if the classpath could not be set. Reasons include:
562          * <ul>
563          * <li> This Java element does not exist (ELEMENT_DOES_NOT_EXIST)</li>
564          * <li> The classpath is being modified during resource change event notification (CORE_EXCEPTION)
565          * <li> The classpath failed the validation check as defined by <code>JavaConventions#validateClasspath</code>
566          * </ul>
567          * @see IClasspathEntry
568          */
569 //      void setRawClasspath(IClasspathEntry[] entries, IProgressMonitor monitor)
570 //              throws JavaModelException;
571                 
572         /**
573          * Sets the both the classpath of this project and its default output
574          * location at once. The classpath is defined using a list of classpath
575          * entries. In particular, such a classpath may contain classpath variable
576          * entries. Classpath variable entries can be resolved individually (see
577          * <code>JavaCore#getClasspathVariable</code>), or the full classpath can be
578          * resolved at once using the helper method
579          * <code>getResolvedClasspath</code>.
580          * <p>
581          * A classpath variable provides an indirection level for better sharing a
582          * classpath. As an example, it allows a classpath to no longer refer
583          * directly to external JARs located in some user specific location. The
584          * classpath can simply refer to some variables defining the proper
585          * locations of these external JARs.
586          * </p>
587          * <p>
588          * Setting the classpath to <code>null</code> specifies a default classpath
589          * (the project root). Setting the classpath to an empty array specifies an
590          * empty classpath.
591          * </p>
592          * <p>
593          * If a cycle is detected while setting this classpath, an error marker will
594          * be added to the project closing the cycle. To avoid this problem, use
595          * <code>hasClasspathCycle(IClasspathEntry[] entries)</code> before setting
596          * the classpath.
597          * </p>
598          * 
599          * @param entries a list of classpath entries
600          * @param monitor the progress monitor
601          * @param outputLocation the default output location
602          * @exception JavaModelException if the classpath could not be set. Reasons
603          * include:
604          * <ul>
605          * <li> This Java element does not exist (ELEMENT_DOES_NOT_EXIST)</li>
606          * <li> Two or more entries specify source roots with the same or overlapping paths (NAME_COLLISION)
607          * <li> A entry of kind <code>CPE_PROJECT</code> refers to this project (INVALID_PATH)
608          *  <li>This Java element does not exist (ELEMENT_DOES_NOT_EXIST)</li>
609          *      <li>The output location path refers to a location not contained in this project (<code>PATH_OUTSIDE_PROJECT</code>)
610          *      <li>The output location path is not an absolute path (<code>RELATIVE_PATH</code>)
611          *  <li>The output location path is nested inside a package fragment root of this project (<code>INVALID_PATH</code>)
612          * <li> The classpath is being modified during resource change event notification (CORE_EXCEPTION)
613          * </ul>
614          * @see IClasspathEntry
615          * @since 2.0
616          */
617 //      void setRawClasspath(IClasspathEntry[] entries, IPath outputLocation, IProgressMonitor monitor)
618 //              throws JavaModelException;
619 }