Project

Clover coverage report - JBind Project

Coverage timestamp: Fr Mai 28 2004 11:17:36 CEST

file stats:	LOC:	407		Methods:	42
	NCLOC:	338		Classes:	1

This license of Clover is provided to support the development of JBind only. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover.

Source file

Conditionals

Statements

Methods

TOTAL

StrBuffer.java

21,2%

28,1%

35,7%

27%

 /*
  * JBind
  *
  * Copyright (c) by Stefan Wachter. All rights reserved.
  *
  * Usage, modification, and redistribution is subject to license terms that are
  * available at 'http://www.jbind.org'. The JBind license is like the
  * 'Apache Software License V 1.1'.
  */
 package org.jbind.util.other;
 
 /**
  * An unsynchornized copy of the java.lang.StrBuffer class.
  */
 public class StrBuffer implements java.io.Serializable {
 
   private char value[];
 
   private int count;
 
   private boolean shared;
 
   static final long serialVersionUID = 3388685877147921107L;
 
   public StrBuffer() {
     this(16);
   }
 
   public StrBuffer(int length) {
     value = new char[length];
     shared = false;
   }
 
   public StrBuffer(String str) {
     this(str.length() + 16);
     append(str);
   }
 
   public int length() {
     return count;
   }
 
   public int capacity() {
     return value.length;
   }
 
   private final void copy() {
     char newValue[] = new char[value.length];
     System.arraycopy(value, 0, newValue, 0, count);
     value = newValue;
     shared = false;
   }
 
   public void ensureCapacity(int minimumCapacity) {
     if (minimumCapacity > value.length) {
       expandCapacity(minimumCapacity);
     }
   }
 
   private void expandCapacity(int minimumCapacity) {
     int newCapacity = (value.length + 1) * 2;
     if (newCapacity < 0) {
       newCapacity = Integer.MAX_VALUE;
     } else if (minimumCapacity > newCapacity) {
       newCapacity = minimumCapacity;
     }
 
     char newValue[] = new char[newCapacity];
     System.arraycopy(value, 0, newValue, 0, count);
     value = newValue;
     shared = false;
   }
 
   public void setLength(int newLength) {
     if (newLength < 0) {
       throw new StringIndexOutOfBoundsException(newLength);
     }
 
     if (newLength > value.length) {
       expandCapacity(newLength);
     }
 
     if (count < newLength) {
       if (shared) {
         copy();
       }
       for (; count < newLength; count++) {
         value[count] = '\0';
       }
     } else {
       count = newLength;
       if (shared) {
         if (newLength > 0) {
           copy();
         } else {
           // If newLength is zero, assume the StrBuffer is being
           // stripped for reuse; Make new buffer of default size
           value = new char[16];
           shared = false;
         }
       }
     }
   }
 
   public char charAt(int index) {
     if ((index < 0) || (index >= count)) {
       throw new StringIndexOutOfBoundsException(index);
     }
     return value[index];
   }
 
   public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
     if (srcBegin < 0) {
       throw new StringIndexOutOfBoundsException(srcBegin);
     }
     if ((srcEnd < 0) || (srcEnd > count)) {
       throw new StringIndexOutOfBoundsException(srcEnd);
     }
     if (srcBegin > srcEnd) {
       throw new StringIndexOutOfBoundsException("srcBegin > srcEnd");
     }
     System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
   }
 
   public void setCharAt(int index, char ch) {
     if ((index < 0) || (index >= count)) {
       throw new StringIndexOutOfBoundsException(index);
     }
     if (shared) {
       copy();
     }
     value[index] = ch;
   }
 
   public StrBuffer append(Object obj) {
     return append(String.valueOf(obj));
   }
 
   public StrBuffer append(String str) {
     if (str == null) {
       str = String.valueOf(str);
     }
 
     int len = str.length();
     int newcount = count + len;
     if (newcount > value.length) {
       expandCapacity(newcount);
     }
     str.getChars(0, len, value, count);
     count = newcount;
     return this;
   }
 
   public StrBuffer append(char str[]) {
     int len = str.length;
     int newcount = count + len;
     if (newcount > value.length) {
       expandCapacity(newcount);
     }
     System.arraycopy(str, 0, value, count, len);
     count = newcount;
     return this;
   }
 
   public StrBuffer append(char str[], int offset, int len) {
     int newcount = count + len;
     if (newcount > value.length) {
       expandCapacity(newcount);
     }
     System.arraycopy(str, offset, value, count, len);
     count = newcount;
     return this;
   }
 
   public StrBuffer append(boolean b) {
     return append(String.valueOf(b));
   }
 
   public StrBuffer append(char c) {
     int newcount = count + 1;
     if (newcount > value.length) {
       expandCapacity(newcount);
     }
     value[count++] = c;
     return this;
   }
 
   public StrBuffer append(int i) {
     return append(String.valueOf(i));
   }
 
   public StrBuffer append(long l) {
     return append(String.valueOf(l));
   }
 
   public StrBuffer append(float f) {
     return append(String.valueOf(f));
   }
 
   public StrBuffer append(double d) {
     return append(String.valueOf(d));
   }
 
   public StrBuffer delete(int start, int end) {
     if (start < 0) {
       throw new StringIndexOutOfBoundsException(start);
     }
     if (end > count) {
       end = count;
     }
     if (start > end) {
       throw new StringIndexOutOfBoundsException();
     }
 
     int len = end - start;
     if (len > 0) {
       if (shared) {
         copy();
       }
       System.arraycopy(value, start + len, value, start, count - end);
       count -= len;
     }
     return this;
   }
 
   public StrBuffer deleteCharAt(int index) {
     if ((index < 0) || (index >= count)) {
       throw new StringIndexOutOfBoundsException();
     }
     if (shared) {
       copy();
     }
     System.arraycopy(value, index + 1, value, index, count - index - 1);
     count--;
     return this;
   }
 
   public StrBuffer replace(int start, int end, String str) {
     if (start < 0) {
       throw new StringIndexOutOfBoundsException(start);
     }
     if (end > count) {
       end = count;
     }
     if (start > end) {
       throw new StringIndexOutOfBoundsException();
     }
 
     int len = str.length();
     int newCount = count + len - (end - start);
     if (newCount > value.length) {
       expandCapacity(newCount);
     } else if (shared) {
       copy();
     }
 
     System.arraycopy(value, end, value, start + len, count - end);
     str.getChars(0, len, value, start);
     count = newCount;
     return this;
   }
 
   public String substring(int start) {
     return substring(start, count);
   }
 
   public String substring(int start, int end) {
     if (start < 0) {
       throw new StringIndexOutOfBoundsException(start);
     }
     if (end > count) {
       throw new StringIndexOutOfBoundsException(end);
     }
     if (start > end) {
       throw new StringIndexOutOfBoundsException(end - start);
     }
     return new String(value, start, end - start);
   }
 
   public StrBuffer insert(int index, char str[], int offset, int len) {
     if ((index < 0) || (index > count)) {
       throw new StringIndexOutOfBoundsException();
     }
     if ((offset < 0) || (offset + len < 0) || (offset + len > str.length)) {
       throw new StringIndexOutOfBoundsException(offset);
     }
     if (len < 0) {
       throw new StringIndexOutOfBoundsException(len);
     }
     int newCount = count + len;
     if (newCount > value.length) {
       expandCapacity(newCount);
     } else if (shared) {
       copy();
     }
     System.arraycopy(value, index, value, index + len, count - index);
     System.arraycopy(str, offset, value, index, len);
     count = newCount;
     return this;
   }
 
   public StrBuffer insert(int offset, Object obj) {
     return insert(offset, String.valueOf(obj));
   }
 
   public StrBuffer insert(int offset, String str) {
     if ((offset < 0) || (offset > count)) {
       throw new StringIndexOutOfBoundsException();
     }
 
     if (str == null) {
       str = String.valueOf(str);
     }
     int len = str.length();
     int newcount = count + len;
     if (newcount > value.length) {
       expandCapacity(newcount);
     } else if (shared) {
       copy();
     }
     System.arraycopy(value, offset, value, offset + len, count - offset);
     str.getChars(0, len, value, offset);
     count = newcount;
     return this;
   }
 
   public StrBuffer insert(int offset, char str[]) {
     if ((offset < 0) || (offset > count)) {
       throw new StringIndexOutOfBoundsException();
     }
     int len = str.length;
     int newcount = count + len;
     if (newcount > value.length) {
       expandCapacity(newcount);
     } else if (shared) {
       copy();
     }
     System.arraycopy(value, offset, value, offset + len, count - offset);
     System.arraycopy(str, 0, value, offset, len);
     count = newcount;
     return this;
   }
 
   public StrBuffer insert(int offset, boolean b) {
     return insert(offset, String.valueOf(b));
   }
 
   public StrBuffer insert(int offset, char c) {
     int newcount = count + 1;
     if (newcount > value.length) {
       expandCapacity(newcount);
     } else if (shared) {
       copy();
     }
     System.arraycopy(value, offset, value, offset + 1, count - offset);
     value[offset] = c;
     count = newcount;
     return this;
   }
 
   public StrBuffer insert(int offset, int i) {
     return insert(offset, String.valueOf(i));
   }
 
   public StrBuffer insert(int offset, long l) {
     return insert(offset, String.valueOf(l));
   }
 
   public StrBuffer insert(int offset, float f) {
     return insert(offset, String.valueOf(f));
   }
 
   public StrBuffer insert(int offset, double d) {
     return insert(offset, String.valueOf(d));
   }
 
   public StrBuffer reverse() {
     if (shared) {
       copy();
     }
     int n = count - 1;
     for (int j = (n - 1) >> 1; j >= 0; --j) {
       char temp = value[j];
       value[j] = value[n - j];
       value[n - j] = temp;
     }
     return this;
   }
 
   public String toString() {
     return new String(value, 0, count);
   }
 
   final void setShared() {
     shared = true;
   }
   final char[] getValue() {
     return value;
   }
 
   private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
     s.defaultReadObject();
     value = (char[])value.clone();
     shared = false;
   }
 }
 

