df61b62f7c2aad73ad77a6279b9e70f09962a2e4
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / core / ClasspathEntry.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  *******************************************************************************/
11 package net.sourceforge.phpdt.internal.core;
12
13 import net.sourceforge.phpdt.core.IClasspathEntry;
14 import net.sourceforge.phpdt.core.IJavaProject;
15 import net.sourceforge.phpdt.core.IPackageFragmentRoot;
16 import net.sourceforge.phpdt.core.JavaModelException;
17 import net.sourceforge.phpdt.core.JavaCore;
18 import net.sourceforge.phpdt.core.compiler.CharOperation;
19 import net.sourceforge.phpdt.internal.corext.Assert;
20
21 import org.eclipse.core.runtime.IPath;
22 import org.eclipse.core.runtime.Path;
23 import org.w3c.dom.Document;
24 import org.w3c.dom.Element;
25
26 /**
27  * @see IClasspathEntry
28  */
29 public class ClasspathEntry implements IClasspathEntry {
30
31         /**
32          * Describes the kind of classpath entry - one of 
33          * CPE_PROJECT, CPE_LIBRARY, CPE_SOURCE, CPE_VARIABLE or CPE_CONTAINER
34          */
35         public int entryKind;
36
37         /**
38          * Describes the kind of package fragment roots found on
39          * this classpath entry - either K_BINARY or K_SOURCE or
40          * K_OUTPUT.
41          */
42         public int contentKind;
43
44         /**
45          * The meaning of the path of a classpath entry depends on its entry kind:<ul>
46          *      <li>Source code in the current project (<code>CPE_SOURCE</code>) -  
47          *      The path associated with this entry is the absolute path to the root folder. </li>
48          *      <li>A binary library in the current project (<code>CPE_LIBRARY</code>) - the path
49          *              associated with this entry is the absolute path to the JAR (or root folder), and 
50          *              in case it refers to an external JAR, then there is no associated resource in 
51          *              the workbench.
52          *      <li>A required project (<code>CPE_PROJECT</code>) - the path of the entry denotes the
53          *              path to the corresponding project resource.</li>
54          *  <li>A variable entry (<code>CPE_VARIABLE</code>) - the first segment of the path 
55          *      is the name of a classpath variable. If this classpath variable
56          *              is bound to the path <it>P</it>, the path of the corresponding classpath entry
57          *              is computed by appending to <it>P</it> the segments of the returned
58          *              path without the variable.</li>
59          *  <li> A container entry (<code>CPE_CONTAINER</code>) - the first segment of the path is denoting
60          *     the unique container identifier (for which a <code>ClasspathContainerInitializer</code> could be
61          *      registered), and the remaining segments are used as additional hints for resolving the container entry to
62          *      an actual <code>IClasspathContainer</code>.</li>
63          */
64         public IPath path;
65
66         /**
67          * Patterns allowing to exclude portions of the resource tree denoted by this entry path.
68          */
69         
70         public IPath[] exclusionPatterns;
71         private char[][] fullCharExclusionPatterns;
72         private final static char[][] UNINIT_PATTERNS = new char[][] { "Non-initialized yet".toCharArray() }; //$NON-NLS-1$
73
74         private String rootID;
75         
76         /**
77          * Default exclusion pattern set
78          */
79         public final static IPath[] NO_EXCLUSION_PATTERNS = {};
80                                 
81         /**
82          * Describes the path to the source archive associated with this
83          * classpath entry, or <code>null</code> if this classpath entry has no
84          * source attachment.
85          * <p>
86          * Only library and variable classpath entries may have source attachments.
87          * For library classpath entries, the result path (if present) locates a source
88          * archive. For variable classpath entries, the result path (if present) has
89          * an analogous form and meaning as the variable path, namely the first segment 
90          * is the name of a classpath variable.
91          */
92         public IPath sourceAttachmentPath;
93
94         /**
95          * Describes the path within the source archive where package fragments
96          * are located. An empty path indicates that packages are located at
97          * the root of the source archive. Returns a non-<code>null</code> value
98          * if and only if <code>getSourceAttachmentPath</code> returns 
99          * a non-<code>null</code> value.
100          */
101         public IPath sourceAttachmentRootPath;
102
103         /**
104          * Specific output location (for this source entry)
105          */
106         public IPath specificOutputLocation;
107         
108         /**
109          * A constant indicating an output location.
110          */
111         public static final int K_OUTPUT = 10;
112
113         /**
114          * The export flag
115          */
116         public boolean isExported;
117
118         /**
119          * Creates a class path entry of the specified kind with the given path.
120          */
121         public ClasspathEntry(
122                 int contentKind,
123                 int entryKind,
124                 IPath path,
125                 IPath[] exclusionPatterns,
126                 IPath sourceAttachmentPath,
127                 IPath sourceAttachmentRootPath,
128                 IPath specificOutputLocation,
129                 boolean isExported) {
130
131                 this.contentKind = contentKind;
132                 this.entryKind = entryKind;
133                 this.path = path;
134                 this.exclusionPatterns = exclusionPatterns;
135                 if (exclusionPatterns.length > 0) {
136                         this.fullCharExclusionPatterns = UNINIT_PATTERNS;
137                 }
138                 this.sourceAttachmentPath = sourceAttachmentPath;
139                 this.sourceAttachmentRootPath = sourceAttachmentRootPath;
140                 this.specificOutputLocation = specificOutputLocation;
141                 this.isExported = isExported;
142         }
143         
144         /*
145          * Returns a char based representation of the exclusions patterns full path.
146          */
147         public char[][] fullExclusionPatternChars() {
148
149                 if (this.fullCharExclusionPatterns == UNINIT_PATTERNS) {
150                         int length = this.exclusionPatterns.length;
151                         this.fullCharExclusionPatterns = new char[length][];
152                         IPath prefixPath = path.removeTrailingSeparator();
153                         for (int i = 0; i < length; i++) {
154                                 this.fullCharExclusionPatterns[i] = 
155                                         prefixPath.append(this.exclusionPatterns[i]).toString().toCharArray();
156                         }
157                 }
158                 return this.fullCharExclusionPatterns;
159         }
160         
161         /**
162          * Returns the XML encoding of the class path.
163          */
164         public Element elementEncode(
165                 Document document,
166                 IPath projectPath)
167                 throws JavaModelException {
168
169                 Element element = document.createElement("classpathentry"); //$NON-NLS-1$
170                 element.setAttribute("kind", kindToString(this.entryKind));     //$NON-NLS-1$
171                 IPath xmlPath = this.path;
172                 if (this.entryKind != IClasspathEntry.CPE_VARIABLE && this.entryKind != IClasspathEntry.CPE_CONTAINER) {
173                         // translate to project relative from absolute (unless a device path)
174                         if (xmlPath.isAbsolute()) {
175                                 if (projectPath != null && projectPath.isPrefixOf(xmlPath)) {
176                                         if (xmlPath.segment(0).equals(projectPath.segment(0))) {
177                                                 xmlPath = xmlPath.removeFirstSegments(1);
178                                                 xmlPath = xmlPath.makeRelative();
179                                         } else {
180                                                 xmlPath = xmlPath.makeAbsolute();
181                                         }
182                                 }
183                         }
184                 }
185                 element.setAttribute("path", xmlPath.toString()); //$NON-NLS-1$
186                 if (this.sourceAttachmentPath != null) {
187                         element.setAttribute("sourcepath", this.sourceAttachmentPath.toString()); //$NON-NLS-1$
188                 }
189                 if (this.sourceAttachmentRootPath != null) {
190                         element.setAttribute("rootpath", this.sourceAttachmentRootPath.toString()); //$NON-NLS-1$
191                 }
192                 if (this.isExported) {
193                         element.setAttribute("exported", "true"); //$NON-NLS-1$ //$NON-NLS-2$
194                 }
195                 
196                 if (this.exclusionPatterns.length > 0) {
197                         StringBuffer excludeRule = new StringBuffer(10);
198                         for (int i = 0, max = this.exclusionPatterns.length; i < max; i++){
199                                 if (i > 0) excludeRule.append('|');
200                                 excludeRule.append(this.exclusionPatterns[i]);
201                         }
202                         element.setAttribute("excluding", excludeRule.toString());  //$NON-NLS-1$
203                 }
204                 
205                 if (this.specificOutputLocation != null) {
206                         IPath outputLocation = this.specificOutputLocation.removeFirstSegments(1);
207                         outputLocation = outputLocation.makeRelative();
208                         element.setAttribute("output", outputLocation.toString()); //$NON-NLS-1$ 
209                 }
210                 return element;
211         }
212         
213         public static IClasspathEntry elementDecode(Element element, IJavaProject project) {
214         
215                 IPath projectPath = project.getProject().getFullPath();
216                 String kindAttr = element.getAttribute("kind"); //$NON-NLS-1$
217                 String pathAttr = element.getAttribute("path"); //$NON-NLS-1$
218
219                 // ensure path is absolute
220                 IPath path = new Path(pathAttr);                
221                 int kind = kindFromString(kindAttr);
222                 if (kind != IClasspathEntry.CPE_VARIABLE && kind != IClasspathEntry.CPE_CONTAINER && !path.isAbsolute()) {
223                         path = projectPath.append(path);
224                 }
225                 // source attachment info (optional)
226                 IPath sourceAttachmentPath = 
227                         element.hasAttribute("sourcepath")      //$NON-NLS-1$
228                         ? new Path(element.getAttribute("sourcepath")) //$NON-NLS-1$
229                         : null;
230                 IPath sourceAttachmentRootPath = 
231                         element.hasAttribute("rootpath") //$NON-NLS-1$
232                         ? new Path(element.getAttribute("rootpath")) //$NON-NLS-1$
233                         : null;
234                 
235                 // exported flag (optional)
236                 boolean isExported = element.getAttribute("exported").equals("true"); //$NON-NLS-1$ //$NON-NLS-2$
237
238                 // exclusion patterns (optional)
239                 String exclusion = element.getAttribute("excluding"); //$NON-NLS-1$ 
240                 IPath[] exclusionPatterns = ClasspathEntry.NO_EXCLUSION_PATTERNS;
241                 if (!exclusion.equals("")) { //$NON-NLS-1$ 
242                         char[][] patterns = CharOperation.splitOn('|', exclusion.toCharArray());
243                         int patternCount;
244                         if ((patternCount  = patterns.length) > 0) {
245                                 exclusionPatterns = new IPath[patternCount];
246                                 for (int j = 0; j < patterns.length; j++){
247                                         exclusionPatterns[j] = new Path(new String(patterns[j]));
248                                 }
249                         }
250                 }
251
252                 // custom output location
253                 IPath outputLocation = element.hasAttribute("output") ? projectPath.append(element.getAttribute("output")) : null; //$NON-NLS-1$ //$NON-NLS-2$
254                 
255                 // recreate the CP entry
256                 switch (kind) {
257
258                         case IClasspathEntry.CPE_PROJECT :
259                                 return JavaCore.newProjectEntry(path, isExported);
260                                 
261 //                      case IClasspathEntry.CPE_LIBRARY :
262 //                              return JavaCore.newLibraryEntry(
263 //                                                                                              path,
264 //                                                                                              sourceAttachmentPath,
265 //                                                                                              sourceAttachmentRootPath,
266 //                                                                                              isExported);
267                                 
268                         case IClasspathEntry.CPE_SOURCE :
269                                 // must be an entry in this project or specify another project
270                                 String projSegment = path.segment(0);
271                                 if (projSegment != null && projSegment.equals(project.getElementName())) { // this project
272                                         return JavaCore.newSourceEntry(path, exclusionPatterns, outputLocation);
273                                 } else { // another project
274                                         return JavaCore.newProjectEntry(path, isExported);
275                                 }
276
277 //                      case IClasspathEntry.CPE_VARIABLE :
278 //                              return PHPCore.newVariableEntry(
279 //                                              path,
280 //                                              sourceAttachmentPath,
281 //                                              sourceAttachmentRootPath, 
282 //                                              isExported);
283                                 
284                         case IClasspathEntry.CPE_CONTAINER :
285                                 return JavaCore.newContainerEntry(
286                                                 path,
287                                                 isExported);
288
289                         case ClasspathEntry.K_OUTPUT :
290                                 if (!path.isAbsolute()) return null;
291                                 return new ClasspathEntry(
292                                                 ClasspathEntry.K_OUTPUT,
293                                                 IClasspathEntry.CPE_LIBRARY,
294                                                 path,
295                                                 ClasspathEntry.NO_EXCLUSION_PATTERNS, 
296                                                 null, // source attachment
297                                                 null, // source attachment root
298                                                 null, // custom output location
299                                                 false);
300                         default :
301                                 throw new Assert.AssertionFailedException(Util.bind("classpath.unknownKind", kindAttr)); //$NON-NLS-1$
302                 }
303         }
304
305         /**
306          * Returns true if the given object is a classpath entry
307          * with equivalent attributes.
308          */
309         public boolean equals(Object object) {
310                 if (this == object)
311                         return true;
312                 if (object instanceof IClasspathEntry) {
313                         IClasspathEntry otherEntry = (IClasspathEntry) object;
314
315                         if (this.contentKind != otherEntry.getContentKind())
316                                 return false;
317
318                         if (this.entryKind != otherEntry.getEntryKind())
319                                 return false;
320
321                         if (this.isExported != otherEntry.isExported())
322                                 return false;
323
324                         if (!this.path.equals(otherEntry.getPath()))
325                                 return false;
326
327                         IPath otherPath = otherEntry.getSourceAttachmentPath();
328                         if (this.sourceAttachmentPath == null) {
329                                 if (otherPath != null)
330                                         return false;
331                         } else {
332                                 if (!this.sourceAttachmentPath.equals(otherPath))
333                                         return false;
334                         }
335
336                         otherPath = otherEntry.getSourceAttachmentRootPath();
337                         if (this.sourceAttachmentRootPath == null) {
338                                 if (otherPath != null)
339                                         return false;
340                         } else {
341                                 if (!this.sourceAttachmentRootPath.equals(otherPath))
342                                         return false;
343                         }
344
345                         IPath[] otherExcludes = otherEntry.getExclusionPatterns();
346                         if (this.exclusionPatterns != otherExcludes){
347                                 int excludeLength = this.exclusionPatterns.length;
348                                 if (otherExcludes.length != excludeLength) 
349                                         return false;
350                                 for (int i = 0; i < excludeLength; i++) {
351                                         // compare toStrings instead of IPaths 
352                                         // since IPath.equals is specified to ignore trailing separators
353                                         if (!this.exclusionPatterns[i].toString().equals(otherExcludes[i].toString()))
354                                                 return false;
355                                 }
356                         }
357                         
358                         otherPath = otherEntry.getOutputLocation();
359                         if (this.specificOutputLocation == null) {
360                                 if (otherPath != null)
361                                         return false;
362                         } else {
363                                 if (!this.specificOutputLocation.equals(otherPath))
364                                         return false;
365                         }
366                         return true;
367                 } else {
368                         return false;
369                 }
370         }
371
372         /**
373          * @see IClasspathEntry
374          */
375         public int getContentKind() {
376                 return this.contentKind;
377         }
378
379         /**
380          * @see IClasspathEntry
381          */
382         public int getEntryKind() {
383                 return this.entryKind;
384         }
385
386         /**
387          * @see IClasspathEntry#getExclusionPatterns()
388          */
389         public IPath[] getExclusionPatterns() {
390                 return this.exclusionPatterns;
391         }
392
393         /**
394          * @see IClasspathEntry#getOutputLocation()
395          */
396         public IPath getOutputLocation() {
397                 return this.specificOutputLocation;
398         }
399
400         /**
401          * @see IClasspathEntry
402          */
403         public IPath getPath() {
404                 return this.path;
405         }
406
407         /**
408          * @see IClasspathEntry
409          */
410         public IPath getSourceAttachmentPath() {
411                 return this.sourceAttachmentPath;
412         }
413
414         /**
415          * @see IClasspathEntry
416          */
417         public IPath getSourceAttachmentRootPath() {
418                 return this.sourceAttachmentRootPath;
419         }
420
421         /**
422          * Returns the hash code for this classpath entry
423          */
424         public int hashCode() {
425                 return this.path.hashCode();
426         }
427
428         /**
429          * @see IClasspathEntry#isExported()
430          */
431         public boolean isExported() {
432                 return this.isExported;
433         }
434
435         /**
436          * Returns the kind of a <code>PackageFragmentRoot</code> from its <code>String</code> form.
437          */
438         static int kindFromString(String kindStr) {
439
440                 if (kindStr.equalsIgnoreCase("prj")) //$NON-NLS-1$
441                         return IClasspathEntry.CPE_PROJECT;
442                 if (kindStr.equalsIgnoreCase("var")) //$NON-NLS-1$
443                         return IClasspathEntry.CPE_VARIABLE;
444                 if (kindStr.equalsIgnoreCase("con")) //$NON-NLS-1$
445                         return IClasspathEntry.CPE_CONTAINER;
446                 if (kindStr.equalsIgnoreCase("src")) //$NON-NLS-1$
447                         return IClasspathEntry.CPE_SOURCE;
448                 if (kindStr.equalsIgnoreCase("lib")) //$NON-NLS-1$
449                         return IClasspathEntry.CPE_LIBRARY;
450                 if (kindStr.equalsIgnoreCase("output")) //$NON-NLS-1$
451                         return ClasspathEntry.K_OUTPUT;
452                 return -1;
453         }
454
455         /**
456          * Returns a <code>String</code> for the kind of a class path entry.
457          */
458         static String kindToString(int kind) {
459
460                 switch (kind) {
461                         case IClasspathEntry.CPE_PROJECT :
462                                 return "src"; // backward compatibility //$NON-NLS-1$
463                         case IClasspathEntry.CPE_SOURCE :
464                                 return "src"; //$NON-NLS-1$
465                         case IClasspathEntry.CPE_LIBRARY :
466                                 return "lib"; //$NON-NLS-1$
467                         case IClasspathEntry.CPE_VARIABLE :
468                                 return "var"; //$NON-NLS-1$
469                         case IClasspathEntry.CPE_CONTAINER :
470                                 return "con"; //$NON-NLS-1$
471                         case ClasspathEntry.K_OUTPUT :
472                                 return "output"; //$NON-NLS-1$
473                         default :
474                                 return "unknown"; //$NON-NLS-1$
475                 }
476         }
477
478         /**
479          * Returns a printable representation of this classpath entry.
480          */
481         public String toString() {
482                 StringBuffer buffer = new StringBuffer();
483                 buffer.append(getPath().toString());
484                 buffer.append('[');
485                 switch (getEntryKind()) {
486                         case IClasspathEntry.CPE_LIBRARY :
487                                 buffer.append("CPE_LIBRARY"); //$NON-NLS-1$
488                                 break;
489                         case IClasspathEntry.CPE_PROJECT :
490                                 buffer.append("CPE_PROJECT"); //$NON-NLS-1$
491                                 break;
492                         case IClasspathEntry.CPE_SOURCE :
493                                 buffer.append("CPE_SOURCE"); //$NON-NLS-1$
494                                 break;
495                         case IClasspathEntry.CPE_VARIABLE :
496                                 buffer.append("CPE_VARIABLE"); //$NON-NLS-1$
497                                 break;
498                         case IClasspathEntry.CPE_CONTAINER :
499                                 buffer.append("CPE_CONTAINER"); //$NON-NLS-1$
500                                 break;
501                 }
502                 buffer.append("]["); //$NON-NLS-1$
503                 switch (getContentKind()) {
504                         case IPackageFragmentRoot.K_BINARY :
505                                 buffer.append("K_BINARY"); //$NON-NLS-1$
506                                 break;
507                         case IPackageFragmentRoot.K_SOURCE :
508                                 buffer.append("K_SOURCE"); //$NON-NLS-1$
509                                 break;
510                         case ClasspathEntry.K_OUTPUT :
511                                 buffer.append("K_OUTPUT"); //$NON-NLS-1$
512                                 break;
513                 }
514                 buffer.append(']');
515                 if (getSourceAttachmentPath() != null) {
516                         buffer.append("[sourcePath:"); //$NON-NLS-1$
517                         buffer.append(getSourceAttachmentPath());
518                         buffer.append(']');
519                 }
520                 if (getSourceAttachmentRootPath() != null) {
521                         buffer.append("[rootPath:"); //$NON-NLS-1$
522                         buffer.append(getSourceAttachmentRootPath());
523                         buffer.append(']');
524                 }
525                 buffer.append("[isExported:"); //$NON-NLS-1$
526                 buffer.append(this.isExported);
527                 buffer.append(']');
528                 IPath[] patterns = getExclusionPatterns();
529                 int length;
530                 if ((length = patterns.length) > 0) {
531                         buffer.append("[excluding:"); //$NON-NLS-1$
532                         for (int i = 0; i < length; i++) {
533                                 buffer.append(patterns[i]);
534                                 if (i != length-1) {
535                                         buffer.append('|');
536                                 }
537                         }
538                         buffer.append(']');
539                 }
540                 if (getOutputLocation() != null) {
541                         buffer.append("[output:"); //$NON-NLS-1$
542                         buffer.append(getOutputLocation());
543                         buffer.append(']');
544                 }
545                 return buffer.toString();
546         }
547         
548         /**
549          * Answers an ID which is used to distinguish entries during package
550          * fragment root computations
551          */
552         public String rootID(){
553
554                 if (this.rootID == null) {
555                         switch(this.entryKind){
556                                 case IClasspathEntry.CPE_LIBRARY :
557                                         this.rootID = "[LIB]"+this.path;  //$NON-NLS-1$
558                                         break;
559                                 case IClasspathEntry.CPE_PROJECT :
560                                         this.rootID = "[PRJ]"+this.path;  //$NON-NLS-1$
561                                         break;
562                                 case IClasspathEntry.CPE_SOURCE :
563                                         this.rootID = "[SRC]"+this.path;  //$NON-NLS-1$
564                                         break;
565                                 case IClasspathEntry.CPE_VARIABLE :
566                                         this.rootID = "[VAR]"+this.path;  //$NON-NLS-1$
567                                         break;
568                                 case IClasspathEntry.CPE_CONTAINER :
569                                         this.rootID = "[CON]"+this.path;  //$NON-NLS-1$
570                                         break;
571                                 default :
572                                         this.rootID = "";  //$NON-NLS-1$
573                                         break;
574                         }
575                 }
576                 return this.rootID;
577         }
578         
579         /**
580          * @see IClasspathEntry
581          * @deprecated
582          */
583         public IClasspathEntry getResolvedEntry() {
584         
585                 return JavaCore.getResolvedClasspathEntry(this);
586         }
587 }