e3bfcda1ab0be42ff34f0c3f96d9ed076dca52b3
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpeclipse / builder / IdentifierIndexManager.java
1 package net.sourceforge.phpeclipse.builder;
2
3 import java.io.BufferedInputStream;
4 import java.io.BufferedReader;
5 import java.io.FileNotFoundException;
6 import java.io.FileReader;
7 import java.io.FileWriter;
8 import java.io.IOException;
9 import java.io.InputStream;
10 import java.util.ArrayList;
11 import java.util.Collection;
12 import java.util.Comparator;
13 import java.util.HashMap;
14 import java.util.Iterator;
15 import java.util.List;
16 import java.util.Set;
17 import java.util.SortedMap;
18 import java.util.StringTokenizer;
19 import java.util.TreeMap;
20
21 import net.sourceforge.phpdt.core.compiler.ITerminalSymbols;
22 import net.sourceforge.phpdt.core.compiler.InvalidInputException;
23 import net.sourceforge.phpdt.internal.compiler.parser.Scanner;
24 import net.sourceforge.phpdt.internal.compiler.parser.SyntaxError;
25 import net.sourceforge.phpdt.internal.compiler.util.Util;
26 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
27 import net.sourceforge.phpeclipse.obfuscator.PHPIdentifier;
28
29 import org.eclipse.core.resources.IFile;
30 import org.eclipse.core.runtime.CoreException;
31 import org.eclipse.core.runtime.IStatus;
32
33 /**
34  * Manages the identifer index information for a specific project
35  *  
36  */
37 public class IdentifierIndexManager {
38   public class LineCreator implements ITerminalSymbols {
39     private Scanner fScanner;
40
41     private int fToken;
42
43     public LineCreator() {
44       fScanner = new Scanner(true, false, false, false, true, null, null);
45     }
46
47     /**
48      * Add the information of the current identifier to the line
49      * 
50      * @param typeOfIdentifier
51      *          the type of the identifier ('c'lass, 'd'efine, 'f'unction, 'm'ethod(class), 'v'ariable(class) 'g'lobal variable)
52      * @param identifier
53      *          current identifier
54      * @param line
55      *          Buffer for the current index line
56      * @param phpdocOffset
57      *          the offset of the PHPdoc comment if available
58      * @param phpdocLength
59      *          the length of the PHPdoc comment if available
60      */
61     private void addIdentifierInformation(char typeOfIdentifier, char[] identifier, StringBuffer line, int phpdocOffset,
62         int phpdocLength) {
63       line.append('\t');
64       line.append(typeOfIdentifier);
65       line.append(identifier);
66       line.append("\to"); // Offset
67       line.append(fScanner.getCurrentTokenStartPosition());
68       if (phpdocOffset >= 0) {
69         line.append("\tp"); // phpdoc offset
70         line.append(phpdocOffset);
71         line.append("\tl"); // phpdoc length
72         line.append(phpdocLength);
73       }
74     }
75
76     private void addClassVariableInformation(char typeOfIdentifier, char[] identifier, StringBuffer line, int phpdocOffset,
77         int phpdocLength) {
78       line.append('\t');
79       line.append(typeOfIdentifier);
80       line.append(identifier);
81       line.append("\to"); // Offset
82       // we don't store the '$' in the index for class variables:
83       line.append(fScanner.getCurrentTokenStartPosition() + 1);
84       if (phpdocOffset >= 0) {
85         line.append("\tp"); // phpdoc offset
86         line.append(phpdocOffset);
87         line.append("\tl"); // phpdoc length
88         line.append(phpdocLength);
89       }
90     }
91
92     /**
93      * Get the next token from input
94      */
95     private void getNextToken() {
96       try {
97         fToken = fScanner.getNextToken();
98         if (Scanner.DEBUG) {
99           int currentEndPosition = fScanner.getCurrentTokenEndPosition();
100           int currentStartPosition = fScanner.getCurrentTokenStartPosition();
101           System.out.print(currentStartPosition + "," + currentEndPosition + ": ");
102           System.out.println(fScanner.toStringAction(fToken));
103         }
104         return;
105       } catch (InvalidInputException e) {
106         // ignore errors
107         //        e.printStackTrace();
108       }
109       fToken = TokenNameERROR;
110     }
111
112     private void parseDeclarations(char[] parent, StringBuffer buf, boolean goBack) {
113       char[] ident;
114       char[] classVariable;
115       int counter = 0;
116       boolean hasModifiers = false;
117       int phpdocOffset = -1;
118       int phpdocLength = -1;
119       try {
120         while (fToken != TokenNameEOF && fToken != TokenNameERROR) {
121           phpdocOffset = -1;
122           hasModifiers = false;
123           if (fToken == TokenNameCOMMENT_PHPDOC) {
124             phpdocOffset = fScanner.getCurrentTokenStartPosition();
125             phpdocLength = fScanner.getCurrentTokenEndPosition() - fScanner.getCurrentTokenStartPosition() + 1;
126             getNextToken();
127             while (fToken == TokenNamestatic || fToken == TokenNamefinal || fToken == TokenNamepublic
128                 || fToken == TokenNameprotected || fToken == TokenNameprivate || fToken == TokenNameabstract) {
129               hasModifiers = true;
130               getNextToken();
131             }
132             if (fToken == TokenNameEOF || fToken == TokenNameERROR) {
133               break;
134             }
135           }
136           if (fToken == TokenNamefunction) {
137             getNextToken();
138             if (fToken == TokenNameAND) {
139               getNextToken();
140             }
141             if (fToken == TokenNameIdentifier) {
142               ident = fScanner.getCurrentIdentifierSource();
143               if (parent != null && equalCharArrays(parent, ident)) {
144                 // constructor function
145                 addIdentifierInformation('k', ident, buf, phpdocOffset, phpdocLength);
146               } else {
147                 if (parent != null) {
148                   // class method function
149                   addIdentifierInformation('m', ident, buf, phpdocOffset, phpdocLength);
150                 } else {
151                   // nested function ?!
152                   addIdentifierInformation('f', ident, buf, phpdocOffset, phpdocLength);
153                 }
154               }
155               getNextToken();
156               parseDeclarations(null, buf, true);
157             }
158           } else if (fToken == TokenNameclass || fToken == TokenNameinterface) {
159             getNextToken();
160             if (fToken == TokenNameIdentifier) {
161               ident = fScanner.getCurrentIdentifierSource();
162               addIdentifierInformation('c', ident, buf, phpdocOffset, phpdocLength);
163               getNextToken();
164               //skip tokens for classname, extends and others until we have
165               // the opening '{'
166               while (fToken != TokenNameLBRACE && fToken != TokenNameEOF && fToken != TokenNameERROR) {
167                 getNextToken();
168               }
169               parseDeclarations(ident, buf, true);
170             }
171           } else if (fToken == TokenNamevar || hasModifiers || fToken == TokenNamestatic || fToken == TokenNamefinal
172               || fToken == TokenNamepublic || fToken == TokenNameprotected || fToken == TokenNameprivate) {
173             while (fToken == TokenNamevar || fToken == TokenNamestatic || fToken == TokenNamefinal || fToken == TokenNamepublic
174                 || fToken == TokenNameprotected || fToken == TokenNameprivate) {
175               getNextToken();
176             }
177             while (fToken == TokenNameVariable) {
178               ident = fScanner.getCurrentIdentifierSource();
179               classVariable = new char[ident.length - 1];
180               System.arraycopy(ident, 1, classVariable, 0, ident.length - 1);
181               addClassVariableInformation('v', classVariable, buf, phpdocOffset, phpdocLength);
182               getNextToken();
183               if (fToken == TokenNameCOMMA) {
184                 getNextToken();
185               }
186             }
187           } else if (!hasModifiers && fToken == TokenNameIdentifier) {
188             ident = fScanner.getCurrentIdentifierSource();
189             getNextToken();
190             if (ident.length == 6 && ident[0] == 'd' && ident[1] == 'e' && ident[2] == 'f' && ident[3] == 'i' && ident[4] == 'n'
191                 && ident[5] == 'e') {
192               if (fToken == TokenNameLPAREN) {
193                 getNextToken();
194                 if (fToken == TokenNameStringDoubleQuote) {
195                   ident = fScanner.getCurrentStringLiteralSource();
196                   addIdentifierInformation('d', ident, buf, phpdocOffset, phpdocLength);
197                   getNextToken();
198                 }
199               }
200             }
201           } else if (fToken == TokenNameglobal) {
202             // global variable
203             while (fToken != TokenNameEOF && fToken != TokenNameERROR && fToken != TokenNameSEMICOLON && fToken != TokenNameLBRACE
204                 && fToken != TokenNameRBRACE) {
205               getNextToken();
206               if (fToken == TokenNameVariable) {
207                 ident = fScanner.getCurrentIdentifierSource();
208                 addIdentifierInformation('g', ident, buf, phpdocOffset, phpdocLength);
209               }
210             }
211           } else if (fToken == TokenNameLBRACE) {
212             getNextToken();
213             counter++;
214           } else if (fToken == TokenNameRBRACE) {
215             getNextToken();
216             --counter;
217             if (counter == 0 && goBack) {
218               return;
219             }
220           } else {
221             getNextToken();
222           }
223         }
224       } catch (SyntaxError e) {
225         // TODO Auto-generated catch block
226         e.printStackTrace();
227       }
228     }
229
230     synchronized public void parseIdentifiers(char[] charArray, StringBuffer buf) {
231       char[] ident;
232       String identifier;
233       int counter = 0;
234       boolean hasModifiers = false;
235       int phpdocOffset = -1;
236       int phpdocLength = -1;
237       fScanner.setSource(charArray);
238       fScanner.setPHPMode(false);
239       fToken = TokenNameEOF;
240       getNextToken();
241       try {
242         while (fToken != TokenNameEOF) { // && fToken != TokenNameERROR) {
243           phpdocOffset = -1;
244           hasModifiers = false;
245           if (fToken == TokenNameCOMMENT_PHPDOC) {
246             phpdocOffset = fScanner.getCurrentTokenStartPosition();
247             phpdocLength = fScanner.getCurrentTokenEndPosition() - fScanner.getCurrentTokenStartPosition() + 1;
248             getNextToken();
249             while (fToken == TokenNamestatic || fToken == TokenNamefinal || fToken == TokenNamepublic
250                 || fToken == TokenNameprotected || fToken == TokenNameprivate || fToken == TokenNameabstract) {
251               hasModifiers = true;
252               getNextToken();
253             }
254             if (fToken == TokenNameEOF || fToken == TokenNameERROR) {
255               break;
256             }
257           }
258           if (fToken == TokenNamefunction) {
259             getNextToken();
260             if (fToken == TokenNameAND) {
261               getNextToken();
262             }
263             if (fToken == TokenNameIdentifier) {
264               ident = fScanner.getCurrentIdentifierSource();
265               addIdentifierInformation('f', ident, buf, phpdocOffset, phpdocLength);
266               getNextToken();
267               parseDeclarations(null, buf, true);
268             }
269           } else if (fToken == TokenNameclass || fToken == TokenNameinterface) {
270             getNextToken();
271             if (fToken == TokenNameIdentifier) {
272               ident = fScanner.getCurrentIdentifierSource();
273               addIdentifierInformation('c', ident, buf, phpdocOffset, phpdocLength);
274               getNextToken();
275               //skip fTokens for classname, extends and others until we have
276               // the opening '{'
277               while (fToken != TokenNameLBRACE && fToken != TokenNameEOF && fToken != TokenNameERROR) {
278                 getNextToken();
279               }
280               parseDeclarations(ident, buf, true);
281             }
282           } else if (fToken == TokenNameVariable) {
283             // global variable
284             ident = fScanner.getCurrentIdentifierSource();
285             addIdentifierInformation('g', ident, buf, phpdocOffset, phpdocLength);
286             getNextToken();
287           } else if (!hasModifiers && fToken == TokenNameIdentifier) {
288             ident = fScanner.getCurrentIdentifierSource();
289             getNextToken();
290             if (ident.length == 6 && ident[0] == 'd' && ident[1] == 'e' && ident[2] == 'f' && ident[3] == 'i' && ident[4] == 'n'
291                 && ident[5] == 'e') {
292               if (fToken == TokenNameLPAREN) {
293                 getNextToken();
294                 if (fToken == TokenNameStringDoubleQuote) {
295                   ident = fScanner.getCurrentStringLiteralSource();
296                   addIdentifierInformation('d', ident, buf, phpdocOffset, phpdocLength);
297                   getNextToken();
298                 }
299               }
300             }
301           } else {
302             getNextToken();
303           }
304         }
305       } catch (SyntaxError e) {
306         // TODO Auto-generated catch block
307         e.printStackTrace();
308       }
309     }
310   }
311
312   class StringComparator implements Comparator {
313     public int compare(Object o1, Object o2) {
314       String s1 = (String) o1;
315       String s2 = (String) o2;
316       return s1.compareTo(s2);
317       //        return s1.toUpperCase().compareTo(s2.toUpperCase());
318     }
319
320     public boolean equals(Object o) {
321       String s = (String) o;
322       return compare(this, o) == 0;
323     }
324   }
325
326   private HashMap fFileMap;
327
328   private String fFilename;
329
330   private TreeMap fIndentifierMap;
331
332   public IdentifierIndexManager(String filename) {
333     fFilename = filename;
334     initialize();
335     readFile();
336   }
337
338   /**
339    * Check if 2 char arrays are equal
340    * 
341    * @param a
342    * @param b
343    * @return
344    */
345   private static boolean equalCharArrays(char[] a, char[] b) {
346     if (a.length != b.length) {
347       return false;
348     }
349     for (int i = 0; i < b.length; i++) {
350       if (a[i] != b[i]) {
351         return false;
352       }
353     }
354     return true;
355   }
356
357   public LineCreator createLineCreator() {
358     return new LineCreator();
359   }
360
361   /**
362    * Add the information for a given IFile resource
363    *  
364    */
365   public void addFile(IFile fileToParse) {
366     //    InputStream iStream;
367     LineCreator lineCreator = createLineCreator();
368     try {
369       addInputStream(new BufferedInputStream(fileToParse.getContents()), fileToParse.getProjectRelativePath().toString(),
370           lineCreator);
371     } catch (CoreException e1) {
372       // TODO Auto-generated catch block
373       e1.printStackTrace();
374     }
375   }
376
377   /**
378    * @param fileToParse
379    * @param lineCreator
380    * @throws CoreException
381    */
382   public void addInputStream(InputStream stream, String filePath, LineCreator lineCreator) throws CoreException {
383     try {
384       StringBuffer lineBuffer = new StringBuffer();
385       lineBuffer.append(filePath);
386       int lineLength = lineBuffer.length();
387       lineCreator.parseIdentifiers(Util.getInputStreamAsCharArray(stream, -1, null), lineBuffer);
388       //      if (lineLength != lineBuffer.length()) {
389       // always add the file for Open Include Action
390       addLine(lineBuffer.toString());
391       //      }
392     } catch (IOException e) {
393       e.printStackTrace();
394     } finally {
395       try {
396         if (stream != null) {
397           stream.close();
398         }
399       } catch (IOException e) {
400       }
401     }
402   }
403
404   /**
405    * Adds a line of the index file for function, class, class-method and class-variable names
406    * 
407    * @param line
408    */
409   private void addLine(String line) {
410     StringTokenizer tokenizer;
411     String phpFileName = null;
412     String token;
413     String identifier = null;
414     String classname = null;
415     String offset = null;
416     PHPIdentifierLocation phpIdentifier = null;
417     boolean tokenExists = false;
418     tokenizer = new StringTokenizer(line, "\t");
419     // first token contains the filename:
420     if (tokenizer.hasMoreTokens()) {
421       phpFileName = tokenizer.nextToken();
422       //System.out.println(token);
423     } else {
424       return;
425     }
426     // all the other tokens are identifiers:
427     while (tokenizer.hasMoreTokens()) {
428       token = tokenizer.nextToken();
429       //System.out.println(token);
430       switch (token.charAt(0)) {
431       case 'c':
432         // class name
433         identifier = token.substring(1);
434         classname = identifier;
435         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.CLASS, phpFileName);
436         break;
437       case 'd':
438         // define
439         identifier = token.substring(1);
440         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.DEFINE, phpFileName);
441         break;
442       case 'f':
443         // function name
444         identifier = token.substring(1);
445         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.FUNCTION, phpFileName);
446         break;
447       case 'g':
448         // global variable
449         identifier = token.substring(1);
450         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.GLOBAL_VARIABLE, phpFileName);
451         break;
452       case 'k':
453         // constructor function name
454         identifier = token.substring(1);
455         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.CONSTRUCTOR, phpFileName);
456         break;
457       case 'm':
458         //method inside a class
459         identifier = token.substring(1);
460         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.METHOD, phpFileName, classname);
461         break;
462       case 'v':
463         // variable inside a class
464         identifier = token.substring(1);
465         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.VARIABLE, phpFileName, classname);
466         break;
467       case 'o':
468         // offset information
469         identifier = null;
470         if (phpIdentifier != null) {
471           offset = token.substring(1);
472           phpIdentifier.setOffset(Integer.parseInt(offset));
473         }
474         break;
475       case 'p':
476         // PHPdoc offset information
477         identifier = null;
478         if (phpIdentifier != null) {
479           offset = token.substring(1);
480           phpIdentifier.setPHPDocOffset(Integer.parseInt(offset));
481         }
482         break;
483       case 'l':
484         // PHPdoc length information
485         identifier = null;
486         if (phpIdentifier != null) {
487           offset = token.substring(1);
488           phpIdentifier.setPHPDocLength(Integer.parseInt(offset));
489         }
490         break;
491       default:
492         PHPeclipsePlugin.log(IStatus.ERROR, "Unknown token character in IdentifierIndexManager: " + token.charAt(0));
493         identifier = null;
494         phpIdentifier = null;
495         classname = null;
496       }
497       if (identifier != null && phpIdentifier != null) {
498         tokenExists = true;
499         ArrayList list = (ArrayList) fIndentifierMap.get(identifier);
500         if (list == null) {
501           list = new ArrayList();
502           list.add(phpIdentifier);
503           fIndentifierMap.put(identifier, list);
504         } else {
505           boolean flag = false;
506           for (int i = 0; i < list.size(); i++) {
507             if (list.get(i).equals(phpIdentifier)) {
508               flag = true;
509               break;
510             }
511           }
512           if (flag == false) {
513             list.add(phpIdentifier);
514           }
515         }
516       }
517     }
518     //    if (tokenExists) {
519     fFileMap.put(phpFileName, line);
520     //    }
521   }
522
523   /**
524    * Change the information for a given IFile resource
525    *  
526    */
527   public void changeFile(IFile fileToParse) {
528     removeFile(fileToParse);
529     addFile(fileToParse);
530   }
531
532   /**
533    * Get a list of all PHPIdentifierLocation object's associated with an identifier
534    * 
535    * @param identifier
536    * @return
537    */
538   public List getLocations(String identifier) {
539     return (List) fIndentifierMap.get(identifier);
540   }
541
542   /**
543    * Initialize (i.e. clear) the current index information
544    *  
545    */
546   public void initialize() {
547     fIndentifierMap = new TreeMap(new StringComparator());
548     fFileMap = new HashMap();
549   }
550
551   private void readFile() {
552     FileReader fileReader;
553     try {
554       fileReader = new FileReader(fFilename);
555       BufferedReader bufferedReader = new BufferedReader(fileReader);
556       String line;
557       while (bufferedReader.ready()) {
558         // all entries for one file are in a line
559         // separated by tabs !
560         line = bufferedReader.readLine();
561         addLine(line);
562       }
563       fileReader.close();
564     } catch (FileNotFoundException e) {
565       // ignore this
566       // TODO DialogBox which asks the user if she/he likes to build new index?
567     } catch (IOException e) {
568       // TODO Auto-generated catch block
569       e.printStackTrace();
570     }
571   }
572
573   /**
574    * Remove the information for a given IFile resource
575    *  
576    */
577   public void removeFile(IFile fileToParse) {
578     //    String line = (String)
579     // fFileMap.get(fileToParse.getLocation().toString());
580     String line = (String) fFileMap.get(fileToParse.getProjectRelativePath().toString());
581     if (line != null) {
582       removeLine(line);
583     }
584   }
585
586   /**
587    * Removes a line of the index file for function, class, class-method and class-variable names
588    * 
589    * @param line
590    */
591   private void removeLine(String line) {
592     StringTokenizer tokenizer;
593     String phpFileName = null;
594     String token;
595     String identifier = null;
596     String classname = null;
597     PHPIdentifier phpIdentifier = null;
598     boolean tokenExists = false;
599     tokenizer = new StringTokenizer(line, "\t");
600     // first token contains the filename:
601     if (tokenizer.hasMoreTokens()) {
602       phpFileName = tokenizer.nextToken();
603       //System.out.println(token);
604     } else {
605       return;
606     }
607     int offset = -1;
608     // all the other tokens are identifiers:
609     while (tokenizer.hasMoreTokens()) {
610       token = tokenizer.nextToken();
611       //System.out.println(token);
612       switch (token.charAt(0)) {
613       case 'c':
614         // class name
615         identifier = token.substring(1);
616         classname = identifier;
617         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.CLASS, phpFileName);
618         break;
619       case 'd':
620         // define
621         identifier = token.substring(1);
622         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.DEFINE, phpFileName);
623         break;
624       case 'f':
625         // function name
626         identifier = token.substring(1);
627         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.FUNCTION, phpFileName);
628         break;
629       case 'g':
630         // global variable
631         identifier = token.substring(1);
632         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.GLOBAL_VARIABLE, phpFileName);
633         break;
634       case 'k':
635         // constructor function name
636         identifier = token.substring(1);
637         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.CONSTRUCTOR, phpFileName);
638         break;
639       case 'm':
640         //method inside a class
641         identifier = token.substring(1);
642         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.METHOD, phpFileName, classname);
643         break;
644       case 'o':
645         // offset information
646         identifier = null;
647         break;
648       case 'p':
649         // PHPdoc offset information
650         identifier = null;
651         break;
652       case 'l':
653         // PHPdoc length information
654         identifier = null;
655         break;
656       case 'v':
657         // variable inside a class
658         identifier = token.substring(1);
659         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.VARIABLE, phpFileName, classname);
660         break;
661       default:
662         PHPeclipsePlugin.log(IStatus.ERROR, "Unknown token character in IdentifierIndexManager: " + token.charAt(0));
663         identifier = null;
664         phpIdentifier = null;
665         classname = null;
666       }
667       if (identifier != null && phpIdentifier != null) {
668         ArrayList list = (ArrayList) fIndentifierMap.get(identifier);
669         if (list == null) {
670         } else {
671           for (int i = 0; i < list.size(); i++) {
672             if (list.get(i).equals(phpIdentifier)) {
673               list.remove(i);
674               break;
675             }
676           }
677           if (list.size() == 0) {
678             fIndentifierMap.remove(identifier);
679           }
680         }
681       }
682     }
683     fFileMap.remove(phpFileName);
684   }
685
686   /**
687    * Save the current index information in the projects index file
688    *  
689    */
690   public void writeFile() {
691     FileWriter fileWriter;
692     try {
693       fileWriter = new FileWriter(fFilename);
694       String line;
695       Collection collection = fFileMap.values();
696       Iterator iterator = collection.iterator();
697       while (iterator.hasNext()) {
698         line = (String) iterator.next();
699         fileWriter.write(line + '\n');
700       }
701       fileWriter.close();
702     } catch (FileNotFoundException e) {
703       // ignore exception; project is deleted by user
704     } catch (IOException e) {
705       // TODO Auto-generated catch block
706       e.printStackTrace();
707     }
708   }
709
710   /**
711    * @param fromKey
712    * @param toKey
713    * @return
714    */
715   public SortedMap getIdentifierMap() {
716     return fIndentifierMap;
717   }
718
719   synchronized public List getFileList(String filePattern) {
720     Set set = fFileMap.keySet();
721     if (set.isEmpty()) {
722       return null;
723     }
724     Iterator iter = set.iterator();
725     ArrayList list = new ArrayList();
726     String fileName;
727     int index;
728     while (iter.hasNext()) {
729       fileName = (String) iter.next();
730       if ((index = fileName.indexOf(filePattern)) != -1 && fileName.length() == (index + filePattern.length())) {
731         list.add(fileName);
732       }
733     }
734     return list;
735   }
736 }