d770f088858f35e53a3afdcb0e88b73f84863681
[jalview.git] / src / com / stevesoft / pat / Transformer.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 com.stevesoft.pat.wrap.*;
11
12 /**
13  * Replacement rule used by the Transformer.
14  * 
15  * @see com.stevesoft.pat.Transformer
16  */
17 class TransRepRule extends ReplaceRule
18 {
19   Transformer t;
20
21   TransRepRule(Transformer t)
22   {
23     this.t = t;
24   }
25
26   public String toString1()
27   {
28     return "";
29   }
30
31   public Object clone1()
32   {
33     return new TransRepRule(t);
34   }
35
36   public void apply(StringBufferLike sb, RegRes rr)
37   {
38     // get the ReplaceRule of the Regex that matched.
39     next = t.tp.ra[t.tp.pn].getReplaceRule();
40   }
41 }
42
43 /**
44  * Sometimes you want to replace a whole bunch of things that might occur within
45  * a single line of text. One efficient way to do this, both in terms of
46  * performance and programming ease, is with Transformer. The Transformer
47  * contains an array of Regex's and uses the Regex that matches earliest within
48  * the text to do the replacing, if two Regex's match at the same time it uses
49  * the one put in the Transformer first.
50  * <p>
51  * This feature can be used to prevent transformations from occurring in certain
52  * regions. For example, if I add the rule s'//.*'$&' and then add the rule
53  * s/hello/goodbye/ the Transformer will replace "hello" with "goodbye" except
54  * when it occurs inside a double-slash style of comment. The transformation on
55  * the comment goes first, does nothing, and precludes transformation on the
56  * same region of text as the s/hello/goodbye/ rule.
57  * <p>
58  * So far, at least, this class does not have the capability of turning into a
59  * giant robot :-)
60  */
61 public class Transformer
62 {
63   TransPat tp;
64
65   Regex rp = new Regex();
66
67   boolean auto_optimize;
68
69   /**
70    * Get a replacer to that works with the current Regex.
71    * 
72    * @see com.stevesoft.pat.Replacer
73    */
74   public Replacer getReplacer()
75   {
76     return rp.getReplacer();
77   }
78
79   /** Instantiate a new Transformer object. */
80   public Transformer(boolean auto)
81   {
82     auto_optimize = auto;
83     tp = new TransPat();
84     rp.setReplaceRule(new TransRepRule(this));
85     rp.thePattern = tp;
86   }
87
88   /** Add a new Regex to the set of Regex's. */
89   public void add(Regex r)
90   {
91     if (auto_optimize)
92     {
93       r.optimize();
94     }
95     tp.ra[tp.ra_len++] = r;
96     if (tp.ra.length == tp.ra_len)
97     {
98       Regex[] ra2 = new Regex[tp.ra_len + 10];
99       for (int i = 0; i < tp.ra_len; i++)
100       {
101         ra2[i] = tp.ra[i];
102       }
103       tp.ra = ra2;
104     }
105     rp.numSubs_ = r.numSubs_ > rp.numSubs_ ? r.numSubs_ : rp.numSubs_;
106   }
107
108   /** Returns the number of Regex's in this Transformer. */
109   public int patterns()
110   {
111     return tp.ra_len;
112   }
113
114   /** Get the Regex at position i in this Transformer. */
115   public Regex getRegexAt(int i)
116   {
117     if (i >= tp.ra_len)
118     {
119       throw new ArrayIndexOutOfBoundsException("i=" + i + ">=" + patterns());
120     }
121     if (i < 0)
122     {
123       throw new ArrayIndexOutOfBoundsException("i=" + i + "< 0");
124     }
125     return tp.ra[i];
126   }
127
128   /** Set the Regex at position i in this Transformer. */
129   public void setRegexAt(Regex rx, int i)
130   {
131     if (i >= tp.ra_len)
132     {
133       throw new ArrayIndexOutOfBoundsException("i=" + i + ">=" + patterns());
134     }
135     if (i < 0)
136     {
137       throw new ArrayIndexOutOfBoundsException("i=" + i + "< 0");
138     }
139     tp.ra[i] = rx;
140   }
141
142   /**
143    * Add a new Regex by calling Regex.perlCode
144    * 
145    * @see com.stevesoft.pat.Regex#perlCode(java.lang.String)
146    */
147   public void add(String rs)
148   {
149     Regex r = Regex.perlCode(rs);
150     if (r == null)
151     {
152       throw new NullPointerException("bad pattern to Regex.perlCode: " + rs);
153     }
154     add(r);
155   }
156
157   /**
158    * Add an array of Strings (which will be converted to Regex's via the
159    * Regex.perlCode method.
160    * 
161    * @see com.stevesoft.pat.Regex#perlCode(java.lang.String)
162    */
163   public void add(String[] array)
164   {
165     for (int i = 0; i < array.length; i++)
166     {
167       add(array[i]);
168     }
169   }
170
171   /** Replace all matches in the current String. */
172   public String replaceAll(String s)
173   {
174     return dorep(s, 0, s.length());
175   }
176
177   public StringLike replaceAll(StringLike s)
178   {
179     return dorep(s, 0, s.length());
180   }
181
182   /** Replace all matching patterns beginning at position start. */
183   public String replaceAllFrom(String s, int start)
184   {
185     return dorep(s, start, s.length());
186   }
187
188   /**
189    * Replace all matching patterns beginning between the positions start and end
190    * inclusive.
191    */
192   public String replaceAllRegion(String s, int start, int end)
193   {
194     return dorep(s, start, end);
195   }
196
197   Replacer repr = new Replacer();
198
199   final StringLike dorep(StringLike s, int start, int end)
200   {
201     StringLike tfmd = repr.replaceAllRegion(s, rp, start, end);
202     tp.lastMatchedTo = repr.lastMatchedTo;
203     return tfmd;
204   }
205
206   final String dorep(String s, int start, int end)
207   {
208     return dorep(new StringWrap(s), start, end).toString();
209   }
210
211   /** Replace the first matching pattern in String s. */
212   public String replaceFirst(String s)
213   {
214     return dorep(s, 0, s.length());
215   }
216
217   /**
218    * Replace the first matching pattern after position start in String s.
219    */
220   public String replaceFirstFrom(String s, int start)
221   {
222     return dorep(s, start, s.length());
223   }
224
225   /**
226    * Replace the first matching pattern that begins between start and end
227    * inclusive.
228    */
229   public String replaceFirstRegion(String s, int start, int end)
230   {
231     return dorep(s, start, end);
232   }
233 }