KickJava   Java API By Example, From Geeks To Geeks.

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


1 /*
2  * $Header: /cvsroot/webman-cms/source/webman/com/teamkonzept/lib/TKHashtable.java,v 1.5 2000/05/22 15:01:19 careck Exp $
3  *
4  */
5 package com.teamkonzept.lib;
6
7 import java.util.*;
8
9 /**
10     Erweitert Hashtable um Methode zur Bearbeitung verschachtelter Hashtables
11 */
12
13 public class TKHashtable extends Hashtable {
14
15     /**
16     Erzeugt leere Hashtable.
17     */
18     public TKHashtable()
19     {
20     }
21     
22     /**
23     Erzeugt leere Hashtable.
24     */
25     public TKHashtable( int initialCapacity )
26     {
27         super( initialCapacity );
28     }
29
30     /**
31     Erzeugt vorgefüllte Hashtable.
32     @param ein key-value Paar
33     */
34     public TKHashtable(Object JavaDoc key, Object JavaDoc val )
35     {
36         put( key, val );
37     }
38
39     /**
40     Erzeugt vorgefüllte Hashtable.
41     @param init Array von key,value-Paaren
42     */
43     public TKHashtable( Object JavaDoc init[][] )
44     {
45         super( init.length );
46         for( int n=0; n<init.length; n++ ) {
47             put( init[n][0], init[n][1] );
48         }
49     }
50     
51     /**
52     &Uuml;berpr&uuml;ft, ob es in einem verschachtelten Hash einen bestimmten Eintrag gibt.
53     @param keyList Liste von Hashkeys, &uuml;ber die die Verschachtelung durchlaufen wird.
54     */
55     public boolean containsKey( Object JavaDoc keyList[] )
56     {
57         return get( keyList ) != null;
58     }
59
60     /**
61     Liefert einen Eintrag aus einem verschachtelten Hash.
62     @param keyList Liste von Hashkeys, &uuml;ber die die Verschachtelung durchlaufen wird.
63     @return Wert, bzw. null falls kein entsprechender Eintrag existiert.
64     */
65     public Object JavaDoc get( Object JavaDoc keyList[] )
66     {
67         Object JavaDoc curr = this;
68         for( int i=0; i<keyList.length; i++ ){
69             if( curr instanceof Hashtable && ((Hashtable)curr).containsKey( keyList[i] ) ){
70                 curr = ((Hashtable)curr).get( keyList[i] );
71             }
72             else{
73                 return null;
74             }
75         }
76         return curr;
77     }
78
79     /**
80     Setzt einen Eintrag in einem verschachtelten Hash.
81     @param keyList Liste von Hashkeys, &uuml;ber die die Verschachtelung durchlaufen wird.
82     @param val zu setzender Wert
83     @return der durch put &uuml;berschriebene Wert, bzw. null falls Eintrag noch nicht existiert hat.
84     */
85     public Object JavaDoc put( Object JavaDoc keyList[], Object JavaDoc val )
86     {
87         Object JavaDoc curr = this;
88         int toScan = keyList.length-1;
89         for( int i=0; i<toScan; i++){
90             Object JavaDoc key = keyList[i];
91             Object JavaDoc next = ((Hashtable)curr).get( key );
92             if( (next == null) || ! (next instanceof Hashtable) ) {
93                 next = new TKHashtable();
94                 ((Hashtable)curr).put( key, next );
95             }
96             curr = next;
97         }
98         return ((Hashtable)curr).put( keyList[toScan], val );
99     }
100     
101     /**
102     Erweitert den Hash um ein (key,value)-Paar. Das Erweitern geschieht
103     nach folgenden Regeln:
104     <UL>
105     <LI> Kommt der key noch nicht im Hash vor, wird das neue (Key,Value)-Paar eingetragen
106     <LI> Bei in beiden Objekten vorkommenden Keys werden deren Values miteinander verbunden.
107     Dabei gelten folgende Regeln:
108         <UL>
109         <LI>Ist einer der beiden Werte ein TKNull-Objekt so wird er ignoriert.
110         <LI>Sind beide Values Hashtables werden sie durch concat verbunden
111         <LI>Andernfalls wird eine Liste mit den beiden Values erzeugt. Bereits bestehende
112         Listenvalues werden aufgel&ouml;st und nur deren Elemente in die neue Liste
113         &uuml;bernommen.
114         </UL>
115     </UL>
116     */
117     public void extend( Object JavaDoc key, Object JavaDoc val )
118     {
119         Object JavaDoc oldVal = get( key );
120         
121         if( oldVal == null || oldVal instanceof TKNull ) {
122             put( key, val );
123         }
124         else if( !(val instanceof TKNull) ) {
125             if( (val instanceof Hashtable) && (oldVal instanceof TKHashtable) ) {
126                 ((TKHashtable)oldVal).concat( (Hashtable) val );
127             }
128             else if( oldVal instanceof TKVector ) {
129                 ((TKVector)oldVal).concat( val );
130             }
131             else if( val instanceof TKVector ) {
132                 TKVector newVal = (TKVector) ((TKVector)val).clone();
133                 newVal.insertElementAt( oldVal, 0 );
134                 put( key, newVal );
135             }
136             else {
137                 Object JavaDoc[] newValDef = { oldVal, val };
138                 if( oldVal != val &&
139                     ( oldVal.getClass() != val.getClass() ||
140                       !oldVal.equals(val) )
141                 ) {
142                     put( key, new TKVector( newValDef ) );
143                 }
144             }
145         }
146     }
147     
148     /**
149     F&uuml;gt alle Elemente einer anderen Hashtable per extend-Aufrufe dem Objekt hinzu.
150     @param hash hinzuzuf&uuml;gende Hashtable.
151     */
152     public void concat( Hashtable hash )
153     {
154         
155         Enumeration keys = hash.keys();
156         
157         while( keys.hasMoreElements() ) {
158             Object JavaDoc key = keys.nextElement();
159             extend( key, hash.get( key ) );
160         }
161     }
162     
163     /**
164     F&uuml;gt alle Elemente einer anderen Hashtable hinzu, falls der entsprechende
165     key noch nicht in der Hashtable enthalten ist.
166     @param hash hinzuzuf&uuml;gende Hashtable.
167     */
168     public void merge( Hashtable hash )
169     {
170         
171         Enumeration keys = hash.keys();
172         
173         while( keys.hasMoreElements() ) {
174             Object JavaDoc key = keys.nextElement();
175             if( !containsKey( key ) ) {
176                 put( key, hash.get( key ) );
177             }
178         }
179     }
180     
181     /**
182     Erzeugt einen String, der den Hash in perl-Notation enthält
183     */
184     
185     public String JavaDoc toPerlString()
186     {
187         return toPerlString(0, true);
188     }
189     
190     /**
191     Erzeugt einen String, der den Hash in perl-Notation enthält
192     */
193     
194     public String JavaDoc toPerlString(int indentCount, boolean withNewline)
195     {
196         String JavaDoc result = "";
197         String JavaDoc indent = "";
198         if( withNewline ) {
199             for( int i=0; i<=indentCount; i++ ) indent += " ";
200         }
201         
202         Enumeration keys = keys();
203         
204         while( keys.hasMoreElements() ) {
205             Object JavaDoc val, key;
206             
207             key = keys.nextElement();
208             val = get( key );
209             result += indent + "'" + key.toString() + "'=>"
210                 + ( val instanceof TKHashtable
211                   ? ((TKHashtable)val).toPerlString( indentCount+1, withNewline )
212                   : ( val instanceof TKVector
213                     ? ((TKVector)val).toPerlString( indentCount+1, withNewline )
214                     : "'"+val.toString()+"'"
215                     )
216                   )
217                 + ( keys.hasMoreElements() ? "," : "" )
218                 + ( withNewline ? "\n" : "" );
219         }
220         return "{" + (withNewline?"\n":"") + result + indent + "}";
221             
222     }
223     /**
224     Erzeugt eine neue Hashtable, die die Verkn&uuml;pfung von zwei Hashtables enth&auml;lt. Die
225     &uuml;bergebenen Hashtables bleiben unver&auml;ndert.
226     @param h1 Quell-Hash.
227     @param h2 hinzuzuf&uuml;gender Hash
228     @return neuer Hash der h1.concat(h2) enth&auml;t
229     */
230     public static TKHashtable concat( TKHashtable h1, TKHashtable h2 )
231     {
232         if( h1 == null ) {
233             if( h2 == null ) {
234                 return null;
235             }
236             return (TKHashtable) h2.clone();
237         }
238         TKHashtable res = (TKHashtable) h1.clone();
239         res.concat( h2 );
240         return res;
241     }
242
243     
244     /**
245     Erzeugt eine neue Hashtable, die die Verkn&uuml;pfung von zwei Hashtables enth&auml;lt. Die
246     &uuml;bergebenen Hashtables bleiben unver&auml;ndert.
247     @param h1 Quell-Hash.
248     @param h2 hinzuzuf&uuml;gender Hash
249     @return neuer Hash der h1.concat(h2) enth&auml;t
250     */
251     public static TKHashtable merge( TKHashtable h1, TKHashtable h2 )
252     {
253         if( h1 == null ) {
254             if( h2 == null ) {
255                 return null;
256             }
257             return (TKHashtable) h2.clone();
258         }
259         TKHashtable res = (TKHashtable) h1.clone();
260         res.merge( h2 );
261         return res;
262     }
263 }
264
Popular Tags