JAL-2629 can now filter by sequence e-value or bit score
[jalview.git] / src / com / stevesoft / pat / RegRes.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 /**
11  Shareware: package pat
12  <a href="copyright.html">Copyright 2001, Steven R. Brandt</a>
13  */
14 /**
15  * This class is used to store a result from Regex
16  */
17 public class RegRes implements Cloneable
18 {
19   protected int[] marks = null;
20
21   protected boolean didMatch_ = false;
22
23   protected StringLike src = null;
24
25   /** Obtain the text String that was matched against. */
26   public String getString()
27   {
28     return src.toString();
29   }
30
31   /** Obtain the source StringLike object. */
32   public StringLike getStringLike()
33   {
34     return src;
35   }
36
37   protected int charsMatched_ = 0, matchFrom_ = 0, numSubs_ = 0;
38
39   public String toString()
40   {
41     StringBuffer sb = new StringBuffer();
42     sb.append("match=" + matchedFrom() + ":" + charsMatched());
43     if (!didMatch())
44     {
45       return sb.toString();
46     }
47     for (int i = 0; i < numSubs(); i++)
48     {
49       int n = i + 1;
50       sb.append(" sub(" + n + ")=" + matchedFrom(n) + ":" + charsMatched(n));
51     }
52     return sb.toString();
53   }
54
55   public RegRes()
56   {
57   }
58
59   public RegRes(RegRes r)
60   {
61     copyOutOf(r);
62   }
63
64   public void copyOutOf(RegRes r)
65   {
66     if (r.marks == null)
67     {
68       marks = null;
69     }
70     else
71     {
72       try
73       {
74         // marks = (Hashtable)r.marks.clone();
75         marks = new int[r.marks.length];
76         for (int i = 0; i < marks.length; i++)
77         {
78           marks[i] = r.marks[i];
79         }
80         // marks = (int[])r.marks.clone();
81       } catch (Throwable t)
82       {
83       }
84     }
85     didMatch_ = r.didMatch_;
86     src = r.src;
87     charsMatched_ = r.charsMatched_;
88     matchFrom_ = r.matchFrom_;
89     numSubs_ = r.numSubs_;
90   }
91
92   public Object clone()
93   {
94     return new RegRes(this);
95   }
96
97   public boolean equals(RegRes r)
98   {
99     if (charsMatched_ != r.charsMatched_ || matchFrom_ != r.matchFrom_
100             || didMatch_ != r.didMatch_ || numSubs_ != r.numSubs_
101             || !src.unwrap().equals(r.src.unwrap()))
102     {
103       return false;
104     }
105     if (marks == null && r.marks != null)
106     {
107       return false;
108     }
109     if (marks != null && r.marks == null)
110     {
111       return false;
112     }
113     for (int i = 1; i <= numSubs_; i++)
114     {
115       if (matchedFrom(i) != r.matchedFrom(i))
116       {
117         return false;
118       }
119       else if (charsMatched(i) != r.charsMatched(i))
120       {
121         return false;
122       }
123     }
124     return true;
125   }
126
127   /** Obtains the match if successful, null otherwise. */
128   public String stringMatched()
129   {
130     int mf = matchedFrom(), cm = charsMatched();
131     return !didMatch_ || mf < 0 || cm < 0 ? null : src.substring(mf, mf
132             + cm);
133   }
134
135   /**
136    * Obtains the position backreference number i begins to match, or -1 if
137    * backreference i was not matched.
138    */
139   public int matchedFrom(int i)
140   {
141     if (marks == null || i > numSubs_)
142     {
143       return -1;
144     }
145     // Integer in=(Integer)marks.get("left"+i);
146     // return in == null ? -1 : in.intValue();
147     return marks[i];
148   }
149
150   /**
151    * Obtains the number of characters matched by backreference i, or -1 if
152    * backreference i was not matched.
153    */
154   public int charsMatched(int i)
155   {
156     if (marks == null || i > numSubs_ || !didMatch_)
157     {
158       return -1;
159     }
160     // Integer in = (Integer)marks.get("right"+i);
161     // int i2 = in==null ? -1 : in.intValue();
162     int mf = matchedFrom(i);
163     return mf < 0 ? -1 : marks[i + numSubs_] - matchedFrom(i);
164   }
165
166   /**
167    * This is either equal to matchedFrom(i)+charsMatched(i) if the match was
168    * successful, or -1 if it was not.
169    */
170   public int matchedTo(int i)
171   {
172     if (marks == null || i > numSubs_ || !didMatch_)
173     {
174       return -1;
175     }
176     return marks[i + numSubs_];
177   }
178
179   /**
180    * Obtains a substring matching the nth set of parenthesis from the pattern.
181    * See numSubs(void), or null if the nth backrefence did not match.
182    */
183   public String stringMatched(int i)
184   {
185     int mf = matchedFrom(i), cm = charsMatched(i);
186     return !didMatch_ || mf < 0 || cm < 0 ? null : src.substring(mf, mf
187             + cm);
188   }
189
190   /**
191    * This returns the part of the string that preceeds the match, or null if the
192    * match failed.
193    */
194   public String left()
195   {
196     int mf = matchedFrom();
197     return !didMatch_ || (mf < 0) ? null : src.substring(0, mf);
198   }
199
200   /**
201    * This returns the part of the string that follows the ith backreference, or
202    * null if the backreference did not match.
203    */
204   public String left(int i)
205   {
206     int mf = matchedFrom(i);
207     return !didMatch_ || (mf < 0) ? null : src.substring(0, mf);
208   }
209
210   /**
211    * This returns the part of the string that follows the match, or null if the
212    * backreference did not match.
213    */
214   public String right()
215   {
216     int mf = matchedFrom(), cm = charsMatched();
217     return !didMatch_ || mf < 0 || cm < 0 ? null : src.substring(mf + cm,
218             src.length());
219   }
220
221   /**
222    * This returns the string to the right of the ith backreference, or null if
223    * the backreference did not match.
224    */
225   public String right(int i)
226   {
227     int mf = matchedFrom(i), cm = charsMatched(i);
228     return !didMatch_ || mf < 0 || cm < 0 ? null : src.substring(mf + cm,
229             src.length());
230   }
231
232   /**
233    * After a successful match, this returns the location of the first matching
234    * character, or -1 if the match failed.
235    */
236   public int matchedFrom()
237   {
238     return !didMatch_ ? -1 : matchFrom_;
239   }
240
241   /**
242    * After a successful match, this returns the number of characters in the
243    * match, or -1 if the match failed.
244    */
245   public int charsMatched()
246   {
247     return !didMatch_ || matchFrom_ < 0 ? -1 : charsMatched_;
248   }
249
250   /**
251    * This is matchedFrom()+charsMatched() after a successful match, or -1
252    * otherwise.
253    */
254   public int matchedTo()
255   {
256     return !didMatch_ ? -1 : matchFrom_ + charsMatched_;
257   }
258
259   /**
260    * This returns the number of backreferences (parenthesis) in the pattern,
261    * i.e. the pattern "(ab)" has one, the pattern "(a)(b)" has two, etc.
262    */
263   public int numSubs()
264   {
265     return numSubs_;
266   }
267
268   /** Contains true if the last match was successful. */
269   public boolean didMatch()
270   {
271     return didMatch_;
272   }
273
274   /** An older name for matchedFrom. */
275   public int matchFrom()
276   {
277     return matchedFrom();
278   }
279
280   /** An older name for stringMatched(). */
281   public String substring()
282   {
283     return stringMatched();
284   }
285
286   /** An older name for matchedFrom. */
287   public int matchFrom(int i)
288   {
289     return matchedFrom(i);
290   }
291
292   /** An older name for stringMatched. */
293   public String substring(int i)
294   {
295     return stringMatched(i);
296   }
297 }