misc
[phpeclipse.git] / net.sourceforge.phpeclipse.ui / src / net / sourceforge / phpeclipse / ui / text / rules / AbstractPartitioner.java
1 /*
2  * Copyright (c) 2002-2004 Widespace, OU 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://solareclipse.sourceforge.net/legal/cpl-v10.html
7  * 
8  * Contributors:
9  *     Igor Malinin - initial contribution
10  * 
11  * $Id: AbstractPartitioner.java,v 1.2 2004-11-13 12:36:32 axelcl Exp $
12  */
13
14 package net.sourceforge.phpeclipse.ui.text.rules;
15
16 import java.util.ArrayList;
17 import java.util.List;
18
19 import org.eclipse.jface.text.Assert;
20 import org.eclipse.jface.text.DocumentEvent;
21 import org.eclipse.jface.text.IDocument;
22 import org.eclipse.jface.text.IDocumentPartitioner;
23 import org.eclipse.jface.text.IDocumentPartitionerExtension;
24 import org.eclipse.jface.text.IRegion;
25 import org.eclipse.jface.text.ITypedRegion;
26 import org.eclipse.jface.text.Region;
27 import org.eclipse.jface.text.TypedRegion;
28 import org.eclipse.jface.text.rules.IPartitionTokenScanner;
29 import org.eclipse.jface.text.rules.IToken;
30
31 /**
32  * Advanced partitioner which maintains partitions as views to connected document. Views have own partitioners themselves. This
33  * class is designed as a base for complex partitioners such as for JSP, PHP, ASP, etc. languages.
34  * 
35  * @author Igor Malinin
36  */
37 public abstract class AbstractPartitioner implements IDocumentPartitioner, IDocumentPartitionerExtension {
38   public final static boolean DEBUG = false;
39
40   /** Partition scanner */
41   protected IPartitionTokenScanner scanner;
42
43   /** Connected document */
44   protected IDocument document;
45
46   /** Flat structure of the document */
47   protected List nodes = new ArrayList();
48
49   /** The offset at which the first changed partition starts */
50   protected int regionStart;
51
52   /** The offset at which the last changed partition ends */
53   protected int regionEnd;
54
55   public AbstractPartitioner(IPartitionTokenScanner scanner) {
56     this.scanner = scanner;
57   }
58
59   protected FlatNode createNode(String type, int offset, int length) {
60     if (DEBUG) {
61       Assert.isTrue(offset >= 0, Integer.toString(offset));
62     }
63     FlatNode node = new FlatNode(type);
64     node.offset = offset;
65     node.length = length;
66     return node;
67   }
68
69   protected void addInnerRegion(FlatNode position) {
70     nodes.add(computeFlatNodeIndex(position.offset), position);
71   }
72
73   protected void removeInnerRegion(FlatNode position) {
74     nodes.remove(position); // TODO: Indexed remove?
75   }
76
77   protected void deleteInnerRegion(FlatNode position) {
78     nodes.remove(position); // TODO: Indexed remove?
79   }
80
81   protected void resizeInnerRegion(FlatNode position) {
82   }
83
84   /*
85    * @see org.eclipse.jface.text.IDocumentPartitioner#connect(IDocument)
86    */
87   public void connect(IDocument document) {
88     this.document = document;
89
90     initialize();
91   }
92
93   /*
94    * @see org.eclipse.jface.text.IDocumentPartitioner#disconnect()
95    */
96   public void disconnect() {
97     nodes.clear();
98     document = null;
99   }
100
101   /**
102    * Performs the initial partitioning of the partitioner's document.
103    */
104   protected void initialize() {
105     scanner.setRange(document, 0, document.getLength());
106     nodes.clear();
107     IToken token = scanner.nextToken();
108     while (!token.isEOF()) {
109       String contentType = getTokenContentType(token);
110
111       if (isSupportedContentType(contentType)) {
112         addInnerRegion(createNode(contentType, scanner.getTokenOffset(), scanner.getTokenLength()));
113       }
114
115       token = scanner.nextToken();
116     }
117   }
118
119   /*
120    * @see org.eclipse.jface.text.IDocumentPartitioner#documentAboutToBeChanged(DocumentEvent)
121    */
122   public void documentAboutToBeChanged(DocumentEvent event) {
123     regionStart = regionEnd = -1;
124   }
125
126   /*
127    * @see org.eclipse.jface.text.IDocumentPartitioner#documentChanged(DocumentEvent)
128    */
129   public boolean documentChanged(DocumentEvent event) {
130     return (documentChanged2(event) != null);
131   }
132
133   /*
134    * @see org.eclipse.jface.text.IDocumentPartitionerExtension#documentChanged2(DocumentEvent)
135    */
136   public IRegion documentChanged2(DocumentEvent event) {
137     int first = fixupPartitions(event);
138
139     FlatNode[] category = (FlatNode[]) nodes.toArray(new FlatNode[nodes.size()]);
140
141     // repartition changed region
142
143     String contentType = IDocument.DEFAULT_CONTENT_TYPE;
144
145     int offset;
146
147     if (first == 0) {
148       offset = 0; // Bug #697414: first offset
149     } else {
150       offset = event.getOffset();
151
152       FlatNode partition = category[first - 1];
153       if (partition.includes(offset)) {
154         offset = partition.offset;
155         contentType = partition.type;
156         --first;
157       } else if (offset == partition.offset + partition.length) {
158         offset = partition.offset;
159         contentType = partition.type;
160         --first;
161       } else {
162         offset = partition.offset + partition.length;
163       }
164     }
165
166     // should not be changed since last conversion
167     // category = (FlatNode[]) nodes.toArray(new FlatNode[nodes.size()]);
168     if (DEBUG) {
169       Assert.isTrue(offset >= 0, Integer.toString(offset));
170     }
171     scanner.setPartialRange(document, offset, document.getLength(), contentType, offset);
172
173     int lastScannedPosition = offset;
174     IToken token = scanner.nextToken();
175     while (!token.isEOF()) {
176       contentType = getTokenContentType(token);
177
178       if (!isSupportedContentType(contentType)) {
179         token = scanner.nextToken();
180         continue;
181       }
182
183       offset = scanner.getTokenOffset();
184       if (DEBUG) {
185         Assert.isTrue(offset >= 0, scanner.toString());
186       }
187       int length = scanner.getTokenLength();
188
189       lastScannedPosition = offset + length;
190
191       // remove all affected positions
192       while (first < category.length) {
193         FlatNode p = category[first];
194         if (p.offset + p.length < lastScannedPosition
195             || (p.overlapsWith(offset, length) && (!containsPosition(offset, length) || !contentType.equals(p.type)))) {
196           removeInnerRegion(p);
197           rememberRegion(p.offset, p.length);
198           ++first;
199         } else {
200           break;
201         }
202       }
203
204       // if position already exists we are done
205       if (containsPosition(offset, length)) {
206         if (lastScannedPosition > event.getOffset()) {
207           // TODO: optional repartition till end of doc
208           return createRegion();
209         }
210
211         ++first;
212       } else {
213         // insert the new type position
214         addInnerRegion(createNode(contentType, offset, length));
215         rememberRegion(offset, length);
216       }
217       //            try {
218       token = scanner.nextToken();
219       //            } catch (ArrayIndexOutOfBoundsException e) {
220       //              System.out.println(this.getClass().toString());
221       //              throw e;
222       //            }
223     }
224
225     // remove all positions behind lastScannedPosition
226     // since there aren't any further types
227
228     // Do not need to recalculate (lost remove events)!
229     // first = computeIndexInInnerDocuments(lastScannedPosition);
230     while (first < category.length) {
231       FlatNode p = category[first++];
232       removeInnerRegion(p);
233       rememberRegion(p.offset, p.length);
234     }
235
236     return createRegion();
237   }
238
239   protected int fixupPartitions(DocumentEvent event) {
240     int offset = event.getOffset();
241     int length = event.getLength();
242     int end = offset + length;
243
244     // fixup flat nodes laying on change boundaries
245
246     int first = computeFlatNodeIndex(offset);
247     if (first > 0) {
248       FlatNode p = (FlatNode) nodes.get(first - 1);
249
250       int right = p.offset + p.length;
251       if (offset < right) {
252         // change overlaps with partition
253         if (end < right) {
254           // cahnge completely inside partition
255           String text = event.getText();
256           p.length -= length;
257           if (text != null) {
258             p.length += text.length();
259           }
260         } else {
261           // cut partition at right
262           int cut = p.offset + p.length - offset;
263           p.length -= cut;
264         }
265       }
266     }
267
268     int last = computeFlatNodeIndex(end);
269     if (first < last) {
270       FlatNode p = (FlatNode) nodes.get(last - 1);
271
272       int right = p.offset + p.length;
273       if (end < right) {
274         // cut partition at left
275         int cut = end - p.offset;
276         p.length -= cut;
277         p.offset = offset;
278
279         String text = event.getText();
280         if (text != null) {
281           p.offset += text.length();
282         }
283
284         --last;
285       }
286     }
287
288     // fixup flat nodes laying afrer change
289
290     String text = event.getText();
291     if (text != null) {
292       length -= text.length();
293     }
294
295     for (int i = last, size = nodes.size(); i < size; i++) {
296       ((FlatNode) nodes.get(i)).offset -= length;
297     }
298
299     // delete flat nodes laying completely inside change boundaries
300
301     if (first < last) {
302       do {
303         deleteInnerRegion((FlatNode) nodes.get(--last));
304       } while (first < last);
305
306       rememberRegion(offset, 0);
307     }
308
309     return first;
310   }
311
312   /**
313    * Returns whether the given type is one of the legal content types.
314    * 
315    * @param contentType
316    *          the content type to check
317    * @return <code>true</code> if the content type is a legal content type
318    */
319   protected boolean isSupportedContentType(String contentType) {
320     /* TODO: implementation */
321     //          if (contentType != null) {
322     //                  for (int i= 0; i < fLegalContentTypes.length; i++) {
323     //                          if (fLegalContentTypes[i].equals(contentType)) {
324     //                                  return true;
325     //                          }
326     //                  }
327     //          }
328     //          return false;
329     return (contentType != null);
330   }
331
332   /**
333    * Returns a content type encoded in the given token. If the token's data is not <code>null</code> and a string it is assumed
334    * that it is the encoded content type.
335    * 
336    * @param token
337    *          the token whose content type is to be determined
338    * @return the token's content type
339    */
340   protected String getTokenContentType(IToken token) {
341     Object data = token.getData();
342     if (data instanceof String) {
343       return (String) data;
344     }
345
346     return null;
347   }
348
349   /*
350    * @see org.eclipse.jface.text.IDocumentPartitioner#getLegalContentTypes()
351    */
352   public String[] getLegalContentTypes() {
353     // TODO: implementation
354     return null;
355   }
356
357   /*
358    * @see org.eclipse.jface.text.IDocumentPartitioner#getContentType(int)
359    */
360   public String getContentType(int offset) {
361     return getPartition(offset).getType();
362   }
363
364   /*
365    * @see org.eclipse.jface.text.IDocumentPartitioner#getPartition(int)
366    */
367   public ITypedRegion getPartition(int offset) {
368     if (nodes.size() == 0) {
369       return new TypedRegion(0, document.getLength(), IDocument.DEFAULT_CONTENT_TYPE);
370     }
371
372     int index = computeFlatNodeIndex(offset);
373     if (index < nodes.size()) {
374       FlatNode next = (FlatNode) nodes.get(index);
375
376       if (offset == next.offset) {
377         return new TypedRegion(next.offset, next.length, next.type);
378       }
379
380       if (index == 0) {
381         return new TypedRegion(0, next.offset, IDocument.DEFAULT_CONTENT_TYPE);
382       }
383
384       FlatNode prev = (FlatNode) nodes.get(index - 1);
385
386       if (prev.includes(offset)) {
387         return new TypedRegion(prev.offset, prev.length, prev.type);
388       }
389
390       int end = prev.offset + prev.length;
391       return new TypedRegion(end, next.offset - end, IDocument.DEFAULT_CONTENT_TYPE);
392     }
393
394     FlatNode prev = (FlatNode) nodes.get(nodes.size() - 1);
395
396     if (prev.includes(offset)) {
397       return new TypedRegion(prev.offset, prev.length, prev.type);
398     }
399
400     int end = prev.offset + prev.length;
401
402     return new TypedRegion(end, document.getLength() - end, IDocument.DEFAULT_CONTENT_TYPE);
403   }
404
405   /*
406    * @see org.eclipse.jface.text.IDocumentPartitioner#computePartitioning(int, int)
407    */
408   public ITypedRegion[] computePartitioning(int offset, int length) {
409     List list = new ArrayList();
410
411     int end = offset + length;
412
413     int index = computeFlatNodeIndex(offset);
414     while (true) {
415       FlatNode prev = (index > 0) ? (FlatNode) nodes.get(index - 1) : null;
416
417       if (prev != null) {
418         if (prev.overlapsWith(offset, length)) {
419           list.add(new TypedRegion(prev.offset, prev.length, prev.type));
420         }
421
422         if (end <= prev.offset + prev.length) {
423           break;
424         }
425       }
426
427       FlatNode next = (index < nodes.size()) ? (FlatNode) nodes.get(index) : null;
428
429       if (next == null || offset < next.offset) {
430         int off0 = offset;
431         int off1 = offset + length;
432
433         if (prev != null && off0 < prev.offset + prev.length) {
434           off0 = prev.offset + prev.length;
435         }
436
437         if (next != null && next.offset < off1) {
438           off1 = next.offset;
439         }
440
441         if (off0 < off1) {
442           list.add(new TypedRegion(off0, off1 - off0, IDocument.DEFAULT_CONTENT_TYPE));
443         }
444       }
445
446       if (next == null) {
447         break;
448       }
449
450       ++index;
451     }
452
453     return (TypedRegion[]) list.toArray(new TypedRegion[list.size()]);
454   }
455
456   /**
457    * Computes the index in the list of flat nodes at which an flat node with the given offset would be inserted. The flat node is
458    * supposed to become the first in this list of all flat nodes with the same offset.
459    * 
460    * @param offset
461    *          the offset for which the index is computed
462    * @return the computed index
463    */
464   protected int computeFlatNodeIndex(int offset) {
465     if (nodes.size() == 0) {
466       return 0;
467     }
468
469     int left = 0, mid = 0;
470     int right = nodes.size() - 1;
471
472     FlatNode p = null;
473
474     while (left < right) {
475       mid = (left + right) / 2;
476
477       p = (FlatNode) nodes.get(mid);
478
479       if (offset < p.offset) {
480         right = (left == mid) ? left : mid - 1;
481       } else if (offset > p.offset) {
482         left = (right == mid) ? right : mid + 1;
483       } else if (offset == p.offset) {
484         left = right = mid;
485       }
486     }
487
488     int pos = left;
489     p = (FlatNode) nodes.get(pos);
490     if (offset > p.offset) {
491       // append to the end
492       pos++;
493     } else {
494       // entry will became the first of all entries with the same offset
495       do {
496         --pos;
497         if (pos < 0) {
498           break;
499         }
500         p = (FlatNode) nodes.get(pos);
501       } while (offset == p.offset);
502       ++pos;
503     }
504
505     return pos;
506   }
507
508   public boolean containsPosition(int offset, int length) {
509     int size = nodes.size();
510     if (size == 0) {
511       return false;
512     }
513
514     int index = computeFlatNodeIndex(offset);
515     if (index < size) {
516       FlatNode p = (FlatNode) nodes.get(index);
517
518       while (p.offset == offset) {
519         if (p.length == length) {
520           return true;
521         }
522
523         if (++index < size) {
524           p = (FlatNode) nodes.get(index);
525         } else {
526           break;
527         }
528       }
529     }
530
531     return false;
532   }
533
534   /**
535    * Helper method for tracking the minimal region containg all partition changes. If <code>offset</code> is smaller than the
536    * remembered offset, <code>offset</code> will from now on be remembered. If <code>offset + length</code> is greater than the
537    * remembered end offset, it will be remembered from now on.
538    * 
539    * @param offset
540    *          the offset
541    * @param length
542    *          the length
543    */
544   protected final void rememberRegion(int offset, int length) {
545     // remember start offset
546     if (regionStart == -1) {
547       regionStart = offset;
548     } else if (offset < regionStart) {
549       regionStart = offset;
550     }
551
552     // remember end offset
553     int endOffset = offset + length;
554
555     if (regionEnd == -1) {
556       regionEnd = endOffset;
557     } else if (endOffset > regionEnd) {
558       regionEnd = endOffset;
559     }
560   }
561
562   /**
563    * Creates the minimal region containing all partition changes using the remembered offsets.
564    * 
565    * @return the minimal region containing all the partition changes
566    */
567   protected final IRegion createRegion() {
568     if (regionStart == -1 || regionEnd == -1) {
569       return null;
570     }
571
572     return new Region(regionStart, regionEnd - regionStart);
573   }
574 }