KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > teamkonzept > web > TKParams


1     /*
2      * $Header: /cvsroot/webman-cms/source/webman/com/teamkonzept/web/TKParams.java,v 1.8 2001/06/11 14:04:38 alex Exp $
3      *
4      */

5     /**
6      * Wird ein HTTP-Request ueber das CGI an den Server gestellt, werden spezielle Informationen
7      * in Form eines Query-Strings an den URL angehangen. Die Applikation, die durch diesen
8      * Request auf dem Server ausgefuehrt werden soll kann nun den Query-String auslesen und diese
9      * fuer die Genereirung eines Templates benutzen.
10      * Team-Konzept hat eine eigene Parameter-Sysntax entwickelt, die in einem Querystring uebergeben
11      * werden.
12      * Der Klasse TKParams wird ein Hash uebergeben, der den Query-String bereits grob bearbeitet hat.
13      * Diese Informationen werden gesplittet und sinnvoll in einem neuen Hash abgelegt.
14      *-------------------------------------------------------------------------------------------------------
15      *
16      * 1. Die Konstruktoren rufen die Methode init() aus, der Folgender Hash uebergeben wird:
17      * keys: URLParameterNamen = TK_PARClassId[TKParameterName;
18      * TKParameterSubklassenName:TKParameterSubklassenWert]
19      *
20      * vals: URLParameterWerte
21      *-------------------------------------------------------------------------------------------------------
22      *
23      * 2. Die URLParameterNamen werden in einem Bsp. mit folgendem Ergebnis bearbeitet:
24      * URLParameterName = URLParameterWert -> TK_PAR[ALTER;TYPE:INT] = 33
25      * Ergebnishash:
26      * -------------------------
27      * | PARAM | --------------- |
28      * | | | ALTER | 33 | |
29      * | | | .... | .. | |
30      * | | -------------- |
31      * ---------------------------
32      * | TYPE | --------------- |
33      * | | | ALTER | INT | |
34      * | | | .... | .. | |
35      * | | -------------- |
36      * ---------------------------
37      *
38      *-------------------------------------------------------------------------------------------------------
39      *
40      * 3. Als Parameter gilt:
41      * a) siehe Punkt1 mit TK_PARClassId = TK_PAR[...]
42      * b) ein Event gilt auch als Parameter: TP_EV[Eventname]=
43      * c) Dies sind bereits implementierte Beispiele, die jedoch nur exemplarisch sind.
44      *
45      *-------------------------------------------------------------------------------------------------------
46      */

47 package com.teamkonzept.web;
48
49 import java.util.*;
50 import com.teamkonzept.lib.*;
51 import com.oroinc.text.regex.*;
52 import org.apache.log4j.Category;
53
54 /**
55  * Klasse TKParams ist Subklasse von TKHashtable
56  * Klasse TKHashtable ist Subklasse von Hashtable
57  * Somit werden alle Felder und Methoden von Hashtable und TKHashtable vererbt.
58  * Das Objekt TKParams ist somit selbst eine Hashtable
59  */

