SedFilteredResource.java

   1 package org.argeo.slc.core.execution;
   2
   3 import java.io.ByteArrayOutputStream;
   4 import java.io.File;
   5 import java.io.FileInputStream;
   6 import java.io.IOException;
   7 import java.nio.ByteBuffer;
   8 import java.nio.CharBuffer;
   9 import java.nio.channels.Channels;
  10 import java.nio.channels.FileChannel;
  11 import java.nio.channels.WritableByteChannel;
  12 import java.nio.charset.Charset;
  13 import java.nio.charset.CharsetDecoder;
  14 import java.nio.charset.CharsetEncoder;
  15 import java.util.ArrayList;
  16 import java.util.HashMap;
  17 import java.util.List;
  18 import java.util.Map;
  19 import java.util.StringTokenizer;
  20 import java.util.regex.Matcher;
  21 import java.util.regex.Pattern;
  22
  23 import org.apache.commons.io.IOUtils;
  24 import org.argeo.slc.SlcException;
  25 import org.springframework.beans.factory.FactoryBean;
  26 import org.springframework.beans.factory.InitializingBean;
  27 import org.springframework.core.io.ByteArrayResource;
  28 import org.springframework.core.io.Resource;
  29
  30 /** Experimental and suboptimal */
  31 public class SedFilteredResource implements FactoryBean, InitializingBean {
  32         private Resource source;
  33
  34         private List<String> filters = new ArrayList<String>();
  35         private Map<Pattern, String> patterns = new HashMap<Pattern, String>();
  36
  37         private String charset = "UTF-8";
  38         private Charset cs;
  39         private CharsetDecoder decoder;
  40         private CharsetEncoder encoder;
  41
  42         public Object getObject() throws Exception {
  43                 if (filters.size() == 0)
  44                         return source;
  45
  46                 //int capacity = 100 * 1024;// 100 KB
  47                 ByteBuffer bb;
  48                 if (source instanceof ByteArrayResource) {
  49                         bb = ByteBuffer.wrap(((ByteArrayResource) source).getByteArray());
  50                 } else {
  51                         try {
  52                                 File file = source.getFile();
  53                                 FileInputStream fis = new FileInputStream(file);
  54                                 FileChannel fc = fis.getChannel();
  55
  56                                 // Get the file's size and then map it into memory
  57                                 int sz = (int) fc.size();
  58                                 bb = fc.map(FileChannel.MapMode.READ_ONLY, 0, sz);
  59                         } catch (IOException e) {
  60                                 // ReadableByteChannel channel = Channels.newChannel(source
  61                                 // .getInputStream());
  62                                 // bb = ByteBuffer.allocateDirect(capacity);
  63                                 // int read = 0;
  64                                 // do {
  65                                 // read = channel.read(bb);
  66                                 // } while (read > 0);
  67                                 // FIXME : use nio to parse the stream as it goes
  68                                 bb = ByteBuffer.wrap(IOUtils.toByteArray(source
  69                                                 .getInputStream()));
  70                         }
  71                 }
  72                 CharBuffer cb = decoder.decode(bb);
  73                 for (Pattern pattern : patterns.keySet()) {
  74                         Matcher matcher = pattern.matcher(cb);
  75                         String output = matcher.replaceAll(patterns.get(pattern));
  76                         cb = CharBuffer.wrap(output);
  77                 }
  78 //              ByteBuffer bbout = encoder.encode(cb);
  79 //              ByteArrayOutputStream out = new ByteArrayOutputStream(capacity);
  80 //              WritableByteChannel wchannel = Channels.newChannel(out);
  81 //              wchannel.write(bbout);
  82                 ByteArrayResource res = new ByteArrayResource(cb.toString().getBytes());
  83                 return res;
  84         }
  85
  86         public Class<?> getObjectType() {
  87                 return Resource.class;
  88         }
  89
  90         public boolean isSingleton() {
  91                 return true;
  92         }
  93
  94         public void afterPropertiesSet() throws Exception {
  95                 cs = Charset.forName(charset);
  96                 decoder = cs.newDecoder();
  97                 encoder = cs.newEncoder();
  98
  99                 for (String sedStr : filters) {
 100                         sedStr = sedStr.trim();
 101                         if (sedStr.length() < 4)
 102                                 throw new SlcException(sedStr + " not properly formatted.");
 103                         if (sedStr.charAt(0) != 's')
 104                                 throw new SlcException(sedStr + " not properly formatted.");
 105                         Character sep = sedStr.charAt(1);
 106                         List<String> tokens = new ArrayList<String>(4);
 107                         StringTokenizer st = new StringTokenizer(sedStr, sep.toString());
 108                         while (st.hasMoreTokens())
 109                                 tokens.add(st.nextToken());
 110                         if (tokens.size() != 3 && tokens.size() != 4)
 111                                 throw new SlcException(sedStr + " not properly formatted.");
 112                         patterns.put(Pattern.compile(tokens.get(1)), tokens.get(2));
 113                 }
 114         }
 115
 116         public void setSource(Resource source) {
 117                 this.source = source;
 118         }
 119
 120         public void setFilters(List<String> filters) {
 121                 this.filters = filters;
 122         }
 123
 124         public void setCharset(String charset) {
 125                 this.charset = charset;
 126         }
 127
 128 }