Fixed: 1774625 - duplicate one function block down into a folded php-doc
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / ui / text / BufferedDocumentScanner.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2004 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.ui.text;
12
13 import org.eclipse.jface.text.Assert;
14 import org.eclipse.jface.text.BadLocationException;
15 import org.eclipse.jface.text.IDocument;
16 import org.eclipse.jface.text.rules.ICharacterScanner;
17
18 /**
19  * A buffered document scanner. The buffer always contains a section of a fixed
20  * size of the document to be scanned.
21  */
22
23 public final class BufferedDocumentScanner implements ICharacterScanner {
24
25         /** The document being scanned. */
26         private IDocument fDocument;
27
28         /** The offset of the document range to scan. */
29         private int fRangeOffset;
30
31         /** The length of the document range to scan. */
32         private int fRangeLength;
33
34         /** The delimiters of the document. */
35         private char[][] fDelimiters;
36
37         /** The buffer. */
38         private final char[] fBuffer;
39
40         /** The offset of the buffer within the document. */
41         private int fBufferOffset;
42
43         /** The valid length of the buffer for access. */
44         private int fBufferLength;
45
46         /** The offset of the scanner within the buffer. */
47         private int fOffset;
48
49         /**
50          * Creates a new buffered document scanner. The buffer size is set to the
51          * given number of characters.
52          * 
53          * @param size
54          *            the buffer size
55          */
56         public BufferedDocumentScanner(int size) {
57                 Assert.isTrue(size >= 1);
58                 fBuffer = new char[size];
59         }
60
61         /**
62          * Fills the buffer with the contens of the document starting at the given
63          * offset.
64          * 
65          * @param offset
66          *            the document offset at which the buffer starts
67          */
68         private final void updateBuffer(int offset) {
69
70                 fBufferOffset = offset;
71
72                 if (fBufferOffset + fBuffer.length > fRangeOffset + fRangeLength)
73                         fBufferLength = fRangeLength - (fBufferOffset - fRangeOffset);
74                 else
75                         fBufferLength = fBuffer.length;
76
77                 try {
78                         final String content = fDocument.get(fBufferOffset, fBufferLength);
79                         if (content != null) {
80                                 content.getChars(0, fBufferLength, fBuffer, 0);
81                         }
82                 } catch (BadLocationException e) {
83                 }
84         }
85
86         /**
87          * Configures the scanner by providing access to the document range over
88          * which to scan.
89          * 
90          * @param document
91          *            the document to scan
92          * @param offset
93          *            the offset of the document range to scan
94          * @param length
95          *            the length of the document range to scan
96          */
97         public final void setRange(IDocument document, int offset, int length) {
98
99                 fDocument = document;
100                 fRangeOffset = offset;
101                 fRangeLength = length;
102
103                 String[] delimiters = document.getLegalLineDelimiters();
104                 fDelimiters = new char[delimiters.length][];
105                 for (int i = 0; i < delimiters.length; i++)
106                         fDelimiters[i] = delimiters[i].toCharArray();
107
108                 updateBuffer(offset);
109                 fOffset = 0;
110         }
111
112         /*
113          * @see ICharacterScanner#read()
114          */
115         public final int read() {
116
117                 if (fOffset == fBufferLength) {
118                         if (fBufferOffset + fBufferLength == fDocument.getLength())
119                                 return EOF;
120                         else {
121                                 updateBuffer(fBufferOffset + fBufferLength);
122                                 fOffset = 0;
123                         }
124                 }
125                 try {
126                         return fBuffer[fOffset++];
127                 } catch (ArrayIndexOutOfBoundsException e) {
128                         System.out.println("Offset:" + fOffset);
129                         System.out.println("Buffer:" + fBuffer.toString());
130                         throw e;
131                 }
132         }
133
134         /*
135          * @see ICharacterScanner#unread
136          */
137         public final void unread() {
138
139                 if (fOffset == 0) {
140                         if (fBufferOffset == fRangeOffset) {
141                                 // error: BOF
142                         } else {
143                                 updateBuffer(fBufferOffset - fBuffer.length);
144                                 fOffset = fBuffer.length - 1;
145                         }
146                 } else {
147                         --fOffset;
148                 }
149         }
150
151         /*
152          * @see ICharacterScanner#getColumn()
153          */
154         public final int getColumn() {
155
156                 try {
157                         final int offset = fBufferOffset + fOffset;
158                         final int line = fDocument.getLineOfOffset(offset);
159                         final int start = fDocument.getLineOffset(line);
160                         return offset - start;
161                 } catch (BadLocationException e) {
162                 }
163
164                 return -1;
165         }
166
167         /*
168          * @see ICharacterScanner#getLegalLineDelimiters()
169          */
170         public final char[][] getLegalLineDelimiters() {
171                 return fDelimiters;
172         }
173 }