Classes in this File | Line Coverage | Branch Coverage | Complexity | ||||
ReadOnlyPassage |
|
| 1.5319148936170213;1.532 |
1 | /** | |
2 | * Distribution License: | |
3 | * JSword is free software; you can redistribute it and/or modify it under | |
4 | * the terms of the GNU Lesser General Public License, version 2.1 or later | |
5 | * as published by the Free Software Foundation. This program is distributed | |
6 | * in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even | |
7 | * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | |
8 | * See the GNU Lesser General Public License for more details. | |
9 | * | |
10 | * The License is available on the internet at: | |
11 | * http://www.gnu.org/copyleft/lgpl.html | |
12 | * or by writing to: | |
13 | * Free Software Foundation, Inc. | |
14 | * 59 Temple Place - Suite 330 | |
15 | * Boston, MA 02111-1307, USA | |
16 | * | |
17 | * © CrossWire Bible Society, 2005 - 2016 | |
18 | * | |
19 | */ | |
20 | package org.crosswire.jsword.passage; | |
21 | ||
22 | import java.io.IOException; | |
23 | import java.io.Reader; | |
24 | import java.io.Writer; | |
25 | import java.util.Iterator; | |
26 | ||
27 | import org.crosswire.jsword.JSOtherMsg; | |
28 | import org.crosswire.jsword.versification.Versification; | |
29 | ||
30 | /** | |
31 | * This is a simple proxy to a real Passage object that denies all attempts to | |
32 | * write to it. | |
33 | * | |
34 | * @see gnu.lgpl.License The GNU Lesser General Public License for details. | |
35 | * @author Joe Walker | |
36 | */ | |
37 | 0 | final class ReadOnlyPassage implements Passage { |
38 | /** | |
39 | * Construct a ReadOnlyPassage from a real Passage to which we proxy. | |
40 | * | |
41 | * @param ref | |
42 | * The real Passage | |
43 | * @param ignore | |
44 | * Do we throw up if someone tries to change us | |
45 | */ | |
46 | 0 | ReadOnlyPassage(Passage ref, boolean ignore) { |
47 | 0 | this.ref = ref; |
48 | 0 | this.ignore = ignore; |
49 | 0 | } |
50 | ||
51 | /* (non-Javadoc) | |
52 | * @see org.crosswire.jsword.passage.Passage#getVersification() | |
53 | */ | |
54 | public Versification getVersification() { | |
55 | 0 | return ref.getVersification(); |
56 | } | |
57 | ||
58 | /* (non-Javadoc) | |
59 | * @see org.crosswire.jsword.passage.Passage#reversify(org.crosswire.jsword.versification.Versification) | |
60 | */ | |
61 | public Passage reversify(Versification newVersification) { | |
62 | 0 | return ref.reversify(newVersification); |
63 | } | |
64 | ||
65 | /* (non-Javadoc) | |
66 | * @see org.crosswire.jsword.passage.VerseKey#isWhole() | |
67 | */ | |
68 | public boolean isWhole() { | |
69 | 0 | return ref.isWhole(); |
70 | } | |
71 | ||
72 | /* (non-Javadoc) | |
73 | * @see org.crosswire.jsword.passage.VerseKey#getWhole() | |
74 | */ | |
75 | public Passage getWhole() { | |
76 | 0 | return ref.getWhole(); |
77 | } | |
78 | ||
79 | /* (non-Javadoc) | |
80 | * @see org.crosswire.jsword.passage.Key#addAll(org.crosswire.jsword.passage.Key) | |
81 | */ | |
82 | public void addAll(Key key) { | |
83 | 0 | if (ignore) { |
84 | 0 | return; |
85 | } | |
86 | ||
87 | 0 | throw new IllegalStateException(JSOtherMsg.lookupText("Cannot alter a read-only passage")); |
88 | } | |
89 | ||
90 | /* | |
91 | * (non-Javadoc) | |
92 | * | |
93 | * @see | |
94 | * org.crosswire.jsword.passage.Key#remove(org.crosswire.jsword.passage.Key) | |
95 | */ | |
96 | public void removeAll(Key key) { | |
97 | 0 | if (ignore) { |
98 | 0 | return; |
99 | } | |
100 | ||
101 | 0 | throw new IllegalStateException(JSOtherMsg.lookupText("Cannot alter a read-only passage")); |
102 | } | |
103 | ||
104 | /* (non-Javadoc) | |
105 | * @see org.crosswire.jsword.passage.Key#retainAll(org.crosswire.jsword.passage.Key) | |
106 | */ | |
107 | public void retainAll(Key key) { | |
108 | 0 | if (ignore) { |
109 | 0 | return; |
110 | } | |
111 | ||
112 | 0 | throw new IllegalStateException(JSOtherMsg.lookupText("Cannot alter a read-only passage")); |
113 | } | |
114 | ||
115 | /* (non-Javadoc) | |
116 | * @see org.crosswire.jsword.passage.Passage#contains(org.crosswire.jsword.passage.Key) | |
117 | */ | |
118 | public boolean contains(Key key) { | |
119 | 0 | return ref.contains(key); |
120 | } | |
121 | ||
122 | /* (non-Javadoc) | |
123 | * @see org.crosswire.jsword.passage.Key#canHaveChildren() | |
124 | */ | |
125 | public boolean canHaveChildren() { | |
126 | 0 | return ref.canHaveChildren(); |
127 | } | |
128 | ||
129 | /* (non-Javadoc) | |
130 | * @see org.crosswire.jsword.passage.Key#getChildCount() | |
131 | */ | |
132 | public int getChildCount() { | |
133 | 0 | return ref.getChildCount(); |
134 | } | |
135 | ||
136 | /* (non-Javadoc) | |
137 | * @see org.crosswire.jsword.passage.Key#getCardinality() | |
138 | */ | |
139 | public int getCardinality() { | |
140 | 0 | return ref.getCardinality(); |
141 | } | |
142 | ||
143 | /* (non-Javadoc) | |
144 | * @see java.lang.Iterable#iterator() | |
145 | */ | |
146 | public Iterator<Key> iterator() { | |
147 | 0 | return ref.iterator(); |
148 | } | |
149 | ||
150 | /* (non-Javadoc) | |
151 | * @see org.crosswire.jsword.passage.Key#get(int) | |
152 | */ | |
153 | public Key get(int index) { | |
154 | 0 | return ref.get(index); |
155 | } | |
156 | ||
157 | /* (non-Javadoc) | |
158 | * @see org.crosswire.jsword.passage.Key#indexOf(org.crosswire.jsword.passage.Key) | |
159 | */ | |
160 | public int indexOf(Key that) { | |
161 | 0 | return ref.indexOf(that); |
162 | } | |
163 | ||
164 | /* (non-Javadoc) | |
165 | * @see org.crosswire.jsword.passage.Key#getParent() | |
166 | */ | |
167 | public Key getParent() { | |
168 | 0 | return ref.getParent(); |
169 | } | |
170 | ||
171 | /* (non-Javadoc) | |
172 | * @see org.crosswire.jsword.passage.Key#getName() | |
173 | */ | |
174 | public String getName() { | |
175 | 0 | return ref.getName(); |
176 | } | |
177 | ||
178 | /* (non-Javadoc) | |
179 | * @see org.crosswire.jsword.passage.Key#getName(org.crosswire.jsword.passage.Key) | |
180 | */ | |
181 | public String getName(Key base) { | |
182 | 0 | return ref.getName(base); |
183 | } | |
184 | ||
185 | /* (non-Javadoc) | |
186 | * @see org.crosswire.jsword.passage.Key#getRootName() | |
187 | */ | |
188 | public String getRootName() { | |
189 | 0 | return ref.getRootName(); |
190 | } | |
191 | ||
192 | /* (non-Javadoc) | |
193 | * @see org.crosswire.jsword.passage.Key#getOsisRef() | |
194 | */ | |
195 | public String getOsisRef() { | |
196 | 0 | return ref.getOsisRef(); |
197 | } | |
198 | ||
199 | /* (non-Javadoc) | |
200 | * @see org.crosswire.jsword.passage.Key#getOsisID() | |
201 | */ | |
202 | public String getOsisID() { | |
203 | 0 | return ref.getOsisID(); |
204 | } | |
205 | ||
206 | /* (non-Javadoc) | |
207 | * @see org.crosswire.jsword.passage.Passage#getOverview() | |
208 | */ | |
209 | public String getOverview() { | |
210 | 0 | return ref.getOverview(); |
211 | } | |
212 | ||
213 | /* (non-Javadoc) | |
214 | * @see org.crosswire.jsword.passage.Key#isEmpty() | |
215 | */ | |
216 | public boolean isEmpty() { | |
217 | 0 | return ref.isEmpty(); |
218 | } | |
219 | ||
220 | /* (non-Javadoc) | |
221 | * @see org.crosswire.jsword.passage.Passage#countVerses() | |
222 | */ | |
223 | public int countVerses() { | |
224 | 0 | return ref.countVerses(); |
225 | } | |
226 | ||
227 | /* (non-Javadoc) | |
228 | * @see org.crosswire.jsword.passage.Passage#hasRanges(org.crosswire.jsword.passage.RestrictionType) | |
229 | */ | |
230 | public boolean hasRanges(RestrictionType restrict) { | |
231 | 0 | return ref.hasRanges(restrict); |
232 | } | |
233 | ||
234 | /* (non-Javadoc) | |
235 | * @see org.crosswire.jsword.passage.Passage#countRanges(org.crosswire.jsword.passage.RestrictionType) | |
236 | */ | |
237 | public int countRanges(RestrictionType restrict) { | |
238 | 0 | return ref.countRanges(restrict); |
239 | } | |
240 | ||
241 | /* (non-Javadoc) | |
242 | * @see org.crosswire.jsword.passage.Passage#trimVerses(int) | |
243 | */ | |
244 | public Passage trimVerses(int count) { | |
245 | 0 | return ref.trimVerses(count); |
246 | } | |
247 | ||
248 | /* (non-Javadoc) | |
249 | * @see org.crosswire.jsword.passage.Passage#trimRanges(int, org.crosswire.jsword.passage.RestrictionType) | |
250 | */ | |
251 | public Passage trimRanges(int count, RestrictionType restrict) { | |
252 | 0 | return ref.trimRanges(count, restrict); |
253 | } | |
254 | ||
255 | /* (non-Javadoc) | |
256 | * @see org.crosswire.jsword.passage.Passage#booksInPassage() | |
257 | */ | |
258 | public int booksInPassage() { | |
259 | 0 | return ref.booksInPassage(); |
260 | } | |
261 | ||
262 | /* (non-Javadoc) | |
263 | * @see org.crosswire.jsword.passage.Passage#getVerseAt(int) | |
264 | */ | |
265 | public Verse getVerseAt(int offset) throws ArrayIndexOutOfBoundsException { | |
266 | 0 | return ref.getVerseAt(offset); |
267 | } | |
268 | ||
269 | /* (non-Javadoc) | |
270 | * @see org.crosswire.jsword.passage.Passage#getRangeAt(int, org.crosswire.jsword.passage.RestrictionType) | |
271 | */ | |
272 | public VerseRange getRangeAt(int offset, RestrictionType restrict) throws ArrayIndexOutOfBoundsException { | |
273 | 0 | return ref.getRangeAt(offset, restrict); |
274 | } | |
275 | ||
276 | /* (non-Javadoc) | |
277 | * @see org.crosswire.jsword.passage.Passage#rangeIterator(org.crosswire.jsword.passage.RestrictionType) | |
278 | */ | |
279 | public Iterator<VerseRange> rangeIterator(RestrictionType restrict) { | |
280 | 0 | return ref.rangeIterator(restrict); |
281 | } | |
282 | ||
283 | /* (non-Javadoc) | |
284 | * @see org.crosswire.jsword.passage.Passage#add(org.crosswire.jsword.passage.Key) | |
285 | */ | |
286 | public void add(Key that) { | |
287 | 0 | if (ignore) { |
288 | 0 | return; |
289 | } | |
290 | ||
291 | 0 | throw new IllegalStateException(JSOtherMsg.lookupText("Cannot alter a read-only passage")); |
292 | } | |
293 | ||
294 | /* (non-Javadoc) | |
295 | * @see org.crosswire.jsword.passage.Passage#remove(org.crosswire.jsword.passage.Key) | |
296 | */ | |
297 | public void remove(Key that) { | |
298 | 0 | if (ignore) { |
299 | 0 | return; |
300 | } | |
301 | ||
302 | 0 | throw new IllegalStateException(JSOtherMsg.lookupText("Cannot alter a read-only passage")); |
303 | } | |
304 | ||
305 | /* (non-Javadoc) | |
306 | * @see org.crosswire.jsword.passage.Passage#containsAll(org.crosswire.jsword.passage.Passage) | |
307 | */ | |
308 | public boolean containsAll(Passage that) { | |
309 | 0 | return ref.containsAll(that); |
310 | } | |
311 | ||
312 | /* (non-Javadoc) | |
313 | * @see org.crosswire.jsword.passage.Key#clear() | |
314 | */ | |
315 | public void clear() { | |
316 | 0 | if (ignore) { |
317 | 0 | return; |
318 | } | |
319 | ||
320 | 0 | throw new IllegalStateException(JSOtherMsg.lookupText("Cannot alter a read-only passage")); |
321 | } | |
322 | ||
323 | /* (non-Javadoc) | |
324 | * @see org.crosswire.jsword.passage.Key#blur(int, org.crosswire.jsword.passage.RestrictionType) | |
325 | */ | |
326 | public void blur(int by, RestrictionType restrict) { | |
327 | 0 | if (ignore) { |
328 | 0 | return; |
329 | } | |
330 | ||
331 | 0 | throw new IllegalStateException(JSOtherMsg.lookupText("Cannot alter a read-only passage")); |
332 | } | |
333 | ||
334 | /* (non-Javadoc) | |
335 | * @see org.crosswire.jsword.passage.Passage#readDescription(java.io.Reader) | |
336 | */ | |
337 | public void readDescription(Reader in) { | |
338 | 0 | if (ignore) { |
339 | 0 | return; |
340 | } | |
341 | ||
342 | 0 | throw new IllegalStateException(JSOtherMsg.lookupText("Cannot alter a read-only passage")); |
343 | } | |
344 | ||
345 | /* (non-Javadoc) | |
346 | * @see org.crosswire.jsword.passage.Passage#writeDescription(java.io.Writer) | |
347 | */ | |
348 | public void writeDescription(Writer out) throws IOException { | |
349 | 0 | ref.writeDescription(out); |
350 | 0 | } |
351 | ||
352 | /* (non-Javadoc) | |
353 | * @see org.crosswire.jsword.passage.Passage#optimizeReads() | |
354 | */ | |
355 | public void optimizeReads() { | |
356 | 0 | ref.optimizeReads(); |
357 | 0 | } |
358 | ||
359 | /* (non-Javadoc) | |
360 | * @see org.crosswire.jsword.passage.Passage#addPassageListener(org.crosswire.jsword.passage.PassageListener) | |
361 | */ | |
362 | public void addPassageListener(PassageListener li) { | |
363 | 0 | } |
364 | ||
365 | /* (non-Javadoc) | |
366 | * @see org.crosswire.jsword.passage.Passage#removePassageListener(org.crosswire.jsword.passage.PassageListener) | |
367 | */ | |
368 | public void removePassageListener(PassageListener li) { | |
369 | 0 | } |
370 | ||
371 | @Override | |
372 | public boolean equals(Object obj) { | |
373 | 0 | return ref.equals(obj); |
374 | } | |
375 | ||
376 | @Override | |
377 | public int hashCode() { | |
378 | 0 | return ref.hashCode(); |
379 | } | |
380 | ||
381 | @Override | |
382 | public String toString() { | |
383 | 0 | return ref.toString(); |
384 | } | |
385 | ||
386 | @Override | |
387 | public ReadOnlyPassage clone() { | |
388 | 0 | ReadOnlyPassage clone = null; |
389 | try { | |
390 | 0 | clone = (ReadOnlyPassage) super.clone(); |
391 | 0 | clone.ref = this.ref; |
392 | 0 | clone.ignore = this.ignore; |
393 | 0 | } catch (CloneNotSupportedException e) { |
394 | 0 | assert false : e; |
395 | 0 | } |
396 | ||
397 | 0 | return clone; |
398 | } | |
399 | ||
400 | /* (non-Javadoc) | |
401 | * @see java.lang.Comparable#compareTo(java.lang.Object) | |
402 | */ | |
403 | public int compareTo(Key o) { | |
404 | 0 | return ref.compareTo(o); |
405 | } | |
406 | ||
407 | /** | |
408 | * The object we are proxying to | |
409 | */ | |
410 | private Passage ref; | |
411 | ||
412 | /** | |
413 | * Do we just silently ignore change attempts or throw up | |
414 | */ | |
415 | private boolean ignore; | |
416 | ||
417 | /** | |
418 | * Serialization ID | |
419 | */ | |
420 | private static final long serialVersionUID = 3257853173036102193L; | |
421 | ||
422 | } |