001: package com.teamkonzept.field;
002:
003: import com.teamkonzept.web.*;
004: import com.teamkonzept.publishing.markups.*;
005: import com.teamkonzept.lib.*;
006: import com.teamkonzept.international.LanguageManager;
007: import com.teamkonzept.field.db.*;
008: import org.w3c.dom.*;
009:
010: /**
011: * The field option control.
012: *
013: * Die Klasse TKFieldoption stellt Methoden zur Verfuegung, optional auszuwaehlen,
014: * ob ein uebergebens Field generiert werden soll oder nicht, die ausgewaehlte Option
015: * zu modifizieren, und um die Daten und Struktur in der Datenbank abzulegen.
016: *
017: * Sie definiert sich ueber einen Namen, einer Beschreibung
018: * und einer Auswahlliste aller verfuegbaren Fields. Im Content-Edit Modus wird
019: * dann das Template field_option.tmpl generiert, welches einen Switch mit der
020: * Auswahl Ja bzw. Nein enthaelt. Wird Ja ausgewaehlt, so wird der Default des
021: * Feldes generiert, das zuvor ausgewaehlt wurde.
022: *
023: * Bsp.: Eine Liste, enthaelt Textfelder. Zu jedem Textfeld kann optional die Moeglichkeit
024: * zur Verfuegung gestellt werden, ein Bild am Ende des Textes hinzuzufuegen oder nicht.
025: *
026: * @author $Author: uli $
027: * @version $Revision: 1.26 $
028: */
029: public class TKFieldOption extends TKBaseField {
030: // $Id: TKFieldOption.java,v 1.26 2002/02/27 11:07:04 uli Exp $
031:
032: /**
033: * The class identifier.
034: */
035: public static final String CLASS_ID = "FIELDOPTION";
036: public static final String OPTION_ENTRY_KEY = "OPTIONENTRY";
037: public static final String YES_NAME_KEY = "YES_NAME";
038: public static final String NO_NAME_KEY = "NO_NAME";
039: /** Default fuer Ja */
040: public static final String DEFAULT_YES_NAME = "Ja";
041: /** Default fuer Nein */
042: public static final String DEFAULT_NO_NAME = "Nein";
043:
044: /** die eigentliche Option */
045: TKBaseField optionEntry;
046:
047: /**
048: * The name for the selected state.
049: */
050: protected String yesName = null;
051:
052: /**
053: * The name for the unselected state.
054: */
055: protected String noName = null;
056:
057: /**
058: * Creates an empty field option control.
059: */
060: public TKFieldOption() {
061: };
062:
063: /**
064: * Konstruktor 2
065: *
066: * @param String name, ein beliebiger Name
067: * @param TKBaseField optionEntry, das ausgewaehlte Field
068: */
069: public TKFieldOption(String name, TKBaseField optionEntry) {
070: //this( name, optionEntry, null );
071: this (name, optionEntry, null, null, null);
072: }
073:
074: /**
075: * Konstruktor 3
076: *
077: * @param String Name, ein beliebiger Name
078: * @param TKBaseField optionEntry, das ausgewaehlte Field
079: * @param String showName, Name, den der Benuzer fuer das Feld gewaehlt hat
080: */
081: public TKFieldOption(String name, TKBaseField optionEntry,
082: String showName) {
083: //initFieldOption( name, optionEntry, showName );
084: this (name, optionEntry, showName, null, null);
085: }
086:
087: public TKFieldOption(String name, TKBaseField optionEntry,
088: String showName, String yesName, String noName) {
089: initFieldOption(name, optionEntry, showName, yesName, noName);
090: }
091:
092: /**
093: * Initialisierung des Fields
094: *
095: * @param String Name, ein beliebiger Name
096: * @param TKBaseField optionEntry, das ausgewaehlte Field
097: * @param String showName, Name, den der Benuzer fuer das Feld gewaehlt hat
098: */
099: public final void initFieldOption(String name,
100: TKBaseField optionEntry, String showName, String yesName,
101: String noName) {
102: initBaseField(CLASS_ID, name, showName);
103: this .optionEntry = optionEntry;
104: this .yesName = yesName;
105: this .noName = noName;
106: }
107:
108: /**
109: * Das Subfield-Objekt wird aus der Registry geholt
110: *
111: * @param String fieldClass, die CLASS_ID
112: * @param Object data, der Datahash
113: */
114: public void init(String fieldClass, Object data)
115: throws TKUnregisteredClassException,
116: ClassNotFoundException, InstantiationException,
117: IllegalAccessException {
118: //---- Konstruktor von Base ----//
119: super .init(fieldClass, data);
120:
121: TKHashtable jaNeinData = (TKHashtable) data;
122: TKFieldSwitchData subType = (TKFieldSwitchData) jaNeinData
123: .get(SUB_TYPE_KEY);
124:
125: if (subType.alternative.length() == 0)
126: throw new InstantiationException("no tabletype for "
127: + fieldType + " " + fieldName);
128:
129: this .optionEntry = (TKBaseField) TKFieldRegistry.registry.get(
130: subType.alternative, subType.data);
131:
132: this .yesName = (String) jaNeinData.get(YES_NAME_KEY);
133: this .noName = (String) jaNeinData.get(NO_NAME_KEY);
134: }
135:
136: /**
137: * Methode zur Definition einer Feldoption
138: * Eine TKFieldOption definiert sich durch ein Inputfeld fuer den internen Namen, ein
139: * Inputfeld fuer die Beschreibung und einer Auswahlliste, die alle Fields enthaelt.
140: *
141: * @param TKFieldSwitch allSwich, eine Optionsgruppe
142: * @param TKFieldSwitchList allSwitchList, eine Optionsliste
143: *
144: * @return eine Gruppe, die die Definitionen enthaelt
145: */
146: public TKFieldGroup getDefGroup(TKFieldSwitch allSwitch,
147: TKFieldSwitchList allSwitchList) {
148: TKBaseField[] optionArray = {
149: new TKInputField(TKFieldOption.NAME_KEY,
150: TKInputField.SMALL_DEFAULT_SIZE,
151: TKInputField.SMALL_DEFAULT_LENGTH,
152: LanguageManager.getText(LANGUAGE_CONTEXT,
153: "FIELDOPTION_NAME"),
154: TKInputField.CHECK_STRING),
155: new TKInputField(TKFieldOption.SHOW_NAME_KEY,
156: TKInputField.LARGE_DEFAULT_SIZE,
157: TKInputField.LARGE_DEFAULT_LENGTH,
158: LanguageManager.getText(LANGUAGE_CONTEXT,
159: "FIELDOPTION_SHOWNAME"),
160: TKInputField.CHECK_STRING),
161: new TKInputField(TKFieldOption.YES_NAME_KEY,
162: TKInputField.LARGE_DEFAULT_SIZE,
163: TKInputField.LARGE_DEFAULT_SIZE,
164: LanguageManager.getText(LANGUAGE_CONTEXT,
165: "FIELDOPTION_YES_NAME_KEY")),
166: new TKInputField(TKFieldOption.NO_NAME_KEY,
167: TKInputField.LARGE_DEFAULT_SIZE,
168: TKInputField.LARGE_DEFAULT_SIZE,
169: LanguageManager.getText(LANGUAGE_CONTEXT,
170: "FIELDOPTION_NO_NAME_KEY")), allSwitch };
171: TKFieldGroup optionGroup = new TKFieldGroup(
172: TKFieldOption.CLASS_ID, new TKVector(optionArray),
173: LanguageManager.getText(LANGUAGE_CONTEXT,
174: TKFieldOption.CLASS_ID));
175:
176: return optionGroup;
177: }
178:
179: /**
180: * Returns the internal representation of this field.
181: *
182: * @return the internal representation of this field.
183: */
184: public Object toData() {
185: TKHashtable result = (TKHashtable) super .toData();
186: result.put(SUB_TYPE_KEY, getDataOfAlternative(optionEntry));
187:
188: if (yesName != null) {
189: result.put(YES_NAME_KEY, yesName);
190: } else {
191: result.put(YES_NAME_KEY, DEFAULT_YES_NAME);
192: }
193: if (noName != null) {
194: result.put(NO_NAME_KEY, noName);
195: } else {
196: result.put(NO_NAME_KEY, DEFAULT_YES_NAME);
197: }
198: return result;
199: }
200:
201: //*************************************************************************************
202: /**
203: * Ja oder Nein wurde ausgewaehlt und der Event Switch abgesetzt.
204: * Nun werden die Daten der Klasse TKFieldOption gesetzt und in der Klasse
205: * TKOptionData abgelegt, welche die interne Praesentaion des Fields darstellt.
206: * Die Information, ob ja oder nein ausgewaehlt wurde, ist im Hash data abgelegt.
207: *
208: * @param String prefix, Fieldstruktur
209: * @param TKHashtable data, Hash mit den Daten
210: *
211: * @return ein Objekt der Klasse, die die Daten fuer TKFieldOption enthaelt
212: */
213: public Object compileData(String prefix, TKHashtable data,
214: TKHashtable context) {
215: prefix += fieldName + ".";
216: String currJaNein = (String) data.get(prefix + "CURRYESNO");
217: String newJaNein = (String) data.get(prefix + "NEWYESNO");
218: if (newJaNein == null)
219: newJaNein = "";
220:
221: if ((currJaNein != null)
222: && (currJaNein.toString().length() > 0)) {
223: return new TKFieldOptionData(currJaNein, newJaNein,
224: (currJaNein.equalsIgnoreCase("YES") ? optionEntry
225: .compileData(prefix + currJaNein + ".",
226: data, context) : null));
227: }
228: return new TKFieldOptionData("", newJaNein, null);
229:
230: }
231:
232: public Object compileData(String prefix, TKMarkupNode data,
233: TKHashtable context) {
234: TKXmlMarkup markup = data == null ? null
235: : (TKXmlMarkup) data.markup;
236: if (markup == null) {
237: return null;
238: }
239:
240: if (!markup.name.equals(getName())) {
241: return null;
242: }
243:
244: TKXmlTree tree = (TKXmlTree) data.tree;
245: if (tree == null) {
246: return null;
247: }
248:
249: Object obj = tree.getSingleSub();
250:
251: TKMarkupNode subNode = null;
252: TKXmlMarkup subMarkup = null;
253:
254: if (obj != null) {
255: if (obj instanceof TKXmlMarkup) { // Atomares Markup
256:
257: subMarkup = (TKXmlMarkup) obj;
258: subNode = new TKMarkupNode(subMarkup, null);
259: } else {
260: subNode = (TKMarkupNode) obj;
261: subMarkup = (TKXmlMarkup) subNode.markup;
262: }
263: }
264: String currJaNein = TKMarkupParam.paramValue(markup.params,
265: "VALUE");
266:
267: if ((currJaNein != null)
268: && (currJaNein.toString().length() > 0)) {
269: return new TKFieldOptionData(currJaNein, "",
270: (currJaNein.equalsIgnoreCase("YES")
271: && (subNode != null) ? optionEntry
272: .compileData(prefix + currJaNein + ".",
273: subNode, context) : null));
274: }
275:
276: return new TKFieldOptionData("", "", null);
277: }
278:
279: /**
280: * Die Daten werden in das Template eingesetzt
281: *
282: * @param TKHTMLTemplate t, das Template field_optiom.tmpl
283: * @param Object data, Hash mit den Daten
284: * @param String prefix, Fieldstruktur
285: */
286: public void fillIntoTemplate(TKHTMLTemplate t, Object data,
287: String prefix) {
288: TKFieldOptionData optionData = (TKFieldOptionData) data;
289: super .fillIntoTemplate(t, data, prefix);
290: if ((yesName == null) || (yesName.equals("")))
291: t.set(YES_NAME_KEY, DEFAULT_YES_NAME);
292: else
293: t.set(YES_NAME_KEY, yesName);
294:
295: if ((noName == null) || (noName.equals("")))
296: t.set(NO_NAME_KEY, DEFAULT_NO_NAME);
297: else
298: t.set(NO_NAME_KEY, noName);
299: t.setListIterator(new TKFieldOptionFakeIterator(optionEntry,
300: optionData, prefix + fieldName + ".", t
301: .getListIterator(), "SWITCH_FAKELIST"));
302: t.set("CURRYESNO", optionData.currJaNein);
303: t.set(prefix + fieldName + ".CURRYESNO", optionData.currJaNein);
304: }
305:
306: public void fillIntoDOM(Document doc, Element node, Object data)
307: throws DOMException {
308: // muss der ganze Quatsch von oben auch rein ?
309: TKFieldOptionData optionData = (TKFieldOptionData) data;
310: Element me = doc.createElement(getInternationalName());
311: node.appendChild(me);
312: fillAttributesIntoNode(me, data);
313: if (optionData.data != null) {
314: if (optionData.currJaNein.equalsIgnoreCase("YES")) {
315: optionEntry.fillIntoDOM(doc, me, optionData.data);
316: }
317: }
318: }
319:
320: /**
321: * Der Scope wird in das Template eingesetzt
322: *
323: * @param TKHTMLTemplate t, das Template
324: * @param Object data, Hash mit den Daten
325: * @param String scope
326: */
327: public void fillIntoPresentation(TKHTMLTemplate t, Object data,
328: String scope) {
329:
330: TKFieldOptionData optionData = (TKFieldOptionData) data;
331:
332: t.set(scope + "." + getName(), optionData.currJaNein);
333:
334: if (optionData.currJaNein.equalsIgnoreCase("YES"))
335: optionEntry.fillIntoPresentation(t, optionData.data, scope
336: + "." + getName());
337:
338: }
339:
340: //*************************************************************************************
341: /**
342: * Die Klasse, die die Daten (interne Raepresentation) haelt, wird initial erzeugt.
343: *
344: * @return die interne Repraesentation der Daten
345: */
346: public Object getDefault() {
347: return new TKFieldOptionData("", "", null);
348: }
349:
350: //*************************************************************************************
351: /**
352: * 1. Die Aktion btrifft das Field selbst
353: * Eine FieldOption ist ein Switch, mit dem ein Ja oder Nein ausgewaehlt werden kann.
354: * Wird nach der Auswahl der Event Switch ausgeloest, wird die Methode modify
355: * angestossen und die Default-Praesentation des Subfields wird eingebunden und im
356: * Template dargestellt.
357: *
358: * 2. Die Aktion berifft das Subfield
359: * Ist das Subfield ein komplexes Field, so kann dieses wiederum eine Methode
360: * modify besitzen, welche ausgefuerhrt werden muss.
361: * Bsp: Ja wurde ausgewaehlt und eine Liste soll erstellt werden. Diese erscheint auf
362: * der Seite als leere Liste (Default) und besitzt einen Button "add". Wird dieses Event abgesetzt,
363: * so wird die Methode modify der Liste aufgerufen, die wiederum ein Komplexes Field mit einer
364: * Methode modify enthalten kann, usw.
365: *
366: * @param String action, das Event das ausgeloest wurde
367: * @param Object data, Hash mit den Daten
368: * @param String prefix, Fieldstruktur
369: * @param StringBuffer destination, fuer die Anzeige des Templates
370: *
371: * @return ein den Hash mit den Daten
372: */
373: public Object modify(String action, String fieldPath, Object data,
374: String prefix, StringBuffer destination) {
375: TKFieldOptionData optionData = (TKFieldOptionData) data;
376:
377: int pLength = prefix.length() + fieldName.length();
378: //---- action betrift JaNein-Auswahl selbst ----//
379: if (fieldPath.length() == pLength) {
380: destination.append(prefix + fieldName);
381: if (action.equals("SWITCH")) {
382: if (!optionData.currJaNein.equals(optionData.newJaNein)) {
383: optionData.currJaNein = optionData.newJaNein;
384: if (optionData.newJaNein.equals("")) {
385: optionData.data = null;
386: } else {
387: optionData.data = optionEntry.getDefault();
388: }
389: }
390: }
391: }
392: //---- action betrifft SubElement ----//
393: else {
394: int subNameEnd = fieldPath.indexOf('.', pLength + 1);
395: String subName = (subNameEnd < 0 ? fieldPath
396: .substring(pLength + 1) : fieldPath.substring(
397: pLength + 1, subNameEnd));
398: if (subName.equals(optionData.currJaNein)) {
399: optionData.data = optionEntry.modify(action, fieldPath,
400: optionData.data, prefix + fieldName + '.'
401: + subName + '.', destination);
402: }
403:
404: }
405:
406: return data;
407: }
408:
409: //***************************************************************
410: /**
411: * Diese Methode wird fuer die Bearbeitung des Events "EXT_MODIFY" fuer
412: * ein Upload benoetigt.
413: *
414: * Diese Methode ermoeglicht es die Field-Hierachie zu durchlaufen.
415: * Komplexe Fields enthalten Sub-Fields, die entweder Atomfields sind oder
416: * wiederum Sub-Fields enthalten. Ist die Hierachie durchlaufen, wird das letzte
417: * Basefield zurueckgegeben.
418: * Siehe auch: doCTExtModify() in CTGenerator.java
419: *
420: * @param String fieldPath
421: * @param String prefix
422: *
423: * @return das Objekt selbst
424: */
425: public TKBaseField getTarget(String fieldPath, String prefix) {
426: TKBaseField targetField = null;
427: int pLength = prefix.length() + fieldName.length();
428:
429: //-------------------------------------//
430: //---- Ein Sub-Element existiert ----//
431: //-------------------------------------//
432: if ((fieldPath.length() != pLength)) {
433: int subNameEnd = fieldPath.indexOf('.', pLength + 1);
434: String subName = (subNameEnd < 0 ? fieldPath
435: .substring(pLength + 1) : fieldPath.substring(
436: pLength + 1, subNameEnd));
437: targetField = optionEntry.getTarget(fieldPath, prefix
438: + fieldName + "." + subName + ".");
439: }
440: return targetField;
441: }
442:
443: //*************************************************************************************
444: /**
445: * Die Daten des Objekts werden in einer Uebergangsstruktur angelegt,
446: * damit diese in die DB eingetragen werden kann. Die Daten des Subelementes
447: * (optionData.data) in der entsprechenden Methode insertDataIntoDB in die
448: * Uebergangsstruktur gelegt.
449: * @param action, das Event das ausgeloest wurde
450: *
451: * @param TKContentDBData db, liefert den Knoten
452: * @param Object data, Hash mit den Daten
453: * @param int contentID, aktuelle ID
454: * @param int leftNr, letzter linker Knoten
455: *
456: * @return ein den Hash mit den Daten
457: */
458: public int insertDataIntoDB(TKContentDBData db, Object data,
459: int contentId, int leftNr) {
460: TKFieldOptionData optionData = (TKFieldOptionData) data;
461: //----------------------------------------------------------------------//
462: //---- Ein Knoten wird gesetzt, TKFieldOption kann nur einen haben ----//
463: //---- Das Objekt node haelt alle noetigen Infos fuer die Struktur: ----//
464: //---- CONTENT_ID, CONTENT_NODE_ID, LEFT_NR, RIGHT_NR,NAME ----//
465: //---- Intern wird die RIGHT_NR = LEFT_NR+1 gesetzt ----//
466: //----------------------------------------------------------------------//
467: TKContentNodeTableData node = insertNewContentNode(db,
468: contentId, leftNr);
469: int newNodeId = node.content_node_id;
470:
471: //TKHttp.out().println("<br>TKContentDBData: "+db.toString());
472: //TKHttp.out().println("<br>Real Data: "+optionData.data);
473: //TKHttp.out().println("<br> TKContentNodeTableData: "+node.toString());
474: //TKHttp.out().println("<br>newNodeId: "+newNodeId);
475:
476: //-----------------------------------------------------------------------------//
477: //---- Infos und Attribut, das aktuelle ausgewaehlte Ja/Nein, wird gesetzt ----//
478: //-----------------------------------------------------------------------------//
479: insertNewContentValue(db, contentId, newNodeId, 0,
480: optionData.currJaNein);
481:
482: //------------------------------------------------------------------------------//
483: //---- Eine Auswahl wurde bereits getroffen, so dass das uebergebene ----//
484: //---- Objekt optionEntry bereits erzeugt wurde. Die Struktur des ----//
485: //---- SubElement muss wiederum in die Uebergangsstruktur eingetragen werden----//
486: //------------------------------------------------------------------------------//
487: if (optionData.currJaNein.equalsIgnoreCase("YES")) {
488: node.right_nr = optionEntry.insertDataIntoDB(db,
489: optionData.data, contentId, leftNr + 1) + 1;
490: }
491:
492: return node.right_nr;
493:
494: }
495:
496: //*************************************************************************************
497: /**
498: * Die Daten werden aus der DB ausgelesen und wieder wie vorher aufgebaut
499: *
500: * @param TKContentDBData db, enthaelt die Struktur
501: *
502: * @return die Klasse, die die Daten enthaelt
503: */
504: public Object getDataFromDB(TKContentDBData db) {
505: //-------------------------------------//
506: //---- Den Knoten wiederherstellen ----//
507: //-------------------------------------//
508: TKContentNodeTableData node = getContentNodeFromDB(db);
509:
510: //---------------------------------------//
511: //---- Attribut (ja oser Nein) holen ----//
512: //---------------------------------------//
513: TKContentValueTableData value = getContentNodeValueFromDB(db,
514: node);
515: String currJaNein = value.value;
516: //------------------------------------------------------//
517: //---- Wurde kein attribut gesetzt => Default von ----//
518: //---- TKFieldOption zurueckgeben ----//
519: //------------------------------------------------------//
520: if (!currJaNein.equalsIgnoreCase("YES"))
521: return getDefault();
522:
523: //------------------------------------------------------------------//
524: //---- Dieser Klasse wird ein TKBaseField uebergeben werden ----//
525: //---- (optionEntry). Ist dies vorhanden, so wird die Klasse, ----//
526: //---- die die realen Daten enthaelt wieder aufgebaut. ----//
527: //------------------------------------------------------------------//
528: if (optionEntry == null)
529: return getDefault();
530: return new TKFieldOptionData(currJaNein, currJaNein,
531: optionEntry.getDataFromDB(db));
532:
533: }
534:
535: //*************************************************************************************
536: /**
537: * Erster Aufruf => sich selbst und das Subelemente auf -1 setzen.
538: * Damit kann im weiteren Verlauf sichergestellt werden, dass, wenn
539: * ein Opbjekt schon eingetragen ist, dies nicht noch einmal
540: * eingetragen wird.
541: */
542: public void clearId() {
543: if (fieldId == -1)
544: return;
545:
546: fieldId = -1;
547: optionEntry.clearId();
548:
549: }
550:
551: //*************************************************************************************
552: /**
553: * Die Struktur des Objekts und seiner Subelemente werden in einer Uebergangsstruktur
554: * fuer die DB abgelegt.
555: *
556: * @param TKFormDBData db
557: * @param int formId, Id der Form
558: *
559: * @return die Id des Fields
560: */
561: public int realInsertIntoDB(TKFormDBData db, int formId) {
562: if (super .realInsertIntoDB(db, formId) == -1)
563: return -1;
564:
565: //---- Attribute in DB speichern (Default Yes/No) ----///
566: if (yesName != null && !yesName.equals(""))
567: insertNewFieldAttribute(db, formId, YES_NAME_KEY, 0,
568: yesName);
569: else
570: insertNewFieldAttribute(db, formId, YES_NAME_KEY, 0,
571: DEFAULT_YES_NAME);
572:
573: if (noName != null && !noName.equals(""))
574: insertNewFieldAttribute(db, formId, NO_NAME_KEY, 0, noName);
575: else
576: insertNewFieldAttribute(db, formId, NO_NAME_KEY, 0,
577: DEFAULT_NO_NAME);
578:
579: //---- das Field option Entry in DB speichern ----//
580: TKSubFieldTableData subFieldDB = insertNewSubField(db, formId,
581: OPTION_ENTRY_KEY, 0);
582: optionEntry.realInsertIntoDB(db, formId);
583: subFieldDB.sub_field_id = optionEntry.fieldId;
584:
585: return fieldId;
586: }
587:
588: /**
589: * Aufgabe wie ein Konstruktor, die Struktur des Objektes und seiner
590: * Subelemente wird wieder aufgebaut
591: *
592: * @param String classId, Name des Fields (CLASS_ID)
593: * @param TKFormDBData db
594: * @param TKVector otherFields
595: */
596: public void initFromDB(String classId, TKFormDBData db,
597: TKVector otherFields) throws TKUnregisteredClassException,
598: ClassNotFoundException, InstantiationException,
599: IllegalAccessException {
600: super .initFromDB(classId, db, otherFields);
601:
602: //---- Attribute aus DB holen ----//
603: if (hasFieldAttribute(db, YES_NAME_KEY, 0))
604: this .yesName = getFieldAttribute(db, YES_NAME_KEY, 0);
605:
606: if (hasFieldAttribute(db, NO_NAME_KEY, 0))
607: this .noName = getFieldAttribute(db, NO_NAME_KEY, 0);
608:
609: //----------- Field oprtionEntry aus DB holen ----//
610: optionEntry = getSubField(db, OPTION_ENTRY_KEY, 0, otherFields);
611: }
612:
613: /**
614: * Checks wether this object and the specified object
615: * may be treated as equal.
616: *
617: * @param object the object to checked for equality.
618: * @return <CODE>true</CODE> if this object and the
619: * specified object may be treated as equal, otherwise
620: * <CODE>false</CODE>.
621: */
622: public boolean equals(Object object) {
623: if (!super .equals(object)) {
624: return false;
625: }
626:
627: TKFieldOption field = (TKFieldOption) object;
628:
629: return (this .yesName == null ? field.yesName == null
630: : this .yesName.equals(field.yesName))
631: && (this .noName == null ? field.noName == null
632: : this .noName.equals(field.noName))
633: && (this .optionEntry == null ? field.optionEntry == null
634: : this .optionEntry.equals(field.optionEntry));
635: }
636:
637: /**
638: * Returns the hash code for this object.
639: *
640: * @return the hash code for this object.
641: */
642: public int hashCode() {
643: // Implementation for JTest only ;-(
644: return super.hashCode();
645: }
646:
647: }
|