60 public class TKParams extends TKHashtable
61 {
62     private static final Category cat = Category.getInstance(TKParams.class);
63
64     static boolean initialized = false;
65     static private final String JavaDoc patTrailer ="TK_";
66     static private Pattern patParName;
67     static private Pattern patSubClass;
68     
69     /**
70      * Konstruktor1
71      *
72      * Wird der Konstruktor ohne Parameter aufgerufen, so muss (z.Z.) zuvor ein Objekt der Klasse
73      * TKHttp erzeugt worden sein und das TKHttpInterface, welches die Methode getParams()
74      * zur Verfuegung stellt.
75      * Die Klasse TkHttp stellt die abstrakte Klassenmethode GetInterface() zur
76      * Verfuegung.
77      *
78      * Der Methode init() wird somit ein TKHashtable uebergeben, der die Parameter enthaelt.
79      */

80     public TKParams()
81     {
82         if( !initialized ) init();
83         initParams( TKHttp.getInterface().getParams() );
84     }
85     
86     /**
87      * Konstruktor2
88      *
89      * Dem Konstruktor wird ein Hash uebergeben, der die Parameter enthaelt. Dieser
90      * wird wiederum der Methode init() uebergeben. Das TKHttpInterface-Objekt muss
91      * bereits erzeugt worden sein.
92      *
93      * Erzeugung eines Obkjekts der Klasse TKParam:
94      * TKHashtable pureParams = httpInterface.getParams();
95      * TKParams params = new TKParams( pureParams );
96      *
97      * @param TKHashtable pureParams
98      */

99     public TKParams( TKHashtable pureParams )
100     {
101         if( !initialized ) init();
102         if( pureParams != null ) initParams( pureParams );
103     }
104     
105     /**
106      * Gibt die Keys der Klasse TKParam zurueck
107      *-----------------------------------------------------------------
108      * Alternative in der Applikation:
109      * Enumeration paramKeys = TKParams-Objekt.keys();
110      * while(paramKeys.hasMoreElements()) {
111      * Object classId = paramKeys.nextElement();
112      * Object val = TKParams-Objekt.get(key);
113      * }
114      *-----------------------------------------------------------------
115      *
116      * @return die Keys der Klasse
117      */

118     public Enumeration classes()
119     {
120         return keys();
121     }
122     
123     /**
124      * Ein Hash der jeweiligen classId wird zurueckgegeben.
125      * Die classId ist ein Key der Klasse TKParam
126      *
127      * Beispiel: TKParam-Objekt.getClass("PAR")
128      * ---------------
129      * | ALTER | 33 |
130      * ==> |--------------|
131      * | .... | .. |
132      * |--------------|
133      *
134      *
135      * @param Object classID, ein Key der Klasse TKParam
136      * @return Hashtable der classID
137      */

138     public final TKHashtable getClass( Object JavaDoc classId )
139     {
140         Object JavaDoc classHash = get( classId );
141         if( classHash == null || !( classHash instanceof TKHashtable ) ) return null;
142         return (TKHashtable) classHash;
143     }
144     
145     /**
146      * Mit dieser Methode kann getestet werden, ob eine ClassId
147      * existiert.
148      *
149      * @param Object classId, ein Key der Klasse TKParam
150      * @return boolean, existiert die classId?
151      */

152     public boolean hasClass( Object JavaDoc classId )
153     {
154         return getClass( classId ) != null;
155     }
156     
157     /**
158      * Der URLParameterWert eines Parameters in einem Hash wird als Objekt
159      * zurueckgegeben.
160      *
161      * Beispiel: TKParam-Objekt.getObject("PAR","ALTER")
162      * ---------------
163      * | ALTER | 33 |
164      * ==>|--------------| ==> 33
165      * | .... | .. |
166      * |--------------|
167      *
168      * @param Object classId, ein Key der Klasse TKParam
169      * @param Object key, key eines TKParameterNamens
170      * @return den Wert eines Parameters, der URLParameterWert
171      */

172     public Object JavaDoc getObject( Object JavaDoc classId , Object JavaDoc key )
173     {
174         TKHashtable classHash = getClass( classId );
175         if( classHash == null ) return null;
176         return classHash.get( key );
177     }
178     
179     /**
180      * Der URLParameterWert eines Parameters wird als String zurueckgegeben.
181      *
182      * Beispiel: TKParam-Objekt.get("PAR","ALTER")
183      * ---------------
184      * | ALTER | 33 |
185      * ==>|--------------| ==> 33 ==> "33"
186      * | .... | .. |
187      * |--------------|
188      *
189      * @param Object classId, ein Key der Klasse TKParam
190      * @param Object key, key eines TKParameterNamens
191      * @return den Wert eines Parameters, der URLParameterWert
192      */

193     public String JavaDoc get( Object JavaDoc classId , Object JavaDoc key )
194     {
195         Object JavaDoc result = getObject( classId, key );
196         if( result == null || result instanceof TKVector ) return null;
197         return result.toString();
198     }
199     
200     /**
201      * 1. Key der Klasse TKParam -- Value eine Hashtabel
202      * 2. Key der Hashtable -- Value ein TKVecto
203      * 3. Ergebnis: Element des Vectors des uebergebenen Indizes
204      *
205      * Beispiel: TKParam-Objekt.get("PAR","ALTERSGRUPPEN",2)
206      * -----------------------------------
207      * | ALTERGRUPPEN | Vector: 20|30|40 |
208      * ==> |--------------|------------------- ==> 30
209      * | .... | ... | ... |
210      * |--------------|-------------------
211      *
212      * @param Object classId, ein Key der Klasse TKParam
213      * @param Object key, key eines TKParameterNamens
214      * @param int idx, ein Index
215      * @return den Wert eines Parameters, der URLParameterWert
216      */

217     public String JavaDoc get( Object JavaDoc classId , Object JavaDoc key, int idx )
218     {
219         Object JavaDoc result = getObject( classId, key );
220         if( result == null || !(result instanceof TKVector) ) return null;
221         return ((TKVector) result).get( idx ).toString();
222     }
223     
224     /**
225      * Der Wert eines Parameters aus einem Hash ist ein TKVector und wird
226      * dann zurueckgegeben.
227      * Beispiel: TKParam-Objekt.get("PAR","ALTERSGRUPPEN")
228      * -----------------------------------
229      * | ALTERGRUPPEN | Vector: 20|30|40 |
230      * ==> |--------------|------------------- ==> TKVector(20|30|40)
231      * | .... | ... | ... |
232      * |--------------|-------------------
233      *
234      * @param Object classId, ein Key der Klasse TKParam
235      * @param Object key, key eines TKParameterNamens
236      *
237      * @return den Wert eines Parameters
238      */

239     public TKVector getVector( Object JavaDoc classId , Object JavaDoc key )
240     {
241         Object JavaDoc result = getObject( classId, key );
242         if( result == null || !(result instanceof TKVector) ) return null;
243         return (TKVector) result;
244     }
245     
246     /**
247      * Existiert der URLParameterWert eines Parameters in einem Hash wird als Objekt
248      * zurueckgegeben.
249      *
250      * Beispiel: TKParams-Objekt.has("PAR", "ALTER")
251      * ---------------
252      * | ALTER | 33 |
253      * ==>|--------------| ==> 33 ==> true
254      * | .... | .. |
255      * |--------------|
256      *
257      * @param Object classId, ein Key der Klasse TKParam
258      * @param Object key, key eines TKParameterNamens
259      *
260      * @return true, wenn der Wert eines Parameters vorhanden ist
261      */

262     public boolean has( Object JavaDoc classId , Object JavaDoc key )
263     {
264         Object JavaDoc val = getObject( classId, key );
265         if( val == null ) return false;
266         if( val instanceof TKVector ) return true;
267         return ( ! (val instanceof TKNull) );
268     }
269     
270     /**
271      * Die Methode get() liefert den Wert eines Parameters zurueck.
272      * Ist dieser Wert eine Instanz der Klasse TKVector, wird true
273      * zurueckgegeben
274      *
275      *
276      * Beispiel: TKParam-Objekt.hasMultiple("PAR","ALTERSGRUPPEN")
277      * -----------------------------------
278      * | ALTERGRUPPEN | Vector: 20|30|40 |
279      * ==> |--------------|------------------- ==> TKVector(20|30|40) ==> true
280      * | .... | ... | ... |
281      * |--------------|-------------------
282      *
283      * @param Object classId, ein Key der Klasse TKParam
284      * @param Object key, key eines TKParameterNamens
285      *
286      * @return true, wenn der Wert eines Parameters Instanz der
287      * Klasse TKVector ist.
288      */

289     public boolean hasMultiple( Object JavaDoc classId , Object JavaDoc key )
290     {
291         Object JavaDoc val = getObject( classId, key );
292         if( val == null ) return false;
293         return ( val instanceof TKVector );
294     }
295     
296     /**
297      * Ist der Wert des Parameters nicht null, wird true zurueckgegeben.
298      * Ist der Wert null, so existiert weder der key noch der value.
299      * Dies bedeutet, dass der Parameter nicht uebergeben wurde (Checkboxen)
300      * (siehe auch has())
301      *
302      * Beispiel: TKParam-Objekt.defined("PAR","ALTER")
303      * ---------------
304      * | ALTER | 33 |
305      * ==>|--------------| ==> 33 ==> "33" ==> true
306      * | .... | .. |
307      * |--------------|
308      *
309      * @param Object classId, ein Key der Klasse TKParam
310      * @param Object key, key eines TKParameterNamens
311      *
312      * @return true, wenn der Wert eines Parameters vorhanden ist
313      */

314     public boolean defined( Object JavaDoc classId , Object JavaDoc key )
315     {
316         Object JavaDoc val = get( classId, key );
317         return ( val != null );
318     }
319     
320     /**
321      * Erweitert den Hash um ein (key,value)-Paarmit folgender Regel
322      * Kommt der key noch nicht im Hash vor, wird das neue
323      * (Key,Value)-Paar eingetragen
324      *
325      * Beispiel: TKParam-Objekt.extend("PAR","NAME","HANS")
326      * --------------- ---------------
327      * | ALTER | 33 | | ALTER | 33 |
328      * ==>|--------------| ==> |--------------|
329      * | .... | .. | | NAME | HANS |
330      * |--------------| |--------------|
331      *
332      * @param Object classId, ein Key der Klasse TKParam
333      * @param Object key, key eines TKParameterNamens
334      * @param Objekt val, der zu setzende neue Wert
335      */

336     public void extend( Object JavaDoc classId, Object JavaDoc key, Object JavaDoc val )
337     {
338         TKHashtable classHash = getClass( classId );
339         if( classHash == null ) {
340             classHash = new TKHashtable( 1 );
341             classHash.put( key, val );
342             put( classId, classHash );
343         }
344         else {
345             classHash.extend( key, val );
346         }
347     }
348     
349     /**
350      * Erweitert den Hash um ein (key,value)-Paar erweitert.
351      *
352      * Beispiel: TKParam-Objekt.put("PAR","NAME","HANS")
353      * --------------- ---------------
354      * | ALTER | 33 | | ALTER | 33 |
355      * ==>|--------------| ==> |--------------|
356      * | .... | .. | | NAME | HANS |
357      * |--------------| |--------------|
358      *
359      * @param Object classId
360      * @param Object key
361      * @param Objekt val, der zu setzende neue Wert
362      */

363     public void put( Object JavaDoc classId, Object JavaDoc key, Object JavaDoc val )
364     {
365         TKHashtable classHash = getClass( classId );
366         if( classHash == null ) {
367             classHash = new TKHashtable( 1 );
368             classHash.put( key, val );
369             put( classId, classHash );
370         }
371         else {
372             classHash.put( key, val );
373         }
374     }
375     
376     /**
377      * Die Methode initParams() wird in den Konstruktoren aufgerufen. Ihr wird ein Hash
378      * uebergeben, der als Keys die URLParameterNamen und als Value die zugehoerigen
379      * URLParameterWerte enthaelt. Die URLParameternamen muessen nun aus-
380      * einandergenommen und in den Hash eingefuegt werden.
381      *
382      * @param TkHashtable pureParams, welche als Key den URL_Parameternamen
383      * und als Value den URLParameterWert beinhaltet.
384      * TK_PARClassId[TKParameterName;TKParameterSubklassenName:TKParameterSubklassenWert]=
385      * URLParameterWert
386      * Bsp: TK_PAR[ALTER;TYPE:INT]=33
387      * Bsp: TK_EV[START]=
388      *
389      *
390      */

391     protected void initParams( TKHashtable pureParams )
392     {
393         Enumeration keys = pureParams.keys();
394         
395         PatternMatcher matcher = TKReg.getMatcher();
396         
397         while( keys.hasMoreElements() ) {
398             Object JavaDoc key = keys.nextElement();
399             Object JavaDoc val = pureParams.get( key );
400             
401             //Nur die x-Koordinate wird beruecksichtigt
402
if( matcher.matches( key.toString(), patParName ) ) {
403 // if( nameReg.search( key.toString() ) ) {
404
MatchResult match = matcher.getMatch();
405                 if( match.groups() == 4 ) {
406                     String JavaDoc third = match.group(3);
407                     if( third != null && third.equalsIgnoreCase(".y") ) {
408                         continue;
409                     }
410                 }
411                 
412                 //--------------------------------------------------------------------------------------------------------------//
413
//Die Pattern:
414
//static private final String patTrailer ="TK_";
415
//static private final Regex nameReg = new Regex( "^(?i)"+patTrailer+"(\\w+)\\[(.*)\\](\\.[xy])?$" );
416
//static private final Regex subReg = new Regex( "^(\\w+)\\b:?(.*)$" );
417
//Das Beispiel: TK_PAR[ALTER;TYPE:INT]
418
//--------------------------------------------------------------------------------------------------------------//
419

420                 //1. Pattern zwischen TK_ und [ = PAR = classId
421
String JavaDoc classId = match.group(1).toUpperCase();
422                 
423                 //2. Innerhalb der Klammern [] wird nach ";" o. "!" gesplittet
424
// Token1=ALTER Token2=TYPE:INT
425
StringTokenizer parts = new StringTokenizer( match.group(2), ";!" );
426                 
427                 //3. Das erste Token ist damit ALTER
428
String JavaDoc name = parts.nextToken().toUpperCase();
429                 
430                 //---------------------------------------------------------------------------//
431
//Hash mit dem key clasId erhaelt als value einen weiteren Hash mit key=name
432
//und value=val
433
// -------------------------
434
// | PARAM | --------------- |
435
// | | | ALTER | 33 | |
436
// | | | .... | .. | |
437
// | | -------------- |
438
// ---------------------------
439
//---------------------------------------------------------------------------//
440

441                 extend( classId, name, val );
442                 
443                 //---------------------------------------------------------------------------//
444
//Existieren weitere Tokens, so handelt es sich um ein Subtoken, was wiederum
445
//gesplittet wird.
446
//Der TKParameterSubklassenName wird als Key in den Hash eingefuegt und
447
//erhaelt als value wiederum einen Hasch. Dieser enthaelt als Key den
448
//TKParameterName und als value den TKParameterSubklassenWert
449
//
450
//Im Bsp: TYPE:INT
451
// -------------------------
452
// | TYPE | --------------- |
453
// | | | ALTER | INT | |
454
// | | | .... | .. | |
455
// | | -------------- |
456
// ---------------------------
457
//---------------------------------------------------------------------------//
458
while( parts.hasMoreTokens() ) {
459                     if( matcher.matches( parts.nextToken(), patSubClass ) ){
460                         MatchResult classMatch = matcher.getMatch();
461                         String JavaDoc classVal = classMatch.group(2);
462                         extend(
463                             classMatch.group(1).toUpperCase(),
464                             name,
465                             ( classVal.length() == 0 ? (Object JavaDoc) TKNull.NULL : (Object JavaDoc) classVal )
466                         );
467                     }
468                 }
469             }
470             //Es gibt nur einen Parameter ohne die Namenskonvention
471
//(kann fuer Ausnahmen genutzt werden)
472
else {
473                 put( key, val );
474             }
475         }
476     }
477     
478     /**
479      * Enthalten die beiden Hashes den gleichen Key wird ein neuer Hash erzeugt
480      * mit key/value Paar vom srcHash
481      *
482      * @param Object srcId, der SourceHash
483      * @param Object refId, der ReferenzHash
484      *
485      * @return den neu erzeugten Hash
486      */

487     public TKHashtable extractClass( Object JavaDoc srcId, Object JavaDoc refId )
488     {
489         TKHashtable refHash = getClass( refId );
490         TKHashtable srcHash = getClass( srcId );
491         
492         if( srcHash == null || refHash == null || srcHash.size() == 0 || refHash.size() == 0 ) {
493             return new TKHashtable();
494         }
495         
496         TKHashtable res = new TKHashtable( refHash.size() );
497         Enumeration keys = refHash.keys();
498         
499         while( keys.hasMoreElements() ) {
500             Object JavaDoc key = keys.nextElement();
501             Object JavaDoc val = srcHash.get( key );
502             if( val != null ) res.put( key, val );
503         }
504         return res;
505     }
506     
507         //---------------------------------------------------------------------
508
/**
509      * Pattern werden fuer die spaetere Patternsuche/ersetzung definiert und
510      * global zur Verfuegung gestellt.
511      */

512     static void init() {
513         if( initialized ) return;
514         
515         PatternCompiler compiler = TKReg.getCompiler();
516         
517         try {
518             patParName = compiler.compile( "^"+patTrailer+"(\\w+)\\[(.*)\\](\\.[xy])?$", Perl5Compiler.CASE_INSENSITIVE_MASK );
519             patSubClass = compiler.compile("^(\\w+)\\b:?(.*)$" );
520         } catch(MalformedPatternException e) {
521             cat.error("Bad pattern.", e);
522         }
523         
524         initialized = true;
525     }
526     
527     //---------------------------------------------------------------------
528
static {
529         init();
530     }
531
532 }
533
534
Popular Tags