source/mir/generator/FreemarkerGenerator.java

   1 package mir.generator;
   2
   3 import java.util.*;
   4 import java.io.*;
   5 import freemarker.template.*;
   6 import mir.entity.*;
   7 import mir.util.*;
   8 import mir.misc.*;
   9 import org.apache.struts.util.MessageResources;
  10
  11 public class FreemarkerGenerator implements Generator {
  12   private Template template;
  13
  14   public FreemarkerGenerator(Template aTemplate) {
  15     template = aTemplate;
  16   }
  17
  18   public void generate(PrintWriter anOutputWriter, Map aValues, PrintWriter aLogger) throws GeneratorException {
  19     aLogger.println("processing...<br/>");
  20                 template.process((TemplateModelRoot) makeMapAdapter(aValues), anOutputWriter);
  21     aLogger.println("processed...<br/>");
  22         }
  23
  24   private static TemplateScalarModel makeStringAdapter(String aString) {
  25     return new SimpleScalar(aString);
  26   }
  27
  28   private static TemplateHashModel makeMapAdapter(Map aMap)  {
  29     return new MapAdapter(aMap);
  30   }
  31
  32   private static TemplateListModel makeIteratorAdapter(Iterator anIterator) {
  33     return new IteratorAdapter(anIterator);
  34   }
  35
  36         private static TemplateModel makeAdapter(Object anObject) throws TemplateModelException {
  37           if (anObject == null)
  38             return null;
  39           if (anObject instanceof TemplateModel)
  40             return (TemplateModel) anObject;
  41 //        if (anObject instanceof Date)
  42 //          return new DateAdapter((Date) anObject);
  43           else if (anObject instanceof MessageResources)
  44             return new MessageMethodModel((MessageResources) anObject);
  45           else if (anObject instanceof String)
  46             return makeStringAdapter((String) anObject);
  47           else if (anObject instanceof Map)
  48             return makeMapAdapter((Map) anObject);
  49           else if (anObject instanceof Iterator)
  50             return makeIteratorAdapter((Iterator) anObject);
  51           else
  52             throw new TemplateModelException("Unadaptable class: " + anObject.getClass().getName());
  53         }
  54
  55         private static class MapAdapter implements TemplateModelRoot {
  56           Map map;
  57           Map valuesCache;
  58
  59           private MapAdapter(Map aMap) {
  60             map = aMap;
  61             valuesCache = new HashMap();
  62           }
  63
  64           public void put(String aKey, TemplateModel aModel) {
  65             valuesCache.put(aKey, aModel);
  66           }
  67
  68           public void remove(String aKey) {
  69             // ML: kinda tricky...
  70           }
  71
  72           public boolean isEmpty() {
  73             return map.isEmpty();
  74           }
  75
  76           public TemplateModel get(String aKey) throws TemplateModelException {
  77             if (!valuesCache.containsKey(aKey)) {
  78               Object value = map.get(aKey);
  79
  80               if (value == null)
  81                 throw new TemplateModelException("MapAdapter: no key "+aKey+" available");
  82
  83               valuesCache.put(aKey, makeAdapter(value));
  84             }
  85
  86             return (TemplateModel) valuesCache.get(aKey);
  87           }
  88         }
  89
  90         private static class IteratorAdapter implements TemplateListModel {
  91           Iterator iterator;
  92           List valuesCache;
  93           int position;
  94
  95           private IteratorAdapter(Iterator anIterator) {
  96             iterator = anIterator;
  97
  98             valuesCache = new Vector();
  99             position=0;
 100
 101
 102             if (iterator instanceof RewindableIterator) {
 103               ((RewindableIterator) iterator).rewind();
 104             }
 105           }
 106
 107           public boolean isEmpty() {
 108             return valuesCache.isEmpty() && !iterator.hasNext();
 109           }
 110
 111           private void getUntil(int anIndex) throws TemplateModelException {
 112             while (valuesCache.size()<=anIndex && iterator.hasNext())
 113             {
 114               valuesCache.add(makeAdapter(iterator.next()));
 115             }
 116           };
 117
 118           public TemplateModel get(int anIndex) throws TemplateModelException {
 119             TemplateModel result;
 120
 121             getUntil(anIndex);
 122
 123             if (anIndex<valuesCache.size())
 124             {
 125               result = (TemplateModel) valuesCache.get(anIndex);
 126
 127               return result;
 128             }
 129             else
 130               throw new TemplateModelException( "Iterator out of bounds" );
 131           }
 132
 133     public boolean hasNext() {
 134       return position<valuesCache.size() || iterator.hasNext();
 135     }
 136
 137     public boolean isRewound() {
 138       return position==0;
 139     }
 140
 141     public TemplateModel next() throws TemplateModelException {
 142       TemplateModel result;
 143
 144       if (hasNext()) {
 145         result = get(position);
 146         position++;
 147       }
 148       else
 149               throw new TemplateModelException( "Iterator out of bounds" );
 150
 151       return result;
 152     }
 153
 154     public void rewind() {
 155       position=0;
 156     }
 157         }
 158
 159         private static class ListAdapter implements TemplateListModel {
 160           List list;
 161           List valuesCache;
 162           int position;
 163
 164           private ListAdapter(List aList) {
 165             list = aList;
 166             valuesCache = new Vector();
 167             position=0;
 168           }
 169
 170           public boolean isEmpty() {
 171             return list.isEmpty();
 172           }
 173
 174           public TemplateModel get(int i) throws TemplateModelException {
 175
 176             if (i>=valuesCache.size() && i<list.size()) {
 177               for(int j=valuesCache.size(); j<=i; j++) {
 178                 valuesCache.add(makeAdapter(list.get(j)));
 179               }
 180             }
 181
 182             if (i<valuesCache.size())
 183               return (TemplateModel) valuesCache.get(i);
 184             else
 185               throw new TemplateModelException( "Iterator out of bounds" );
 186           }
 187
 188     public boolean hasNext() {
 189       return position<list.size();
 190     }
 191
 192     public boolean isRewound() {
 193       return position==0;
 194     }
 195
 196     public TemplateModel next() throws TemplateModelException {
 197       TemplateModel result;
 198
 199       if (hasNext()) {
 200         result = get(position);
 201         position++;
 202       }
 203             else
 204               throw new TemplateModelException( "Iterator out of bounds" );
 205
 206       return result;
 207     }
 208
 209     public void rewind() {
 210       position=0;
 211     }
 212         }
 213
 214 /*      private static class DateAdapter implements TemplateHashModel {
 215           Date date;
 216
 217           private DateAdapter(Date aDate) {
 218             date = aDate;
 219           }
 220
 221           public boolean isEmpty() {
 222             return false;
 223           }
 224
 225           public TemplateModel get(String aKey) throws TemplateModelException {
 226             return makeAdapter(new SimpleDateFormat(aKey).format(date));
 227           }
 228         }
 229 */
 230 }