001: package com.teamkonzept.lib.templates;
002:
003: //import com.teamkonzept.lib.templates.xml.*;
004: import com.teamkonzept.lib.*;
005: import org.w3c.dom.*;
006: import de.webman.util.legacy.Legacy;
007:
008: /**
009: * In dieser Klasse werden die Ersetzungsdaten eines Templates verwaltet.
010: *
011: * @author $Author: sebastian $
012: * @version $Revision: 1.25 $
013: */
014: public class TKTemplateData {
015:
016: /** incl. DOM Daten */
017: private DOMTemplateData domData;
018:
019: /** Parent Template */
020: public TKTemplateData parent = null;
021:
022: /** die TemplateVariablen */
023: private TKHashtable variables = new TKHashtable();
024:
025: /** Lookup fuer Listenteilstuecke */
026: private TKTemplateData lookup = null;
027:
028: /** der Listiterator */
029: private TKListIterator listIterator = null;
030:
031: /** a hashtable of hashtables */
032: public TKHashtable enumerationContext = new TKHashtable();
033:
034: /**
035: * Creates a new template data container.
036: */
037: public TKTemplateData() {
038: // NOP.
039: }
040:
041: /**
042: * Creates a new template data container with the given parent.
043: *
044: * @param td the parent template data container.
045: */
046: public TKTemplateData(TKTemplateData td) {
047: if (td == null) {
048: return;
049: }
050:
051: this .listIterator = td.listIterator;
052: this .parent = td;
053:
054: merge(td);
055: }
056:
057: /** @return DOMTemplateData */
058: public DOMTemplateData getDOMData() {
059:
060: try {
061: if (domData == null)
062: domData = new DOMTemplateData();
063: return domData;
064: } catch (Exception e) {
065: return null;
066: }
067: }
068:
069: /**
070: Die Methode wird vor dem apply-Aufruf des zugeordneten Syntax-Objekts
071: aufgerufen um eventuelle globalen Vorbereitungen fŸr die Tag-Ersetzung
072: durchzufŸhren
073: */
074: public void prepareApply() {
075: }
076:
077: public TKListIterator getListIterator() {
078: // if (domData == null)
079: return listIterator;
080: //
081: // return new DOMListIterator((DOMModel)domData);
082:
083: }
084:
085: public void setListIterator(TKListIterator iterator) {
086: listIterator = iterator;
087: }
088:
089: /**
090: Die Methode wird vor dem apply-Aufruf des Listen-Sub-Syntax-Objekts
091: aufgerufen um eventuelle globalen Vorbereitungen fŸr die Tag-Ersetzung
092: durchzufŸhren, bzw. um die in der Šu§eren Syntax definierten, und in
093: td Ÿbergebenene Ersetzungsdaten zu Ÿbernehmen
094: */
095: public void setMergedApply(TKTemplateData td) {
096: lookup = td;
097: /* wer hatte das rausgenohmen und wieso ? ohne funktioniert die 1.5 nicht (Bug 789) */
098: variables = ((variables == null || variables.size() == 0) ? td.variables
099: : TKHashtable.merge(variables, td.variables));
100: }
101:
102: /**
103: Erzeugt eine neue Hashtabelle aus der alten und der Uebergebenen, wobei
104: im Unterschied zu prepareMergedApply() auf jeden Fall ein neuer Scope
105: erzeugt wird, d.h. die uebergebene Tabelle nur kopiert wird und nicht evtl.
106: die alte ersetzt. Vorhandene Eintraege in der alten bleiben erhalten
107: (siehe TKHashtable.merge());
108: */
109: public void merge(TKTemplateData td) {
110: if (variables == null)
111: variables = new TKHashtable();
112:
113: if ((td != null) && (td.variables != null))
114: variables.merge(td.variables);
115: }
116:
117: public void setVariable(Object key, Object value) {
118: if ((parent == null) || (parent.variables != variables)) {
119: variables.put(key, value);
120: }
121: if (parent != null) {
122: parent.setVariable(key, value);
123: }
124: }
125:
126: public void mergeVariables(TKHashtable merger) {
127: variables.merge(merger);
128: }
129:
130: public void concatVariables(TKHashtable merger) {
131: variables.concat(merger);
132: }
133:
134: public void removeVariable(String key) {
135: variables.remove(key);
136: }
137:
138: public Object getVariable(Object key) {
139: Object back = variables.get(key);
140: if (back == null && lookup != null)
141: back = lookup.getVariable(key);
142: // if (back == null && domData != null)
143: // back = ((DOMModel)domData).getVariable((String) key);
144: return back;
145: }
146:
147: public void setLocalVariable(Object key, Object value) {
148: variables.put(key, value);
149: }
150:
151: public void extendVariable(String key, Object value) {
152: variables.extend(key, value);
153: }
154:
155: /**
156: in nested lists, there is sometimes the neccessarity to pass some data from
157: the implementation of the outer iterator to the implementation of the inner
158: iterator. this can be done by the enumeration context. the implementation
159: ensures, that a enumerationContext which is set by a call of the apply-method
160: of the outer iterator is available to all corresponding apply-calls of the
161: inner iterator.
162: */
163:
164: public void setEnumerationContext(Object key, Object value) {
165: enumerationContext.put(key, value);
166: }
167:
168: /**
169: @see setEnumerationContext
170: */
171:
172: public Object getEnumerationContext(Object key) {
173: Object result;
174: return ((result = enumerationContext.get(key)) == null) ? (parent == null ? null
175: : parent.getEnumerationContext(key))
176: : result;
177: }
178:
179: }
|