TKTemplate


1   /**
2    * Diese Klasse stellt folgende Funktionalitaeten zur Verfuegung:
3    *
4    * 1.   Die in einem Template vorkommenden TKTags werden gestzt
5    *
6    * 2.   Der Syntaxbaum eines Templates wird erzeugt
7    *
8    * 3.   Der Syntaxbaum eines Templates wird ausgelesen und je nach 
9    *      gesetzten Tags aus TKTemplateData als String generiert,
10   *      Dieser enthaelt eine fertige Seite, die an den Browser geschickt #
11   *      werden kann.
12   *  
13   * 4.   Der Syntaxbaum eines Templates wird in eine Datenbank abgelegt
14   *
15   * 5.   Das in der datenbank abgelegte Template wird aus der Datenbank ausgelesen
16   *      und ein Syntaxbaum wird generiert
17   */
18  package com.teamkonzept.lib;
19  
20  import java.io.*;
21  import com.oroinc.text.regex.*;
22  import javax.servlet.http.HttpServletRequest  ;
23  import com.teamkonzept.lib.TKException;
24  import com.teamkonzept.lib.templates.*;
25  import org.apache.log4j.Category;
26  
27  /**
28   * Die Klasse TKTemplate stellt Methoden fuer die Generierung eines Templates
29   * zur Verfuegung
30   * @author  $Author: sebastian $
31   * @version $Revision: 1.24 $
32   */
33  public class TKTemplate implements TemplateBasic, TemplateTypes
34  {
35      private static final Category CAT = Category.getInstance(TKTemplate.class);
36      
37      static protected final String   PAT_PRETAG                = "TK[_:]";
38      static protected final String   PAT_REFTAG                = "(SRC|HREF|ACTION|BACKGROUND)";
39      
40      static Pattern patCopyRight;
41      static Pattern patCleanEmpty;
42      static Pattern patBaseURL;
43      static public Pattern patTKTag; // REDESIGN: public ist n�tig weil TKTemplateSyntax das Pattern braucht
44  
45      static boolean initialized = false;
46      
47      private static String   NEW_LINE = System.getProperty("line.separator");
48      
49      private String   currAppName                      = "TKTemplate";
50      
51      /** Syntax des Templates */
52      public TKTemplateSyntax syntax                      = null;
53      
54      /** Daten f�r das Template */
55      public TKTemplateData td                            = null;
56      
57      /** das expandierte Template */
58      public String   text;
59  
60      /**
61      Returns a new syntax instance associated to the template.
62      Overwritten by TLKHTMLTemplate.
63      */
64      public TKTemplateSyntax newSyntax()
65      {
66          return new TKTemplateSyntax();
67      }
68      
69      /**
70      Returns a new syntax instance associated to the template.
71      Overwritten by TLKHTMLTemplate.
72      */
73      public TKTemplateSyntax newSyntax (Pattern patTKTag)
74      {
75          return new TKTemplateSyntax (patTKTag);
76      }
77      
78      public String   getType()
79      {
80          return TK_TEMPLATE;
81      }
82      
83      /**
84       * Konstruktor1
85       * Ein File-Objekt wird erzeugt und an Konstruktor2 uebergeben
86       *
87       * @param String filename, Pfad und Name des Templates
88       */
89      public TKTemplate( String   location ) throws TKTemplateSyntaxException, FileNotFoundException
90      {
91          init( location );
92      }
93      
94      /**
95       * Konstruktor3  
96       * Durch den Aufruf der statischen Methode init() werden Pattern fuer die 
97       * spaetere Patternsuche/ersetzung definiert und global zur Verfuegung gestellt.
98       *
99       *@param ts, Ein TKTemplateSyntax-Objekt 
100      *@param filename, das template als File-Objekt
101      */
102     public TKTemplate( TKTemplateSyntax ts/*, File templateFile*/ )
103     {
104         init( ts );
105     }
106     
107     public DOMTemplateData getDOMData()
108     {
109         return td.getDOMData();
110     }
111     
112     protected void init( TKTemplateSyntax ts )
113     {
114         if( !initialized ) initStatic(); // ???-alex
115         syntax = ts;
116         td = ts.getNewTemplateData();
117     }
118     
119     protected void init( String   location ) throws TKTemplateSyntaxException, FileNotFoundException
120     {
121         init( TKTemplateCache.getSyntax( location, this ) );
122     }
123     
124     
125     /**
126      * Ein TKListIterator wird gesetzt. Das TKListIterator-Objekt wird der
127      * Variablen listIterator der Klasse TKTemplateData zugewiesen.
128      * Aufruf dieser Methode: TemlateObjekt.setListIterator(TKListIteratorObject);  
129      *
130      * @param aIterator, Objekt vom typ TKLIstIterator
131      */
132     public void setListIterator(TKListIterator aIterator){
133         td.setListIterator(aIterator);
134     }
135     
136     /**
137      * Ein TKListIterator-Objekt, welches in der Klasse TKTemplateData existiert,
138      * wird zurueckgegeben.
139      * Aufruf dieser Methode: TemlateObjekt.getListIterator();  
140      *
141      * @return ein Objekt vom Typ TKListIterator  
142      */
143     public TKListIterator getListIterator(){
144         return td.getListIterator();
145     }
146     // nur fuer jsp wichtig !
147     public void setOriginalRequest(HttpServletRequest   request)
148     {
149     }
150 
151     /**
152     in nested lists, there is sometimes the neccessarity to pass some data from 
153     the implementation of the outer iterator to the implementation of the inner 
154     iterator. this can be done by the enumeration context. the implementation 
155     of the list-tags ensures, that the enumerationContext of a call of the 
156     apply-method of the outer iterator gets passed to all calls of the
157     corresponding calls of the inner iterator.
158     */
159     
160     public void setEnumerationContext( Object   key, Object   value )
161     {
162         td.setEnumerationContext( key, value );
163     }
164     
165     /**
166     @see setEnumerationContext
167     */
168     
169     public Object   getEnumerationContext( Object   key )
170     {
171         return td.getEnumerationContext( key );
172     }
173     
174     
175     
176     /**
177      * Ein Hash fuer die Ersetzung wird der Variable subst der Klasse
178      * TKTemplateData uebergeben. 
179      *   
180      * @param   ein Objekt vom Typ TKHashtable, der die zu ersetzenden 
181      *          Informationen enthaelt  
182      */
183     public void set( TKHashtable aSubst )
184     {
185         td.mergeVariables( aSubst );
186     }
187 
188     /**
189      * Ein Hash fuer die Ersetzung wird fuer die Klasse TKTemplateData
190      * erzeugt und in diesen eingefuegt.
191      *   
192      * @param String key, ein Schluessel    
193      * @param Object val, die Information zum Schluessel          
194      */
195     public void set( String   key, Object   val )
196     {
197         td.setLocalVariable( key, val );
198     }
199     
200     /**
201      * An einem Hash der Klasse TKTemplateData fuer die Ersetzung in einem 
202      * bestimmten Template wird ein  weiterer Hash angehaengt. 
203      * Die TKTags werden im Template durch die Values ersetzt. 
204      *
205      * Aufruf: templateObject.addSubst(TKHashtableObject)
206      *   
207      * @param TKHashtable aSubst, der zu konkatinierende Hash             
208      */
209     public void add( TKHashtable aSubst )
210     {
211         td.concatVariables( aSubst );
212     }
213     
214     /**
215      * An einem Hash fuer die Ersetzung in einem bestimmten Template wird ein 
216      * weitereres Element angehaengt. Die TKTags werden im Template durch die 
217      * Values ersetzt.  
218      * Aufruf: templateObject.addSubst("Schluessel",Object)
219      *
220      * @param String    key, ein Schluessel, z.B. der zu ersetzende TKTag   
221      * @param Object    val, der Wert zu dem Schuessel, durch den der TKTag 
222                         ersetzt werden soll           
223      */
224     public void add( String   key, Object   val )
225     {
226         td.extendVariable( key, val );
227     }
228     
229     /**
230      * Das substituierte Template wird als String zuueckgegeben.
231      * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates 
232      * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst 
233      * substituiert werden.  
234      *
235      * Bsp. Reihenfolge der Aufrufe: 
236      *      TKTemplateObject.doTagSubstitution();
237      *      TKTemplateObject.doCleanup();
238      *      TKTemplateObject.getText();
239      *
240      * @return einen String des substituierten Templates
241      */
242 
243     public String   getText()
244     {
245         return text;
246     }
247     
248     /**
249      * Die Instanzvariable ist mit "TKTemplate" initialisiert 
250      *
251      * @return einen String der Applikation.
252      */
253     public String   setAppName( String   appName )
254     {
255         return currAppName = appName;
256     }
257     
258     /**
259      * Das Template wird in den PrintStream geschrieben.
260      * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates 
261      * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst 
262      * substituiert werden.  
263      *
264      * Bsp. Reihenfolge der Aufrufe: 
265      *      TKTemplateObject.doTagSubstitution();
266      *      TKTemplateObject.doCleanup();
267      *      TKTemplateObject.printTemplate();
268      */
269     public void printTemplate( PrintStream out ){
270         out.print(text);
271     }
272     
273     /**
274      * Das Template wird in den Writer geschrieben.
275      * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates 
276      * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst 
277      * substituiert werden.  
278      *
279      * Bsp. Reihenfolge der Aufrufe: 
280      *      TKTemplateObject.doTagSubstitution();
281      *      TKTemplateObject.doCleanup();
282      *      TKTemplateObject.printTemplate();
283      */
284     public void printTemplate( Writer writer ) throws IOException
285     {
286         writer.write(text);
287     }
288     
289     /**
290      * Das Template wird auf stdout geschrieben.
291      * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates 
292      * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst 
293      * substituiert werden.  
294      *
295      * Bsp. Reihenfolge der Aufrufe: 
296      *      TKTemplateObject.doTagSubstitution();
297      *      TKTemplateObject.doCleanup();
298      *      TKTemplateObject.printTemplate();
299      */
300     public void printTemplate()
301     {
302         printTemplate( System.out );
303     }
304     
305     /**
306      * Das substituierte Template wird in ein File geschrieben werden.
307      * Hierfuer muss die Instanzvariable "text" mit dem Text eines Templates 
308      * zuvor gefuellt werden. Dies geschieht, indem die Tags im Template zuerst 
309      * substituiert werden.  
310      *
311      * Bsp. Reihenfolge der Aufrufe: 
312      *      TKTemplateObject.doTagSubstitution();
313      *      TKTemplateObject.doCleanup();
314      *      TKTemplateObject.printTemplate(String file)
315      *
316      * @param String file, der Filename des zu speichernden templates   
317      */
318     public void printTemplate(String   file) throws IOException {
319         FileOutputStream f = new FileOutputStream( file);  
320         PrintStream out =  new PrintStream(f);
321         
322         printTemplate( out );
323     }
324     
325     /**
326      * Durch den Aufruf der Methode doMainSubstitution enthaelt die 
327      * Instanzvariable "text" das Template mit den substituierten TKTags. 
328      * Die nicht vollstaendigen Pfade werden ersetzt.
329      *
330      * Die URL-Base ist gestzt, wenn Images ausserhalb des CGI-Verzeichnisses 
331      * abgelegt sind. Fuer diese Bilder muss der vollstaendige Pfad im 
332      * Template gesetzt werden.
333      */
334     public void doTagSubstitution() throws TKTemplateSyntaxException
335     {
336         doMainSubstitutions();
337     }
338 
339     /**
340      * Die Instanzvariable "text" enthaelt das Template mit den 
341      * substituierten TKTags
342      *
343      * 1.   TKTemplateData-Objekt.prepareApply() => Bearbeitung der Hashes
344      *      fuer folgende Tags: if,check,select, case
345      * 2.   Die Variable text enthaelt das generierte Template
346      */
347     public void doMainSubstitutions() throws TKTemplateSyntaxException
348     {
349         td.prepareApply();
350         
351         //OLD version using 'String's
352         // text = syntax.apply( td );
353         //OLD
354         
355         //NEW version using Writer
356         try {
357             StringWriter writer = new StringWriter();
358             syntax.apply( td, writer );
359             text = writer.toString();
360         }
361         catch (IOException e)
362         {
363             CAT.error("Catched IOException in TKTemplate.doMainSubstition() thrown by StringWriter", e);
364         }
365     }
366     
367     /**
368      * Nachdem alle Tags ersetzt worden sind, wird das Template gsaeubert,
369      * so dass nur noch regulaere Tags im Template existieren. Danach kann das
370      * Template ausgegeben werden.
371      *
372      * 1.Template-Objekt.doTagSubstitution()
373      * 2.Template-Objekt.doCleanup()
374      * 3.Template-Objekt.printTemplate()
375      */
376     public void doCleanup(){
377         text = Util.substitute( TKReg.getMatcher(), patCleanEmpty, NEW_LINE, text, Util.SUBSTITUTE_ALL );
378     }
379     
380     /**
381      * Pattern werden fuer die spaetere Patternsuche/ersetzung definiert und 
382      * global zur Verfuegung gestellt.
383      */
384     static void initStatic() {
385         if( initialized ) return;
386         
387         PatternCompiler compiler = TKReg.getCompiler();
388         
389         try {
390             patCopyRight        = compiler.compile( "<HTML>", Perl5Compiler.CASE_INSENSITIVE_MASK );
391             patBaseURL          = compiler.compile(" "+PAT_REFTAG+"\\s*\\=\\s*\"(?!(/|#|\\w+?(:|&#58)))", Perl5Compiler.CASE_INSENSITIVE_MASK);
392             patTKTag            = compiler.compile("</?"+PAT_PRETAG, Perl5Compiler.CASE_INSENSITIVE_MASK);
393             patCleanEmpty       = compiler.compile(NEW_LINE + "\\s*" + NEW_LINE);
394         } catch(MalformedPatternException e) {
395             CAT.error("Bad pattern.", e);
396         }
397         
398         initialized = true;
399     }
400 
401     static {
402         initStatic();
403     }
404 }
405 
406 
407
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags