001: package com.teamkonzept.lib;
002:
003: import java.io.*;
004: import java.util.*;
005: import org.apache.log4j.Category;
006:
007: /**
008: * @author $Author: alex $
009: * @version $Revision: 1.7 $
010: */
011: public class TKLib {
012: private static final Category CAT = Category
013: .getInstance(TKLib.class);
014:
015: /**
016: * Constructor
017: */
018: public TKLib() {
019: }
020:
021: /**
022: * slurpfile auf File-Handle
023: * Ein File (xx.tmpl) wird in einen String eingelesen
024: *
025: * @param File file, das einzulesende File
026: * @return das File als String
027: */
028: public static String slurpfile(File file) {
029: try {
030: FileInputStream f = new FileInputStream(file);
031: DataInputStream d = new DataInputStream(f);
032:
033: byte out[] = new byte[(int) file.length()];
034: d.readFully(out);
035: String txt = new String(out, 0);
036:
037: d.close();
038: f.close();
039:
040: return (txt);
041:
042: } catch (IOException e) {
043: CAT.error("slurpFile: " + e.getMessage() + " in "
044: + file.getAbsolutePath(), e);
045: // e.printStackTrace(System.out);
046: return ("0");
047: }
048:
049: }
050:
051: /**
052: * slurpfile auf File-Handle
053: * Ein Filename (/../xx.tmpl) wird als String uebergeben
054: * @param File file, das einzulesende File
055: * @return das File als String
056: */
057: public static String slurpfile(String filename) {
058: File file = new File(filename);
059: return slurpfile(file);
060: }
061:
062: /**
063: * spitfile auf File-Handle
064: * Ein File (xx.tmpl) wird aus einen String erzeugt
065: *
066: * @param File file, das zu erzeugende File
067: * @param String data, die zu schreibenden Daten
068: */
069: public static void spitfile(File file, String data) {
070: try {
071: FileOutputStream f = new FileOutputStream(file);
072: DataOutputStream d = new DataOutputStream(f);
073:
074: d.writeBytes(data);
075: d.close();
076: f.close();
077: } catch (IOException e) {
078: CAT.error("spitfile", e);
079: }
080:
081: }
082:
083: /**
084: * spitfile auf File-Handle
085: * Ein Filename (/../xx.tmpl) wird als String uebergeben
086: * @param String filename, das zu erzeugende File
087: * @param String data, die zu schreibenden Daten
088: */
089: public static void spitfile(String filename, String data) {
090: File file = new File(filename);
091: spitfile(file, data);
092: }
093:
094: /**
095: * Ein Array soll sortiert werden
096: *
097: * @param Object[] array, welches die zu sortierenden Objekte enthaelt
098: */
099: public static final void qsort(Object[] array) {
100: if (array.length > 1)
101: doSort(array, 0, array.length - 1);
102: }
103:
104: /**
105: * Ein Array soll sortiert werden
106: *
107: * @param Object[] array, welches die zu sortierenden Objekte enthaelt
108: * @param int l
109: * @param int r
110: */
111: private static final void doSort(Object[] array, int l, int r) {
112: int i = l;
113: int j = r;
114: Object x = array[(l + r) / 2];
115: boolean isSortable = x instanceof TKSortable;
116: if (isSortable) {
117: TKSortable sx = (TKSortable) x;
118: String xs = x.toString();
119: do {
120: while (x != array[i]
121: && (array[i] instanceof TKSortable ? (((TKSortable) array[i])
122: .cmp(sx) < 0)
123: : (array[i].toString().compareTo(xs) < 0))) {
124: i++;
125: }
126: while (x != array[j]
127: && (array[j] instanceof TKSortable ? (sx
128: .cmp(((TKSortable) array[j])) < 0)
129: : (xs.compareTo(array[j].toString()) < 0))) {
130: j--;
131: }
132: if (i <= j) {
133: Object w = array[i];
134: array[i] = array[j];
135: array[j] = w;
136: i++;
137: j--;
138: }
139: } while (i <= j);
140: } else {
141: String xs = x.toString();
142: do {
143: while (x != array[i]
144: && array[i].toString().compareTo(xs) < 0)
145: i++;
146: while (x != array[j]
147: && xs.compareTo(array[j].toString()) < 0)
148: j--;
149: if (i <= j) {
150: Object w = array[i];
151: array[i] = array[j];
152: array[j] = w;
153: i++;
154: j--;
155: }
156: } while (i <= j);
157: }
158: if (l < j)
159: doSort(array, l, j);
160: if (i < r)
161: doSort(array, i, r);
162: }
163:
164: /**
165: * Ein Array soll rueckwaerts sortiert werden
166: *
167: * @param Object[] array, welches die zu sortierenden Objekte enthaelt
168: */
169: public static final void qrsort(Object[] array) {
170: if (array.length > 1)
171: doReverseSort(array, 0, array.length - 1);
172: }
173:
174: /**
175: * Ein Array soll rueckwaerts sortiert werden
176: *
177: * @param Object[] array, welches die zu sortierenden Objekte enthaelt
178: * @param int l
179: * @param int r
180: */
181: private static final void doReverseSort(Object[] array, int l, int r) {
182: int i = l;
183: int j = r;
184: Object x = array[(l + r) / 2];
185: boolean isSortable = x instanceof TKSortable;
186: if (isSortable) {
187: TKSortable sx = (TKSortable) x;
188: String xs = x.toString();
189: do {
190: while (x != array[i]
191: && (array[i] instanceof TKSortable ? (((TKSortable) array[i])
192: .cmp(sx) > 0)
193: : (array[i].toString().compareTo(xs) > 0))) {
194: i++;
195: }
196: while (x != array[j]
197: && (array[j] instanceof TKSortable ? (sx
198: .cmp(((TKSortable) array[j])) > 0)
199: : (xs.compareTo(array[j].toString()) > 0))) {
200: j--;
201: }
202: if (i <= j) {
203: Object w = array[i];
204: array[i] = array[j];
205: array[j] = w;
206: i++;
207: j--;
208: }
209: } while (i <= j);
210: } else {
211: String xs = x.toString();
212: do {
213: while (x != array[i]
214: && array[i].toString().compareTo(xs) > 0)
215: i++;
216: while (x != array[j]
217: && xs.compareTo(array[j].toString()) > 0)
218: j--;
219: if (i <= j) {
220: Object w = array[i];
221: array[i] = array[j];
222: array[j] = w;
223: i++;
224: j--;
225: }
226: } while (i <= j);
227: }
228: if (l < j)
229: doReverseSort(array, l, j);
230: if (i < r)
231: doReverseSort(array, i, r);
232: }
233:
234: /**
235: * Haengst den char rechts an den String an
236: *
237: * @param String src, der zu ereweiternde String
238: * @param int len, korrekte Laenge des Strings
239: * @param int char c, der anzuhaengende Buchstabe
240: */
241: public static String fillUp(String src, int len, char c) {
242: return fillUp(src, len, c, false);
243: }
244:
245: /**
246: * FillLeft true: haengst den char links an den String an
247: * FillLeft false: haengst den char rechts an den String an
248: *
249: * @param String src, der zu erweiternde String
250: * @param int len, korrekte Laenge des Strings
251: * @param int char c, der anzuhaengende Buchstabe
252: * @param boolean fillLeft
253: *
254: * @return den neuen String
255: */
256: public static String fillUp(String val, int len, char c,
257: boolean fillLeft) {
258: int missing = len - val.length();
259: if (missing <= 0)
260: return val;
261: StringBuffer newVal = new StringBuffer(val);
262: while (missing > 0) {
263: if (fillLeft) {
264: newVal.insert(0, c);
265: } else {
266: newVal.append(c);
267: }
268: missing--;
269: }
270: return newVal.toString();
271: }
272:
273: /**
274: * Eine "0" wird an den Anfang des Strings gehaengt
275: *
276: * @param String src, der zu ereweiternde String
277: * @param int len, korrekte Laenge des Strings
278: */
279: public static String fillInt(String src, int len) {
280: return fillUp(src, len, '0', true);
281: }
282:
283: /**
284: * Ein leeres Zeichen wird angehaengt
285: *
286: * @param String src, der zu ereweiternde String
287: * @param int len, korrekte Laenge des Strings
288: */
289: public static String fillString(String src, int len) {
290: return fillUp(src, len, ' ', false);
291: }
292:
293: // ------------- listConcat 2 Listen
294: /**
295: *
296: */
297: public static String[] listConcat(String list1[], String list2[]) {
298:
299: if (list1 == null) {
300: return (list2);
301: }
302: if (list2 == null) {
303: return (list1);
304: }
305:
306: String resultList[] = new String[list1.length + list2.length];
307: int i;
308: for (i = 0; i < list1.length; i++) {
309: resultList[i] = list1[i];
310: }
311: for (i = 0; i < list2.length; i++) {
312: resultList[list1.length + i] = list2[i];
313: }
314: return (resultList);
315: }
316:
317: // ------------- listConcat 1 Liste ein Object
318: /**
319: *
320: */
321: public static String[] listConcat(String list1[], String list2) {
322:
323: if (list1 == null) {
324: String rList[] = new String[1];
325: rList[0] = list2;
326: return (rList);
327: }
328:
329: String resultList[] = new String[list1.length + 1];
330: int i;
331: for (i = 0; i < list1.length; i++) {
332: resultList[i] = list1[i];
333: }
334: resultList[list1.length] = list2;
335:
336: return (resultList);
337: }
338:
339: // ------------- listConcat ein Object eine Liste
340: /**
341: *
342: */
343: public static String[] listConcat(String list1, String list2[]) {
344:
345: if (list2 == null) {
346: String rList[] = new String[1];
347: rList[0] = list1;
348: return (rList);
349: }
350:
351: String resultList[] = new String[list2.length + 1];
352: int i;
353:
354: resultList[0] = list1;
355: for (i = 1; i <= list2.length; i++) {
356: resultList[i] = list2[i];
357: }
358: return (resultList);
359: }
360:
361: // ------------- listConcat zwei Objecte
362: /**
363: *
364: */
365: public static String[] listConcat(String list1, String list2) {
366:
367: String resultList[] = new String[2];
368: resultList[0] = list1;
369: resultList[1] = list2;
370:
371: return (resultList);
372: }
373:
374: // ------------- hashConcat
375: /*******************************************************
376: /**
377: *
378: */
379: public static Hashtable hashConcat(Hashtable hash1, Hashtable hash2) {
380:
381: if (hash1 == null) {
382: return (hash2);
383: }
384: if (hash2 == null) {
385: return (hash1);
386: }
387:
388: Enumeration keys = hash2.keys();
389: Enumeration vals = hash2.elements();
390:
391: while (keys.hasMoreElements()) {
392: Object val, key;
393:
394: val = vals.nextElement();
395: key = keys.nextElement();
396:
397: if (val instanceof Hashtable) {
398: if (hash1.get(key) instanceof Hashtable) {
399: hash1.put(key, hashConcat(((Hashtable) hash1
400: .get(key)), (Hashtable) val));
401: } else {
402: hash1.put(key, val);
403: }
404: } else {
405: if (val instanceof String[]) {
406: if (hash1.get(key) instanceof String[]) {
407: hash1.put(key, listConcat(((String[]) hash1
408: .get(key)), (String[]) val));
409: } else {
410: if (hash1.get(key) instanceof String) {
411: hash1.put(key, listConcat(((String) hash1
412: .get(key)), (String[]) val));
413: } else {
414: hash1.put(key, val);
415: }
416: }
417: } else {
418: if (hash1.get(key) instanceof String[]) {
419: hash1.put(key, listConcat(((String[]) hash1
420: .get(key)), (String) val));
421: } else {
422: if (hash1.get(key) instanceof String) {
423: hash1.put(key, listConcat(((String) hash1
424: .get(key)), (String) val));
425: } else {
426: hash1.put(key, val);
427: }
428: }
429: }
430: }
431: }
432:
433: return (hash1);
434: }
435:
436: /**
437: *
438: */
439: public static void printHash(Hashtable hash) {
440: Enumeration keys = hash.keys();
441: Enumeration vals = hash.elements();
442:
443: Object val;
444:
445: while (keys.hasMoreElements()) {
446: val = vals.nextElement();
447: if (val instanceof String[]) {
448: int i;
449: CAT.debug(keys.nextElement() + "= List:");
450: for (i = 0; i < ((String[]) val).length; i++) {
451: CAT.debug(((String[]) val)[i] + ",");
452: }
453: } else {
454: CAT.debug(keys.nextElement() + "=" + val);
455: }
456: }
457:
458: }
459:
460: // ------------- split
461: public static String[] split(String txt, String seperator) {
462:
463: StringTokenizer st = new StringTokenizer(txt, seperator);
464: int number = st.countTokens();
465: String[] list = new String[number];
466: int i;
467:
468: try {
469: for (i = 0; i < number; i++) {
470: list[i] = st.nextToken();
471: }
472: } catch (Exception e) {
473: CAT.error("checkKeys: Wrong number of Tokens in String", e);
474: }
475:
476: return (list);
477: }
478:
479: public static String getPackageName(Object obj) {
480:
481: String pathName = obj.getClass().getName();
482: int i = pathName.lastIndexOf(".");
483: return i < 0 ? null : pathName.substring(0, i);
484: }
485:
486: /**
487: * new for the identification of querys using a class object
488: * alex
489: */
490: public static String getPackageName(Class cl) {
491:
492: String pathName = cl.getName();
493: int i = pathName.lastIndexOf(".");
494: return i < 0 ? null : pathName.substring(0, i);
495: }
496:
497: public static String getClassName(Object obj) {
498:
499: String pathName = obj.getClass().getName();
500: int i = pathName.lastIndexOf(".");
501: return i < 0 ? null : pathName.substring(i + 1);
502: }
503:
504: /**
505: * new for the identification of querys using a class object
506: * alex
507: */
508: public static String getClassName(Class cl) {
509:
510: String pathName = cl.getName();
511: int i = pathName.lastIndexOf(".");
512: return i < 0 ? null : pathName.substring(i + 1);
513: }
514: }
|