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


1 /*
2  * $Header: /cvsroot/webman-cms/source/webman/com/teamkonzept/web/TKForm.java,v 1.8 2001/06/11 09:14:10 alex Exp $
3  *
4  */
5 package com.teamkonzept.web;
6
7 import java.io.*;
8 import java.util.*;
9
10 import com.teamkonzept.lib.*;
11
12 public class TKForm {
13
14     //------Unveraenderbare Konstanten------//
15 public static final String PARAM = "PAR";
16     public static final String REQUIRED = "REQ";
17     public static final String TYPE = "TYPE";
18     public static final String REQUIREDSELECTOR = "REQSEL";
19     public static final String SWAP = "SWAP";
20     
21     public static final String CLASS_LIST [] = {
22         PARAM, REQUIRED, REQUIREDSELECTOR, TYPE, SWAP
23     };
24     
25     public static final String ERRORCASE = "ERROR";
26     
27     protected TKParams classes = new TKParams( null );
28     protected TKHTMLTemplate template;
29     protected TKFormTypes formTypes;
30
31     protected final Hashtable errors = new Hashtable();
32     
33     /**
34      * Konstruktor1
35      * Keine Uebergabeparameter, Konstruktor3 wird aufgerufen.
36      * Ihm wird null uebergeben.
37      */
38     public TKForm()
39     {
40         this( (TKParams)null );
41     }
42     
43     /**
44      * Konstruktor2
45      * Keine Uebergabeparameter, Konstruktor4 wird aufgerufen.
46      * Ihm wird null uebergeben.
47      *
48      * @param TKFormTypes formTypes, Klasse zur Typ¸berpr¸fung
49      */
50     public TKForm( final TKFormTypes formTypes )
51     {
52         this( null, formTypes );
53     }
54     
55     /**
56      * Konstruktor3
57      * Konstruktor5 wird aufgerufen
58      *
59      * @param TKParams params, die Parameter des URL's werden uebergeben
60      */
61     public TKForm( final TKParams params )
62     {
63         this( params, (TKHTMLTemplate)null );
64     }
65     
66     /**
67      * Konstruktor4
68      * Konstruktor6 wird aufgerufen
69      *
70      * @param TKParams params, die Parameter des URL's werden uebergeben
71      * @param TKFormTypes formTypes, Klasse zur Typ¸berpr¸fung
72      */
73     public TKForm( final TKParams params, final TKFormTypes formTypes )
74     {
75         this( params, null, formTypes );
76     }
77         
78     
79     /**
80      * Konstruktor5
81      * Konstruktor7 wird aufgerufen
82      *
83      * @param TKParams params, die Parameter des URL's werden uebergeben
84      * @param TKTemplate template, das Template-Objekt mit der Form
85      */
86     public TKForm( final TKParams params, final TKHTMLTemplate template )
87     {
88         this( params, template, CLASS_LIST );
89     }
90
91     /**
92      * Konstruktor6
93      * Konstruktor8 wird aufgerufen
94      *
95      * @param TKParams params, die Parameter des URL's werden uebergeben
96      * @param TKTemplate template, das Template-Objekt mit der Form
97      * @param TKFormTypes formTypes, Klasse zur Typ¸berpr¸fung
98      */
99     public TKForm( final TKParams params, final TKHTMLTemplate template, final TKFormTypes formTypes )
100     {
101         this( params, template, CLASS_LIST, formTypes );
102     }
103     
104     /**
105      * Konstruktor7
106      * Ist das uebergebene TKParam-Objekt nicht null, so werden die Parameter
107      * in einem verschachtelten hash abgelegt.
108      *
109      * @param TKParams params, die Parameter des URL's werden uebergeben
110      * @param TKTemplate template, das Template-Objekt mit der Form
111      * @param String classList[], Konstanter String der Klasse TKForm
112      */
113     public TKForm( final TKParams params, final TKHTMLTemplate template, final String classList[] )
114     {
115         this( params, template, classList, null );
116     }
117     
118     /**
119      * Konstruktor8
120      * Ist das uebergebene TKParam-Objekt nicht null, so werden die Parameter
121      * in einem verschachtelten hash abgelegt.
122      *
123      * @param TKParams params, die Parameter des URL's werden uebergeben
124      * @param TKTemplate template, das Template-Objekt mit der Form
125      * @param String classList[], Konstanter String der Klasse TKForm
126      * @param TKFormTypes formTypes, Klasse zur Typ¸berpr¸fung
127      */
128     public TKForm( final TKParams params, final TKHTMLTemplate template, final String classList[], final TKFormTypes formTypes )
129     {
130         if( params != null )
131             setClasses( params, classList );
132         this.template = template;
133         this.formTypes = ( formTypes == null ? new TKFormTypes() : formTypes );
134     }
135     /**
136      * das aktuelle Template wird zurueckgegeben.
137      *
138      * @return das aktuelle Template, welches dem konstruktor uebergeben wurde
139      */
140     public TKTemplate getTemplate()
141     {
142         return template;
143     }
144
145     /**
146      * Zu jedem Element="className" der classList[] wird nachgeschaut, ob es dazu
147      * Werte gibt, welche die Methode getClass() in der Klasse TKParams
148      * als Hash zurueckgibt. Diese Key-Value-Parameter
149      * werden gann als Hash in einem Hash abgelegt.
150      *
151      *----------------------------------------------------------------------
152      * Syntax: TK_PARClassId[TKParameterName;
153      * TKParameterSubklassenName:TKParameterSubklassenWert]
154      * = URLParameterWert
155      *----------------------------------------------------------------------
156      *
157      * Beispiel:Es wurde folgender Parameter in einer Hashtabel abgelegt:
158      * TK_PAR[ALTER;TYPE:INT] = 33
159      *----------------------------------------------------------------------
160      *
161      * 1. Ein Hash der jeweiligen classId wird zurueckgegeben.
162      * Die classId ist ein Key der Klasse TKParam
163      *
164      * Beispiel: TKParam-Objekt.getClass("PAR")
165      * ---------------
166      * | ALTER | 33 |
167      * ==> |--------------|
168      * | .... | .. |
169      * |--------------|
170      *
171      * 2. Ein Hash der jeweiligen classId wird zurueckgegeben.
172      * Die classId ist ein Key der Klasse TKParam
173      *
174      * Beispiel: TKParam-Objekt.getClass("TYPE")
175      * ---------------
176      * | ALTER | INT |
177      * ==> |--------------|
178      * | .... | .. |
179      * |--------------|
180      *
181      * 3. Der className ist der Key des neuen Hashes, dessen Value
182      * ist wiederum der Hasg, den getClass() zurueckgeliefert hat.
183      * --------------------------
184      * | PARAM | --------------- |
185      * | | | ALTER| 33 | |
186      * | | | ... | ... | |
187      * | | -------------- |
188      * ---------------------------
189      * | TYPE | -------------- |
190      * | | | ALTER| INT | |
191      * | | --------------- |
192      * ---------------------------
193      *
194      * 4. Eine weitere Variante des zurueckgegebenen Hashes von
195      * TKParam-Objekt.getClass(classId)
196      *
197      * ---------------------------------------------
198      * | TKParameterName | TKVector.URLParameterWert |
199      * ==> |-----------------|---------------------------
200      * | .... | .. |
201      * |-----------------|----------------------------
202      *
203      * @param TKParams params, die Parameter des URL's werden uebergeben
204      * @param String classList[], Konstanter String der Klasse TKForm
205      */
206     protected void setClasses( final TKParams params, final String classList[] )
207     {
208         for( int i=0; i<classList.length; i++ ) {
209             String className = classList[i];
210             TKHashtable classHash;
211             
212             //------siehe Class TKForm------//
213 if( (classHash = params.getClass( className ) ) != null ) {
214                 classes.put( className, classHash.clone() );
215             }
216             else {
217                 classes.put( className, new TKHashtable() );
218             }
219         }
220         doSwapReqs();
221     }
222     
223     /**
224      * Die Methode getClass() ruft die gleichnahmige Methode von der Klasse TKParam auf.
225      * Beispiel: TKParam-Objekt.getClass(classId)
226      *
227      * ---------------
228      * | key | val |
229      * ==> |--------------|
230      * | .... | .. |
231      * |--------------|
232      *
233      * @param String classId, ist ein Element aus CLASS_LIST[],
234      * zuvor auch className genannt
235      *
236      * @return TKHashtable, der alle Key-Value-Werte zu einer classId (Klassenname)
237      * enthaelt.
238      */
239     protected final TKHashtable getClass( final String classId )
240     {
241         return classes.getClass( classId );
242     }
243     
244     /**
245      * siehe: Methode getClass in TKParams
246      * Ein Hash der jeweiligen classId (PARAM)wird zurueckgegeben.
247      *
248      * Beispiel: TKParam-Objekt.getClass(PARAM)
249      * ---------------
250      * | ALTER | 33 |
251      * ==> |--------------|
252      * | .... | .. |
253      * |--------------|
254      *
255      * @return TKHashtable, der alle Key-Value-Werte zu einer classId (Klassenname)
256      * PARAM enthaelt.
257      */
258     public final TKHashtable getParams()
259     {
260         return getClass( PARAM );
261     }
262     
263     /**
264      * siehe: Methode getClass in TKParams
265      * Ein Hash der jeweiligen classId (REQUIRED)wird zurueckgegeben.
266      *
267      * @return TKHashtable, der alle Key-Value-Werte zu einer classId (Klassenname)
268      * REQUIRED enthaelt.
269      */
270     public final TKHashtable getRequired()
271     {
272         return getClass( REQUIRED );
273     }
274     
275     /**
276      * siehe: Methode getClass in TKParams
277      * Ein Hash der jeweiligen classId (REQUIREDSELECTOR)wird zurueckgegeben.
278      *
279      * @return TKHashtable, der alle Key-Value-Werte zu einer classId (Klassenname)
280      * REQUIREDSELECTOR enthaelt.
281      */
282     public final TKHashtable getRequiredSelector()
283     {
284         return getClass( REQUIREDSELECTOR );
285     }
286     
287     /**
288      * siehe: Methode getClass in TKParams
289      * Ein Hash der jeweiligen classId (SWAP)wird zurueckgegeben.
290      *
291      * @return TKHashtable, der alle Key-Value-Werte zu einer classId (Klassenname)
292      * SWAP enthaelt.
293      */
294     public final TKHashtable getSwapReqs()
295     {
296         return getClass( SWAP );
297     }
298
299     /**
300      * doSwapReqs f¸hrt f¸r alle in der Klasse SWAP vorkommenden
301      * Parameter REQ gegen REQSEL vertaushungen durch.
302      *
303      * So erh‰lt z.B. bei folgendem
304      *
305      * <INPUT TYPE="RADIO" NAME="TK_PAR[ANREDE;REQ:1,2]" <TK_CHK:ANREDE=1>> Herr<P>
306      * <INPUT TYPE="RADIO" NAME="TK_PAR[ANREDE;REQ:1,2]" <TK_CHK:ANREDE=2>> Frau<P>
307      * <INPUT TYPE="RADIO" NAME="TK_PAR[ANREDE;REQ:1,2]" <TK_CHK:ANREDE=3>> Firma<P>
308      * <P>
309      * Name:<INPUT TYPE="NAME" NAME="TK_PAR[NAME;REQSEL:1;SWAP:ANREDE=1,2]" VALUE="<TK:NAME>">
310      * <P>
311      * Firma:<INPUT TYPE="NAME" NAME="TK_PAR[FIRMA;REQSEL:2;SWAP:ANREDE=3]" VALUE="<TK:FIRMA>">
312      *
313      * der Parameter ANREDE ein REQSEL:1, wenn ANREDE den Wert eins oder zwei hat,
314      * ansonsten REQSEL:2 . Gleichzeitig erh‰lt im Gegenzug der Parameter FIRMA bzw. NAME
315      * ein REQ:1,2
316      *
317      */
318     public void doSwapReqs() {
319         final TKHashtable swap = getSwapReqs();
320         final TKHashtable req = getRequired();
321         final TKHashtable reqsel = getRequiredSelector();
322         final TKHashtable params = getParams();
323         
324         final Enumeration swap_enum = swap.keys();
325         while ( swap_enum.hasMoreElements() ) {
326             final Object key = swap_enum.nextElement();
327
328             final Object swap_oval = swap.get( key );
329             if ( swap_oval == null
330                     || !( swap_oval instanceof String ) ) {
331                 continue;
332             }
333
334             final String swap_val = (String )swap_oval;
335             final int eq_ndx = swap_val.indexOf( '=' );
336             if ( eq_ndx >= 0 ) {
337                 final String dest = swap_val.substring( 0, eq_ndx );
338                 
339                 final Object parm_oval = params.get( dest );
340                 if ( parm_oval == null
341                         || !( parm_oval instanceof String ) ) {
342                     continue;
343                 }
344
345                 final StringTokenizer tokenizer =
346                         new StringTokenizer( swap_val.substring(
347                                                     eq_ndx + 1,
348                                                     swap_val.length()
349                                                 ), ","
350                                            );
351                 final String parm_val = (String )parm_oval;
352                 while ( tokenizer.hasMoreTokens() ) {
353                     if ( parm_val.equals( tokenizer.nextToken() ) ) {
354                         final Object reqsel_val = reqsel.get( key );
355                         final Object req_val = req.get( dest );
356                         
357                         if ( reqsel_val != null && req_val != null ) {
358                             req.remove( dest );
359                             reqsel.remove( key );
360                             
361                             req.put( key, reqsel_val );
362                             reqsel.put( dest, req_val );
363                         }
364                         break;
365                     }
366                 }
367             } else {
368                 final String dest = swap_val;
369                 
370                 final Object parm_oval = params.get( dest );
371                 if ( parm_oval == null
372                         || !( parm_oval instanceof String ) ) {
373                     continue;
374                 }
375                 
376                 final Object reqsel_val = reqsel.get( key );
377                 final Object req_val = req.get( dest );
378                         
379                 if ( reqsel_val != null && req_val != null ) {
380                     req.remove( dest );
381                     reqsel.remove( key );
382                     
383                     req.put( key, reqsel_val );
384                     reqsel.put( dest, req_val );
385                 }
386             }
387         }
388     }
389     
390     /**
391      * siehe: Methode getClass in TKParams
392      * Ein Hash der jeweiligen classId (TYPE)wird zurueckgegeben.
393      *
394      * Beispiel: TKParam-Objekt.getClass(TYPE)
395      * ---------------
396      * | ALTER | INT |
397      * ==> |--------------|
398      * | .... | .. |
399      * |--------------|
400      *
401      * @return TKHashtable, der alle Key-Value-Werte zu einer classId (Klassenname)
402      * TYPE enthaelt.
403      */
404     public final TKHashtable getTypes()
405     {
406         return getClass( TYPE );
407     }
408     
409     /**
410      * In dem aktuellen Template wird die Errorliste gesetzt
411      *
412      * @param TKVector errorList, eine spezielle Errorliste, die im Template
413      * in folgender Notation steht: <TK_LIST:ERROR_errorType> ... </TK_LIST:ERROR_errorType>
414      * @param String errorType ????
415      */
416     public void addErrorParams( final TKVector errorList, final String errorType )
417     {
418         if( errorType != null ) {
419     
420             errors.put( errorType, errorList );
421         
422             if( errorType.length() > 0 ) {
423                 template.set( ERRORCASE + "_" + errorType, Boolean.TRUE );
424                 template.set( ERRORCASE, Boolean.TRUE );
425             }
426         }
427     }
428         
429     /**
430      * 1. In dem aktuellen Template wird die Errorliste gesetzt
431      * 2. Die Tags im Template werden substituiert
432      * 3. Der Text des Templates wird aufbereitet
433      * 4. template.getText() gibt das Template als String zurueck, welcher
434      * auf STDOUT geschrieben werden kann.
435      *
436      * @param TKVector errorList
437      * @param String errorType
438      */
439     public void printErrorParams( final PrintStream out ) throws TKTemplateSyntaxException
440     {
441         
442               TKListIterator prev_iter = template.getListIterator();
443         final Enumeration error_enum = errors.keys();
444         while ( error_enum.hasMoreElements() ) {
445             final String errorType = (String ) error_enum.nextElement();
446             
447             prev_iter = new ErrorListIterator( errorType, (TKVector) errors.get( errorType ), prev_iter );
448         }
449                 
450         template.setListIterator( new ErrorListIterator( errors, prev_iter ) );
451     }
452      
453     /**
454      * Liefert eine Liste aller Parameternamen, die nicht ausgef&uuml;llt
455      * wurden, obwohl dies als zwingend in der Form angegeben wurde.
456      *
457      * @param TKVector TKVector reqSelectors
458      * @return einen Vektor aller fehlenden Parameter
459      */
460     public TKVector checkRequiredParams( final TKVector reqSelectors )
461     {
462         final TKHashtable paramHash = getParams();
463         final TKHashtable reqHash = getRequired();
464         
465         final TKVector missing = new TKVector();
466
467         //reqEnum enthaelt ist ein Enumerations-Objekt, mit dem alle Schluessel der
468 //Tabelle reqHash durchlaufen werden koennen.
469 final Enumeration reqEnum = reqHash.keys();
470         while( reqEnum.hasMoreElements() ) {
471             final Object key = reqEnum.nextElement();
472             final Object reqVal = reqHash.get( key );
473             final Object parVal = paramHash.get( key );
474                 
475             if( reqVal == null || reqVal instanceof TKNull
476                 || ( reqVal instanceof String && isEmptyString( (String ) reqVal ) ) ) {
477                 if( parVal == null || parVal instanceof TKNull
478                         || ( parVal instanceof String && isEmptyString( (String ) parVal ) ) ) {
479                     missing.addElement( key );
480                 }
481             }
482             else if( reqSelectors != null && !reqSelectors.isEmpty() ){
483
484                 /* F¸lle reqConditions mit REQ-Bezeichner f¸r den
485                  * Parameter key.
486                  */
487                 final TKVector reqConditions = new TKVector();
488                 if( reqVal instanceof TKVector ) {
489                     final Enumeration reqValEnum = ((TKVector)reqVal).elements();
490                     while( reqValEnum.hasMoreElements() ) {
491                         reqConditions.fill( new StringTokenizer( reqValEnum.nextElement().toString(), "," ) );
492                     }
493                 }
494                 else
495                     reqConditions.fill( new StringTokenizer( reqVal.toString(), "," ) );
496                     
497                 /* ‹berpr¸fe, ob f¸r jeden REQ-Bezeichner ein REQ-Selektor vorhanden ist;
498                  * Und wenn ja, diesem einem Wert zugewiesen wurde.
499                  */
500                 final Enumeration condEnum = reqConditions.unique().elements();
501                       boolean noError = true;
502                 while( condEnum.hasMoreElements() && noError ) {
503                     final Enumeration selEnum = reqSelectors.elements();
504                     final String currCond = condEnum.nextElement().toString();
505                     while( selEnum.hasMoreElements() && noError ) {
506                         final String selCond = selEnum.nextElement().toString();
507                         if( selCond.equalsIgnoreCase( currCond ) ) {
508                             if( parVal == null || parVal instanceof TKNull
509                                     || ( parVal instanceof String && ((String ) parVal).length() == 0 ) ) {
510                                 missing.addElement( key );
511                                 noError = false;
512                             }
513                         }
514                     }
515                 }
516             }
517         }
518         return missing;
519     }
520     
521     /**
522      * &Uuuml;berpr&uuml;ft, inwiefern alle, als erforderlich gekennzeichneten
523      * Parameter auch in der Form ausgef&uuml;llt wurden.
524      * Im Fehlerfall wird die Form neu gef&uuml;llt und nochmals ausgegeben.
525      *
526      * @return true, falls alle als ben&ouml;tigt gekennzeichneten Formularfelder
527      * auch gef&uuml;llt wurden; false sonst.
528      */
529     public boolean checkRequired( final PrintStream out )
530                             throws TKTemplateSyntaxException {
531         if ( !checkRequired() ) {
532             printForm( out );
533             return false;
534         }
535         return true;
536     }
537     
538     /**
539      * &Uuuml;berpr&uuml;ft, inwiefern alle, als erforderlich gekennzeichneten
540      * Parameter auch in der Form ausgef&uuml;llt wurden.
541      *
542      * @return true, falls alle als ben&ouml;tigt gekennzeichneten Formularfelder
543      * auch gef&uuml;llt wurden; false sonst.
544      */
545     public boolean checkRequired() throws TKTemplateSyntaxException
546     {
547         final TKHashtable reqSelectors = getRequiredSelector();
548         final TKHashtable par = getParams();
549         final TKVector reqList = new TKVector();
550         
551         final Enumeration reqKeys = reqSelectors.keys();
552         while( reqKeys.hasMoreElements() ) {
553             final Object key = reqKeys.nextElement();
554             final Object parVal = par.get( key );
555             if( ! (parVal == null || parVal instanceof TKNull ) ) {
556                 final StringTokenizer selEnum = new StringTokenizer( reqSelectors.get( key ).toString(), "," );
557                 while ( selEnum.hasMoreElements() ) {
558                     reqList.addElement( selEnum.nextElement().toString() );
559                 }
560             }
561         }
562         
563         return checkRequired( reqList.unique() );
564     }
565     
566     /**
567      * &Uuuml;berpr&uuml;ft, inwiefern alle, als erforderlich gekennzeichneten
568      * Parameter auch in der Form ausgef&uuml;llt wurden.
569      *
570      * @return true, falls alle als ben&ouml;tigt gekennzeichneten Formularfelder
571      * auch gef&uuml;llt wurden; false sonst.
572      */
573     public boolean checkRequired( TKVector reqSelector ) throws TKTemplateSyntaxException
574     {
575         final TKVector missing = checkRequiredParams( reqSelector );
576         if( !missing.isEmpty() ) {
577             addErrorParams( missing, REQUIRED );
578             return false;
579         }
580         return true;
581     }
582     
583     /**
584      * &Uuml;berpr&uuml;ft, ob alle Formularparameter den korrekten Typ
585      * besitzen. Im Fehlerfall wird die Form neu gef&uuml;llt und nochmals ausgegeben.
586      *
587      * @return true, falls alle Parameter vom Typ her korrekt sind;
588      * false, sonst.
589      */
590     public boolean checkType( final PrintStream out )
591                             throws TKTemplateSyntaxException {
592         if ( !checkType() ) {
593             printForm( out );
594             return false;
595         }
596         return true;
597     }
598
599     /**
600      * &Uuml;berpr&uuml;ft, ob alle Formularparameter den korrekten Typ
601      * besitzen.
602      *
603      * @return true, falls alle Parameter vom Typ her korrekt sind;
604      * false, sonst.
605      */
606     public boolean checkType()
607     {
608         final Hashtable typeHash = getTypes();
609         final Hashtable valHash = getParams();
610         final Enumeration parEnum = typeHash.keys();
611         final TKVector errors = new TKVector();
612         
613         while ( parEnum.hasMoreElements() ) {
614             final String parName = (String ) parEnum.nextElement();
615             final String type = (String ) typeHash.get( parName );
616             
617             final Object value = valHash.get( parName );
618             
619             if ( value == null
620                     || !( value instanceof String )
621                     || !formTypes.checkType( (String ) value, type ) ) {
622                 errors.addElement( parName );
623             }
624         }
625
626         if ( !errors.isEmpty() ) {
627             addErrorParams( errors, TYPE );
628             return false;
629         } else {
630             return true;
631         }
632     }
633     
634     /**
635      * Werden in der Applikation die Parameter einer Form eingelesen,
636      * so kann zuerst auf die Korrektheit der Form geprueft werden.
637      *
638      * @return true, wenn die Form korrekt ist.
639      */
640     public boolean checkForm( PrintStream out ) throws TKTemplateSyntaxException
641     {
642         final boolean req = checkRequired();
643         final boolean type = checkType();
644         
645         if ( !( req && type ) ) {
646             printForm( out );
647             return false;
648         } else {
649             return true;
650         }
651     }
652     
653     /**
654      * Die leere Form wird ausgegeben, d.h es werden keine
655      * Parameter zum Template mehr hinzugef¸gt.
656      */
657     public void printEmptyForm( final PrintStream out ) throws TKTemplateSyntaxException
658     {
659         template.doTagSubstitution();
660         template.doCleanup();
661         template.printTemplate( out );
662     }
663     
664     /**
665      * Die Form wird samt der Listiteratoren (ERROR, ERROR_TYPE, ERROR_REQ) ausgegeben
666      */
667     public void printForm( final PrintStream out ) throws TKTemplateSyntaxException
668     {
669         final TKHashtable params = getParams();
670         printErrorParams( out );
671         template.set( params );
672         printEmptyForm( out );
673     }
674
675     /**
676      * @see com.teamkonzept.web.TKFormTypes#setLocale
677      */
678     public final void setLocale( final Locale locale ) {
679         formTypes.setLocale( locale );
680     }
681
682     /**
683      * @see com.teamkonzept.web.TKFormTypes#setLocale
684      * @see com.teamkonzept.web.TKFormTypes#setStyle
685      */
686     public final void setLocale( final int style, final Locale locale ) {
687         formTypes.setLocale( locale );
688         formTypes.setStyle( style );
689     }
690
691     /**
692      * setzen einer eignen TKFormTypes-Klasse
693      */
694     public final void setFormTypes( final TKFormTypes formTypes ) {
695         this.formTypes = formTypes;
696     }
697         
698     /**
699      * @see com.teamkonzept.web.TKFormTypes#setStyle
700      */
701     public final void setStyle( final int style ) {
702         formTypes.setStyle( style );
703     }
704     
705     public final static boolean isEmptyString( final String text ) {
706         if ( text == null ) {
707             return true;
708         }
709         final int len = text.length();
710         for ( int i = 0; i < len; i++ ) {
711             if ( !Character.isWhitespace( text.charAt( i ) ) ) {
712                 return false;
713             }
714         }
715         
716         return true;
717     }
718 }
719
720 /**
721  * Implementierung des Interfaces TKListIterator
722  * In einem Template kann <TK_LIST:ERROR> ... </TK_LIST:ERROR> verwendet
723  * werden. Zwischen diesen Tags koennen verschiedenen Errormeldungen stehen,
724  * die in eine Liste aufgenommen werden.
725  */
726 class ErrorListIterator implements TKListIterator {
727     
728     public static final String ERRORLIST = "ERROR";
729     
730     protected String listName;
731     protected Enumeration typeEnum;
732     protected Hashtable errorList;
733     protected Enumeration errorEnum;
734     protected String errorType;
735
736     protected TKListIterator primaryIterator;
737     
738     public ErrorListIterator( final Hashtable errorList, final TKListIterator primaryIterator )
739     {
740         this( ERRORLIST, errorList, primaryIterator );
741     }
742         
743     public ErrorListIterator( final String errorType,
744                               final Vector errorList, final TKListIterator primaryIterator )
745     {
746         this( ERRORLIST + "_" + errorType, buildHash( errorType, errorList ), primaryIterator );
747     
748     }
749
750     private ErrorListIterator( final String listName,
751                                final Hashtable errorList, final TKListIterator primaryIterator )
752     {
753         this.listName = listName;
754         this.primaryIterator = primaryIterator;
755         
756         this.errorList = errorList;
757         this.typeEnum = errorList.keys();
758         this.errorType = (String ) typeEnum.nextElement();
759         this.errorEnum = ((Vector) errorList.get( errorType )).elements();
760     }
761     
762     private static final Hashtable buildHash( final String errorType, final Vector errorList )
763     {
764         final Hashtable typeList = new Hashtable( 1 );
765         typeList.put( errorType, errorList );
766         return typeList;
767     }
768         
769     public boolean apply( final TKTemplate template, final int count, final String listName)
770     {
771         if( this.listName.equalsIgnoreCase( listName ) ) {
772             return substitute( template );
773         } else if( primaryIterator == null ) {
774             return false;
775         } else {
776             return primaryIterator.apply( template, count, listName );
777         }
778     }
779     
780     protected boolean substitute( final TKTemplate template ) {
781         if ( errorEnum.hasMoreElements() ) {
782             final String par = (String ) errorEnum.nextElement();
783             
784             template.set( errorType + '_' + par, Boolean.TRUE );
785             template.set( errorType, par );
786             
787             return true;
788         } else if ( typeEnum.hasMoreElements() ) {
789             errorType = (String ) typeEnum.nextElement();
790             errorEnum = ((Vector) errorList.get( errorType )).elements();
791         
792             return substitute( template );
793         } else {
794             return false;
795         }
796     }
797 }
798
799

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags