JAL-2629 can now filter by sequence e-value or bit score
[jalview.git] / src / com / stevesoft / pat / RegexReader.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.Reader;
12
13 import com.stevesoft.pat.wrap.StringBufferWrap;
14
15 /**
16  * This class allows you to replace the text in strings as you read them in. Be
17  * careful what you do with this freedom... using Regex.perlCode("s{.*}{x}s") as
18  * your pattern will result in loading the entire contents of the Reader into
19  * memory.
20  */
21 public class RegexReader extends Reader
22 {
23   RBuffer rb = new RBuffer(new StringBuffer());
24
25   PartialBuffer wrap = new PartialBuffer(rb.sb);
26
27   boolean moreToRead = true;
28
29   Reader r;
30
31   Replacer rp;
32
33   // the buffer size
34   int nmax = 2 * 1024;
35
36   public RegexReader(Regex rex, Reader r)
37   {
38     this.r = r;
39     rp = rex.getReplacer();
40   }
41
42   public RegexReader(Transformer tex, Reader r)
43   {
44     this.r = r;
45     rp = tex.getReplacer();
46   }
47
48   public void reset() throws IOException
49   {
50     r.reset();
51     rb = new RBuffer(new StringBuffer());
52     wrap = new PartialBuffer(rb.sb);
53     moreToRead = true;
54   }
55
56   void readData() throws IOException
57   {
58     int c;
59     int n = 0;
60     while ((c = r.read()) != -1)
61     {
62       rb.sb.append((char) c);
63       if (n++ > nmax)
64       {
65         break;
66       }
67     }
68     if (c == -1 && n == 0)
69     {
70       moreToRead = false;
71       wrap.allowOverRun = false;
72     }
73   }
74
75   void getMoreData() throws IOException
76   {
77     while (rb.pos >= rb.epos)
78     {
79       wrap.overRun = false;
80       if (rb.next != null)
81       {
82         rb = rb.next;
83       }
84       else if (rb.done)
85       {
86         break;
87       }
88       else if (rb.epos >= rb.sb.length() && rb.epos > nmax)
89       {
90         rb.pos = 1;
91         rb.epos = 1;
92         rb.sb.setLength(1);
93         readData();
94       }
95       else if (rb.epos >= rb.sb.length() && moreToRead)
96       {
97         readData();
98       }
99       else if (rp.getRegex().matchAt(wrap, rb.epos))
100       {
101         if (wrap.overRun)
102         {
103           readData();
104         }
105         else
106         {
107           StringBufferWrap sbw = new StringBufferWrap();
108           StringBufferLike sbl = new StringBufferLike(sbw);
109           /*
110            * ReplaceRule rr = rex.getReplaceRule(); while(rr != null) {
111            * rr.apply(sbl,rex); rr = rr.next; }
112            */
113           Regex rex = rp.getRegex();
114           int npos = rex.matchedTo();
115           rp.setBuffer(sbl);
116           rp.setSource(wrap);
117           rp.setPos(npos);
118           rp.apply(rex, rex.getReplaceRule());
119           int opos = rb.epos;
120           RBuffer rb2 = new RBuffer((StringBuffer) sbw.unwrap());
121           rb2.epos = rb2.sb.length();
122           RBuffer rb3 = new RBuffer(rb.sb);
123
124           rb.next = rb2;
125           rb2.next = rb3;
126
127           if (npos == opos)
128           {
129             rb3.epos = npos + 1;
130             if (rb3.epos > rb3.sb.length())
131             {
132               if (rb.pos >= rb.epos)
133               {
134                 rb = rb.next;
135               }
136               rb3.pos = rb3.epos = 0;
137               rb3.done = true;
138               // break;
139             }
140             rb3.pos = npos;
141           }
142           else
143           {
144             rb3.pos = rb3.epos = npos;
145           }
146
147         }
148       }
149       else
150       {
151         if (wrap.overRun)
152         {
153           readData();
154         }
155         else if (rb.epos < rb.sb.length())
156         {
157           rb.epos++;
158         }
159         else
160         {
161           break;
162         }
163       }
164     }
165   }
166
167   public int read() throws IOException
168   {
169     if (rb.pos >= rb.epos)
170     {
171       getMoreData();
172       if (rb.pos >= rb.epos)
173       {
174         return -1;
175       }
176     }
177     // System.out.println(rb);
178     return rb.sb.charAt(rb.pos++);
179   }
180
181   public int read(char[] buf, int off, int len) throws IOException
182   {
183     int c = -1;
184     int end = off + len;
185     for (int i = off; i < end; i++)
186     {
187       c = read();
188       if (c < 0)
189       {
190         if (i == off)
191         {
192           return -1;
193         }
194         return i - off;
195       }
196       buf[i] = (char) c;
197     }
198     return len;
199   }
200
201   public void close() throws IOException
202   {
203     r.close();
204   }
205
206   public boolean markSupported()
207   {
208     return false;
209   }
210
211   /**
212    * Get the size of the working buffer. The current buffer may be larger if the
213    * pattern demands it.
214    */
215   public int getBufferSize()
216   {
217     return nmax;
218   }
219
220   /**
221    * Set the size of the working buffer. The current buffer may be larger if the
222    * pattern demands it.
223    */
224   public void setBufferSize(int n)
225   {
226     nmax = n;
227   }
228
229   int max_lines = 2;
230
231   /**
232    * This function no longer serves any purpose.
233    * 
234    * @deprecated
235    */
236   @Deprecated
237   public int getMaxLines()
238   {
239     return max_lines;
240   }
241
242   /**
243    * This function no longer serves any purpose.
244    * 
245    * @deprecated
246    */
247   @Deprecated
248   public void setMaxLines(int ml)
249   {
250     max_lines = ml;
251   }
252
253   char EOLchar = '\n';
254
255   /**
256    * This function no longer serves any purpose.
257    * 
258    * @deprecated
259    */
260   @Deprecated
261   public char getEOLchar()
262   {
263     return EOLchar;
264   }
265
266   /**
267    * This function no longer serves any purpose.
268    * 
269    * @deprecated
270    */
271   @Deprecated
272   public void setEOLchar(char c)
273   {
274     EOLchar = c;
275   }
276
277   public long skip(long d) throws IOException
278   {
279     // This is probably inefficient, I just did it
280     // this way to avoid possible bugs.
281     long n = 0;
282     while (n < d && read() != -1)
283     {
284       n++;
285     }
286     return n;
287   }
288
289   /*
290    * static void test(String re,String inp,int n) throws Exception { Reader r =
291    * new StringReader(inp); r = new BufferedReader(r); Regex rex =
292    * Regex.perlCode(re); String res1 = rex.replaceAll(inp); int c = -1;
293    * StringBuffer sb = new StringBuffer(); RegexReader rr = new
294    * RegexReader(rex,r); rr.setBufferSize(n); while( (c = rr.read()) != -1)
295    * sb.append((char)c); String res2 = sb.toString(); if(!res1.equals(res2)) {
296    * System.out.println("nmax="+n); System.out.println("re="+re);
297    * System.out.println("inp="+inp); System.out.println("res1="+res1);
298    * System.out.println("res2="+res2); System.exit(255); } } public static void
299    * main(String[] args) throws Exception { for(int n=6;n<15;n++) {
300    * test("s/x/y/","-----x123456789",n); test("s/x/y/","x123456789",n);
301    * test("s/x/y/","-----x",n);
302    * test("s/x.*?x/y/",".xx..x..x...x...x....x....x",n);
303    * test("s/x.*x/[$&]/","--x........x--xx",n);
304    * test("s/x.*x/[$&]/","--x........x------",n);
305    * test("s/.$/a/m","bb\nbbb\nbbbb\nbbbbb\nbbbbbb\nbbbbbbbbbbbb",n);
306    * test("s/.$/a/","123",n);
307    * test("s/.$/a/","bb\nbbb\nbbbb\nbbbbb\nbbbbbb\nbb",n);
308    * test("s/^./a/","bb\nbbb\nbbbb\nbbbbb\nbbbbbb\nbb",n);
309    * test("s/$/a/","bbb",n); test("s/^/a/","bbb",n); test("s/^/a/","",n);
310    * test("s{.*}{N}","xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",n);
311    * test("s/.{0,7}/y/","AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",n);
312    * test("s/x/$&/","xxx",n); } System.out.println("Success!!!"); }
313    */
314 }