1		/*
2		* JBind
3		*
4		* Copyright (c) by Stefan Wachter. All rights reserved.
5		*
6		* Usage, modification, and redistribution is subject to license terms that are
7		* available at 'http://www.jbind.org'. The JBind license is like the
8		* 'Apache Software License V 1.1'.
9		*/
10		package org.jbind.util.other;
11
12		/**
13		* An unsynchornized copy of the java.lang.StrBuffer class.
14		*/
15		public class StrBuffer implements java.io.Serializable {
16
17		private char value[];
18
19		private int count;
20
21		private boolean shared;
22
23		static final long serialVersionUID = 3388685877147921107L;
24
25	2536	public StrBuffer() {
26	2536	this(16);
27		}
28
29	145710	public StrBuffer(int length) {
30	145710	value = new char[length];
31	145710	shared = false;
32		}
33
34	16160	public StrBuffer(String str) {
35	16160	this(str.length() + 16);
36	16160	append(str);
37		}
38
39	48663	public int length() {
40	48663	return count;
41		}
42
43	0	public int capacity() {
44	0	return value.length;
45		}
46
47	0	private final void copy() {
48	0	char newValue[] = new char[value.length];
49	0	System.arraycopy(value, 0, newValue, 0, count);
50	0	value = newValue;
51	0	shared = false;
52		}
53
54	0	public void ensureCapacity(int minimumCapacity) {
55	0	if (minimumCapacity > value.length) {
56	0	expandCapacity(minimumCapacity);
57		}
58		}
59
60	4336	private void expandCapacity(int minimumCapacity) {
61	4336	int newCapacity = (value.length + 1) * 2;
62	4336	if (newCapacity < 0) {
63	0	newCapacity = Integer.MAX_VALUE;
64	4336	} else if (minimumCapacity > newCapacity) {
65	765	newCapacity = minimumCapacity;
66		}
67
68	4336	char newValue[] = new char[newCapacity];
69	4336	System.arraycopy(value, 0, newValue, 0, count);
70	4336	value = newValue;
71	4336	shared = false;
72		}
73
74	4795	public void setLength(int newLength) {
75	4795	if (newLength < 0) {
76	0	throw new StringIndexOutOfBoundsException(newLength);
77		}
78
79	4795	if (newLength > value.length) {
80	0	expandCapacity(newLength);
81		}
82
83	4795	if (count < newLength) {
84	0	if (shared) {
85	0	copy();
86		}
87	0	for (; count < newLength; count++) {
88	0	value[count] = '\0';
89		}
90		} else {
91	4795	count = newLength;
92	4795	if (shared) {
93	0	if (newLength > 0) {
94	0	copy();
95		} else {
96		// If newLength is zero, assume the StrBuffer is being
97		// stripped for reuse; Make new buffer of default size
98	0	value = new char[16];
99	0	shared = false;
100		}
101		}
102		}
103		}
104
105	17150	public char charAt(int index) {
106	17150	if ((index < 0) \|\| (index >= count)) {
107	0	throw new StringIndexOutOfBoundsException(index);
108		}
109	17150	return value[index];
110		}
111
112	0	public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
113	0	if (srcBegin < 0) {
114	0	throw new StringIndexOutOfBoundsException(srcBegin);
115		}
116	0	if ((srcEnd < 0) \|\| (srcEnd > count)) {
117	0	throw new StringIndexOutOfBoundsException(srcEnd);
118		}
119	0	if (srcBegin > srcEnd) {
120	0	throw new StringIndexOutOfBoundsException("srcBegin > srcEnd");
121		}
122	0	System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
123		}
124
125	15691	public void setCharAt(int index, char ch) {
126	15691	if ((index < 0) \|\| (index >= count)) {
127	0	throw new StringIndexOutOfBoundsException(index);
128		}
129	15691	if (shared) {
130	0	copy();
131		}
132	15691	value[index] = ch;
133		}
134
135	34888	public StrBuffer append(Object obj) {
136	34888	return append(String.valueOf(obj));
137		}
138
139	328065	public StrBuffer append(String str) {
140	328065	if (str == null) {
141	0	str = String.valueOf(str);
142		}
143
144	328065	int len = str.length();
145	328065	int newcount = count + len;
146	328065	if (newcount > value.length) {
147	3462	expandCapacity(newcount);
148		}
149	328065	str.getChars(0, len, value, count);
150	328065	count = newcount;
151	328065	return this;
152		}
153
154	0	public StrBuffer append(char str[]) {
155	0	int len = str.length;
156	0	int newcount = count + len;
157	0	if (newcount > value.length) {
158	0	expandCapacity(newcount);
159		}
160	0	System.arraycopy(str, 0, value, count, len);
161	0	count = newcount;
162	0	return this;
163		}
164
165	0	public StrBuffer append(char str[], int offset, int len) {
166	0	int newcount = count + len;
167	0	if (newcount > value.length) {
168	0	expandCapacity(newcount);
169		}
170	0	System.arraycopy(str, offset, value, count, len);
171	0	count = newcount;
172	0	return this;
173		}
174
175	0	public StrBuffer append(boolean b) {
176	0	return append(String.valueOf(b));
177		}
178
179	184615	public StrBuffer append(char c) {
180	184615	int newcount = count + 1;
181	184615	if (newcount > value.length) {
182	874	expandCapacity(newcount);
183		}
184	184615	value[count++] = c;
185	184615	return this;
186		}
187
188	922	public StrBuffer append(int i) {
189	922	return append(String.valueOf(i));
190		}
191
192	0	public StrBuffer append(long l) {
193	0	return append(String.valueOf(l));
194		}
195
196	0	public StrBuffer append(float f) {
197	0	return append(String.valueOf(f));
198		}
199
200	0	public StrBuffer append(double d) {
201	0	return append(String.valueOf(d));
202		}
203
204	0	public StrBuffer delete(int start, int end) {
205	0	if (start < 0) {
206	0	throw new StringIndexOutOfBoundsException(start);
207		}
208	0	if (end > count) {
209	0	end = count;
210		}
211	0	if (start > end) {
212	0	throw new StringIndexOutOfBoundsException();
213		}
214
215	0	int len = end - start;
216	0	if (len > 0) {
217	0	if (shared) {
218	0	copy();
219		}
220	0	System.arraycopy(value, start + len, value, start, count - end);
221	0	count -= len;
222		}
223	0	return this;
224		}
225
226	79	public StrBuffer deleteCharAt(int index) {
227	79	if ((index < 0) \|\| (index >= count)) {
228	0	throw new StringIndexOutOfBoundsException();
229		}
230	79	if (shared) {
231	0	copy();
232		}
233	79	System.arraycopy(value, index + 1, value, index, count - index - 1);
234	79	count--;
235	79	return this;
236		}
237
238	51	public StrBuffer replace(int start, int end, String str) {
239	51	if (start < 0) {
240	0	throw new StringIndexOutOfBoundsException(start);
241		}
242	51	if (end > count) {
243	0	end = count;
244		}
245	51	if (start > end) {
246	0	throw new StringIndexOutOfBoundsException();
247		}
248
249	51	int len = str.length();
250	51	int newCount = count + len - (end - start);
251	51	if (newCount > value.length) {
252	0	expandCapacity(newCount);
253	51	} else if (shared) {
254	0	copy();
255		}
256
257	51	System.arraycopy(value, end, value, start + len, count - end);
258	51	str.getChars(0, len, value, start);
259	51	count = newCount;
260	51	return this;
261		}
262
263	0	public String substring(int start) {
264	0	return substring(start, count);
265		}
266
267	0	public String substring(int start, int end) {
268	0	if (start < 0) {
269	0	throw new StringIndexOutOfBoundsException(start);
270		}
271	0	if (end > count) {
272	0	throw new StringIndexOutOfBoundsException(end);
273		}
274	0	if (start > end) {
275	0	throw new StringIndexOutOfBoundsException(end - start);
276		}
277	0	return new String(value, start, end - start);
278		}
279
280	0	public StrBuffer insert(int index, char str[], int offset, int len) {
281	0	if ((index < 0) \|\| (index > count)) {
282	0	throw new StringIndexOutOfBoundsException();
283		}
284	0	if ((offset < 0) \|\| (offset + len < 0) \|\| (offset + len > str.length)) {
285	0	throw new StringIndexOutOfBoundsException(offset);
286		}
287	0	if (len < 0) {
288	0	throw new StringIndexOutOfBoundsException(len);
289		}
290	0	int newCount = count + len;
291	0	if (newCount > value.length) {
292	0	expandCapacity(newCount);
293	0	} else if (shared) {
294	0	copy();
295		}
296	0	System.arraycopy(value, index, value, index + len, count - index);
297	0	System.arraycopy(str, offset, value, index, len);
298	0	count = newCount;
299	0	return this;
300		}
301
302	0	public StrBuffer insert(int offset, Object obj) {
303	0	return insert(offset, String.valueOf(obj));
304		}
305
306	0	public StrBuffer insert(int offset, String str) {
307	0	if ((offset < 0) \|\| (offset > count)) {
308	0	throw new StringIndexOutOfBoundsException();
309		}
310
311	0	if (str == null) {
312	0	str = String.valueOf(str);
313		}
314	0	int len = str.length();
315	0	int newcount = count + len;
316	0	if (newcount > value.length) {
317	0	expandCapacity(newcount);
318	0	} else if (shared) {
319	0	copy();
320		}
321	0	System.arraycopy(value, offset, value, offset + len, count - offset);
322	0	str.getChars(0, len, value, offset);
323	0	count = newcount;
324	0	return this;
325		}
326
327	0	public StrBuffer insert(int offset, char str[]) {
328	0	if ((offset < 0) \|\| (offset > count)) {
329	0	throw new StringIndexOutOfBoundsException();
330		}
331	0	int len = str.length;
332	0	int newcount = count + len;
333	0	if (newcount > value.length) {
334	0	expandCapacity(newcount);
335	0	} else if (shared) {
336	0	copy();
337		}
338	0	System.arraycopy(value, offset, value, offset + len, count - offset);
339	0	System.arraycopy(str, 0, value, offset, len);
340	0	count = newcount;
341	0	return this;
342		}
343
344	0	public StrBuffer insert(int offset, boolean b) {
345	0	return insert(offset, String.valueOf(b));
346		}
347
348	0	public StrBuffer insert(int offset, char c) {
349	0	int newcount = count + 1;
350	0	if (newcount > value.length) {
351	0	expandCapacity(newcount);
352	0	} else if (shared) {
353	0	copy();
354		}
355	0	System.arraycopy(value, offset, value, offset + 1, count - offset);
356	0	value[offset] = c;
357	0	count = newcount;
358	0	return this;
359		}
360
361	0	public StrBuffer insert(int offset, int i) {
362	0	return insert(offset, String.valueOf(i));
363		}
364
365	0	public StrBuffer insert(int offset, long l) {
366	0	return insert(offset, String.valueOf(l));
367		}
368
369	0	public StrBuffer insert(int offset, float f) {
370	0	return insert(offset, String.valueOf(f));
371		}
372
373	0	public StrBuffer insert(int offset, double d) {
374	0	return insert(offset, String.valueOf(d));
375		}
376
377	0	public StrBuffer reverse() {
378	0	if (shared) {
379	0	copy();
380		}
381	0	int n = count - 1;
382	0	for (int j = (n - 1) >> 1; j >= 0; --j) {
383	0	char temp = value[j];
384	0	value[j] = value[n - j];
385	0	value[n - j] = temp;
386		}
387	0	return this;
388		}
389
390	194561	public String toString() {
391	194561	return new String(value, 0, count);
392		}
393
394	0	final void setShared() {
395	0	shared = true;
396		}
397	0	final char[] getValue() {
398	0	return value;
399		}
400
401	0	private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
402	0	s.defaultReadObject();
403	0	value = (char[])value.clone();
404	0	shared = false;
405		}
406		}
407