1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
|
/*******************************************************************************
* Copyright (c) 2000, 2006 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.cdt.internal.ui.text;
import java.text.CharacterIterator;
import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
/**
* An <code>IDocument</code> based implementation of
* <code>CharacterIterator</code> and <code>CharSequence</code>. Note that
* the supplied document is not copied; if the document is modified during the
* lifetime of a <code>DocumentCharacterIterator</code>, the methods
* returning document content may not always return the same values. Also, if
* accessing the document fails with a {@link BadLocationException}, any of
* <code>CharacterIterator</code> methods as well as <code>charAt</code>may
* return {@link CharacterIterator#DONE}.
*
* @since 4.0
*/
public class DocumentCharacterIterator implements CharacterIterator, CharSequence {
private int fIndex= -1;
private final IDocument fDocument;
private final int fFirst;
private final int fLast;
private void invariant() {
Assert.isTrue(fIndex >= fFirst);
Assert.isTrue(fIndex <= fLast);
}
/**
* Creates an iterator for the entire document.
*
* @param document the document backing this iterator
*/
public DocumentCharacterIterator(IDocument document) {
this(document, 0);
}
/**
* Creates an iterator, starting at offset <code>first</code>.
*
* @param document the document backing this iterator
* @param first the first character to consider
* @throws IllegalArgumentException if the indices are out of bounds
*/
public DocumentCharacterIterator(IDocument document, int first) throws IllegalArgumentException {
this(document, first, document.getLength());
}
/**
* Creates an iterator for the document contents from <code>first</code>
* (inclusive) to <code>last</code> (exclusive).
*
* @param document the document backing this iterator
* @param first the first character to consider
* @param last the last character index to consider
* @throws IllegalArgumentException if the indices are out of bounds
*/
public DocumentCharacterIterator(IDocument document, int first, int last) throws IllegalArgumentException {
if (document == null)
throw new NullPointerException();
if (first < 0 || first > last)
throw new IllegalArgumentException();
if (last > document.getLength())
throw new IllegalArgumentException();
fDocument= document;
fFirst= first;
fLast= last;
fIndex= first;
invariant();
}
/*
* @see java.text.CharacterIterator#first()
*/
public char first() {
return setIndex(getBeginIndex());
}
/*
* @see java.text.CharacterIterator#last()
*/
public char last() {
if (fFirst == fLast)
return setIndex(getEndIndex());
return setIndex(getEndIndex() - 1);
}
/*
* @see java.text.CharacterIterator#current()
*/
public char current() {
if (fIndex >= fFirst && fIndex < fLast)
try {
return fDocument.getChar(fIndex);
} catch (BadLocationException e) {
// ignore
}
return DONE;
}
/*
* @see java.text.CharacterIterator#next()
*/
public char next() {
return setIndex(Math.min(fIndex + 1, getEndIndex()));
}
/*
* @see java.text.CharacterIterator#previous()
*/
public char previous() {
if (fIndex > getBeginIndex()) {
return setIndex(fIndex - 1);
}
return DONE;
}
/*
* @see java.text.CharacterIterator#setIndex(int)
*/
public char setIndex(int position) {
if (position >= getBeginIndex() && position <= getEndIndex())
fIndex= position;
else
throw new IllegalArgumentException();
invariant();
return current();
}
/*
* @see java.text.CharacterIterator#getBeginIndex()
*/
public int getBeginIndex() {
return fFirst;
}
/*
* @see java.text.CharacterIterator#getEndIndex()
*/
public int getEndIndex() {
return fLast;
}
/*
* @see java.text.CharacterIterator#getIndex()
*/
public int getIndex() {
return fIndex;
}
/*
* @see java.text.CharacterIterator#clone()
*/
@Override
public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
}
/*
* @see java.lang.CharSequence#length()
*/
public int length() {
return getEndIndex() - getBeginIndex();
}
/**
* {@inheritDoc}
* <p>
* Note that, if the document is modified concurrently, this method may
* return {@link CharacterIterator#DONE} if a {@link BadLocationException}
* was thrown when accessing the backing document.
* </p>
*
* @param index {@inheritDoc}
* @return {@inheritDoc}
*/
public char charAt(int index) {
if (index >= 0 && index < length())
try {
return fDocument.getChar(getBeginIndex() + index);
} catch (BadLocationException e) {
// ignore and return DONE
return DONE;
}
throw new IndexOutOfBoundsException();
}
/*
* @see java.lang.CharSequence#subSequence(int, int)
*/
public CharSequence subSequence(int start, int end) {
if (start < 0)
throw new IndexOutOfBoundsException();
if (end < start)
throw new IndexOutOfBoundsException();
if (end > length())
throw new IndexOutOfBoundsException();
return new DocumentCharacterIterator(fDocument, getBeginIndex() + start, getBeginIndex() + end);
}
}
|
