KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > teamkonzept > publishing > markups > TKMarkupDefinition


1 /*
2  * $Header: /cvsroot/webman-cms/source/webman/com/teamkonzept/publishing/markups/TKMarkupDefinition.java,v 1.8 2001/06/11 09:14:10 alex Exp $
3  *
4  */

5 package com.teamkonzept.publishing.markups;
6
7 import java.sql.*;
8 import java.util.*;
9
10 import com.teamkonzept.db.*;
11 import com.teamkonzept.lib.*;
12 import com.teamkonzept.publishing.markups.db.*;
13 import com.teamkonzept.publishing.markups.db.queries.*;
14 import org.apache.log4j.Category;
15
16 public class TKMarkupDefinition implements TKSortable
17 {
18     private static final Category cat = Category.getInstance(TKMarkupDefinition.class);
19
20     public int id;
21     public String JavaDoc name;
22     public TKMarkupParamCall idPar;
23     public String JavaDoc info;
24     public boolean isAtom;
25
26     public int idParId = -1;
27
28     // Bitte nicht ˆffentlich machen !
29
private TKHashtable params;
30     private TKMarkupStatics statics = TKMarkupStatics.setup();
31
32     public TKMarkupDefinition (int id, String JavaDoc name, TKMarkupParamCall idPar,
33         boolean isAtom, String JavaDoc info, TKHashtable params) {
34
35         this.id = id;
36         this.name = name.toUpperCase();
37         this.idPar = idPar;
38         this.isAtom = isAtom;
39         this.info = info;
40         this.params = params;
41     }
42
43     public TKMarkupDefinition (int id, String JavaDoc name, int idParId, boolean isAtom, String JavaDoc info) {
44
45         this.id = id;
46         this.name = name.toUpperCase();
47         this.idPar = null;
48         this.isAtom = isAtom;
49         this.info = info;
50         this.params = null;
51
52         this.idParId = idParId;
53     }
54
55     public TKMarkupDefinition (TKMarkupDefinition definition, Enumeration params) throws Error JavaDoc {
56
57         if (definition == null) throw new Error JavaDoc ("Markup-Definition fehlt");
58
59         this.id = definition.id;
60         this.name = definition.name.toUpperCase();
61         this.idPar = definition.idPar;
62         this.isAtom = definition.isAtom;
63         this.info = definition.info;
64
65         this.params = null;
66         if (params == null) return;
67
68         while ((params != null) && (params.hasMoreElements())) {
69
70             TKMarkupParamCall paramDef = (TKMarkupParamCall) params.nextElement();
71             if ((paramDef != null) && (paramDef.name != null)) defineParam (paramDef);
72         }
73     }
74
75     public void setIdPar (TKMarkupParamCall idPar) {
76
77         if (idPar != null) this.idPar = idPar;
78     }
79
80     public void unSetIdPar () {
81
82         this.idPar = null;
83     }
84
85     public Enumeration allParams () {
86
87         return params == null ? null : params.elements();
88     }
89
90     public TKMarkupParamCall lookupParam (String JavaDoc name) {
91
92         return params == null ? null : name == null ? null : (TKMarkupParamCall) params.get(name);
93     }
94
95     public void defineParam (TKMarkupParamCall param) {
96
97         if ((param == null) || (param.name == null) ||
98             (param.name.length() == 0)) return;
99
100         if (params == null) this.params = new TKHashtable ();
101         params.put (param.name,param);
102
103         if ((idParId >= 0) && (idParId == param.param.id)) idPar = param;
104     }
105
106     public static Enumeration allMarkups () {
107
108         return TKMarkupStatics.setup().markupNames.elements();
109     }
110
111     public static Enumeration allMarkups (TKMarkupStatics statics) {
112
113         return statics.markupNames.elements();
114     }
115
116     public static Enumeration allAtomMarkups () {
117
118         TKVector vec = new TKVector();
119
120         Enumeration e = TKMarkupStatics.setup().markupNames.elements();
121         while ((e != null) && e.hasMoreElements()) {
122
123             TKMarkupDefinition definition = (TKMarkupDefinition) e.nextElement();
124
125             if ((definition != null ) && definition.isAtom)
126                 vec.addElement(definition);
127         }
128
129         return vec.elements();
130     }
131
132     public static Enumeration allCompoundMarkups () {
133
134         TKVector vec = new TKVector();
135
136         Enumeration e = TKMarkupStatics.setup().markupNames.elements();
137         while ((e != null) && e.hasMoreElements()) {
138
139             TKMarkupDefinition definition = (TKMarkupDefinition) e.nextElement();
140
141             if ((definition != null ) && !definition.isAtom)
142                 vec.addElement(definition);
143         }
144
145         return vec.elements();
146     }
147
148     public static void define (TKMarkupStatics statics, TKMarkupDefinition definition) {
149
150         if ((definition == null) || (definition.id < 0)) return;
151
152         statics.markupIds.put (new Integer JavaDoc(definition.id),definition);
153         statics.markupNames.put (definition.name.toUpperCase(),definition);
154     }
155
156     public static synchronized void define (TKMarkupDefinition definition) {
157
158         define (TKMarkupStatics.setup(),definition);
159     }
160
161     public static synchronized void unDefine (String JavaDoc name) {
162
163         if (name == null) return;
164
165         TKMarkupStatics statics = TKMarkupStatics.setup();
166         TKMarkupDefinition definition = lookup (statics,name);
167
168         if (definition != null) statics.markupIds.remove (new Integer JavaDoc(definition.id));
169         if (name != null) statics.markupNames.remove (name.toUpperCase());
170     }
171
172     public static synchronized void unDefine (int id) {
173
174         if (id < 0) return;
175
176         TKMarkupStatics statics = TKMarkupStatics.setup();
177         TKMarkupDefinition definition = lookup (id);
178
179         if ((definition != null) && (definition.name != null))
180             statics.markupNames.remove (definition.name.toUpperCase());
181
182         statics.markupIds.remove (new Integer JavaDoc(id));
183     }
184
185     public static synchronized TKMarkupDefinition lookup (TKMarkupStatics statics, String JavaDoc name) {
186
187         return name == null ? null : (TKMarkupDefinition) statics.markupNames.get(name.toUpperCase());
188     }
189
190     public static synchronized TKMarkupDefinition lookup (TKMarkupStatics statics, int id) {
191
192         return id < 0 ? null : (TKMarkupDefinition) statics.markupIds.get(new Integer JavaDoc(id));
193     }
194
195     public static TKMarkupDefinition lookup (String JavaDoc name) {
196
197         return lookup (TKMarkupStatics.setup(),name);
198     }
199
200     public static TKMarkupDefinition lookup (int id) {
201
202         return lookup (TKMarkupStatics.setup(),id);
203     }
204
205     public static void defineParam (TKHashtable params, TKMarkupParamCall paramCall) {
206
207         if ((paramCall == null) || (paramCall.name == null)) return;
208
209         params.put (paramCall.name.toUpperCase(),paramCall);
210     }
211
212     public static void defineParam (TKMarkupStatics statics, int id, TKMarkupParamCall paramCall)
213         throws Exception JavaDoc {
214
215         if ((paramCall == null) || (paramCall.param == null) ||
216             (paramCall.param.id < 0)) return;
217
218         TKMarkupDefinition definition = lookup(statics,id);
219         if (definition == null)
220             throw new Exception JavaDoc ("TKMarkupDefinition.defineParam(): markup-id "+
221                 id+" undefined in DB");
222
223         definition.defineParam(paramCall);
224
225         if (definition.idParId == paramCall.param.id) definition.idPar = paramCall;
226     }
227
228     public String JavaDoc toString() {
229
230         StringBuffer JavaDoc buf = new StringBuffer JavaDoc();
231
232         buf.append("name=").append(name)
233             .append(" id=").append(id)
234             .append(" idPar=[").append(idPar).append(']')
235             .append(" info=").append(info)
236             .append(" isAtom=").append(isAtom);
237
238         Enumeration e = allParams();
239         while ((e != null) && e.hasMoreElements()) {
240
241             TKMarkupParamCall param = (TKMarkupParamCall) e.nextElement();
242             if (param != null) buf.append(" param=[").append(param).append(']');
243         }
244
245         return new String JavaDoc (buf);
246     }
247
248     public int cmp (TKSortable other) {
249
250         if (!(other instanceof TKMarkupDefinition))
251             return toString().compareTo (other.toString());
252
253         TKMarkupDefinition otherMarkup = (TKMarkupDefinition) other;
254
255         if ((name == null) && (otherMarkup.name != null)) return -1;
256         else if ((name != null) && (otherMarkup.name == null)) return 1;
257         else if ((name == null) && (otherMarkup.name == null)) return 0;
258         else return name.compareTo (otherMarkup.name);
259     };
260
261     public static boolean doCrConversion (TKMarkupStatics statics) {
262
263         return statics.doCrConversion;
264
265     }
266
267     public static String JavaDoc crMarkup (TKMarkupStatics statics) {
268
269         return statics.crMarkup;
270
271     }
272
273     public static String JavaDoc crcrMarkup (TKMarkupStatics statics) {
274
275         return statics.crcrMarkup;
276
277     }
278
279     public static void doCrConversion (TKMarkupStatics statics, boolean doCrConversion) {
280
281         statics.doCrConversion = doCrConversion;
282     }
283
284     public static void crMarkup (TKMarkupStatics statics, String JavaDoc crMarkup) {
285
286         if ((crMarkup != null) && (crMarkup.trim().length() == 0)) crMarkup = null;
287         statics.crMarkup = crMarkup;
288     }
289
290     public static void crcrMarkup (TKMarkupStatics statics, String JavaDoc crcrMarkup) {
291
292         if ((crcrMarkup != null) && (crcrMarkup.trim().length() == 0)) crcrMarkup = null;
293         statics.crcrMarkup = crcrMarkup;
294     }
295
296     public static boolean doCrConversion () {
297
298         return doCrConversion (TKMarkupStatics.setup());
299
300     }
301
302     public static String JavaDoc crMarkup () {
303
304         return crMarkup (TKMarkupStatics.setup());
305
306     }
307
308     public static String JavaDoc crcrMarkup () {
309
310         return crcrMarkup (TKMarkupStatics.setup());
311
312     }
313
314     public static void doCrConversion (boolean doCrConversion) {
315
316         doCrConversion (TKMarkupStatics.setup(),doCrConversion);
317     }
318
319     public static void crMarkup (String JavaDoc crMarkup) {
320
321         crMarkup (TKMarkupStatics.setup(),crMarkup);
322     }
323
324     public static void crcrMarkup (String JavaDoc crcrMarkup) {
325
326         crcrMarkup (TKMarkupStatics.setup(),crcrMarkup);
327     }
328
329     public static void getDefinitions() throws SQLException {
330
331         TKMarkupStatics statics = TKMarkupStatics.setup();
332
333         statics.markupNames = new TKHashtable ();
334         statics.markupIds = new TKHashtable ();
335
336         TKQuery q = TKDBManager.newQuery(TKMarkupGetDefinitions.class);
337         q.execute();
338         ResultSet rs = q.fetchResultSet();
339
340         while (rs.next()) {
341
342             TKMarkupDefinition markup = TKMarkupDefinitionDBData.newMarkupFromResultSet (rs);
343             if (markup != null) define (statics,markup);
344         }
345
346         rs = q.fetchResultSet();
347
348         while (rs.next()) {
349
350             try {
351                 TKMarkupParamCallTableData param =
352                     new TKMarkupParamCallTableData (rs);
353
354                 if (param != null) defineParam (statics,param.markupId,param.param);
355
356             } catch (Exception JavaDoc ex)
357             {
358                 cat.error ("TKMarkupParamCall.getDefinitions() failed: ", ex);
359             }
360         }
361
362         String JavaDoc doConversionStr = null;
363         String JavaDoc crMarkup = null;
364         String JavaDoc crcrMarkup = null;
365
366         q = TKDBManager.newQuery( TKMarkupPropGet.class);
367         q.execute();
368         rs = q.fetchResultSet();
369
370         while (rs.next()) {
371
372             String JavaDoc name = rs.getString ("NAME");
373             String JavaDoc value = rs.getString ("VALUE");
374
375             if (name == null);
376             else if (name.trim().equalsIgnoreCase ("CR_CONTROL")) doConversionStr = value;
377             else if (name.trim().equalsIgnoreCase ("CR_MARKUP")) crMarkup = value;
378             else if (name.trim().equalsIgnoreCase ("CR_CR_MARKUP")) crcrMarkup = value;
379         }
380
381         boolean doConversion = doConversionStr != null && !doConversionStr.trim().equals ("0");
382
383         TKMarkupDefinition.doCrConversion (statics,doConversion);
384         TKMarkupDefinition.crMarkup (statics,crMarkup);
385         TKMarkupDefinition.crcrMarkup (statics,crcrMarkup);
386     }
387
388     public static synchronized void setup () {
389
390         try {
391             getDefinitions();
392         }
393         catch (Exception JavaDoc ex)
394         {
395             cat.error ("TKMarkupDefinition.setup() failed: ", ex);
396         } catch (TKSQLError er)
397         {
398             cat.error("TKMarkupDefinition.setup() failed: ", er);
399         }
400     }
401
402     public static void putCrControl(
403         boolean doCrConversion, String JavaDoc crMarkup, String JavaDoc crcrMarkup) throws SQLException, Exception JavaDoc {
404
405         StringBuffer JavaDoc diagnostics = new StringBuffer JavaDoc ();
406
407         TKQuery q = TKDBManager.newQuery(TKMarkupPropPut.class);
408         q.setQueryParams( "CR_CONTROL", String.valueOf (doCrConversion ? 1 : 0));
409         q.setQueryParams( "CR_MARKUP", crMarkup == null ? "" : crMarkup);
410         q.setQueryParams( "CR_CR_MARKUP", crcrMarkup == null ? "" : crcrMarkup);
411         q.execute();
412
413         TKMarkupStatics statics = TKMarkupStatics.setup();
414
415         TKMarkupDefinition.doCrConversion (statics,doCrConversion);
416         TKMarkupDefinition.crMarkup (statics,crMarkup);
417         TKMarkupDefinition.crcrMarkup (statics,crcrMarkup);
418     }
419
420     public static synchronized void saveCrControl (
421         boolean doCrConversion, String JavaDoc crMarkup, String JavaDoc crcrMarkup)
422     {
423
424         try
425         {
426             putCrControl(doCrConversion,crMarkup,crcrMarkup);
427         } catch (Throwable JavaDoc ex)
428         {
429             cat.error("TKMarkupDefinition.saveCrControl() failed: ", ex);
430         }
431     }
432
433     public static void putDefinition(TKMarkupDefinition definition) throws SQLException, Exception JavaDoc
434     {
435         if (definition == null) return;
436
437         StringBuffer JavaDoc diagnostics = new StringBuffer JavaDoc ();
438         TKMarkupDefinitionDBData dbData = new TKMarkupDefinitionDBData (definition,diagnostics);
439
440         if (definition.id < 0) TKMarkupDefinitionDBInterface.New (dbData);
441
442         TKMarkupDefinitionDBInterface.Put (dbData);
443
444         if (diagnostics.length() != 0) throw new Exception JavaDoc (diagnostics.toString());
445
446         unDefine (definition.id);
447         definition.id = dbData.markup.id;
448         define (dbData.markup);
449     }
450
451     public synchronized void save () throws Exception JavaDoc {
452
453         try { putDefinition(this); } catch (Exception JavaDoc ex)
454         {
455             cat.error ("TKMarkupDefinition.save() failed: definition="+this, ex);
456             throw new Exception JavaDoc ("save failed: "+ex);
457
458         } catch (TKSQLError er)
459         {
460             cat.error("TKMarkupDefinition.save() failed: definition="+this, er);
461             throw new Exception JavaDoc ("save failed: "+ er);
462         }
463     }
464
465     public static void deleteDefinition(TKMarkupDefinition definition) throws SQLException, Exception JavaDoc {
466
467         if (definition == null) return;
468
469         StringBuffer JavaDoc diagnostics = new StringBuffer JavaDoc ();
470         TKMarkupDefinitionDBData dbData = new TKMarkupDefinitionDBData (definition,diagnostics);
471
472         TKMarkupDefinitionDBInterface.Del (dbData);
473
474         if (diagnostics.length() != 0) throw new Exception JavaDoc (diagnostics.toString());
475
476         unDefine (dbData.markup.id);
477     }
478
479     public synchronized void delete () throws Exception JavaDoc {
480
481         try { deleteDefinition(this); } catch (Exception JavaDoc ex)
482         {
483             cat.error("TKMarkupDefinition.delete() failed: definition="+this, ex);
484             throw new Exception JavaDoc ("delete failed: "+ex);
485
486         } catch (TKSQLError er)
487         {
488             cat.error("TKMarkupDefinition.delete() failed: definition="+this, er);
489             throw new Exception JavaDoc ("delete failed: definition='"+this+"'");
490         }
491     }
492 }
493
494
Popular Tags