src/com/stevesoft/pat/Replacer.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 jalview.util.MessageManager;
  11
  12 import com.stevesoft.pat.wrap.StringWrap;
  13
  14 /** Internally used class. */
  15 class RegHolder
  16 {
  17   Regex me = null;
  18
  19   RegHolder prev = null;
  20 }
  21
  22 /**
  23  * Internally used class.
  24  *
  25  * @see CodeRule
  26  */
  27 class CodeVal
  28 {
  29   int pos;
  30
  31   char code;
  32
  33   CodeVal(int p, char c)
  34   {
  35     pos = p;
  36     code = c;
  37   }
  38
  39   public String toString()
  40   {
  41     return "(" + pos + "," + code + ")";
  42   }
  43 }
  44
  45 /**
  46  * To use this class, first use either the getReplacer() method from Transformer
  47  * or Regex. You can then use replaceAll, replaceFirst, etc. methods on the
  48  * Replacer in the same way that you can from either of those two classes.
  49  * <p>
  50  * The only potential difference between using the methods of Replacer to do the
  51  * replacing is that Replacer remembers changes to the replacing object between
  52  * calls to replaceAll, replaceFirst etc. For details, see the example file <a
  53  * href="http://javaregex.com/code/trans3.java.html">trans3.java</a>.
  54  *
  55  * @see com.stevesoft.pat.Transformer
  56  * @see com.stevesoft.pat.Regex
  57  */
  58 public class Replacer
  59 {
  60   boolean first;
  61
  62   /** Instantiate a new Replacer. */
  63   public Replacer()
  64   {
  65   }
  66
  67   public StringLike replaceFirstRegion(String s, Regex r, int start, int end)
  68   {
  69     return replaceFirstRegion(new StringWrap(s), r, start, end);
  70   }
  71
  72   /**
  73    * This method replaces the first occurence of the Regex in the String
  74    * starting with position pos according to the Replacer rule of this object.
  75    */
  76   public StringLike replaceFirstRegion(StringLike s, Regex r, int start,
  77           int end)
  78   {
  79     first = true;
  80     rh.me = r;
  81     rh.prev = null;
  82     return dorep(s, start, end);
  83   }
  84
  85   public StringLike replaceFirst(StringLike s)
  86   {
  87     return replaceFirstRegion(s, 0, s.length());
  88   }
  89
  90   public StringLike replaceFirstFrom(StringLike s, int start)
  91   {
  92     return replaceFirstRegion(s, start, s.length());
  93   }
  94
  95   public StringLike replaceFirstRegion(StringLike s, int start, int end)
  96   {
  97     first = true;
  98     return dorep(s, start, end);
  99   }
 100
 101   RegHolder rh = new RegHolder();
 102
 103   public StringLike replaceAllRegion(String s, Regex r, int start, int end)
 104   {
 105     return replaceAllRegion(new StringWrap(s), r, start, end);
 106   }
 107
 108   /**
 109    * This method replaces all occurences of the Regex in the String starting
 110    * with postition pos according to the Replacer rule of this object.
 111    */
 112   public StringLike replaceAllRegion(StringLike s, Regex r, int start,
 113           int end)
 114   {
 115     first = false;
 116     // reset
 117     rh.me = r;
 118     rh.prev = null;
 119     return dorep(s, start, end);
 120   }
 121
 122   public StringLike replaceAll(StringLike s)
 123   {
 124     return replaceAllRegion(s, 0, s.length());
 125   }
 126
 127   public StringLike replaceAllFrom(StringLike s, int start)
 128   {
 129     return replaceAllRegion(s, start, s.length());
 130   }
 131
 132   public StringLike replaceAllRegion(StringLike s, int start, int end)
 133   {
 134     first = false;
 135     return dorep(s, start, end);
 136   }
 137
 138   public String replaceAll(String s)
 139   {
 140     return replaceAllRegion(new StringWrap(s), 0, s.length()).toString();
 141   }
 142
 143   public String replaceAllFrom(String s, int start)
 144   {
 145     return replaceAllRegion(new StringWrap(s), start, s.length())
 146             .toString();
 147   }
 148
 149   public String replaceAllRegion(String s, int start, int end)
 150   {
 151     first = false;
 152     return dorep(new StringWrap(s), start, end).toString();
 153   }
 154
 155   final public boolean isSpecial(ReplaceRule x)
 156   {
 157     while (x != null)
 158     {
 159       if (x instanceof SpecialRule
 160               || (x instanceof RuleHolder && ((RuleHolder) x).held instanceof SpecialRule))
 161       {
 162         return true;
 163       }
 164       x = x.next;
 165     }
 166     return false;
 167   }
 168
 169   final public void apply1(RegRes rr)
 170   {
 171     rr.charsMatched_++;
 172     apply(rr, null);
 173     rr.charsMatched_--;
 174   }
 175
 176   final StringLike dorep(StringLike s, int start, int end)
 177   {
 178     StringLike ret = s;
 179     want_more_text = false;
 180     lastMatchedTo = 0;
 181     if (rh.me == null)
 182     {
 183       throw new NullPointerException(
 184               MessageManager
 185                       .getString("exception.replace_null_regex_pointer"));
 186     }
 187     if (rh.me._search(s, start, end))
 188     {
 189       int rmn = rh.me.matchedTo();
 190       if (rh.me.charsMatched() == 0 && !isSpecial(rh.me.getReplaceRule()))
 191       {
 192         apply1(rh.me);
 193         rmn++;
 194       }
 195       apply(rh.me);
 196       if (!first)
 197       {
 198         for (int i = rmn; !want_more_text && rh.me._search(s, i, end); i = rmn)
 199         {
 200           rmn = rh.me.matchedTo();
 201           if (rh.me.charsMatched() == 0)
 202           {
 203             if (!isSpecial(rh.me.getReplaceRule()))
 204             {
 205               apply1(rh.me);
 206             }
 207             rmn++;
 208           }
 209           apply(rh.me);
 210         }
 211       }
 212       ret = finish();
 213       ret = ret == null ? s : ret;
 214     }
 215     return ret;
 216   }
 217
 218   StringBufferLike sb = null;
 219
 220   StringLike src = null;
 221
 222   int pos = 0;
 223
 224   /**
 225    * This method allows you to apply the results of several matches in a
 226    * sequence to modify a String of text. Each call in the sequence must operate
 227    * on the same piece of text and the matchedFrom() of each RegRes given to
 228    * this method must be greater in value than the preceeding RegRes's
 229    * matchedTo() value.
 230    */
 231   public void apply(RegRes r, ReplaceRule rp)
 232   {
 233     if (rp == null || (rp.next == null && rp instanceof AmpersandRule))
 234     {
 235       return;
 236     }
 237     if (r.didMatch())
 238     {
 239       if (src == null)
 240       {
 241         src = r.getStringLike();
 242       }
 243       if (sb == null)
 244       {
 245         sb = new StringBufferLike(src.newStringBufferLike());
 246       }
 247       int rmf = r.matchedFrom();
 248       for (int ii = pos; ii < rmf; ii++)
 249       {
 250         sb.append(src.charAt(ii));
 251       }
 252
 253       for (ReplaceRule x = rp; x != null; x = x.next)
 254       {
 255         x.apply(sb, r);
 256         if (x instanceof SpecialRule)
 257         {
 258           if (x instanceof WantMoreTextReplaceRule && want_more_text_enable)
 259           {
 260             want_more_text = true;
 261           }
 262           else if (x instanceof PushRule)
 263           {
 264             RegHolder rh2 = new RegHolder();
 265             rh2.me = ((PushRule) x).NewRule;
 266             rh2.prev = rh;
 267             rh = rh2;
 268           }
 269           else if (x instanceof PopRule)
 270           {
 271             if (rh.prev != null)
 272             {
 273               rh = rh.prev;
 274             }
 275           }
 276           else if (x instanceof ChangeRule)
 277           {
 278             rh.me = ((ChangeRule) x).NewRule;
 279           }
 280         }
 281       }
 282       if (!want_more_text)
 283       {
 284         pos = r.matchedTo();
 285       }
 286     }
 287   }
 288
 289   boolean want_more_text = false, want_more_text_enable = false;
 290
 291   public boolean WantMoreText()
 292   {
 293     return want_more_text;
 294   }
 295
 296   /**
 297    * Another form of apply, it is the same as apply(r,r.getReplaceRule()).
 298    */
 299   public void apply(Regex r)
 300   {
 301     apply(r, r.getReplaceRule());
 302   }
 303
 304   /**
 305    * This finishes the replacement, appending the right() part of the last
 306    * RegRes given to substitute(RegRes). After this method is called, the
 307    * Replace object is reset to perform another substitution. If no RegRes
 308    * objects with a true didMatch are applied, this returns null.
 309    */
 310   public StringLike finish()
 311   {
 312     if (src == null)
 313     {
 314       return null;
 315     }
 316     // sb.append(src.substring(pos,src.length()));
 317     int s_end = src.length();
 318     for (int ii = pos; ii < s_end; ii++)
 319     {
 320       sb.append(src.charAt(ii));
 321     }
 322     src = null;
 323     lastMatchedTo = pos;
 324     pos = 0;
 325     StringLike retstr = sb.toStringLike();
 326     sb = null;
 327     return retstr;
 328   }
 329
 330   int lastMatchedTo = 0;
 331
 332   public Object clone()
 333   {
 334     Replacer r = new Replacer();
 335     r.first = first;
 336     r.src = src;
 337     r.sb = sb;
 338     r.pos = pos;
 339     r.lastMatchedTo = lastMatchedTo;
 340     r.want_more_text = want_more_text;
 341     r.want_more_text_enable = want_more_text_enable;
 342     r.rh.me = rh.me;
 343     r.rh.prev = rh.prev;
 344     return r;
 345   }
 346
 347   public int lastMatchedTo()
 348   {
 349     return lastMatchedTo;
 350   }
 351
 352   public Regex getRegex()
 353   {
 354     return rh.me;
 355   }
 356
 357   public void setSource(StringLike sl)
 358   {
 359     src = sl;
 360   }
 361
 362   public void setBuffer(StringBufferLike sbl)
 363   {
 364     sb = sbl;
 365   }
 366
 367   public void setPos(int pos)
 368   {
 369     this.pos = pos;
 370   }
 371 }