JAL-2629 can now filter by sequence e-value or bit score
[jalview.git] / src / com / stevesoft / pat / RegexWriter.java
1 //
2 // This software is now distributed according to
3 // the Lesser Gnu Public License.  Please see
4 // http://www.gnu.org/copyleft/lesser.txt for
5 // the details.
6 //    -- Happy Computing!
7 //
8 package com.stevesoft.pat;
9
10 import java.io.IOException;
11 import java.io.StringWriter;
12 import java.io.Writer;
13
14 import com.stevesoft.pat.wrap.WriterWrap;
15
16 /**
17  * A basic extension of FilterWriter that uses Transformer to make replacements
18  * in data as it is written out. It attempts to transform a string whenever the
19  * End-of-Line (EOL) character is written (which is, by default, the carriage
20  * return '\n'). Only the transformed portion of the line is written out,
21  * allowing the RegexWriter to wait until a complete pattern is present before
22  * attempting to write out info. Until a pattern completes, data is stored in a
23  * StringBuffer -- which can be accessed through the length() and charAt()
24  * methods of this class.
25  * <p>
26  * Note a subtlety here -- while a Transformer normally matches at higher
27  * priority against the pattern added to it first, this will not necessarily be
28  * true when a multi-line match is in progress because one of the complete
29  * multi-line patterns may not be completely loaded in RegexWriter's buffer. For
30  * this reason, the Transformer class is equipped with a way to add a pattern
31  * and replacement rule in three pieces -- a beginning (once this matches,
32  * nothing else in the Transformer can match until the whole pattern matches),
33  * an ending (the whole pattern is a String formed by adding the beginning and
34  * ending), and a ReplaceRule.
35  * <p>
36  * An illustration of this is given in the this <a
37  * href="../test/trans.java">example.</a>
38  */
39 public class RegexWriter extends Writer
40 {
41   Replacer repr;
42
43   Writer w;
44
45   WriterWrap ww;
46
47   StringBuffer sb = new StringBuffer();
48
49   PartialBuffer wrap = new PartialBuffer(sb);
50
51   int pos, epos;
52
53   int interval = 128;
54
55   int bufferSize = 2 * 1024;
56
57   public RegexWriter(Transformer t, Writer w)
58   {
59     this.w = w;
60     ww = new WriterWrap(w);
61     repr = t.getReplacer();
62     repr.setBuffer(new StringBufferLike(ww));
63     repr.setSource(wrap);
64   }
65
66   public RegexWriter(Regex r, Writer w)
67   {
68     this.w = w;
69     ww = new WriterWrap(w);
70     repr = r.getReplacer();
71     repr.setBuffer(new StringBufferLike(ww));
72     repr.setSource(wrap);
73   }
74
75   char EOLchar = '\n';
76
77   /**
78    * This method no longer serves any purpose.
79    * 
80    * @deprecated
81    */
82   @Deprecated
83   public char getEOLchar()
84   {
85     return EOLchar;
86   }
87
88   /**
89    * This method no longer serves any purpose.
90    * 
91    * @deprecated
92    */
93   @Deprecated
94   public void setEOLchar(char c)
95   {
96     EOLchar = c;
97   }
98
99   int max_lines = 2;
100
101   /**
102    * This method no longer serves any purpose.
103    * 
104    * @deprecated
105    */
106   @Deprecated
107   public int getMaxLines()
108   {
109     return max_lines;
110   }
111
112   /**
113    * This method no longer serves any purpose.
114    * 
115    * @deprecated
116    */
117   @Deprecated
118   public void setMaxLines(int ml)
119   {
120     max_lines = ml;
121   }
122
123   void write() throws IOException
124   {
125     Regex rex = repr.getRegex();
126     int eposOld = epos;
127     if (rex.matchAt(wrap, epos) && !wrap.overRun)
128     {
129       while (pos < epos)
130       {
131         w.write(sb.charAt(pos++));
132       }
133       int to = rex.matchedTo();
134       repr.setPos(to);
135       repr.apply(rex, rex.getReplaceRule());
136       epos = pos = to;
137       if (epos == eposOld && epos < sb.length())
138       {
139         epos++;
140       }
141     }
142     else if (!wrap.overRun && epos < sb.length())
143     {
144       epos++;
145     }
146     while (pos < epos)
147     {
148       w.write(sb.charAt(pos++));
149     }
150     if (epos == sb.length())
151     {
152       sb.setLength(1);
153       pos = epos = 1;
154     }
155     else if (pos > bufferSize)
156     {
157       for (int i = bufferSize; i < sb.length(); i++)
158       {
159         sb.setCharAt(i - bufferSize, sb.charAt(i));
160       }
161       pos -= bufferSize;
162       epos -= bufferSize;
163       sb.setLength(sb.length() - bufferSize);
164     }
165   }
166
167   public void write(char[] ca, int b, int n) throws IOException
168   {
169     int m = b + n;
170     for (int i = b; i < m; i++)
171     {
172       sb.append(ca[i]);
173       if (sb.length() % interval == interval - 1)
174       {
175         wrap.overRun = false;
176         while (epos + interval < sb.length() && !wrap.overRun)
177         {
178           write();
179         }
180       }
181     }
182   }
183
184   public void flush() throws IOException
185   {
186   }
187
188   public void close() throws IOException
189   {
190     wrap.allowOverRun = false;
191     wrap.overRun = false;
192     while (epos < sb.length())
193     {
194       write();
195     }
196     write();
197     w.close();
198   }
199
200   /** The current size of the StringBuffer in use by RegexWriter. */
201   public int length()
202   {
203     return sb.length();
204   }
205
206   /** The character at location i in the StringBuffer. */
207   public char charAt(int i)
208   {
209     return sb.charAt(i);
210   }
211
212   /** Set the interval at which regex patterns are checked. */
213   public void setInterval(int i)
214   {
215     interval = i;
216   }
217
218   /** Get the interval at which regex matches are checked. */
219   public int getInterval()
220   {
221     return interval;
222   }
223
224   /** Get the buffer size. */
225   public int getBufferSize()
226   {
227     return bufferSize;
228   }
229
230   /** Set the buffer size. */
231   public void setBufferSize(int i)
232   {
233     bufferSize = i;
234   }
235
236   static void test(String re, String inp, int n) throws Exception
237   {
238     StringWriter sw = new StringWriter();
239     Regex rex = Regex.perlCode(re);
240     String res1 = rex.replaceAll(inp);
241     RegexWriter rw = new RegexWriter(rex, sw);
242     for (int i = 0; i < inp.length(); i++)
243     {
244       rw.write(inp.charAt(i));
245     }
246     rw.close();
247     String res2 = sw.toString();
248     if (!res1.equals(res2))
249     {
250       System.out.println("nmax=" + n);
251       System.out.println("re=" + re);
252       System.out.println("inp=" + inp);
253       System.out.println("res1=" + res1);
254       System.out.println("res2=" + res2);
255       System.exit(255);
256     }
257   }
258
259   public static void main(String[] args) throws Exception
260   {
261     for (int n = 1; n <= 1; n++)
262     {
263       test("s/x/y/", "-----x123456789", n);
264       test("s/x/y/", "x123456789", n);
265       test("s/x/y/", "-----x", n);
266       test("s/x.*?x/y/", ".xx..x..x...x...x....x....x", n);
267       test("s/x.*x/[$&]/", "--x........x--xx", n);
268       test("s/x.*x/[$&]/", "--x........x------", n);
269       test("s/.$/a/m", "bb\nbbb\nbbbb\nbbbbb\nbbbbbb\nbbbbbbbbbbbb", n);
270       test("s/.$/a/", "123", n);
271       test("s/.$/a/", "bb\nbbb\nbbbb\nbbbbb\nbbbbbb\nbb", n);
272       test("s/^./a/", "bb\nbbb\nbbbb\nbbbbb\nbbbbbb\nbb", n);
273       test("s/$/a/", "bbb", n);
274       test("s/^/a/", "bbb", n);
275       test("s/^/a/", "", n);
276       test("s{.*}{N}", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", n);
277       test("s/.{0,7}/y/", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", n);
278       test("s/x/$&/", "xxx", n);
279     }
280     System.out.println("Success!!!");
281   }
282 }