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