Coverage Report

Coverage Report - org.crosswire.jsword.passage.ReadOnlyPassage

Classes in this File

Line Coverage

Branch Coverage

Complexity

ReadOnlyPassage

0/76

0/18

1.532

 /**
  * Distribution License:
  * JSword is free software; you can redistribute it and/or modify it under
  * the terms of the GNU Lesser General Public License, version 2.1 or later
  * as published by the Free Software Foundation. This program is distributed
  * in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
  * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  * See the GNU Lesser General Public License for more details.
  *
  * The License is available on the internet at:
  *      http://www.gnu.org/copyleft/lgpl.html
  * or by writing to:
  *      Free Software Foundation, Inc.
  *      59 Temple Place - Suite 330
  *      Boston, MA 02111-1307, USA
  *
  * © CrossWire Bible Society, 2005 - 2016
  *
  */
 package org.crosswire.jsword.passage;
 
 import java.io.IOException;
 import java.io.Reader;
 import java.io.Writer;
 import java.util.Iterator;
 
 import org.crosswire.jsword.JSOtherMsg;
 import org.crosswire.jsword.versification.Versification;
 
 /**
  * This is a simple proxy to a real Passage object that denies all attempts to
  * write to it.
  * 
  * @see gnu.lgpl.License The GNU Lesser General Public License for details.
  * @author Joe Walker
  */
 final class ReadOnlyPassage implements Passage {
     /**
      * Construct a ReadOnlyPassage from a real Passage to which we proxy.
      * 
      * @param ref
      *            The real Passage
      * @param ignore
      *            Do we throw up if someone tries to change us
      */
     ReadOnlyPassage(Passage ref, boolean ignore) {
         this.ref = ref;
         this.ignore = ignore;
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#getVersification()
      */
     public Versification getVersification() {
         return ref.getVersification();
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#reversify(org.crosswire.jsword.versification.Versification)
      */
     public Passage reversify(Versification newVersification) {
         return ref.reversify(newVersification);
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.VerseKey#isWhole()
      */
     public boolean isWhole() {
         return ref.isWhole();
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.VerseKey#getWhole()
      */
     public Passage getWhole() {
         return ref.getWhole();
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Key#addAll(org.crosswire.jsword.passage.Key)
      */
     public void addAll(Key key) {
         if (ignore) {
             return;
         }
 
         throw new IllegalStateException(JSOtherMsg.lookupText("Cannot alter a read-only passage"));
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see
      * org.crosswire.jsword.passage.Key#remove(org.crosswire.jsword.passage.Key)
      */
     public void removeAll(Key key) {
         if (ignore) {
             return;
         }
 
         throw new IllegalStateException(JSOtherMsg.lookupText("Cannot alter a read-only passage"));
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Key#retainAll(org.crosswire.jsword.passage.Key)
      */
     public void retainAll(Key key) {
         if (ignore) {
             return;
         }
 
         throw new IllegalStateException(JSOtherMsg.lookupText("Cannot alter a read-only passage"));
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#contains(org.crosswire.jsword.passage.Key)
      */
     public boolean contains(Key key) {
         return ref.contains(key);
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Key#canHaveChildren()
      */
     public boolean canHaveChildren() {
         return ref.canHaveChildren();
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Key#getChildCount()
      */
     public int getChildCount() {
         return ref.getChildCount();
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Key#getCardinality()
      */
     public int getCardinality() {
         return ref.getCardinality();
     }
 
     /* (non-Javadoc)
      * @see java.lang.Iterable#iterator()
      */
     public Iterator<Key> iterator() {
         return ref.iterator();
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Key#get(int)
      */
     public Key get(int index) {
         return ref.get(index);
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Key#indexOf(org.crosswire.jsword.passage.Key)
      */
     public int indexOf(Key that) {
         return ref.indexOf(that);
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Key#getParent()
      */
     public Key getParent() {
         return ref.getParent();
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Key#getName()
      */
     public String getName() {
         return ref.getName();
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Key#getName(org.crosswire.jsword.passage.Key)
      */
     public String getName(Key base) {
         return ref.getName(base);
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Key#getRootName()
      */
     public String getRootName() {
         return ref.getRootName();
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Key#getOsisRef()
      */
     public String getOsisRef() {
         return ref.getOsisRef();
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Key#getOsisID()
      */
     public String getOsisID() {
         return ref.getOsisID();
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#getOverview()
      */
     public String getOverview() {
         return ref.getOverview();
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Key#isEmpty()
      */
     public boolean isEmpty() {
         return ref.isEmpty();
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#countVerses()
      */
     public int countVerses() {
         return ref.countVerses();
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#hasRanges(org.crosswire.jsword.passage.RestrictionType)
      */
     public boolean hasRanges(RestrictionType restrict) {
         return ref.hasRanges(restrict);
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#countRanges(org.crosswire.jsword.passage.RestrictionType)
      */
     public int countRanges(RestrictionType restrict) {
         return ref.countRanges(restrict);
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#trimVerses(int)
      */
     public Passage trimVerses(int count) {
         return ref.trimVerses(count);
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#trimRanges(int, org.crosswire.jsword.passage.RestrictionType)
      */
     public Passage trimRanges(int count, RestrictionType restrict) {
         return ref.trimRanges(count, restrict);
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#booksInPassage()
      */
     public int booksInPassage() {
         return ref.booksInPassage();
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#getVerseAt(int)
      */
     public Verse getVerseAt(int offset) throws ArrayIndexOutOfBoundsException {
         return ref.getVerseAt(offset);
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#getRangeAt(int, org.crosswire.jsword.passage.RestrictionType)
      */
     public VerseRange getRangeAt(int offset, RestrictionType restrict) throws ArrayIndexOutOfBoundsException {
         return ref.getRangeAt(offset, restrict);
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#rangeIterator(org.crosswire.jsword.passage.RestrictionType)
      */
     public Iterator<VerseRange> rangeIterator(RestrictionType restrict) {
         return ref.rangeIterator(restrict);
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#add(org.crosswire.jsword.passage.Key)
      */
     public void add(Key that) {
         if (ignore) {
             return;
         }
 
         throw new IllegalStateException(JSOtherMsg.lookupText("Cannot alter a read-only passage"));
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#remove(org.crosswire.jsword.passage.Key)
      */
     public void remove(Key that) {
         if (ignore) {
             return;
         }
 
         throw new IllegalStateException(JSOtherMsg.lookupText("Cannot alter a read-only passage"));
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#containsAll(org.crosswire.jsword.passage.Passage)
      */
     public boolean containsAll(Passage that) {
         return ref.containsAll(that);
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Key#clear()
      */
     public void clear() {
         if (ignore) {
             return;
         }
 
         throw new IllegalStateException(JSOtherMsg.lookupText("Cannot alter a read-only passage"));
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Key#blur(int, org.crosswire.jsword.passage.RestrictionType)
      */
     public void blur(int by, RestrictionType restrict) {
         if (ignore) {
             return;
         }
 
         throw new IllegalStateException(JSOtherMsg.lookupText("Cannot alter a read-only passage"));
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#readDescription(java.io.Reader)
      */
     public void readDescription(Reader in) {
         if (ignore) {
             return;
         }
 
         throw new IllegalStateException(JSOtherMsg.lookupText("Cannot alter a read-only passage"));
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#writeDescription(java.io.Writer)
      */
     public void writeDescription(Writer out) throws IOException {
         ref.writeDescription(out);
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#optimizeReads()
      */
     public void optimizeReads() {
         ref.optimizeReads();
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#addPassageListener(org.crosswire.jsword.passage.PassageListener)
      */
     public void addPassageListener(PassageListener li) {
     }
 
     /* (non-Javadoc)
      * @see org.crosswire.jsword.passage.Passage#removePassageListener(org.crosswire.jsword.passage.PassageListener)
      */
     public void removePassageListener(PassageListener li) {
     }
 
     @Override
     public boolean equals(Object obj) {
         return ref.equals(obj);
     }
 
     @Override
     public int hashCode() {
         return ref.hashCode();
     }
 
     @Override
     public String toString() {
         return ref.toString();
     }
 
     @Override
     public ReadOnlyPassage clone() {
         ReadOnlyPassage clone = null;
         try {
             clone = (ReadOnlyPassage) super.clone();
             clone.ref = this.ref;
             clone.ignore = this.ignore;
         } catch (CloneNotSupportedException e) {
             assert false : e;
         }
 
         return clone;
     }
 
     /* (non-Javadoc)
      * @see java.lang.Comparable#compareTo(java.lang.Object)
      */
     public int compareTo(Key o) {
         return ref.compareTo(o);
     }
 
     /**
      * The object we are proxying to
      */
     private Passage ref;
 
     /**
      * Do we just silently ignore change attempts or throw up
      */
     private boolean ignore;
 
     /**
      * Serialization ID
      */
     private static final long serialVersionUID = 3257853173036102193L;
 
 }

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		}