![[Jenkins]](/jenkins/static/aeeb6498/images/jenkins-header-logo-v2.svg){kind=logo}
Method: equals(char[][], char[][])
1: /*
2: * #%~
3: * org.overture.ide.debug
4: * %%
5: * Copyright (C) 2008 - 2014 Overture
6: * %%
7: * This program is free software: you can redistribute it and/or modify
8: * it under the terms of the GNU General Public License as
9: * published by the Free Software Foundation, either version 3 of the
10: * License, or (at your option) any later version.
11: *
12: * This program is distributed in the hope that it will be useful,
13: * but WITHOUT ANY WARRANTY; without even the implied warranty of
14: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: * GNU General Public License for more details.
16: *
17: * You should have received a copy of the GNU General Public
18: * License along with this program. If not, see
19: * <http://www.gnu.org/licenses/gpl-3.0.html>.
20: * #~%
21: */
22: package org.overture.ide.debug.utils;
23:
24: /**
25: * This class is a collection of helper methods to manipulate char arrays.
26: */
27: public final class CharOperation
28: {
29:
30: /**
31: * Constant for an empty char array
32: */
33: public static final char[] NO_CHAR = new char[0];
34:
35: /**
36: * Constant for an empty char array with two dimensions.
37: */
38: public static final char[][] NO_CHAR_CHAR = new char[0][];
39:
40: /**
41: * Constant for an empty String array.
42: */
43: public static final String[] NO_STRINGS = new String[0];
44:
45: // private static final char MAX_OBVIOUS = 128;
46:
47: /**
48: * Answers a new array with appending the suffix character at the end of the array. <br>
49: * <br>
50: * For example:<br>
51: * <ol>
52: * <li>
53: *
54: * <pre>
55: * array = { 'a', 'b' }
56: * suffix = 'c'
57: * => result = { 'a', 'b' , 'c' }
58: * </pre>
59: *
60: * </li>
61: * <li>
62: *
63: * <pre>
64: * array = null
65: * suffix = 'c'
66: * => result = { 'c' }
67: * </pre>
68: *
69: * </li>
70: * </ol>
71: *
72: * @param array
73: * the array that is concanated with the suffix character
74: * @param suffix
75: * the suffix character
76: * @return the new array
77: */
78: public static final char[] append(char[] array, char suffix)
79: {
80: if (array == null)
81: {
82: return new char[] { suffix };
83: }
84: int length = array.length;
85: System.arraycopy(array, 0, array = new char[length + 1], 0, length);
86: array[length] = suffix;
87: return array;
88: }
89:
90: /**
91: * Append the given subarray to the target array starting at the given index in the target array. The start of the
92: * subarray is inclusive, the end is exclusive. Answers a new target array if it needs to grow, otherwise answers
93: * the same target array. <br>
94: * For example:<br>
95: * <ol>
96: * <li>
97: *
98: * <pre>
99: * target = { 'a', 'b', '0' }
100: * index = 2
101: * array = { 'c', 'd' }
102: * start = 0
103: * end = 1
104: * => result = { 'a', 'b' , 'c' }
105: * </pre>
106: *
107: * </li>
108: * <li>
109: *
110: * <pre>
111: * target = { 'a', 'b' }
112: * index = 2
113: * array = { 'c', 'd' }
114: * start = 0
115: * end = 1
116: * => result = { 'a', 'b' , 'c', '0', '0' , '0' } (new array)
117: * </pre>
118: *
119: * </li>
120: * <li>
121: *
122: * <pre>
123: * target = { 'a', 'b', 'c' }
124: * index = 1
125: * array = { 'c', 'd', 'e', 'f' }
126: * start = 1
127: * end = 4
128: * => result = { 'a', 'd' , 'e', 'f', '0', '0', '0', '0' } (new array)
129: * </pre>
130: *
131: * </li>
132: * </ol>
133: *
134: * @param target
135: * the given target
136: * @param index
137: * the given index
138: * @param array
139: * the given array
140: * @param start
141: * the given start index
142: * @param end
143: * the given end index
144: * @return the new array
145: * @throws NullPointerException
146: * if the target array is null
147: */
148: public static final char[] append(char[] target, int index, char[] array,
149: int start, int end)
150: {
151: int targetLength = target.length;
152: int subLength = end - start;
153: int newTargetLength = subLength + index;
154: if (newTargetLength > targetLength)
155: {
156: System.arraycopy(target, 0, target = new char[newTargetLength * 2], 0, index);
157: }
158: System.arraycopy(array, start, target, index, subLength);
159: return target;
160: }
161:
162: /**
163: * Answers the concatenation of the two arrays. It answers null if the two arrays are null. If the first array is
164: * null, then the second array is returned. If the second array is null, then the first array is returned. <br>
165: * <br>
166: * For example:
167: * <ol>
168: * <li>
169: *
170: * <pre>
171: * first = null
172: * second = null
173: * => result = null
174: * </pre>
175: *
176: * </li>
177: * <li>
178: *
179: * <pre>
180: * first = { { ' a' } }
181: * second = null
182: * => result = { { ' a' } }
183: * </pre>
184: *
185: * </li>
186: * <li>
187: *
188: * <pre>
189: * first = null
190: * second = { { ' a' } }
191: * => result = { { ' a' } }
192: * </pre>
193: *
194: * </li>
195: * <li>
196: *
197: * <pre>
198: * first = { { ' b' } }
199: * second = { { ' a' } }
200: * => result = { { ' b' }, { ' a' } }
201: * </pre>
202: *
203: * </li>
204: * </ol>
205: *
206: * @param first
207: * the first array to concatenate
208: * @param second
209: * the second array to concatenate
210: * @return the concatenation of the two arrays, or null if the two arrays are null.
211: */
212: public static final char[][] arrayConcat(char[][] first, char[][] second)
213: {
214: if (first == null)
215: {
216: return second;
217: }
218: if (second == null)
219: {
220: return first;
221: }
222:
223: int length1 = first.length;
224: int length2 = second.length;
225: char[][] result = new char[length1 + length2][];
226: System.arraycopy(first, 0, result, 0, length1);
227: System.arraycopy(second, 0, result, length1, length2);
228: return result;
229: }
230:
231: /**
232: * Returns the char arrays as an array of Strings
233: *
234: * @param charArrays
235: * the char array to convert
236: * @return the char arrays as an array of Strings or null if the given char arrays is null.
237: */
238: public static String[] charArrayToStringArray(char[][] charArrays)
239: {
240: if (charArrays == null)
241: {
242: return null;
243: }
244: int length = charArrays.length;
245: if (length == 0)
246: {
247: return NO_STRINGS;
248: }
249: String[] strings = new String[length];
250: for (int i = 0; i < length; i++)
251: {
252: strings[i] = new String(charArrays[i]);
253: }
254: return strings;
255: }
256:
257: /**
258: * Returns the char array as a String
259: *
260: * @param charArray
261: * the char array to convert
262: * @return the char array as a String or null if the given char array is null.
263: */
264: public static String charToString(char[] charArray)
265: {
266: if (charArray == null)
267: {
268: return null;
269: }
270: return new String(charArray);
271: }
272:
273: /**
274: * Answers a new array adding the second array at the end of first array. It answers null if the first and second
275: * are null. If the first array is null, then a new array char[][] is created with second. If the second array is
276: * null, then the first array is returned. <br>
277: * <br>
278: * For example:
279: * <ol>
280: * <li>
281: *
282: * <pre>
283: * first = null
284: * second = { 'a' }
285: * => result = { { ' a' } }
286: * </pre>
287: * <li>
288: *
289: * <pre>
290: * first = { { ' a' } }
291: * second = null
292: * => result = { { ' a' } }
293: * </pre>
294: *
295: * </li>
296: * <li>
297: *
298: * <pre>
299: * first = { { ' a' } }
300: * second = { ' b' }
301: * => result = { { ' a' } , { ' b' } }
302: * </pre>
303: *
304: * </li>
305: * </ol>
306: *
307: * @param first
308: * the first array to concatenate
309: * @param second
310: * the array to add at the end of the first array
311: * @return a new array adding the second array at the end of first array, or null if the two arrays are null.
312: */
313: public static final char[][] arrayConcat(char[][] first, char[] second)
314: {
315: if (second == null)
316: {
317: return first;
318: }
319: if (first == null)
320: {
321: return new char[][] { second };
322: }
323:
324: int length = first.length;
325: char[][] result = new char[length + 1][];
326: System.arraycopy(first, 0, result, 0, length);
327: result[length] = second;
328: return result;
329: }
330:
331: /**
332: * Compares the contents of the two arrays array and prefix. Returns
333: * <ul>
334: * <li>zero if the array starts with the prefix contents</li>
335: * <li>the difference between the first two characters that are not equal</li>
336: * <li>one if array length is lower than the prefix length and that the prefix starts with the array contents.</li>
337: * </ul>
338: * <p>
339: * For example:
340: * <ol>
341: * <li>
342: *
343: * <pre>
344: * array = null
345: * prefix = null
346: * => result = NullPointerException
347: * </pre>
348: *
349: * </li>
350: * <li>
351: *
352: * <pre>
353: * array = { 'a', 'b', 'c', 'd', 'e' }
354: * prefix = { 'a', 'b', 'c'}
355: * => result = 0
356: * </pre>
357: *
358: * </li>
359: * <li>
360: *
361: * <pre>
362: * array = { 'a', 'b', 'c', 'd', 'e' }
363: * prefix = { 'a', 'B', 'c'}
364: * => result = 32
365: * </pre>
366: *
367: * </li>
368: * <li>
369: *
370: * <pre>
371: * array = { 'd', 'b', 'c', 'd', 'e' }
372: * prefix = { 'a', 'b', 'c'}
373: * => result = 3
374: * </pre>
375: *
376: * </li>
377: * <li>
378: *
379: * <pre>
380: * array = { 'a', 'b', 'c', 'd', 'e' }
381: * prefix = { 'd', 'b', 'c'}
382: * => result = -3
383: * </pre>
384: *
385: * </li>
386: * <li>
387: *
388: * <pre>
389: * array = { 'a', 'a', 'c', 'd', 'e' }
390: * prefix = { 'a', 'e', 'c'}
391: * => result = -4
392: * </pre>
393: *
394: * </li>
395: * </ol>
396: * </p>
397: *
398: * @param array
399: * the given array
400: * @param prefix
401: * the given prefix
402: * @return the result of the comparison (>=0 if array>prefix)
403: * @throws NullPointerException
404: * if either array or prefix is null
405: */
406: public static final int compareWith(char[] array, char[] prefix)
407: {
408: int arrayLength = array.length;
409: int prefixLength = prefix.length;
410: int min = Math.min(arrayLength, prefixLength);
411: int i = 0;
412: while (min-- != 0)
413: {
414: char c1 = array[i];
415: char c2 = prefix[i++];
416: if (c1 != c2)
417: {
418: return c1 - c2;
419: }
420: }
421: if (prefixLength == i)
422: {
423: return 0;
424: }
425: return -1; // array is shorter than prefix (e.g. array:'ab' <
426: // prefix:'abc').
427: }
428:
429: /**
430: * Answers the concatenation of the two arrays. It answers null if the two arrays are null. If the first array is
431: * null, then the second array is returned. If the second array is null, then the first array is returned. <br>
432: * <br>
433: * For example:
434: * <ol>
435: * <li>
436: *
437: * <pre>
438: * first = null
439: * second = { 'a' }
440: * => result = { ' a' }
441: * </pre>
442: *
443: * </li>
444: * <li>
445: *
446: * <pre>
447: * first = { ' a' }
448: * second = null
449: * => result = { ' a' }
450: * </pre>
451: *
452: * </li>
453: * <li>
454: *
455: * <pre>
456: * first = { ' a' }
457: * second = { ' b' }
458: * => result = { ' a' , ' b' }
459: * </pre>
460: *
461: * </li>
462: * </ol>
463: *
464: * @param first
465: * the first array to concatenate
466: * @param second
467: * the second array to concatenate
468: * @return the concatenation of the two arrays, or null if the two arrays are null.
469: */
470: public static final char[] concat(char[] first, char[] second)
471: {
472: if (first == null)
473: {
474: return second;
475: }
476: if (second == null)
477: {
478: return first;
479: }
480:
481: int length1 = first.length;
482: int length2 = second.length;
483: char[] result = new char[length1 + length2];
484: System.arraycopy(first, 0, result, 0, length1);
485: System.arraycopy(second, 0, result, length1, length2);
486: return result;
487: }
488:
489: /**
490: * Answers the concatenation of the three arrays. It answers null if the three arrays are null. If first is null, it
491: * answers the concatenation of second and third. If second is null, it answers the concatenation of first and
492: * third. If third is null, it answers the concatenation of first and second. <br>
493: * <br>
494: * For example:
495: * <ol>
496: * <li>
497: *
498: * <pre>
499: * first = null
500: * second = { 'a' }
501: * third = { 'b' }
502: * => result = { ' a', 'b' }
503: * </pre>
504: *
505: * </li>
506: * <li>
507: *
508: * <pre>
509: * first = { 'a' }
510: * second = null
511: * third = { 'b' }
512: * => result = { ' a', 'b' }
513: * </pre>
514: *
515: * </li>
516: * <li>
517: *
518: * <pre>
519: * first = { 'a' }
520: * second = { 'b' }
521: * third = null
522: * => result = { ' a', 'b' }
523: * </pre>
524: *
525: * </li>
526: * <li>
527: *
528: * <pre>
529: * first = null
530: * second = null
531: * third = null
532: * => result = null
533: * </pre>
534: *
535: * </li>
536: * <li>
537: *
538: * <pre>
539: * first = { 'a' }
540: * second = { 'b' }
541: * third = { 'c' }
542: * => result = { 'a', 'b', 'c' }
543: * </pre>
544: *
545: * </li>
546: * </ol>
547: *
548: * @param first
549: * the first array to concatenate
550: * @param second
551: * the second array to concatenate
552: * @param third
553: * the third array to concatenate
554: * @return the concatenation of the three arrays, or null if the three arrays are null.
555: */
556: public static final char[] concat(char[] first, char[] second, char[] third)
557: {
558: if (first == null)
559: {
560: return concat(second, third);
561: }
562: if (second == null)
563: {
564: return concat(first, third);
565: }
566: if (third == null)
567: {
568: return concat(first, second);
569: }
570:
571: int length1 = first.length;
572: int length2 = second.length;
573: int length3 = third.length;
574: char[] result = new char[length1 + length2 + length3];
575: System.arraycopy(first, 0, result, 0, length1);
576: System.arraycopy(second, 0, result, length1, length2);
577: System.arraycopy(third, 0, result, length1 + length2, length3);
578: return result;
579: }
580:
581: /**
582: * Answers the concatenation of the two arrays inserting the separator character between the two arrays. It answers
583: * null if the two arrays are null. If the first array is null, then the second array is returned. If the second
584: * array is null, then the first array is returned. <br>
585: * <br>
586: * For example:
587: * <ol>
588: * <li>
589: *
590: * <pre>
591: * first = null
592: * second = { 'a' }
593: * separator = '/'
594: * => result = { ' a' }
595: * </pre>
596: *
597: * </li>
598: * <li>
599: *
600: * <pre>
601: * first = { ' a' }
602: * second = null
603: * separator = '/'
604: * => result = { ' a' }
605: * </pre>
606: *
607: * </li>
608: * <li>
609: *
610: * <pre>
611: * first = { ' a' }
612: * second = { ' b' }
613: * separator = '/'
614: * => result = { ' a' , '/', 'b' }
615: * </pre>
616: *
617: * </li>
618: * </ol>
619: *
620: * @param first
621: * the first array to concatenate
622: * @param second
623: * the second array to concatenate
624: * @param separator
625: * the character to insert
626: * @return the concatenation of the two arrays inserting the separator character between the two arrays , or null if
627: * the two arrays are null.
628: */
629: public static final char[] concat(char[] first, char[] second,
630: char separator)
631: {
632: if (first == null)
633: {
634: return second;
635: }
636: if (second == null)
637: {
638: return first;
639: }
640:
641: int length1 = first.length;
642: if (length1 == 0)
643: {
644: return second;
645: }
646: int length2 = second.length;
647: if (length2 == 0)
648: {
649: return first;
650: }
651:
652: char[] result = new char[length1 + length2 + 1];
653: System.arraycopy(first, 0, result, 0, length1);
654: result[length1] = separator;
655: System.arraycopy(second, 0, result, length1 + 1, length2);
656: return result;
657: }
658:
659: public static final char[] concatWithSeparator(char[] first, char[] second,
660: char[] separator)
661: {
662: if (first == null)
663: {
664: return second;
665: }
666: if (second == null)
667: {
668: return first;
669: }
670:
671: int length1 = first.length;
672: if (length1 == 0)
673: {
674: return second;
675: }
676: int length2 = second.length;
677: if (length2 == 0)
678: {
679: return first;
680: }
681: int length3 = separator.length;
682:
683: char[] result = new char[length1 + length2 + length3];
684: System.arraycopy(first, 0, result, 0, length1);
685: System.arraycopy(separator, 0, result, length1, length3);
686: System.arraycopy(second, 0, result, length1 + length3, length2);
687: return result;
688: }
689:
690: /**
691: * Answers the concatenation of the three arrays inserting the sep1 character between the first two arrays and sep2
692: * between the last two. It answers null if the three arrays are null. If the first array is null, then it answers
693: * the concatenation of second and third inserting the sep2 character between them. If the second array is null,
694: * then it answers the concatenation of first and third inserting the sep1 character between them. If the third
695: * array is null, then it answers the concatenation of first and second inserting the sep1 character between them. <br>
696: * <br>
697: * For example:
698: * <ol>
699: * <li>
700: *
701: * <pre>
702: * first = null
703: * sep1 = '/'
704: * second = { 'a' }
705: * sep2 = ':'
706: * third = { 'b' }
707: * => result = { ' a' , ':', 'b' }
708: * </pre>
709: *
710: * </li>
711: * <li>
712: *
713: * <pre>
714: * first = { 'a' }
715: * sep1 = '/'
716: * second = null
717: * sep2 = ':'
718: * third = { 'b' }
719: * => result = { ' a' , '/', 'b' }
720: * </pre>
721: *
722: * </li>
723: * <li>
724: *
725: * <pre>
726: * first = { 'a' }
727: * sep1 = '/'
728: * second = { 'b' }
729: * sep2 = ':'
730: * third = null
731: * => result = { ' a' , '/', 'b' }
732: * </pre>
733: *
734: * </li>
735: * <li>
736: *
737: * <pre>
738: * first = { 'a' }
739: * sep1 = '/'
740: * second = { 'b' }
741: * sep2 = ':'
742: * third = { 'c' }
743: * => result = { ' a' , '/', 'b' , ':', 'c' }
744: * </pre>
745: *
746: * </li>
747: * </ol>
748: *
749: * @param first
750: * the first array to concatenate
751: * @param sep1
752: * the character to insert
753: * @param second
754: * the second array to concatenate
755: * @param sep2
756: * the character to insert
757: * @param third
758: * the second array to concatenate
759: * @return the concatenation of the three arrays inserting the sep1 character between the two arrays and sep2
760: * between the last two.
761: */
762: public static final char[] concat(char[] first, char sep1, char[] second,
763: char sep2, char[] third)
764: {
765: if (first == null)
766: {
767: return concat(second, third, sep2);
768: }
769: if (second == null)
770: {
771: return concat(first, third, sep1);
772: }
773: if (third == null)
774: {
775: return concat(first, second, sep1);
776: }
777:
778: int length1 = first.length;
779: int length2 = second.length;
780: int length3 = third.length;
781: char[] result = new char[length1 + length2 + length3 + 2];
782: System.arraycopy(first, 0, result, 0, length1);
783: result[length1] = sep1;
784: System.arraycopy(second, 0, result, length1 + 1, length2);
785: result[length1 + length2 + 1] = sep2;
786: System.arraycopy(third, 0, result, length1 + length2 + 2, length3);
787: return result;
788: }
789:
790: /**
791: * Answers a new array with prepending the prefix character and appending the suffix character at the end of the
792: * array. If array is null, it answers a new array containing the prefix and the suffix characters. <br>
793: * <br>
794: * For example:<br>
795: * <ol>
796: * <li>
797: *
798: * <pre>
799: * prefix = 'a'
800: * array = { 'b' }
801: * suffix = 'c'
802: * => result = { 'a', 'b' , 'c' }
803: * </pre>
804: *
805: * </li>
806: * <li>
807: *
808: * <pre>
809: * prefix = 'a'
810: * array = null
811: * suffix = 'c'
812: * => result = { 'a', 'c' }
813: * </pre>
814: *
815: * </li>
816: * </ol>
817: *
818: * @param prefix
819: * the prefix character
820: * @param array
821: * the array that is concanated with the prefix and suffix characters
822: * @param suffix
823: * the suffix character
824: * @return the new array
825: */
826: public static final char[] concat(char prefix, char[] array, char suffix)
827: {
828: if (array == null)
829: {
830: return new char[] { prefix, suffix };
831: }
832:
833: int length = array.length;
834: char[] result = new char[length + 2];
835: result[0] = prefix;
836: System.arraycopy(array, 0, result, 1, length);
837: result[length + 1] = suffix;
838: return result;
839: }
840:
841: /**
842: * Answers the concatenation of the given array parts using the given separator between each part and appending the
843: * given name at the end. <br>
844: * <br>
845: * For example:<br>
846: * <ol>
847: * <li>
848: *
849: * <pre>
850: * name = { 'c' }
851: * array = { { 'a' }, { 'b' } }
852: * separator = '.'
853: * => result = { 'a', '.', 'b' , '.', 'c' }
854: * </pre>
855: *
856: * </li>
857: * <li>
858: *
859: * <pre>
860: * name = null
861: * array = { { 'a' }, { 'b' } }
862: * separator = '.'
863: * => result = { 'a', '.', 'b' }
864: * </pre>
865: *
866: * </li>
867: * <li>
868: *
869: * <pre>
870: * name = { ' c' }
871: * array = null
872: * separator = '.'
873: * => result = { 'c' }
874: * </pre>
875: *
876: * </li>
877: * </ol>
878: *
879: * @param name
880: * the given name
881: * @param array
882: * the given array
883: * @param separator
884: * the given separator
885: * @return the concatenation of the given array parts using the given separator between each part and appending the
886: * given name at the end
887: */
888: public static final char[] concatWith(char[] name, char[][] array,
889: char separator)
890: {
891: int nameLength = name == null ? 0 : name.length;
892: if (nameLength == 0)
893: {
894: return concatWith(array, separator);
895: }
896:
897: int length = array == null ? 0 : array.length;
898: if (length == 0)
899: {
900: return name;
901: }
902:
903: int size = nameLength;
904: int index = length;
905: while (--index >= 0)
906: {
907: if (array[index].length > 0)
908: {
909: size += array[index].length + 1;
910: }
911: }
912: char[] result = new char[size];
913: index = size;
914: for (int i = length - 1; i >= 0; i--)
915: {
916: int subLength = array[i].length;
917: if (subLength > 0)
918: {
919: index -= subLength;
920: System.arraycopy(array[i], 0, result, index, subLength);
921: result[--index] = separator;
922: }
923: }
924: System.arraycopy(name, 0, result, 0, nameLength);
925: return result;
926: }
927:
928: /**
929: * Answers the concatenation of the given array parts using the given separator between each part and appending the
930: * given name at the end. <br>
931: * <br>
932: * For example:<br>
933: * <ol>
934: * <li>
935: *
936: * <pre>
937: * name = { 'c' }
938: * array = { { 'a' }, { 'b' } }
939: * separator = '.'
940: * => result = { 'a', '.', 'b' , '.', 'c' }
941: * </pre>
942: *
943: * </li>
944: * <li>
945: *
946: * <pre>
947: * name = null
948: * array = { { 'a' }, { 'b' } }
949: * separator = '.'
950: * => result = { 'a', '.', 'b' }
951: * </pre>
952: *
953: * </li>
954: * <li>
955: *
956: * <pre>
957: * name = { ' c' }
958: * array = null
959: * separator = '.'
960: * => result = { 'c' }
961: * </pre>
962: *
963: * </li>
964: * </ol>
965: *
966: * @param array
967: * the given array
968: * @param name
969: * the given name
970: * @param separator
971: * the given separator
972: * @return the concatenation of the given array parts using the given separator between each part and appending the
973: * given name at the end
974: */
975: public static final char[] concatWith(char[][] array, char[] name,
976: char separator)
977: {
978: int nameLength = name == null ? 0 : name.length;
979: if (nameLength == 0)
980: {
981: return concatWith(array, separator);
982: }
983:
984: int length = array == null ? 0 : array.length;
985: if (length == 0)
986: {
987: return name;
988: }
989:
990: int size = nameLength;
991: int index = length;
992: while (--index >= 0)
993: {
994: if (array[index].length > 0)
995: {
996: size += array[index].length + 1;
997: }
998: }
999: char[] result = new char[size];
1000: index = 0;
1001: for (int i = 0; i < length; i++)
1002: {
1003: int subLength = array[i].length;
1004: if (subLength > 0)
1005: {
1006: System.arraycopy(array[i], 0, result, index, subLength);
1007: index += subLength;
1008: result[index++] = separator;
1009: }
1010: }
1011: System.arraycopy(name, 0, result, index, nameLength);
1012: return result;
1013: }
1014:
1015: /**
1016: * Answers the concatenation of the given array parts using the given separator between each part. <br>
1017: * <br>
1018: * For example:<br>
1019: * <ol>
1020: * <li>
1021: *
1022: * <pre>
1023: * array = { { 'a' }, { 'b' } }
1024: * separator = '.'
1025: * => result = { 'a', '.', 'b' }
1026: * </pre>
1027: *
1028: * </li>
1029: * <li>
1030: *
1031: * <pre>
1032: * array = null
1033: * separator = '.'
1034: * => result = { }
1035: * </pre>
1036: *
1037: * </li>
1038: * </ol>
1039: *
1040: * @param array
1041: * the given array
1042: * @param separator
1043: * the given separator
1044: * @return the concatenation of the given array parts using the given separator between each part
1045: */
1046: public static final char[] concatWith(char[][] array, char separator)
1047: {
1048: int length = array == null ? 0 : array.length;
1049: if (length == 0)
1050: {
1051: return CharOperation.NO_CHAR;
1052: }
1053:
1054: int size = length - 1;
1055: int index = length;
1056: while (--index >= 0)
1057: {
1058: if (array[index].length == 0)
1059: {
1060: size--;
1061: } else
1062: {
1063: size += array[index].length;
1064: }
1065: }
1066: if (size <= 0)
1067: {
1068: return CharOperation.NO_CHAR;
1069: }
1070: char[] result = new char[size];
1071: index = length;
1072: while (--index >= 0)
1073: {
1074: length = array[index].length;
1075: if (length > 0)
1076: {
1077: System.arraycopy(array[index], 0, result, size -= length, length);
1078: if (--size >= 0)
1079: {
1080: result[size] = separator;
1081: }
1082: }
1083: }
1084: return result;
1085: }
1086:
1087: public static final char[] concatWith(String[] array, char separator)
1088: {
1089: int length = array == null ? 0 : array.length;
1090: if (length == 0)
1091: {
1092: return CharOperation.NO_CHAR;
1093: }
1094:
1095: int size = length - 1;
1096: int index = length;
1097: while (--index >= 0)
1098: {
1099: final int len = array[index].length();
1100: if (len == 0)
1101: {
1102: size--;
1103: } else
1104: {
1105: size += len;
1106: }
1107: }
1108: if (size <= 0)
1109: {
1110: return CharOperation.NO_CHAR;
1111: }
1112: char[] result = new char[size];
1113: index = length;
1114: while (--index >= 0)
1115: {
1116: length = array[index].length();
1117: if (length > 0)
1118: {
1119: array[index].getChars(0, length, result, size -= length);
1120: if (--size >= 0)
1121: {
1122: result[size] = separator;
1123: }
1124: }
1125: }
1126: return result;
1127: }
1128:
1129: /**
1130: * Answers true if the array contains an occurrence of character, false otherwise. <br>
1131: * <br>
1132: * For example:
1133: * <ol>
1134: * <li>
1135: *
1136: * <pre>
1137: * character = 'c'
1138: * array = { { ' a' }, { ' b' } }
1139: * result => false
1140: * </pre>
1141: *
1142: * </li>
1143: * <li>
1144: *
1145: * <pre>
1146: * character = 'a'
1147: * array = { { ' a' }, { ' b' } }
1148: * result => true
1149: * </pre>
1150: *
1151: * </li>
1152: * </ol>
1153: *
1154: * @param character
1155: * the character to search
1156: * @param array
1157: * the array in which the search is done
1158: * @return true if the array contains an occurrence of character, false otherwise.
1159: * @throws NullPointerException
1160: * if array is null.
1161: */
1162: public static final boolean contains(char character, char[][] array)
1163: {
1164: for (int i = array.length; --i >= 0;)
1165: {
1166: char[] subarray = array[i];
1167: for (int j = subarray.length; --j >= 0;)
1168: {
1169: if (subarray[j] == character)
1170: {
1171: return true;
1172: }
1173: }
1174: }
1175: return false;
1176: }
1177:
1178: /**
1179: * Answers true if the array contains an occurrence of character, false otherwise. <br>
1180: * <br>
1181: * For example:
1182: * <ol>
1183: * <li>
1184: *
1185: * <pre>
1186: * character = 'c'
1187: * array = { ' b' }
1188: * result => false
1189: * </pre>
1190: *
1191: * </li>
1192: * <li>
1193: *
1194: * <pre>
1195: * character = 'a'
1196: * array = { ' a' , ' b' }
1197: * result => true
1198: * </pre>
1199: *
1200: * </li>
1201: * </ol>
1202: *
1203: * @param character
1204: * the character to search
1205: * @param array
1206: * the array in which the search is done
1207: * @return true if the array contains an occurrence of character, false otherwise.
1208: * @throws NullPointerException
1209: * if array is null.
1210: */
1211: public static final boolean contains(char character, char[] array)
1212: {
1213: for (int i = array.length; --i >= 0;)
1214: {
1215: if (array[i] == character)
1216: {
1217: return true;
1218: }
1219: }
1220: return false;
1221: }
1222:
1223: /**
1224: * Answers true if the array contains an occurrence of one of the characters, false otherwise. <br>
1225: * <br>
1226: * For example:
1227: * <ol>
1228: * <li>
1229: *
1230: * <pre>
1231: * characters = { 'c', 'd' }
1232: * array = { 'a', ' b' }
1233: * result => false
1234: * </pre>
1235: *
1236: * </li>
1237: * <li>
1238: *
1239: * <pre>
1240: * characters = { 'c', 'd' }
1241: * array = { 'a', ' b', 'c' }
1242: * result => true
1243: * </pre>
1244: *
1245: * </li>
1246: * </ol>
1247: *
1248: * @param characters
1249: * the characters to search
1250: * @param array
1251: * the array in which the search is done
1252: * @return true if the array contains an occurrence of one of the characters, false otherwise.
1253: * @throws NullPointerException
1254: * if array is null.
1255: */
1256: public static final boolean contains(char[] characters, char[] array)
1257: {
1258: for (int i = array.length; --i >= 0;)
1259: {
1260: for (int j = characters.length; --j >= 0;)
1261: {
1262: if (array[i] == characters[j])
1263: {
1264: return true;
1265: }
1266: }
1267: }
1268: return false;
1269: }
1270:
1271: /**
1272: * Answers a deep copy of the toCopy array.
1273: *
1274: * @param toCopy
1275: * the array to copy
1276: * @return a deep copy of the toCopy array.
1277: */
1278:
1279: public static final char[][] deepCopy(char[][] toCopy)
1280: {
1281: int toCopyLength = toCopy.length;
1282: char[][] result = new char[toCopyLength][];
1283: for (int i = 0; i < toCopyLength; i++)
1284: {
1285: char[] toElement = toCopy[i];
1286: int toElementLength = toElement.length;
1287: char[] resultElement = new char[toElementLength];
1288: System.arraycopy(toElement, 0, resultElement, 0, toElementLength);
1289: result[i] = resultElement;
1290: }
1291: return result;
1292: }
1293:
1294: /**
1295: * Return <code>true</code> if array starts with the sequence of characters contained in toBeFound, otherwise
1296: * <code>false</code>.
1297: *
1298: * @param array
1299: * @param toBeFound
1300: * @return
1301: */
1302: public static final boolean startsWith(char[] array, char[] toBeFound)
1303: {
1304: int i = toBeFound.length;
1305: if (array.length < i)
1306: {
1307: return false;
1308: }
1309: while (--i >= 0)
1310: {
1311: if (toBeFound[i] != array[i])
1312: {
1313: return false;
1314: }
1315: }
1316: return true;
1317: }
1318:
1319: /**
1320: * Return true if array ends with the sequence of characters contained in toBeFound, otherwise false. <br>
1321: * <br>
1322: * For example:
1323: * <ol>
1324: * <li>
1325: *
1326: * <pre>
1327: * array = { 'a', 'b', 'c', 'd' }
1328: * toBeFound = { 'b', 'c' }
1329: * result => false
1330: * </pre>
1331: *
1332: * </li>
1333: * <li>
1334: *
1335: * <pre>
1336: * array = { 'a', 'b', 'c' }
1337: * toBeFound = { 'b', 'c' }
1338: * result => true
1339: * </pre>
1340: *
1341: * </li>
1342: * </ol>
1343: *
1344: * @param array
1345: * the array to check
1346: * @param toBeFound
1347: * the array to find
1348: * @return true if array ends with the sequence of characters contained in toBeFound, otherwise false.
1349: * @throws NullPointerException
1350: * if array is null or toBeFound is null
1351: */
1352: public static final boolean endsWith(char[] array, char[] toBeFound)
1353: {
1354: int i = toBeFound.length;
1355: int j = array.length - i;
1356:
1357: if (j < 0)
1358: {
1359: return false;
1360: }
1361: while (--i >= 0)
1362: {
1363: if (toBeFound[i] != array[i + j])
1364: {
1365: return false;
1366: }
1367: }
1368: return true;
1369: }
1370:
1371: /**
1372: * Answers true if the two arrays are identical character by character, otherwise false. The equality is case
1373: * sensitive. <br>
1374: * <br>
1375: * For example:
1376: * <ol>
1377: * <li>
1378: *
1379: * <pre>
1380: * first = null
1381: * second = null
1382: * result => true
1383: * </pre>
1384: *
1385: * </li>
1386: * <li>
1387: *
1388: * <pre>
1389: * first = { { } }
1390: * second = null
1391: * result => false
1392: * </pre>
1393: *
1394: * </li>
1395: * <li>
1396: *
1397: * <pre>
1398: * first = { { 'a' } }
1399: * second = { { 'a' } }
1400: * result => true
1401: * </pre>
1402: *
1403: * </li>
1404: * <li>
1405: *
1406: * <pre>
1407: * first = { { 'A' } }
1408: * second = { { 'a' } }
1409: * result => false
1410: * </pre>
1411: *
1412: * </li>
1413: * </ol>
1414: *
1415: * @param first
1416: * the first array
1417: * @param second
1418: * the second array
1419: * @return true if the two arrays are identical character by character, otherwise false
1420: */
1421: public static final boolean equals(char[][] first, char[][] second)
1422: {
1423:• if (first == second)
1424: {
1425: return true;
1426: }
1427:• if (first == null || second == null)
1428: {
1429: return false;
1430: }
1431:• if (first.length != second.length)
1432: {
1433: return false;
1434: }
1435:
1436:• for (int i = first.length; --i >= 0;)
1437: {
1438:• if (!equals(first[i], second[i]))
1439: {
1440: return false;
1441: }
1442: }
1443: return true;
1444: }
1445:
1446: /**
1447: * Compares two strings null-safe.
1448: *
1449: * @param first
1450: * @param second
1451: * @return
1452: */
1453: public static final boolean equals(String first, String second)
1454: {
1455: if (first == second)
1456: {
1457: return true;
1458: } else if (first == null || second == null)
1459: {
1460: return false;
1461: } else
1462: {
1463: return first.equals(second);
1464: }
1465: }
1466:
1467: public static final boolean equals(String[] first, String[] second)
1468: {
1469: if (first == second)
1470: {
1471: return true;
1472: }
1473: if (first == null || second == null)
1474: {
1475: return false;
1476: }
1477: if (first.length != second.length)
1478: {
1479: return false;
1480: }
1481:
1482: for (int i = first.length; --i >= 0;)
1483: {
1484: if (first[i] == null && second[i] != null)
1485: {
1486: return false;
1487: }
1488: if (first[i] != null && second[i] == null)
1489: {
1490: return false;
1491: }
1492: if (first[i] != null && !first[i].equals(second[i]))
1493: {
1494: return false;
1495: }
1496: }
1497: return true;
1498: }
1499:
1500: /**
1501: * If isCaseSensite is true, answers true if the two arrays are identical character by character, otherwise false.
1502: * If it is false, answers true if the two arrays are identical character by character without checking the case,
1503: * otherwise false. <br>
1504: * <br>
1505: * For example:
1506: * <ol>
1507: * <li>
1508: *
1509: * <pre>
1510: * first = null
1511: * second = null
1512: * isCaseSensitive = true
1513: * result => true
1514: * </pre>
1515: *
1516: * </li>
1517: * <li>
1518: *
1519: * <pre>
1520: * first = { { } }
1521: * second = null
1522: * isCaseSensitive = true
1523: * result => false
1524: * </pre>
1525: *
1526: * </li>
1527: * <li>
1528: *
1529: * <pre>
1530: * first = { { 'A' } }
1531: * second = { { 'a' } }
1532: * isCaseSensitive = true
1533: * result => false
1534: * </pre>
1535: *
1536: * </li>
1537: * <li>
1538: *
1539: * <pre>
1540: * first = { { 'A' } }
1541: * second = { { 'a' } }
1542: * isCaseSensitive = false
1543: * result => true
1544: * </pre>
1545: *
1546: * </li>
1547: * </ol>
1548: *
1549: * @param first
1550: * the first array
1551: * @param second
1552: * the second array
1553: * @param isCaseSensitive
1554: * check whether or not the equality should be case sensitive
1555: * @return true if the two arrays are identical character by character according to the value of isCaseSensitive,
1556: * otherwise false
1557: */
1558: public static final boolean equals(char[][] first, char[][] second,
1559: boolean isCaseSensitive)
1560: {
1561:
1562: if (isCaseSensitive)
1563: {
1564: return equals(first, second);
1565: }
1566: if (first == second)
1567: {
1568: return true;
1569: }
1570: if (first == null || second == null)
1571: {
1572: return false;
1573: }
1574: if (first.length != second.length)
1575: {
1576: return false;
1577: }
1578:
1579: for (int i = first.length; --i >= 0;)
1580: {
1581: if (!equals(first[i], second[i], false))
1582: {
1583: return false;
1584: }
1585: }
1586: return true;
1587: }
1588:
1589: /**
1590: * Answers true if the two arrays are identical character by character, otherwise false. The equality is case
1591: * sensitive. <br>
1592: * <br>
1593: * For example:
1594: * <ol>
1595: * <li>
1596: *
1597: * <pre>
1598: * first = null
1599: * second = null
1600: * result => true
1601: * </pre>
1602: *
1603: * </li>
1604: * <li>
1605: *
1606: * <pre>
1607: * first = { }
1608: * second = null
1609: * result => false
1610: * </pre>
1611: *
1612: * </li>
1613: * <li>
1614: *
1615: * <pre>
1616: * first = { 'a' }
1617: * second = { 'a' }
1618: * result => true
1619: * </pre>
1620: *
1621: * </li>
1622: * <li>
1623: *
1624: * <pre>
1625: * first = { 'a' }
1626: * second = { 'A' }
1627: * result => false
1628: * </pre>
1629: *
1630: * </li>
1631: * </ol>
1632: *
1633: * @param first
1634: * the first array
1635: * @param second
1636: * the second array
1637: * @return true if the two arrays are identical character by character, otherwise false
1638: */
1639: public static final boolean equals(char[] first, char[] second)
1640: {
1641: if (first == second)
1642: {
1643: return true;
1644: }
1645: if (first == null || second == null)
1646: {
1647: return false;
1648: }
1649: if (first.length != second.length)
1650: {
1651: return false;
1652: }
1653:
1654: for (int i = first.length; --i >= 0;)
1655: {
1656: if (first[i] != second[i])
1657: {
1658: return false;
1659: }
1660: }
1661: return true;
1662: }
1663:
1664: /**
1665: * Answers true if the first array is identical character by character to a portion of the second array delimited
1666: * from position secondStart (inclusive) to secondEnd(exclusive), otherwise false. The equality is case sensitive. <br>
1667: * <br>
1668: * For example:
1669: * <ol>
1670: * <li>
1671: *
1672: * <pre>
1673: * first = null
1674: * second = null
1675: * secondStart = 0
1676: * secondEnd = 0
1677: * result => true
1678: * </pre>
1679: *
1680: * </li>
1681: * <li>
1682: *
1683: * <pre>
1684: * first = { }
1685: * second = null
1686: * secondStart = 0
1687: * secondEnd = 0
1688: * result => false
1689: * </pre>
1690: *
1691: * </li>
1692: * <li>
1693: *
1694: * <pre>
1695: * first = { 'a' }
1696: * second = { 'a' }
1697: * secondStart = 0
1698: * secondEnd = 1
1699: * result => true
1700: * </pre>
1701: *
1702: * </li>
1703: * <li>
1704: *
1705: * <pre>
1706: * first = { 'a' }
1707: * second = { 'A' }
1708: * secondStart = 0
1709: * secondEnd = 1
1710: * result => false
1711: * </pre>
1712: *
1713: * </li>
1714: * </ol>
1715: *
1716: * @param first
1717: * the first array
1718: * @param second
1719: * the second array
1720: * @param secondStart
1721: * inclusive start position in the second array to compare
1722: * @param secondEnd
1723: * exclusive end position in the second array to compare
1724: * @return true if the first array is identical character by character to fragment of second array ranging from
1725: * secondStart to secondEnd-1, otherwise false
1726: */
1727: public static final boolean equals(char[] first, char[] second,
1728: int secondStart, int secondEnd)
1729: {
1730: if (first == second)
1731: {
1732: return true;
1733: }
1734: if (first == null || second == null)
1735: {
1736: return false;
1737: }
1738: if (first.length != secondEnd - secondStart)
1739: {
1740: return false;
1741: }
1742:
1743: for (int i = first.length; --i >= 0;)
1744: {
1745: if (first[i] != second[i + secondStart])
1746: {
1747: return false;
1748: }
1749: }
1750: return true;
1751: }
1752:
1753: /**
1754: * If isCaseSensite is true, answers true if the two arrays are identical character by character, otherwise false.
1755: * If it is false, answers true if the two arrays are identical character by character without checking the case,
1756: * otherwise false. <br>
1757: * <br>
1758: * For example:
1759: * <ol>
1760: * <li>
1761: *
1762: * <pre>
1763: * first = null
1764: * second = null
1765: * isCaseSensitive = true
1766: * result => true
1767: * </pre>
1768: *
1769: * </li>
1770: * <li>
1771: *
1772: * <pre>
1773: * first = { }
1774: * second = null
1775: * isCaseSensitive = true
1776: * result => false
1777: * </pre>
1778: *
1779: * </li>
1780: * <li>
1781: *
1782: * <pre>
1783: * first = { 'A' }
1784: * second = { 'a' }
1785: * isCaseSensitive = true
1786: * result => false
1787: * </pre>
1788: *
1789: * </li>
1790: * <li>
1791: *
1792: * <pre>
1793: * first = { 'A' }
1794: * second = { 'a' }
1795: * isCaseSensitive = false
1796: * result => true
1797: * </pre>
1798: *
1799: * </li>
1800: * </ol>
1801: *
1802: * @param first
1803: * the first array
1804: * @param second
1805: * the second array
1806: * @param isCaseSensitive
1807: * check whether or not the equality should be case sensitive
1808: * @return true if the two arrays are identical character by character according to the value of isCaseSensitive,
1809: * otherwise false
1810: */
1811: public static final boolean equals(char[] first, char[] second,
1812: boolean isCaseSensitive)
1813: {
1814:
1815: if (isCaseSensitive)
1816: {
1817: return equals(first, second);
1818: }
1819: if (first == second)
1820: {
1821: return true;
1822: }
1823: if (first == null || second == null)
1824: {
1825: return false;
1826: }
1827: if (first.length != second.length)
1828: {
1829: return false;
1830: }
1831:
1832: for (int i = first.length; --i >= 0;)
1833: {
1834: if (Character.toLowerCase(first[i]) != Character.toLowerCase(second[i]))
1835: {
1836: return false;
1837: }
1838: }
1839: return true;
1840: }
1841:
1842: /**
1843: * If isCaseSensite is true, the equality is case sensitive, otherwise it is case insensitive. Answers true if the
1844: * name contains the fragment at the starting index startIndex, otherwise false. <br>
1845: * <br>
1846: * For example:
1847: * <ol>
1848: * <li>
1849: *
1850: * <pre>
1851: * fragment = { 'b', 'c' , 'd' }
1852: * name = { 'a', 'b', 'c' , 'd' }
1853: * startIndex = 1
1854: * isCaseSensitive = true
1855: * result => true
1856: * </pre>
1857: *
1858: * </li>
1859: * <li>
1860: *
1861: * <pre>
1862: * fragment = { 'b', 'c' , 'd' }
1863: * name = { 'a', 'b', 'C' , 'd' }
1864: * startIndex = 1
1865: * isCaseSensitive = true
1866: * result => false
1867: * </pre>
1868: *
1869: * </li>
1870: * <li>
1871: *
1872: * <pre>
1873: * fragment = { 'b', 'c' , 'd' }
1874: * name = { 'a', 'b', 'C' , 'd' }
1875: * startIndex = 0
1876: * isCaseSensitive = false
1877: * result => false
1878: * </pre>
1879: *
1880: * </li>
1881: * <li>
1882: *
1883: * <pre>
1884: * fragment = { 'b', 'c' , 'd' }
1885: * name = { 'a', 'b'}
1886: * startIndex = 0
1887: * isCaseSensitive = true
1888: * result => false
1889: * </pre>
1890: *
1891: * </li>
1892: * </ol>
1893: *
1894: * @param fragment
1895: * the fragment to check
1896: * @param name
1897: * the array to check
1898: * @param startIndex
1899: * the starting index
1900: * @param isCaseSensitive
1901: * check whether or not the equality should be case sensitive
1902: * @return true if the name contains the fragment at the starting index startIndex according to the value of
1903: * isCaseSensitive, otherwise false.
1904: * @throws NullPointerException
1905: * if fragment or name is null.
1906: */
1907: public static final boolean fragmentEquals(char[] fragment, char[] name,
1908: int startIndex, boolean isCaseSensitive)
1909: {
1910:
1911: int max = fragment.length;
1912: if (name.length < max + startIndex)
1913: {
1914: return false;
1915: }
1916: if (isCaseSensitive)
1917: {
1918: for (int i = max; --i >= 0;)
1919: {
1920: // assumes the prefix is not larger than the name
1921: if (fragment[i] != name[i + startIndex])
1922: {
1923: return false;
1924: }
1925: }
1926: return true;
1927: }
1928: for (int i = max; --i >= 0;)
1929: {
1930: // assumes the prefix is not larger than the name
1931: if (Character.toLowerCase(fragment[i]) != Character.toLowerCase(name[i
1932: + startIndex]))
1933: {
1934: return false;
1935: }
1936: }
1937: return true;
1938: }
1939:
1940: /**
1941: * Answers a hashcode for the array
1942: *
1943: * @param array
1944: * the array for which a hashcode is required
1945: * @return the hashcode
1946: * @throws NullPointerException
1947: * if array is null
1948: */
1949: public static final int hashCode(char[] array)
1950: {
1951: int length = array.length;
1952: int hash = length == 0 ? 31 : array[0];
1953: if (length < 8)
1954: {
1955: for (int i = length; --i > 0;)
1956: {
1957: hash = hash * 31 + array[i];
1958: }
1959: } else
1960: {
1961: // 8 characters is enough to compute a decent hash code, don't waste
1962: // time examining every character
1963: for (int i = length - 1, last = i > 16 ? i - 16 : 0; i > last; i -= 2)
1964: {
1965: hash = hash * 31 + array[i];
1966: }
1967: }
1968: return hash & 0x7FFFFFFF;
1969: }
1970:
1971: /**
1972: * Answers true if c is a whitespace according to the JLS (\u000a, \u000c, \u000d, \u0009),
1973: * otherwise false. <br>
1974: * <br>
1975: * For example:
1976: * <ol>
1977: * <li>
1978: *
1979: * <pre>
1980: * c = ' '
1981: * result => true
1982: * </pre>
1983: *
1984: * </li>
1985: * <li>
1986: *
1987: * <pre>
1988: * c = ' \u3000'
1989: * result => false
1990: * </pre>
1991: *
1992: * </li>
1993: * </ol>
1994: *
1995: * @param c
1996: * the character to check
1997: * @return true if c is a whitespace according to the JLS, otherwise false.
1998: */
1999: public static boolean isWhitespace(char c)
2000: {
2001: switch (c)
2002: {
2003: case 10: /* \ u000a: LINE FEED */
2004: case 12: /* \ u000c: FORM FEED */
2005: case 13: /* \ u000d: CARRIAGE RETURN */
2006: case 32: /* \ u0020: SPACE */
2007: case 9: /* \ u0009: HORIZONTAL TABULATION */
2008: return true;
2009: default:
2010: return false;
2011: }
2012: }
2013:
2014: /**
2015: * Answers the first index in the array for which the corresponding character is equal to toBeFound. Answers -1 if
2016: * no occurrence of this character is found. <br>
2017: * <br>
2018: * For example:
2019: * <ol>
2020: * <li>
2021: *
2022: * <pre>
2023: * toBeFound = 'c'
2024: * array = { ' a', 'b', 'c', 'd' }
2025: * result => 2
2026: * </pre>
2027: *
2028: * </li>
2029: * <li>
2030: *
2031: * <pre>
2032: * toBeFound = 'e'
2033: * array = { ' a', 'b', 'c', 'd' }
2034: * result => -1
2035: * </pre>
2036: *
2037: * </li>
2038: * </ol>
2039: *
2040: * @param toBeFound
2041: * the character to search
2042: * @param array
2043: * the array to be searched
2044: * @return the first index in the array for which the corresponding character is equal to toBeFound, -1 otherwise
2045: * @throws NullPointerException
2046: * if array is null
2047: */
2048: public static final int indexOf(char toBeFound, char[] array)
2049: {
2050: return indexOf(toBeFound, array, 0);
2051: }
2052:
2053: /**
2054: * Answers the first index in the array for which the toBeFound array is a matching subarray following the case
2055: * rule. Answers -1 if no match is found. <br>
2056: * <br>
2057: * For example:
2058: * <ol>
2059: * <li>
2060: *
2061: * <pre>
2062: * toBeFound = { 'c' }
2063: * array = { ' a', 'b', 'c', 'd' }
2064: * result => 2
2065: * </pre>
2066: *
2067: * </li>
2068: * <li>
2069: *
2070: * <pre>
2071: * toBeFound = { 'e' }
2072: * array = { ' a', 'b', 'c', 'd' }
2073: * result => -1
2074: * </pre>
2075: *
2076: * </li>
2077: * </ol>
2078: *
2079: * @param toBeFound
2080: * the subarray to search
2081: * @param array
2082: * the array to be searched
2083: * @param isCaseSensitive
2084: * flag to know if the matching should be case sensitive
2085: * @return the first index in the array for which the toBeFound array is a matching subarray following the case
2086: * rule, -1 otherwise
2087: * @throws NullPointerException
2088: * if array is null or toBeFound is null
2089: */
2090: public static final int indexOf(char[] toBeFound, char[] array,
2091: boolean isCaseSensitive)
2092: {
2093: return indexOf(toBeFound, array, isCaseSensitive, 0);
2094: }
2095:
2096: /**
2097: * Answers the first index in the array for which the toBeFound array is a matching subarray following the case rule
2098: * starting at the index start. Answers -1 if no match is found. <br>
2099: * <br>
2100: * For example:
2101: * <ol>
2102: * <li>
2103: *
2104: * <pre>
2105: * toBeFound = { 'c' }
2106: * array = { ' a', 'b', 'c', 'd' }
2107: * result => 2
2108: * </pre>
2109: *
2110: * </li>
2111: * <li>
2112: *
2113: * <pre>
2114: * toBeFound = { 'e' }
2115: * array = { ' a', 'b', 'c', 'd' }
2116: * result => -1
2117: * </pre>
2118: *
2119: * </li>
2120: * </ol>
2121: *
2122: * @param toBeFound
2123: * the subarray to search
2124: * @param array
2125: * the array to be searched
2126: * @param isCaseSensitive
2127: * flag to know if the matching should be case sensitive
2128: * @param start
2129: * the starting index
2130: * @return the first index in the array for which the toBeFound array is a matching subarray following the case rule
2131: * starting at the index start, -1 otherwise
2132: * @throws NullPointerException
2133: * if array is null or toBeFound is null
2134: */
2135: public static final int indexOf(final char[] toBeFound, final char[] array,
2136: final boolean isCaseSensitive, final int start)
2137: {
2138: return indexOf(toBeFound, array, isCaseSensitive, start, array.length);
2139: }
2140:
2141: /**
2142: * Answers the first index in the array for which the toBeFound array is a matching subarray following the case rule
2143: * starting at the index start. Answers -1 if no match is found. <br>
2144: * <br>
2145: * For example:
2146: * <ol>
2147: * <li>
2148: *
2149: * <pre>
2150: * toBeFound = { 'c' }
2151: * array = { ' a', 'b', 'c', 'd' }
2152: * result => 2
2153: * </pre>
2154: *
2155: * </li>
2156: * <li>
2157: *
2158: * <pre>
2159: * toBeFound = { 'e' }
2160: * array = { ' a', 'b', 'c', 'd' }
2161: * result => -1
2162: * </pre>
2163: *
2164: * </li>
2165: * </ol>
2166: *
2167: * @param toBeFound
2168: * the subarray to search
2169: * @param array
2170: * the array to be searched
2171: * @param isCaseSensitive
2172: * flag to know if the matching should be case sensitive
2173: * @param start
2174: * the starting index (inclusive)
2175: * @param end
2176: * the end index (exclusive)
2177: * @return the first index in the array for which the toBeFound array is a matching subarray following the case rule
2178: * starting at the index start, -1 otherwise
2179: * @throws NullPointerException
2180: * if array is null or toBeFound is null
2181: */
2182: public static final int indexOf(final char[] toBeFound, final char[] array,
2183: final boolean isCaseSensitive, final int start, final int end)
2184: {
2185: final int arrayLength = end;
2186: final int toBeFoundLength = toBeFound.length;
2187: if (toBeFoundLength > arrayLength)
2188: {
2189: return -1;
2190: }
2191: if (toBeFoundLength == 0)
2192: {
2193: return 0;
2194: }
2195: if (toBeFoundLength == arrayLength)
2196: {
2197: if (isCaseSensitive)
2198: {
2199: for (int i = start; i < arrayLength; i++)
2200: {
2201: if (array[i] != toBeFound[i])
2202: {
2203: return -1;
2204: }
2205: }
2206: return 0;
2207: } else
2208: {
2209: for (int i = start; i < arrayLength; i++)
2210: {
2211: if (Character.toLowerCase(array[i]) != Character.toLowerCase(toBeFound[i]))
2212: {
2213: return -1;
2214: }
2215: }
2216: return 0;
2217: }
2218: }
2219: if (isCaseSensitive)
2220: {
2221: arrayLoop: for (int i = start, max = arrayLength - toBeFoundLength
2222: + 1; i < max; i++)
2223: {
2224: if (array[i] == toBeFound[0])
2225: {
2226: for (int j = 1; j < toBeFoundLength; j++)
2227: {
2228: if (array[i + j] != toBeFound[j])
2229: {
2230: continue arrayLoop;
2231: }
2232: }
2233: return i;
2234: }
2235: }
2236: } else
2237: {
2238: arrayLoop: for (int i = start, max = arrayLength - toBeFoundLength
2239: + 1; i < max; i++)
2240: {
2241: if (Character.toLowerCase(array[i]) == Character.toLowerCase(toBeFound[0]))
2242: {
2243: for (int j = 1; j < toBeFoundLength; j++)
2244: {
2245: if (Character.toLowerCase(array[i + j]) != Character.toLowerCase(toBeFound[j]))
2246: {
2247: continue arrayLoop;
2248: }
2249: }
2250: return i;
2251: }
2252: }
2253: }
2254: return -1;
2255: }
2256:
2257: /**
2258: * Answers the first index in the array for which the corresponding character is equal to toBeFound starting the
2259: * search at index start. Answers -1 if no occurrence of this character is found. <br>
2260: * <br>
2261: * For example:
2262: * <ol>
2263: * <li>
2264: *
2265: * <pre>
2266: * toBeFound = 'c'
2267: * array = { ' a', 'b', 'c', 'd' }
2268: * start = 2
2269: * result => 2
2270: * </pre>
2271: *
2272: * </li>
2273: * <li>
2274: *
2275: * <pre>
2276: * toBeFound = 'c'
2277: * array = { ' a', 'b', 'c', 'd' }
2278: * start = 3
2279: * result => -1
2280: * </pre>
2281: *
2282: * </li>
2283: * <li>
2284: *
2285: * <pre>
2286: * toBeFound = 'e'
2287: * array = { ' a', 'b', 'c', 'd' }
2288: * start = 1
2289: * result => -1
2290: * </pre>
2291: *
2292: * </li>
2293: * </ol>
2294: *
2295: * @param toBeFound
2296: * the character to search
2297: * @param array
2298: * the array to be searched
2299: * @param start
2300: * the starting index
2301: * @return the first index in the array for which the corresponding character is equal to toBeFound, -1 otherwise
2302: * @throws NullPointerException
2303: * if array is null
2304: * @throws ArrayIndexOutOfBoundsException
2305: * if start is lower than 0
2306: */
2307: public static final int indexOf(char toBeFound, char[] array, int start)
2308: {
2309: for (int i = start; i < array.length; i++)
2310: {
2311: if (toBeFound == array[i])
2312: {
2313: return i;
2314: }
2315: }
2316: return -1;
2317: }
2318:
2319: /**
2320: * Answers the first index in the array for which the corresponding character is equal to toBeFound starting the
2321: * search at index start and before the ending index. Answers -1 if no occurrence of this character is found. <br>
2322: * <br>
2323: * For example:
2324: * <ol>
2325: * <li>
2326: *
2327: * <pre>
2328: * toBeFound = 'c'
2329: * array = { ' a', 'b', 'c', 'd' }
2330: * start = 2
2331: * result => 2
2332: * </pre>
2333: *
2334: * </li>
2335: * <li>
2336: *
2337: * <pre>
2338: * toBeFound = 'c'
2339: * array = { ' a', 'b', 'c', 'd' }
2340: * start = 3
2341: * result => -1
2342: * </pre>
2343: *
2344: * </li>
2345: * <li>
2346: *
2347: * <pre>
2348: * toBeFound = 'e'
2349: * array = { ' a', 'b', 'c', 'd' }
2350: * start = 1
2351: * result => -1
2352: * </pre>
2353: *
2354: * </li>
2355: * </ol>
2356: *
2357: * @param toBeFound
2358: * the character to search
2359: * @param array
2360: * the array to be searched
2361: * @param start
2362: * the starting index (inclusive)
2363: * @param end
2364: * the ending index (exclusive)
2365: * @return the first index in the array for which the corresponding character is equal to toBeFound, -1 otherwise
2366: * @throws NullPointerException
2367: * if array is null
2368: * @throws ArrayIndexOutOfBoundsException
2369: * if start is lower than 0 or ending greater than array length
2370: */
2371: public static final int indexOf(char toBeFound, char[] array, int start,
2372: int end)
2373: {
2374: for (int i = start; i < end; i++)
2375: {
2376: if (toBeFound == array[i])
2377: {
2378: return i;
2379: }
2380: }
2381: return -1;
2382: }
2383:
2384: /**
2385: * Answers the last index in the array for which the corresponding character is equal to toBeFound starting from the
2386: * end of the array. Answers -1 if no occurrence of this character is found. <br>
2387: * <br>
2388: * For example:
2389: * <ol>
2390: * <li>
2391: *
2392: * <pre>
2393: * toBeFound = 'c'
2394: * array = { ' a', 'b', 'c', 'd' , 'c', 'e' }
2395: * result => 4
2396: * </pre>
2397: *
2398: * </li>
2399: * <li>
2400: *
2401: * <pre>
2402: * toBeFound = 'e'
2403: * array = { ' a', 'b', 'c', 'd' }
2404: * result => -1
2405: * </pre>
2406: *
2407: * </li>
2408: * </ol>
2409: *
2410: * @param toBeFound
2411: * the character to search
2412: * @param array
2413: * the array to be searched
2414: * @return the last index in the array for which the corresponding character is equal to toBeFound starting from the
2415: * end of the array, -1 otherwise
2416: * @throws NullPointerException
2417: * if array is null
2418: */
2419: public static final int lastIndexOf(char toBeFound, char[] array)
2420: {
2421: for (int i = array.length; --i >= 0;)
2422: {
2423: if (toBeFound == array[i])
2424: {
2425: return i;
2426: }
2427: }
2428: return -1;
2429: }
2430:
2431: /**
2432: * Answers the last index in the array for which the corresponding character is equal to toBeFound stopping at the
2433: * index startIndex. Answers -1 if no occurrence of this character is found. <br>
2434: * <br>
2435: * For example:
2436: * <ol>
2437: * <li>
2438: *
2439: * <pre>
2440: * toBeFound = 'c'
2441: * array = { ' a', 'b', 'c', 'd' }
2442: * startIndex = 2
2443: * result => 2
2444: * </pre>
2445: *
2446: * </li>
2447: * <li>
2448: *
2449: * <pre>
2450: * toBeFound = 'c'
2451: * array = { ' a', 'b', 'c', 'd', 'e' }
2452: * startIndex = 3
2453: * result => -1
2454: * </pre>
2455: *
2456: * </li>
2457: * <li>
2458: *
2459: * <pre>
2460: * toBeFound = 'e'
2461: * array = { ' a', 'b', 'c', 'd' }
2462: * startIndex = 0
2463: * result => -1
2464: * </pre>
2465: *
2466: * </li>
2467: * </ol>
2468: *
2469: * @param toBeFound
2470: * the character to search
2471: * @param array
2472: * the array to be searched
2473: * @param startIndex
2474: * the stopping index
2475: * @return the last index in the array for which the corresponding character is equal to toBeFound stopping at the
2476: * index startIndex, -1 otherwise
2477: * @throws NullPointerException
2478: * if array is null
2479: * @throws ArrayIndexOutOfBoundsException
2480: * if startIndex is lower than 0
2481: */
2482: public static final int lastIndexOf(char toBeFound, char[] array,
2483: int startIndex)
2484: {
2485: for (int i = array.length; --i >= startIndex;)
2486: {
2487: if (toBeFound == array[i])
2488: {
2489: return i;
2490: }
2491: }
2492: return -1;
2493: }
2494:
2495: /**
2496: * Answers the last index in the array for which the corresponding character is equal to toBeFound starting from
2497: * endIndex to startIndex. Answers -1 if no occurrence of this character is found. <br>
2498: * <br>
2499: * For example:
2500: * <ol>
2501: * <li>
2502: *
2503: * <pre>
2504: * toBeFound = 'c'
2505: * array = { ' a', 'b', 'c', 'd' }
2506: * startIndex = 2
2507: * endIndex = 2
2508: * result => 2
2509: * </pre>
2510: *
2511: * </li>
2512: * <li>
2513: *
2514: * <pre>
2515: * toBeFound = 'c'
2516: * array = { ' a', 'b', 'c', 'd', 'e' }
2517: * startIndex = 3
2518: * endIndex = 4
2519: * result => -1
2520: * </pre>
2521: *
2522: * </li>
2523: * <li>
2524: *
2525: * <pre>
2526: * toBeFound = 'e'
2527: * array = { ' a', 'b', 'c', 'd' }
2528: * startIndex = 0
2529: * endIndex = 3
2530: * result => -1
2531: * </pre>
2532: *
2533: * </li>
2534: * </ol>
2535: *
2536: * @param toBeFound
2537: * the character to search
2538: * @param array
2539: * the array to be searched
2540: * @param startIndex
2541: * the stopping index
2542: * @param endIndex
2543: * the starting index
2544: * @return the last index in the array for which the corresponding character is equal to toBeFound starting from
2545: * endIndex to startIndex, -1 otherwise
2546: * @throws NullPointerException
2547: * if array is null
2548: * @throws ArrayIndexOutOfBoundsException
2549: * if endIndex is greater or equals to array length or starting is lower than 0
2550: */
2551: public static final int lastIndexOf(char toBeFound, char[] array,
2552: int startIndex, int endIndex)
2553: {
2554: for (int i = endIndex; --i >= startIndex;)
2555: {
2556: if (toBeFound == array[i])
2557: {
2558: return i;
2559: }
2560: }
2561: return -1;
2562: }
2563:
2564: /**
2565: * Answers the last portion of a name given a separator. <br>
2566: * <br>
2567: * For example,
2568: *
2569: * <pre>
2570: * lastSegment("java.lang.Object".toCharArray(),'.') --> Object
2571: * </pre>
2572: *
2573: * @param array
2574: * the array
2575: * @param separator
2576: * the given separator
2577: * @return the last portion of a name given a separator
2578: * @throws NullPointerException
2579: * if array is null
2580: */
2581: final static public char[] lastSegment(char[] array, char separator)
2582: {
2583: int pos = lastIndexOf(separator, array);
2584: if (pos < 0)
2585: {
2586: return array;
2587: }
2588: return subarray(array, pos + 1, array.length);
2589: }
2590:
2591: /**
2592: * Answers true if the pattern matches the given name, false otherwise. This char[] pattern matching accepts
2593: * wild-cards '*' and '?'. When not case sensitive, the pattern is assumed to already be lowercased, the name will
2594: * be lowercased character per character as comparing. If name is null, the answer is false. If pattern is null, the
2595: * answer is true if name is not null. <br>
2596: * <br>
2597: * For example:
2598: * <ol>
2599: * <li>
2600: *
2601: * <pre>
2602: * pattern = { '?', 'b', '*' }
2603: * name = { 'a', 'b', 'c' , 'd' }
2604: * isCaseSensitive = true
2605: * result => true
2606: * </pre>
2607: *
2608: * </li>
2609: * <li>
2610: *
2611: * <pre>
2612: * pattern = { '?', 'b', '?' }
2613: * name = { 'a', 'b', 'c' , 'd' }
2614: * isCaseSensitive = true
2615: * result => false
2616: * </pre>
2617: *
2618: * </li>
2619: * <li>
2620: *
2621: * <pre>
2622: * pattern = { 'b', '*' }
2623: * name = { 'a', 'b', 'c' , 'd' }
2624: * isCaseSensitive = true
2625: * result => false
2626: * </pre>
2627: *
2628: * </li>
2629: * </ol>
2630: *
2631: * @param pattern
2632: * the given pattern
2633: * @param name
2634: * the given name
2635: * @param isCaseSensitive
2636: * flag to know whether or not the matching should be case sensitive
2637: * @return true if the pattern matches the given name, false otherwise
2638: */
2639: public static final boolean match(char[] pattern, char[] name,
2640: boolean isCaseSensitive)
2641: {
2642:
2643: if (name == null)
2644: {
2645: return false; // null name cannot match
2646: }
2647: if (pattern == null)
2648: {
2649: return true; // null pattern is equivalent to '*'
2650: }
2651:
2652: return match(pattern, 0, pattern.length, name, 0, name.length, isCaseSensitive);
2653: }
2654:
2655: /**
2656: * Answers true if a sub-pattern matches the subpart of the given name, false otherwise. char[] pattern matching,
2657: * accepting wild-cards '*' and '?'. Can match only subset of name/pattern. end positions are non-inclusive. The
2658: * subpattern is defined by the patternStart and pattternEnd positions. When not case sensitive, the pattern is
2659: * assumed to already be lowercased, the name will be lowercased character per character as comparing. <br>
2660: * <br>
2661: * For example:
2662: * <ol>
2663: * <li>
2664: *
2665: * <pre>
2666: * pattern = { '?', 'b', '*' }
2667: * patternStart = 1
2668: * patternEnd = 3
2669: * name = { 'a', 'b', 'c' , 'd' }
2670: * nameStart = 1
2671: * nameEnd = 4
2672: * isCaseSensitive = true
2673: * result => true
2674: * </pre>
2675: *
2676: * </li>
2677: * <li>
2678: *
2679: * <pre>
2680: * pattern = { '?', 'b', '*' }
2681: * patternStart = 1
2682: * patternEnd = 2
2683: * name = { 'a', 'b', 'c' , 'd' }
2684: * nameStart = 1
2685: * nameEnd = 2
2686: * isCaseSensitive = true
2687: * result => false
2688: * </pre>
2689: *
2690: * </li>
2691: * </ol>
2692: *
2693: * @param pattern
2694: * the given pattern
2695: * @param patternStart
2696: * the given pattern start
2697: * @param patternEnd
2698: * the given pattern end
2699: * @param name
2700: * the given name
2701: * @param nameStart
2702: * the given name start
2703: * @param nameEnd
2704: * the given name end
2705: * @param isCaseSensitive
2706: * flag to know if the matching should be case sensitive
2707: * @return true if a sub-pattern matches the subpart of the given name, false otherwise
2708: */
2709: public static final boolean match(char[] pattern, int patternStart,
2710: int patternEnd, char[] name, int nameStart, int nameEnd,
2711: boolean isCaseSensitive)
2712: {
2713:
2714: if (name == null)
2715: {
2716: return false; // null name cannot match
2717: }
2718: if (pattern == null)
2719: {
2720: return true; // null pattern is equivalent to '*'
2721: }
2722: int iPattern = patternStart;
2723: int iName = nameStart;
2724:
2725: if (patternEnd < 0)
2726: {
2727: patternEnd = pattern.length;
2728: }
2729: if (nameEnd < 0)
2730: {
2731: nameEnd = name.length;
2732: }
2733:
2734: /* check first segment */
2735: char patternChar = 0;
2736: while (iPattern < patternEnd
2737: && (patternChar = pattern[iPattern]) != '*')
2738: {
2739: if (iName == nameEnd)
2740: {
2741: return false;
2742: }
2743: if (patternChar != (isCaseSensitive ? name[iName]
2744: : Character.toLowerCase(name[iName])) && patternChar != '?')
2745: {
2746: return false;
2747: }
2748: iName++;
2749: iPattern++;
2750: }
2751: /* check sequence of star+segment */
2752: int segmentStart;
2753: if (patternChar == '*')
2754: {
2755: segmentStart = ++iPattern; // skip star
2756: } else
2757: {
2758: segmentStart = 0; // force iName check
2759: }
2760: int prefixStart = iName;
2761: checkSegment: while (iName < nameEnd)
2762: {
2763: if (iPattern == patternEnd)
2764: {
2765: iPattern = segmentStart; // mismatch - restart current
2766: // segment
2767: iName = ++prefixStart;
2768: continue checkSegment;
2769: }
2770: /* segment is ending */
2771: if ((patternChar = pattern[iPattern]) == '*')
2772: {
2773: segmentStart = ++iPattern; // skip start
2774: if (segmentStart == patternEnd)
2775: {
2776: return true;
2777: }
2778: prefixStart = iName;
2779: continue checkSegment;
2780: }
2781: /* check current name character */
2782: if ((isCaseSensitive ? name[iName]
2783: : Character.toLowerCase(name[iName])) != patternChar
2784: && patternChar != '?')
2785: {
2786: iPattern = segmentStart; // mismatch - restart current
2787: // segment
2788: iName = ++prefixStart;
2789: continue checkSegment;
2790: }
2791: iName++;
2792: iPattern++;
2793: }
2794:
2795: return segmentStart == patternEnd || iName == nameEnd
2796: && iPattern == patternEnd || iPattern == patternEnd - 1
2797: && pattern[iPattern] == '*';
2798: }
2799:
2800: /**
2801: * Answers true if the pattern matches the filepath using the pathSepatator, false otherwise. Path char[] pattern
2802: * matching, accepting wild-cards '**', '*' and '?' (using Ant directory tasks conventions, also see
2803: * "http://jakarta.apache.org/ant/manual/dirtasks.html#defaultexcludes"). Path pattern matching is enhancing regular
2804: * pattern matching in supporting extra rule where '**' represent any folder combination. Special rule: - foo\ is
2805: * equivalent to foo\** When not case sensitive, the pattern is assumed to already be lowercased, the name will be
2806: * lowercased character per character as comparing.
2807: *
2808: * @param pattern
2809: * the given pattern
2810: * @param filepath
2811: * the given path
2812: * @param isCaseSensitive
2813: * to find out whether or not the matching should be case sensitive
2814: * @param pathSeparator
2815: * the given path separator
2816: * @return true if the pattern matches the filepath using the pathSepatator, false otherwise
2817: */
2818: public static final boolean pathMatch(char[] pattern, char[] filepath,
2819: boolean isCaseSensitive, char pathSeparator)
2820: {
2821:
2822: if (filepath == null)
2823: {
2824: return false; // null name cannot match
2825: }
2826: if (pattern == null)
2827: {
2828: return true; // null pattern is equivalent to '*'
2829: }
2830:
2831: // offsets inside pattern
2832: int pSegmentStart = pattern[0] == pathSeparator ? 1 : 0;
2833: int pLength = pattern.length;
2834: int pSegmentEnd = CharOperation.indexOf(pathSeparator, pattern, pSegmentStart + 1);
2835: if (pSegmentEnd < 0)
2836: {
2837: pSegmentEnd = pLength;
2838: }
2839:
2840: // special case: pattern foo\ is equivalent to foo\**
2841: boolean freeTrailingDoubleStar = pattern[pLength - 1] == pathSeparator;
2842:
2843: // offsets inside filepath
2844: int fSegmentStart, fLength = filepath.length;
2845: if (filepath[0] != pathSeparator)
2846: {
2847: fSegmentStart = 0;
2848: } else
2849: {
2850: fSegmentStart = 1;
2851: }
2852: if (fSegmentStart != pSegmentStart)
2853: {
2854: return false; // both must start with a separator or none.
2855: }
2856: int fSegmentEnd = CharOperation.indexOf(pathSeparator, filepath, fSegmentStart + 1);
2857: if (fSegmentEnd < 0)
2858: {
2859: fSegmentEnd = fLength;
2860: }
2861:
2862: // first segments
2863: while (pSegmentStart < pLength
2864: && !(pSegmentEnd == pLength && freeTrailingDoubleStar || pSegmentEnd == pSegmentStart + 2
2865: && pattern[pSegmentStart] == '*'
2866: && pattern[pSegmentStart + 1] == '*'))
2867: {
2868:
2869: if (fSegmentStart >= fLength)
2870: {
2871: return false;
2872: }
2873: if (!CharOperation.match(pattern, pSegmentStart, pSegmentEnd, filepath, fSegmentStart, fSegmentEnd, isCaseSensitive))
2874: {
2875: return false;
2876: }
2877:
2878: // jump to next segment
2879: pSegmentEnd = CharOperation.indexOf(pathSeparator, pattern, pSegmentStart = pSegmentEnd + 1);
2880: // skip separator
2881: if (pSegmentEnd < 0)
2882: {
2883: pSegmentEnd = pLength;
2884: }
2885:
2886: fSegmentEnd = CharOperation.indexOf(pathSeparator, filepath, fSegmentStart = fSegmentEnd + 1);
2887: // skip separator
2888: if (fSegmentEnd < 0)
2889: {
2890: fSegmentEnd = fLength;
2891: }
2892: }
2893:
2894: /* check sequence of doubleStar+segment */
2895: int pSegmentRestart;
2896: if (pSegmentStart >= pLength && freeTrailingDoubleStar
2897: || pSegmentEnd == pSegmentStart + 2
2898: && pattern[pSegmentStart] == '*'
2899: && pattern[pSegmentStart + 1] == '*')
2900: {
2901: pSegmentEnd = CharOperation.indexOf(pathSeparator, pattern, pSegmentStart = pSegmentEnd + 1);
2902: // skip separator
2903: if (pSegmentEnd < 0)
2904: {
2905: pSegmentEnd = pLength;
2906: }
2907: pSegmentRestart = pSegmentStart;
2908: } else
2909: {
2910: if (pSegmentStart >= pLength)
2911: {
2912: return fSegmentStart >= fLength; // true if filepath is done
2913: }
2914: // too.
2915: pSegmentRestart = 0; // force fSegmentStart check
2916: }
2917: int fSegmentRestart = fSegmentStart;
2918: checkSegment: while (fSegmentStart < fLength)
2919: {
2920:
2921: if (pSegmentStart >= pLength)
2922: {
2923: if (freeTrailingDoubleStar)
2924: {
2925: return true;
2926: }
2927: // mismatch - restart current path segment
2928: pSegmentEnd = CharOperation.indexOf(pathSeparator, pattern, pSegmentStart = pSegmentRestart);
2929: if (pSegmentEnd < 0)
2930: {
2931: pSegmentEnd = pLength;
2932: }
2933:
2934: fSegmentRestart = CharOperation.indexOf(pathSeparator, filepath, fSegmentRestart + 1);
2935: // skip separator
2936: if (fSegmentRestart < 0)
2937: {
2938: fSegmentRestart = fLength;
2939: } else
2940: {
2941: fSegmentRestart++;
2942: }
2943: fSegmentEnd = CharOperation.indexOf(pathSeparator, filepath, fSegmentStart = fSegmentRestart);
2944: if (fSegmentEnd < 0)
2945: {
2946: fSegmentEnd = fLength;
2947: }
2948: continue checkSegment;
2949: }
2950:
2951: /* path segment is ending */
2952: if (pSegmentEnd == pSegmentStart + 2
2953: && pattern[pSegmentStart] == '*'
2954: && pattern[pSegmentStart + 1] == '*')
2955: {
2956: pSegmentEnd = CharOperation.indexOf(pathSeparator, pattern, pSegmentStart = pSegmentEnd + 1);
2957: // skip separator
2958: if (pSegmentEnd < 0)
2959: {
2960: pSegmentEnd = pLength;
2961: }
2962: pSegmentRestart = pSegmentStart;
2963: fSegmentRestart = fSegmentStart;
2964: if (pSegmentStart >= pLength)
2965: {
2966: return true;
2967: }
2968: continue checkSegment;
2969: }
2970: /* chech current path segment */
2971: if (!CharOperation.match(pattern, pSegmentStart, pSegmentEnd, filepath, fSegmentStart, fSegmentEnd, isCaseSensitive))
2972: {
2973: // mismatch - restart current path segment
2974: pSegmentEnd = CharOperation.indexOf(pathSeparator, pattern, pSegmentStart = pSegmentRestart);
2975: if (pSegmentEnd < 0)
2976: {
2977: pSegmentEnd = pLength;
2978: }
2979:
2980: fSegmentRestart = CharOperation.indexOf(pathSeparator, filepath, fSegmentRestart + 1);
2981: // skip separator
2982: if (fSegmentRestart < 0)
2983: {
2984: fSegmentRestart = fLength;
2985: } else
2986: {
2987: fSegmentRestart++;
2988: }
2989: fSegmentEnd = CharOperation.indexOf(pathSeparator, filepath, fSegmentStart = fSegmentRestart);
2990: if (fSegmentEnd < 0)
2991: {
2992: fSegmentEnd = fLength;
2993: }
2994: continue checkSegment;
2995: }
2996: // jump to next segment
2997: pSegmentEnd = CharOperation.indexOf(pathSeparator, pattern, pSegmentStart = pSegmentEnd + 1);
2998: // skip separator
2999: if (pSegmentEnd < 0)
3000: {
3001: pSegmentEnd = pLength;
3002: }
3003:
3004: fSegmentEnd = CharOperation.indexOf(pathSeparator, filepath, fSegmentStart = fSegmentEnd + 1);
3005: // skip separator
3006: if (fSegmentEnd < 0)
3007: {
3008: fSegmentEnd = fLength;
3009: }
3010: }
3011:
3012: return pSegmentRestart >= pSegmentEnd || fSegmentStart >= fLength
3013: && pSegmentStart >= pLength || pSegmentStart == pLength - 2
3014: && pattern[pSegmentStart] == '*'
3015: && pattern[pSegmentStart + 1] == '*'
3016: || pSegmentStart == pLength && freeTrailingDoubleStar;
3017: }
3018:
3019: /**
3020: * Answers the number of occurrences of the given character in the given array, 0 if any. <br>
3021: * <br>
3022: * For example:
3023: * <ol>
3024: * <li>
3025: *
3026: * <pre>
3027: * toBeFound = 'b'
3028: * array = { 'a' , 'b', 'b', 'a', 'b', 'a' }
3029: * result => 3
3030: * </pre>
3031: *
3032: * </li>
3033: * <li>
3034: *
3035: * <pre>
3036: * toBeFound = 'c'
3037: * array = { 'a' , 'b', 'b', 'a', 'b', 'a' }
3038: * result => 0
3039: * </pre>
3040: *
3041: * </li>
3042: * </ol>
3043: *
3044: * @param toBeFound
3045: * the given character
3046: * @param array
3047: * the given array
3048: * @return the number of occurrences of the given character in the given array, 0 if any
3049: * @throws NullPointerException
3050: * if array is null
3051: */
3052: public static final int occurencesOf(char toBeFound, char[] array)
3053: {
3054: int count = 0;
3055: for (int i = 0; i < array.length; i++)
3056: {
3057: if (toBeFound == array[i])
3058: {
3059: count++;
3060: }
3061: }
3062: return count;
3063: }
3064:
3065: /**
3066: * Answers the number of occurrences of the given character in the given array starting at the given index, 0 if
3067: * any. <br>
3068: * <br>
3069: * For example:
3070: * <ol>
3071: * <li>
3072: *
3073: * <pre>
3074: * toBeFound = 'b'
3075: * array = { 'a' , 'b', 'b', 'a', 'b', 'a' }
3076: * start = 2
3077: * result => 2
3078: * </pre>
3079: *
3080: * </li>
3081: * <li>
3082: *
3083: * <pre>
3084: * toBeFound = 'c'
3085: * array = { 'a' , 'b', 'b', 'a', 'b', 'a' }
3086: * start = 0
3087: * result => 0
3088: * </pre>
3089: *
3090: * </li>
3091: * </ol>
3092: *
3093: * @param toBeFound
3094: * the given character
3095: * @param array
3096: * the given array
3097: * @param start
3098: * the given index
3099: * @return the number of occurrences of the given character in the given array, 0 if any
3100: * @throws NullPointerException
3101: * if array is null
3102: * @throws ArrayIndexOutOfBoundsException
3103: * if start is lower than 0
3104: */
3105: public static final int occurencesOf(char toBeFound, char[] array, int start)
3106: {
3107: int count = 0;
3108: for (int i = start; i < array.length; i++)
3109: {
3110: if (toBeFound == array[i])
3111: {
3112: count++;
3113: }
3114: }
3115: return count;
3116: }
3117:
3118: /**
3119: * Answers true if the given name starts with the given prefix, false otherwise. The comparison is case sensitive. <br>
3120: * <br>
3121: * For example:
3122: * <ol>
3123: * <li>
3124: *
3125: * <pre>
3126: * prefix = { 'a' , 'b' }
3127: * name = { 'a' , 'b', 'b', 'a', 'b', 'a' }
3128: * result => true
3129: * </pre>
3130: *
3131: * </li>
3132: * <li>
3133: *
3134: * <pre>
3135: * prefix = { 'a' , 'c' }
3136: * name = { 'a' , 'b', 'b', 'a', 'b', 'a' }
3137: * result => false
3138: * </pre>
3139: *
3140: * </li>
3141: * </ol>
3142: *
3143: * @param prefix
3144: * the given prefix
3145: * @param name
3146: * the given name
3147: * @return true if the given name starts with the given prefix, false otherwise
3148: * @throws NullPointerException
3149: * if the given name is null or if the given prefix is null
3150: */
3151: public static final boolean prefixEquals(char[] prefix, char[] name)
3152: {
3153:
3154: int max = prefix.length;
3155: if (name.length < max)
3156: {
3157: return false;
3158: }
3159: for (int i = max; --i >= 0;)
3160: {
3161: // assumes the prefix is not larger than the name
3162: if (prefix[i] != name[i])
3163: {
3164: return false;
3165: }
3166: }
3167: return true;
3168: }
3169:
3170: /**
3171: * Answers true if the given name starts with the given prefix, false otherwise. isCaseSensitive is used to find out
3172: * whether or not the comparison should be case sensitive. <br>
3173: * <br>
3174: * For example:
3175: * <ol>
3176: * <li>
3177: *
3178: * <pre>
3179: * prefix = { 'a' , 'B' }
3180: * name = { 'a' , 'b', 'b', 'a', 'b', 'a' }
3181: * isCaseSensitive = false
3182: * result => true
3183: * </pre>
3184: *
3185: * </li>
3186: * <li>
3187: *
3188: * <pre>
3189: * prefix = { 'a' , 'B' }
3190: * name = { 'a' , 'b', 'b', 'a', 'b', 'a' }
3191: * isCaseSensitive = true
3192: * result => false
3193: * </pre>
3194: *
3195: * </li>
3196: * </ol>
3197: *
3198: * @param prefix
3199: * the given prefix
3200: * @param name
3201: * the given name
3202: * @param isCaseSensitive
3203: * to find out whether or not the comparison should be case sensitive
3204: * @return true if the given name starts with the given prefix, false otherwise
3205: * @throws NullPointerException
3206: * if the given name is null or if the given prefix is null
3207: */
3208: public static final boolean prefixEquals(char[] prefix, char[] name,
3209: boolean isCaseSensitive)
3210: {
3211:
3212: int max = prefix.length;
3213: if (name.length < max)
3214: {
3215: return false;
3216: }
3217: if (isCaseSensitive)
3218: {
3219: for (int i = max; --i >= 0;)
3220: {
3221: // assumes the prefix is not larger than the name
3222: if (prefix[i] != name[i])
3223: {
3224: return false;
3225: }
3226: }
3227: return true;
3228: }
3229:
3230: for (int i = max; --i >= 0;)
3231: {
3232: // assumes the prefix is not larger than the name
3233: if (Character.toLowerCase(prefix[i]) != Character.toLowerCase(name[i]))
3234: {
3235: return false;
3236: }
3237: }
3238: return true;
3239: }
3240:
3241: /**
3242: * Replace all occurrence of the character to be replaced with the remplacement character in the given array. <br>
3243: * <br>
3244: * For example:
3245: * <ol>
3246: * <li>
3247: *
3248: * <pre>
3249: * array = { 'a' , 'b', 'b', 'a', 'b', 'a' }
3250: * toBeReplaced = 'b'
3251: * replacementChar = 'a'
3252: * result => No returned value, but array is now equals to { 'a' , 'a', 'a', 'a', 'a', 'a' }
3253: * </pre>
3254: *
3255: * </li>
3256: * <li>
3257: *
3258: * <pre>
3259: * array = { 'a' , 'b', 'b', 'a', 'b', 'a' }
3260: * toBeReplaced = 'c'
3261: * replacementChar = 'a'
3262: * result => No returned value, but array is now equals to { 'a' , 'b', 'b', 'a', 'b', 'a' }
3263: * </pre>
3264: *
3265: * </li>
3266: * </ol>
3267: *
3268: * @param array
3269: * the given array
3270: * @param toBeReplaced
3271: * the character to be replaced
3272: * @param replacementChar
3273: * the replacement character
3274: * @throws NullPointerException
3275: * if the given array is null
3276: */
3277: public static final void replace(char[] array, char toBeReplaced,
3278: char replacementChar)
3279: {
3280: if (toBeReplaced != replacementChar)
3281: {
3282: for (int i = 0, max = array.length; i < max; i++)
3283: {
3284: if (array[i] == toBeReplaced)
3285: {
3286: array[i] = replacementChar;
3287: }
3288: }
3289: }
3290: }
3291:
3292: /**
3293: * Replace all occurrence of characters to be replaced with the remplacement character in the given array. <br>
3294: * <br>
3295: * For example:
3296: * <ol>
3297: * <li>
3298: *
3299: * <pre>
3300: * array = { 'a' , 'b', 'b', 'c', 'a', 'b', 'c', 'a' }
3301: * toBeReplaced = { 'b', 'c' }
3302: * replacementChar = 'a'
3303: * result => No returned value, but array is now equals to { 'a' , 'a', 'a', 'a', 'a', 'a', 'a', 'a' }
3304: * </pre>
3305: *
3306: * </li>
3307: * </ol>
3308: *
3309: * @param array
3310: * the given array
3311: * @param toBeReplaced
3312: * characters to be replaced
3313: * @param replacementChar
3314: * the replacement character
3315: * @throws NullPointerException
3316: * if arrays are null.
3317: */
3318: public static final void replace(char[] array, char[] toBeReplaced,
3319: char replacementChar)
3320: {
3321: for (int i = array.length; --i >= 0;)
3322: {
3323: for (int j = toBeReplaced.length; --j >= 0;)
3324: {
3325: if (array[i] == toBeReplaced[j])
3326: {
3327: array[i] = replacementChar;
3328: }
3329: }
3330: }
3331: }
3332:
3333: /**
3334: * Answers a new array of characters with substitutions. No side-effect is operated on the original array, in case
3335: * no substitution happened, then the result is the same as the original one. <br>
3336: * <br>
3337: * For example:
3338: * <ol>
3339: * <li>
3340: *
3341: * <pre>
3342: * array = { 'a' , 'b', 'b', 'a', 'b', 'a' }
3343: * toBeReplaced = { 'b' }
3344: * replacementChar = { 'a', 'a' }
3345: * result => { 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a' }
3346: * </pre>
3347: *
3348: * </li>
3349: * <li>
3350: *
3351: * <pre>
3352: * array = { 'a' , 'b', 'b', 'a', 'b', 'a' }
3353: * toBeReplaced = { 'c' }
3354: * replacementChar = { 'a' }
3355: * result => { 'a' , 'b', 'b', 'a', 'b', 'a' }
3356: * </pre>
3357: *
3358: * </li>
3359: * </ol>
3360: *
3361: * @param array
3362: * the given array
3363: * @param toBeReplaced
3364: * characters to be replaced
3365: * @param replacementChars
3366: * the replacement characters
3367: * @return a new array of characters with substitutions or the given array if none
3368: * @throws NullPointerException
3369: * if the given array is null
3370: */
3371: public static final char[] replace(char[] array, char[] toBeReplaced,
3372: char[] replacementChars)
3373: {
3374:
3375: int max = array.length;
3376: int replacedLength = toBeReplaced.length;
3377: int replacementLength = replacementChars.length;
3378:
3379: int[] starts = new int[5];
3380: int occurrenceCount = 0;
3381:
3382: if (!equals(toBeReplaced, replacementChars))
3383: {
3384:
3385: next: for (int i = 0; i < max; i++)
3386: {
3387: int j = 0;
3388: while (j < replacedLength)
3389: {
3390: if (i + j == max)
3391: {
3392: continue next;
3393: }
3394: if (array[i + j] != toBeReplaced[j++])
3395: {
3396: continue next;
3397: }
3398: }
3399: if (occurrenceCount == starts.length)
3400: {
3401: System.arraycopy(starts, 0, starts = new int[occurrenceCount * 2], 0, occurrenceCount);
3402: }
3403: starts[occurrenceCount++] = i;
3404: }
3405: }
3406: if (occurrenceCount == 0)
3407: {
3408: return array;
3409: }
3410: char[] result = new char[max + occurrenceCount
3411: * (replacementLength - replacedLength)];
3412: int inStart = 0, outStart = 0;
3413: for (int i = 0; i < occurrenceCount; i++)
3414: {
3415: int offset = starts[i] - inStart;
3416: System.arraycopy(array, inStart, result, outStart, offset);
3417: inStart += offset;
3418: outStart += offset;
3419: System.arraycopy(replacementChars, 0, result, outStart, replacementLength);
3420: inStart += replacedLength;
3421: outStart += replacementLength;
3422: }
3423: System.arraycopy(array, inStart, result, outStart, max - inStart);
3424: return result;
3425: }
3426:
3427: /**
3428: * Replace all occurrence of the character to be replaced with the remplacement character in a copy of the given
3429: * array. Returns the given array if no occurrences of the character to be replaced are found. <br>
3430: * <br>
3431: * For example:
3432: * <ol>
3433: * <li>
3434: *
3435: * <pre>
3436: * array = { 'a' , 'b', 'b', 'a', 'b', 'a' }
3437: * toBeReplaced = 'b'
3438: * replacementChar = 'a'
3439: * result => A new array that is equals to { 'a' , 'a', 'a', 'a', 'a', 'a' }
3440: * </pre>
3441: *
3442: * </li>
3443: * <li>
3444: *
3445: * <pre>
3446: * array = { 'a' , 'b', 'b', 'a', 'b', 'a' }
3447: * toBeReplaced = 'c'
3448: * replacementChar = 'a'
3449: * result => The original array that remains unchanged.
3450: * </pre>
3451: *
3452: * </li>
3453: * </ol>
3454: *
3455: * @param array
3456: * the given array
3457: * @param toBeReplaced
3458: * the character to be replaced
3459: * @param replacementChar
3460: * the replacement character
3461: * @throws NullPointerException
3462: * if the given array is null
3463: */
3464: public static final char[] replaceOnCopy(char[] array, char toBeReplaced,
3465: char replacementChar)
3466: {
3467:
3468: char[] result = null;
3469: for (int i = 0, length = array.length; i < length; i++)
3470: {
3471: char c = array[i];
3472: if (c == toBeReplaced)
3473: {
3474: if (result == null)
3475: {
3476: result = new char[length];
3477: System.arraycopy(array, 0, result, 0, i);
3478: }
3479: result[i] = replacementChar;
3480: } else if (result != null)
3481: {
3482: result[i] = c;
3483: }
3484: }
3485: if (result == null)
3486: {
3487: return array;
3488: }
3489: return result;
3490: }
3491:
3492: /**
3493: * Return a new array which is the split of the given array using the given divider and triming each subarray to
3494: * remove whitespaces equals to ' '. <br>
3495: * <br>
3496: * For example:
3497: * <ol>
3498: * <li>
3499: *
3500: * <pre>
3501: * divider = 'b'
3502: * array = { 'a' , 'b', 'b', 'a', 'b', 'a' }
3503: * result => { { 'a' }, { }, { 'a' }, { 'a' } }
3504: * </pre>
3505: *
3506: * </li>
3507: * <li>
3508: *
3509: * <pre>
3510: * divider = 'c'
3511: * array = { 'a' , 'b', 'b', 'a', 'b', 'a' }
3512: * result => { { 'a', 'b', 'b', 'a', 'b', 'a' } }
3513: * </pre>
3514: *
3515: * </li>
3516: * <li>
3517: *
3518: * <pre>
3519: * divider = 'b'
3520: * array = { 'a' , ' ', 'b', 'b', 'a', 'b', 'a' }
3521: * result => { { 'a' }, { }, { 'a' }, { 'a' } }
3522: * </pre>
3523: *
3524: * </li>
3525: * <li>
3526: *
3527: * <pre>
3528: * divider = 'c'
3529: * array = { ' ', ' ', 'a' , 'b', 'b', 'a', 'b', 'a', ' ' }
3530: * result => { { 'a', 'b', 'b', 'a', 'b', 'a' } }
3531: * </pre>
3532: *
3533: * </li>
3534: * </ol>
3535: *
3536: * @param divider
3537: * the given divider
3538: * @param array
3539: * the given array
3540: * @return a new array which is the split of the given array using the given divider and triming each subarray to
3541: * remove whitespaces equals to ' '
3542: */
3543: public static final char[][] splitAndTrimOn(char divider, char[] array)
3544: {
3545: int length = array == null ? 0 : array.length;
3546: if (length == 0)
3547: {
3548: return NO_CHAR_CHAR;
3549: }
3550:
3551: int wordCount = 1;
3552: for (int i = 0; i < length; i++)
3553: {
3554: if (array[i] == divider)
3555: {
3556: wordCount++;
3557: }
3558: }
3559: char[][] split = new char[wordCount][];
3560: int last = 0, currentWord = 0;
3561: for (int i = 0; i < length; i++)
3562: {
3563: if (array[i] == divider)
3564: {
3565: int start = last, end = i - 1;
3566: while (start < i && array[start] == ' ')
3567: {
3568: start++;
3569: }
3570: while (end > start && array[end] == ' ')
3571: {
3572: end--;
3573: }
3574: split[currentWord] = new char[end - start + 1];
3575: System.arraycopy(array, start, split[currentWord++], 0, end
3576: - start + 1);
3577: last = i + 1;
3578: }
3579: }
3580: int start = last, end = length - 1;
3581: while (start < length && array[start] == ' ')
3582: {
3583: start++;
3584: }
3585: while (end > start && array[end] == ' ')
3586: {
3587: end--;
3588: }
3589: split[currentWord] = new char[end - start + 1];
3590: System.arraycopy(array, start, split[currentWord++], 0, end - start + 1);
3591: return split;
3592: }
3593:
3594: /**
3595: * Return a new array which is the split of the given array using the given divider. <br>
3596: * <br>
3597: * For example:
3598: * <ol>
3599: * <li>
3600: *
3601: * <pre>
3602: * divider = 'b'
3603: * array = { 'a' , 'b', 'b', 'a', 'b', 'a' }
3604: * result => { { 'a' }, { }, { 'a' }, { 'a' } }
3605: * </pre>
3606: *
3607: * </li>
3608: * <li>
3609: *
3610: * <pre>
3611: * divider = 'c'
3612: * array = { 'a' , 'b', 'b', 'a', 'b', 'a' }
3613: * result => { { 'a', 'b', 'b', 'a', 'b', 'a' } }
3614: * </pre>
3615: *
3616: * </li>
3617: * <li>
3618: *
3619: * <pre>
3620: * divider = 'c'
3621: * array = { ' ', ' ', 'a' , 'b', 'b', 'a', 'b', 'a', ' ' }
3622: * result => { { ' ', 'a', 'b', 'b', 'a', 'b', 'a', ' ' } }
3623: * </pre>
3624: *
3625: * </li>
3626: * </ol>
3627: *
3628: * @param divider
3629: * the given divider
3630: * @param array
3631: * the given array
3632: * @return a new array which is the split of the given array using the given divider
3633: */
3634: public static final char[][] splitOn(char divider, char[] array)
3635: {
3636: int length = array == null ? 0 : array.length;
3637: if (length == 0)
3638: {
3639: return NO_CHAR_CHAR;
3640: }
3641:
3642: int wordCount = 1;
3643: for (int i = 0; i < length; i++)
3644: {
3645: if (array[i] == divider)
3646: {
3647: wordCount++;
3648: }
3649: }
3650: char[][] split = new char[wordCount][];
3651: int last = 0, currentWord = 0;
3652: for (int i = 0; i < length; i++)
3653: {
3654: if (array[i] == divider)
3655: {
3656: split[currentWord] = new char[i - last];
3657: System.arraycopy(array, last, split[currentWord++], 0, i - last);
3658: last = i + 1;
3659: }
3660: }
3661: split[currentWord] = new char[length - last];
3662: System.arraycopy(array, last, split[currentWord], 0, length - last);
3663: return split;
3664: }
3665:
3666: /**
3667: * Return a new array which is the split of the given array using the given divider.
3668: *
3669: * @param divider
3670: * the given divider
3671: * @param array
3672: * the given array
3673: * @return a new array which is the split of the given array using the given divider or <code>null</code> if
3674: * {@code array} parameter is <code>null</code>.
3675: */
3676: public static final char[][] splitOn(char[] divider, char[] array)
3677: {
3678: if (array == null)
3679: {
3680: return null;
3681: }
3682: int length = array.length;
3683: if (length == 0)
3684: {
3685: return NO_CHAR_CHAR;
3686: }
3687:
3688: int wordCount = 1;
3689: {
3690: int i = 0;
3691: while (i + divider.length <= length)
3692: {
3693: i = indexOf(divider, array, false, i);
3694: if (i == -1)
3695: {
3696: break;
3697: }
3698: ++wordCount;
3699: i += divider.length;
3700: }
3701: }
3702: char[][] split = new char[wordCount][];
3703: int last = 0, currentWord = 0;
3704: int i = 0;
3705: while (i + divider.length <= length)
3706: {
3707: i = indexOf(divider, array, false, i);
3708: if (i == -1)
3709: {
3710: break;
3711: }
3712: split[currentWord] = new char[i - last];
3713: System.arraycopy(array, last, split[currentWord++], 0, i - last);
3714: i += divider.length;
3715: last = i;
3716: }
3717: split[currentWord] = new char[length - last];
3718: System.arraycopy(array, last, split[currentWord], 0, length - last);
3719: return split;
3720: }
3721:
3722: /**
3723: * Return a new array which is the split of the given array using the given divider. The given end is exclusive and
3724: * the given start is inclusive. <br>
3725: * <br>
3726: * For example:
3727: * <ol>
3728: * <li>
3729: *
3730: * <pre>
3731: * divider = 'b'
3732: * array = { 'a' , 'b', 'b', 'a', 'b', 'a' }
3733: * start = 2
3734: * end = 5
3735: * result => { { }, { 'a' }, { } }
3736: * </pre>
3737: *
3738: * </li>
3739: * </ol>
3740: *
3741: * @param divider
3742: * the given divider
3743: * @param array
3744: * the given array
3745: * @param start
3746: * the given starting index
3747: * @param end
3748: * the given ending index
3749: * @return a new array which is the split of the given array using the given divider
3750: * @throws ArrayIndexOutOfBoundsException
3751: * if start is lower than 0 or end is greater than the array length
3752: */
3753: public static final char[][] splitOn(char divider, char[] array, int start,
3754: int end)
3755: {
3756: int length = array == null ? 0 : array.length;
3757: if (length == 0 || start > end)
3758: {
3759: return NO_CHAR_CHAR;
3760: }
3761:
3762: int wordCount = 1;
3763: for (int i = start; i < end; i++)
3764: {
3765: if (array[i] == divider)
3766: {
3767: wordCount++;
3768: }
3769: }
3770: char[][] split = new char[wordCount][];
3771: int last = start, currentWord = 0;
3772: for (int i = start; i < end; i++)
3773: {
3774: if (array[i] == divider)
3775: {
3776: split[currentWord] = new char[i - last];
3777: System.arraycopy(array, last, split[currentWord++], 0, i - last);
3778: last = i + 1;
3779: }
3780: }
3781: split[currentWord] = new char[end - last];
3782: System.arraycopy(array, last, split[currentWord], 0, end - last);
3783: return split;
3784: }
3785:
3786: /**
3787: * Answers a new array which is a copy of the given array starting at the given start and ending at the given end.
3788: * The given start is inclusive and the given end is exclusive. Answers null if start is greater than end, if start
3789: * is lower than 0 or if end is greater than the length of the given array. If end equals -1, it is converted to the
3790: * array length. <br>
3791: * <br>
3792: * For example:
3793: * <ol>
3794: * <li>
3795: *
3796: * <pre>
3797: * array = { { 'a' } , { 'b' } }
3798: * start = 0
3799: * end = 1
3800: * result => { { 'a' } }
3801: * </pre>
3802: *
3803: * </li>
3804: * <li>
3805: *
3806: * <pre>
3807: * array = { { 'a' } , { 'b' } }
3808: * start = 0
3809: * end = -1
3810: * result => { { 'a' }, { 'b' } }
3811: * </pre>
3812: *
3813: * </li>
3814: * </ol>
3815: *
3816: * @param array
3817: * the given array
3818: * @param start
3819: * the given starting index
3820: * @param end
3821: * the given ending index
3822: * @return a new array which is a copy of the given array starting at the given start and ending at the given end
3823: * @throws NullPointerException
3824: * if the given array is null
3825: */
3826: public static final char[][] subarray(char[][] array, int start, int end)
3827: {
3828: if (end == -1)
3829: {
3830: end = array.length;
3831: }
3832: if (start > end)
3833: {
3834: return null;
3835: }
3836: if (start < 0)
3837: {
3838: return null;
3839: }
3840: if (end > array.length)
3841: {
3842: return null;
3843: }
3844:
3845: char[][] result = new char[end - start][];
3846: System.arraycopy(array, start, result, 0, end - start);
3847: return result;
3848: }
3849:
3850: /**
3851: * Answers a new array which is a copy of the given array starting at the given start and ending at the given end.
3852: * The given start is inclusive and the given end is exclusive. Answers null if start is greater than end, if start
3853: * is lower than 0 or if end is greater than the length of the given array. If end equals -1, it is converted to the
3854: * array length. <br>
3855: * <br>
3856: * For example:
3857: * <ol>
3858: * <li>
3859: *
3860: * <pre>
3861: * array = { 'a' , 'b' }
3862: * start = 0
3863: * end = 1
3864: * result => { 'a' }
3865: * </pre>
3866: *
3867: * </li>
3868: * <li>
3869: *
3870: * <pre>
3871: * array = { 'a', 'b' }
3872: * start = 0
3873: * end = -1
3874: * result => { 'a' , 'b' }
3875: * </pre>
3876: *
3877: * </li>
3878: * </ol>
3879: *
3880: * @param array
3881: * the given array
3882: * @param start
3883: * the given starting index
3884: * @param end
3885: * the given ending index
3886: * @return a new array which is a copy of the given array starting at the given start and ending at the given end
3887: * @throws NullPointerException
3888: * if the given array is null
3889: */
3890: public static final char[] subarray(char[] array, int start, int end)
3891: {
3892: if (end == -1)
3893: {
3894: end = array.length;
3895: }
3896: if (start > end)
3897: {
3898: return null;
3899: }
3900: if (start < 0)
3901: {
3902: return null;
3903: }
3904: if (end > array.length)
3905: {
3906: return null;
3907: }
3908:
3909: char[] result = new char[end - start];
3910: System.arraycopy(array, start, result, 0, end - start);
3911: return result;
3912: }
3913:
3914: /**
3915: * Answers the result of a char[] conversion to lowercase. Answers null if the given chars array is null. <br>
3916: * NOTE: If no conversion was necessary, then answers back the argument one. <br>
3917: * <br>
3918: * For example:
3919: * <ol>
3920: * <li>
3921: *
3922: * <pre>
3923: * chars = { 'a' , 'b' }
3924: * result => { 'a' , 'b' }
3925: * </pre>
3926: *
3927: * </li>
3928: * <li>
3929: *
3930: * <pre>
3931: * array = { 'A', 'b' }
3932: * result => { 'a' , 'b' }
3933: * </pre>
3934: *
3935: * </li>
3936: * </ol>
3937: *
3938: * @param chars
3939: * the chars to convert
3940: * @return the result of a char[] conversion to lowercase
3941: */
3942: final static public char[] toLowerCase(char[] chars)
3943: {
3944: if (chars == null)
3945: {
3946: return null;
3947: }
3948: int length = chars.length;
3949: char[] lowerChars = null;
3950: for (int i = 0; i < length; i++)
3951: {
3952: char c = chars[i];
3953: char lc = Character.toLowerCase(c);
3954: if (c != lc || lowerChars != null)
3955: {
3956: if (lowerChars == null)
3957: {
3958: System.arraycopy(chars, 0, lowerChars = new char[length], 0, i);
3959: }
3960: lowerChars[i] = lc;
3961: }
3962: }
3963: return lowerChars == null ? chars : lowerChars;
3964: }
3965:
3966: /**
3967: * Answers a new array removing leading and trailing spaces (' '). Answers the given array if there is no space
3968: * characters to remove. <br>
3969: * <br>
3970: * For example:
3971: * <ol>
3972: * <li>
3973: *
3974: * <pre>
3975: * chars = { ' ', 'a' , 'b', ' ', ' ' }
3976: * result => { 'a' , 'b' }
3977: * </pre>
3978: *
3979: * </li>
3980: * <li>
3981: *
3982: * <pre>
3983: * array = { 'A', 'b' }
3984: * result => { 'A' , 'b' }
3985: * </pre>
3986: *
3987: * </li>
3988: * </ol>
3989: *
3990: * @param chars
3991: * the given array
3992: * @return a new array removing leading and trailing spaces (' ')
3993: */
3994: final static public char[] trim(char[] chars)
3995: {
3996:
3997: if (chars == null)
3998: {
3999: return null;
4000: }
4001:
4002: int start = 0, length = chars.length, end = length - 1;
4003: while (start < length && chars[start] == ' ')
4004: {
4005: start++;
4006: }
4007: while (end > start && chars[end] == ' ')
4008: {
4009: end--;
4010: }
4011: if (start != 0 || end != length - 1)
4012: {
4013: return subarray(chars, start, end + 1);
4014: }
4015: return chars;
4016: }
4017:
4018: /**
4019: * Answers a string which is the concatenation of the given array using the '.' as a separator. <br>
4020: * <br>
4021: * For example:
4022: * <ol>
4023: * <li>
4024: *
4025: * <pre>
4026: * array = { { 'a' } , { 'b' } }
4027: * result => "a.b"
4028: * </pre>
4029: *
4030: * </li>
4031: * <li>
4032: *
4033: * <pre>
4034: * array = { { ' ', 'a' } , { 'b' } }
4035: * result => " a.b"
4036: * </pre>
4037: *
4038: * </li>
4039: * </ol>
4040: *
4041: * @param array
4042: * the given array
4043: * @return a string which is the concatenation of the given array using the '.' as a separator
4044: */
4045: final static public String toString(char[][] array)
4046: {
4047: char[] result = concatWith(array, '.');
4048: return new String(result);
4049: }
4050:
4051: /**
4052: * Answers an array of strings from the given array of char array.
4053: *
4054: * @param array
4055: * the given array
4056: * @return an array of strings
4057: */
4058: final static public String[] toStrings(char[][] array)
4059: {
4060: if (array == null)
4061: {
4062: return NO_STRINGS;
4063: }
4064: int length = array.length;
4065: if (length == 0)
4066: {
4067: return NO_STRINGS;
4068: }
4069: String[] result = new String[length];
4070: for (int i = 0; i < length; i++)
4071: {
4072: result[i] = new String(array[i]);
4073: }
4074: return result;
4075: }
4076:
4077: /**
4078: * @param name
4079: * @param separator
4080: * @return
4081: */
4082: public static String lastSegment(String name, char separator)
4083: {
4084: int pos = name.lastIndexOf(separator);
4085: if (pos >= 0)
4086: {
4087: return name.substring(pos + 1);
4088: } else
4089: {
4090: return name;
4091: }
4092: }
4093: }