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 }