KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > teamkonzept > lib > TKLib


1 package com.teamkonzept.lib;
2
3 import java.io.*;
4 import java.util.*;
5 import org.apache.log4j.Category;
6
7 /**
8  * @author $Author: alex $
9  * @version $Revision: 1.7 $
10 */

11 public class TKLib
12 {
13     private static final Category CAT = Category.getInstance(TKLib.class);
14
15     /**
16      * Constructor
17      */

18     public TKLib(){
19     }
20
21     /**
22      * slurpfile auf File-Handle
23      * Ein File (xx.tmpl) wird in einen String eingelesen
24      *
25      * @param File file, das einzulesende File
26      * @return das File als String
27      */

28     public static String JavaDoc slurpfile(File file){
29         try{
30              FileInputStream f = new FileInputStream( file);
31              DataInputStream d = new DataInputStream(f);
32
33
34              byte out[] = new byte[(int) file.length()];
35              d.readFully(out);
36              String JavaDoc txt = new String JavaDoc(out, 0);
37
38              d.close();
39              f.close();
40
41              return(txt);
42
43         }
44         catch(IOException e)
45         {
46             CAT.error("slurpFile: " + e.getMessage() + " in " + file.getAbsolutePath(), e);
47             // e.printStackTrace(System.out);
48
return("0");
49         }
50
51     }
52
53
54     /**
55      * slurpfile auf File-Handle
56      * Ein Filename (/../xx.tmpl) wird als String uebergeben
57      * @param File file, das einzulesende File
58      * @return das File als String
59      */

60     public static String JavaDoc slurpfile(String JavaDoc filename){
61         File file = new File( filename );
62         return slurpfile( file );
63     }
64
65
66     /**
67      * spitfile auf File-Handle
68      * Ein File (xx.tmpl) wird aus einen String erzeugt
69      *
70      * @param File file, das zu erzeugende File
71      * @param String data, die zu schreibenden Daten
72      */

73     public static void spitfile(File file, String JavaDoc data){
74         try
75         {
76              FileOutputStream f = new FileOutputStream( file);
77              DataOutputStream d = new DataOutputStream(f);
78
79              d.writeBytes(data);
80              d.close();
81              f.close();
82         }
83         catch(IOException e)
84         {
85             CAT.error("spitfile", e);
86         }
87
88     }
89
90
91     /**
92      * spitfile auf File-Handle
93      * Ein Filename (/../xx.tmpl) wird als String uebergeben
94      * @param String filename, das zu erzeugende File
95      * @param String data, die zu schreibenden Daten
96      */

97     public static void spitfile(String JavaDoc filename, String JavaDoc data){
98         File file = new File( filename );
99         spitfile( file, data );
100     }
101
102     /**
103      * Ein Array soll sortiert werden
104      *
105      * @param Object[] array, welches die zu sortierenden Objekte enthaelt
106      */

107     public static final void qsort( Object JavaDoc[] array )
108     {
109         if( array.length > 1 ) doSort( array, 0, array.length-1 );
110     }
111
112     /**
113      * Ein Array soll sortiert werden
114      *
115      * @param Object[] array, welches die zu sortierenden Objekte enthaelt
116      * @param int l
117      * @param int r
118      */

119     private static final void doSort( Object JavaDoc[] array, int l, int r )
120     {
121         int i = l;
122         int j = r;
123         Object JavaDoc x = array[ (l+r) / 2 ];
124         boolean isSortable = x instanceof TKSortable;
125         if( isSortable ) {
126             TKSortable sx = (TKSortable) x;
127             String JavaDoc xs = x.toString();
128             do {
129                 while( x != array[i] && ( array[i] instanceof TKSortable
130                      ? ( ((TKSortable)array[i]).cmp( sx ) < 0 )
131                      : ( array[i].toString().compareTo( xs ) < 0 )
132                 ) ) {
133                     i++;
134                 }
135                 while( x != array[j] && ( array[j] instanceof TKSortable
136                      ? ( sx.cmp( ((TKSortable)array[j]) ) < 0 )
137                      : ( xs.compareTo( array[j].toString() ) < 0 )
138                 ) ) {
139                     j--;
140                 }
141                 if( i <= j ) {
142                     Object JavaDoc w = array[i];
143                     array[i] = array[j];
144                     array[j] = w;
145                     i++;
146                     j--;
147                 }
148             } while( i <= j );
149         }
150         else {
151             String JavaDoc xs = x.toString();
152             do {
153                 while( x != array[i] && array[i].toString().compareTo( xs ) < 0 ) i++;
154                 while( x != array[j] && xs.compareTo( array[j].toString() ) < 0 ) j--;
155                 if( i<= j ) {
156                     Object JavaDoc w = array[i];
157                     array[i] = array[j];
158                     array[j] = w;
159                     i++;
160                     j--;
161                 }
162             } while( i <= j );
163         }
164         if( l < j ) doSort( array, l, j );
165         if( i < r ) doSort( array, i, r );
166     }
167
168
169     /**
170      * Ein Array soll rueckwaerts sortiert werden
171      *
172      * @param Object[] array, welches die zu sortierenden Objekte enthaelt
173      */

174     public static final void qrsort( Object JavaDoc[] array )
175     {
176         if( array.length > 1 ) doReverseSort( array, 0, array.length-1 );
177     }
178
179     /**
180      * Ein Array soll rueckwaerts sortiert werden
181      *
182      * @param Object[] array, welches die zu sortierenden Objekte enthaelt
183      * @param int l
184      * @param int r
185      */

186     private static final void doReverseSort( Object JavaDoc[] array, int l, int r )
187     {
188         int i = l;
189         int j = r;
190         Object JavaDoc x = array[ (l+r) / 2 ];
191         boolean isSortable = x instanceof TKSortable;
192         if( isSortable ) {
193             TKSortable sx = (TKSortable) x;
194             String JavaDoc xs = x.toString();
195             do {
196                 while( x != array[i] && ( array[i] instanceof TKSortable
197                      ? ( ((TKSortable)array[i]).cmp( sx ) > 0 )
198                      : ( array[i].toString().compareTo( xs ) > 0 )
199                 ) ) {
200                     i++;
201                 }
202                 while( x != array[j] && ( array[j] instanceof TKSortable
203                      ? ( sx.cmp( ((TKSortable)array[j]) ) > 0 )
204                      : ( xs.compareTo( array[j].toString() ) > 0 )
205                 ) ) {
206                     j--;
207                 }
208                 if( i <= j ) {
209                     Object JavaDoc w = array[i];
210                     array[i] = array[j];
211                     array[j] = w;
212                     i++;
213                     j--;
214                 }
215             } while( i <= j );
216         }
217         else {
218             String JavaDoc xs = x.toString();
219             do {
220                 while( x != array[i] && array[i].toString().compareTo( xs ) > 0 ) i++;
221                 while( x != array[j] && xs.compareTo( array[j].toString() ) > 0 ) j--;
222                 if( i<= j ) {
223                     Object JavaDoc w = array[i];
224                     array[i] = array[j];
225                     array[j] = w;
226                     i++;
227                     j--;
228                 }
229             } while( i <= j );
230         }
231         if( l < j ) doReverseSort( array, l, j );
232         if( i < r ) doReverseSort( array, i, r );
233     }
234
235     /**
236      * Haengst den char rechts an den String an
237      *
238      * @param String src, der zu ereweiternde String
239      * @param int len, korrekte Laenge des Strings
240      * @param int char c, der anzuhaengende Buchstabe
241      */

242     public static String JavaDoc fillUp( String JavaDoc src, int len, char c )
243     {
244         return fillUp( src, len, c, false );
245     }
246
247     /**
248      * FillLeft true: haengst den char links an den String an
249      * FillLeft false: haengst den char rechts an den String an
250      *
251      * @param String src, der zu erweiternde String
252      * @param int len, korrekte Laenge des Strings
253      * @param int char c, der anzuhaengende Buchstabe
254      * @param boolean fillLeft
255      *
256      * @return den neuen String
257      */

258     public static String JavaDoc fillUp( String JavaDoc val, int len, char c, boolean fillLeft )
259     {
260         int missing = len - val.length();
261         if( missing <= 0 ) return val;
262         StringBuffer JavaDoc newVal = new StringBuffer JavaDoc( val );
263         while( missing > 0 ) {
264             if( fillLeft ) {
265                 newVal.insert( 0, c );
266             }
267             else {
268                 newVal.append( c );
269             }
270             missing--;
271         }
272         return newVal.toString();
273     }
274
275     /**
276      * Eine "0" wird an den Anfang des Strings gehaengt
277      *
278      * @param String src, der zu ereweiternde String
279      * @param int len, korrekte Laenge des Strings
280      */

281     public static String JavaDoc fillInt( String JavaDoc src, int len )
282     {
283         return fillUp( src, len, '0', true );
284     }
285
286     /**
287      * Ein leeres Zeichen wird angehaengt
288      *
289      * @param String src, der zu ereweiternde String
290      * @param int len, korrekte Laenge des Strings
291      */

292     public static String JavaDoc fillString( String JavaDoc src, int len )
293     {
294         return fillUp( src, len, ' ', false );
295     }
296
297     // ------------- listConcat 2 Listen
298
/**
299      *
300      */

301     public static String JavaDoc[] listConcat( String JavaDoc list1[], String JavaDoc list2[]){
302
303         if (list1 == null){
304             return(list2);
305         }
306         if (list2 == null){
307             return(list1);
308         }
309
310         String JavaDoc resultList[] = new String JavaDoc[list1.length + list2.length];
311         int i;
312         for(i=0;i<list1.length;i++){
313             resultList[i] = list1[i];
314         }
315         for(i=0;i<list2.length;i++){
316             resultList[list1.length +i] = list2[i];
317         }
318         return(resultList);
319     }
320
321     // ------------- listConcat 1 Liste ein Object
322
/**
323      *
324      */

325     public static String JavaDoc[] listConcat( String JavaDoc list1[], String JavaDoc list2){
326
327         if (list1 == null){
328             String JavaDoc rList[] = new String JavaDoc[1];
329             rList[0] = list2;
330             return(rList);
331         }
332
333
334         String JavaDoc resultList[] = new String JavaDoc[list1.length + 1];
335         int i;
336         for(i=0;i<list1.length;i++){
337             resultList[i] = list1[i];
338         }
339         resultList[list1.length] = list2;
340
341         return(resultList);
342     }
343
344
345     // ------------- listConcat ein Object eine Liste
346
/**
347      *
348      */

349     public static String JavaDoc[] listConcat( String JavaDoc list1, String JavaDoc list2[]){
350
351         if (list2 == null){
352             String JavaDoc rList[] = new String JavaDoc[1];
353             rList[0] = list1;
354             return(rList);
355         }
356
357
358
359         String JavaDoc resultList[] = new String JavaDoc[list2.length + 1];
360         int i;
361
362         resultList[0] = list1;
363         for(i=1;i<=list2.length;i++){
364             resultList[i] = list2[i];
365         }
366         return(resultList);
367     }
368
369     // ------------- listConcat zwei Objecte
370
/**
371      *
372      */

373     public static String JavaDoc[] listConcat( String JavaDoc list1, String JavaDoc list2){
374
375         String JavaDoc resultList[] = new String JavaDoc[2];
376         resultList[0] = list1;
377         resultList[1] = list2;
378
379         return(resultList);
380     }
381
382
383
384     // ------------- hashConcat
385
/*******************************************************
386     /**
387      *
388      */

389     public static Hashtable hashConcat( Hashtable hash1 , Hashtable hash2){
390
391         if (hash1 == null){
392             return (hash2);
393         }
394         if (hash2 == null){
395             return (hash1);
396         }
397
398         Enumeration keys = hash2.keys();
399         Enumeration vals = hash2.elements();
400
401         while(keys.hasMoreElements()){
402             Object JavaDoc val, key;
403
404             val = vals.nextElement();
405             key = keys.nextElement();
406
407             if (val instanceof Hashtable){
408                 if (hash1.get(key) instanceof Hashtable){
409                     hash1.put(key, hashConcat(((Hashtable)hash1.get(key)), (Hashtable) val));
410                 }else{
411                     hash1.put(key, val);
412                 }
413             }else{
414                 if (val instanceof String JavaDoc[]){
415                     if (hash1.get(key) instanceof String JavaDoc[]){
416                         hash1.put(key, listConcat(((String JavaDoc[]) hash1.get(key)), (String JavaDoc[]) val));
417                     }else{
418                         if (hash1.get(key) instanceof String JavaDoc){
419                             hash1.put(key, listConcat(((String JavaDoc) hash1.get(key)), (String JavaDoc[]) val));
420                         }else{
421                             hash1.put(key, val);
422                         }
423                     }
424                 }else{
425                     if (hash1.get(key) instanceof String JavaDoc[]){
426                         hash1.put(key, listConcat(((String JavaDoc[]) hash1.get(key)), (String JavaDoc) val));
427                     }else{
428                         if (hash1.get(key) instanceof String JavaDoc){
429                             hash1.put(key, listConcat(((String JavaDoc) hash1.get(key)), (String JavaDoc) val));
430                         }else{
431                             hash1.put(key, val);
432                         }
433                     }
434                 }
435             }
436         }
437
438         return(hash1);
439     }
440
441     /**
442      *
443      */

444     public static void printHash( Hashtable hash)
445     {
446         Enumeration keys = hash.keys();
447         Enumeration vals = hash.elements();
448
449         Object JavaDoc val;
450
451         while(keys.hasMoreElements()){
452             val = vals.nextElement();
453             if (val instanceof String JavaDoc[]){
454                 int i;
455                 CAT.debug(keys.nextElement()+ "= List:");
456                 for(i=0;i<((String JavaDoc[]) val).length;i++){
457                     CAT.debug(((String JavaDoc[]) val)[i]+",");
458                 }
459             }else{
460                 CAT.debug(keys.nextElement() + "=" + val);
461             }
462         }
463
464     }
465
466
467     // ------------- split
468
public static String JavaDoc[] split (String JavaDoc txt, String JavaDoc seperator){
469
470         StringTokenizer st = new StringTokenizer(txt, seperator);
471         int number = st.countTokens();
472         String JavaDoc[] list = new String JavaDoc[number];
473         int i;
474
475         try {
476             for(i=0;i<number;i++){
477                 list[i]= st.nextToken();
478             }
479         }catch (Exception JavaDoc e){
480             CAT.error("checkKeys: Wrong number of Tokens in String", e);
481         }
482
483         return(list);
484     }
485
486     public static String JavaDoc getPackageName (Object JavaDoc obj) {
487
488         String JavaDoc pathName = obj.getClass().getName();
489         int i = pathName.lastIndexOf(".");
490         return i < 0 ? null : pathName.substring (0,i);
491     }
492
493     /**
494     * new for the identification of querys using a class object
495     * alex
496     */

497     public static String JavaDoc getPackageName (Class JavaDoc cl) {
498
499         String JavaDoc pathName = cl.getName();
500         int i = pathName.lastIndexOf(".");
501         return i < 0 ? null : pathName.substring (0,i);
502     }
503
504     public static String JavaDoc getClassName (Object JavaDoc obj) {
505
506         String JavaDoc pathName = obj.getClass().getName();
507         int i = pathName.lastIndexOf(".");
508         return i < 0 ? null : pathName.substring (i+1);
509     }
510
511     /**
512     * new for the identification of querys using a class object
513     * alex
514     */

515     public static String JavaDoc getClassName (Class JavaDoc cl) {
516
517         String JavaDoc pathName = cl.getName();
518         int i = pathName.lastIndexOf(".");
519         return i < 0 ? null : pathName.substring (i+1);
520     }
521 }
522
Popular Tags