//
// This software is now distributed according to
// the Lesser Gnu Public License.  Please see
// http://www.gnu.org/copyleft/lesser.txt for
// the details.
//    -- Happy Computing!
//
package com.stevesoft.pat;

/**
        Shareware: package pat
   <a href="copyright.html">Copyright 2001, Steven R. Brandt</a>
 */
/**
 This class is used to store a result from Regex */
public class RegRes
    implements Cloneable
{
  protected int[] marks = null;
  protected boolean didMatch_ = false;
  protected StringLike src = null;

  /** Obtain the text String that was matched against. */
  public String getString()
  {
    return src.toString();
  }

  /** Obtain the source StringLike object. */
  public StringLike getStringLike()
  {
    return src;
  }

  protected int charsMatched_ = 0, matchFrom_ = 0, numSubs_ = 0;
  public String toString()
  {
    StringBuffer sb = new StringBuffer();
    sb.append("match=" + matchedFrom() + ":" + charsMatched());
    if (!didMatch())
    {
      return sb.toString();
    }
    for (int i = 0; i < numSubs(); i++)
    {
      int n = i + 1;
      sb.append(" sub(" + n + ")=" + matchedFrom(n) +
                ":" + charsMatched(n));
    }
    return sb.toString();
  }

  public RegRes()
  {}

  public RegRes(RegRes r)
  {
    copyOutOf(r);
  }

  public void copyOutOf(RegRes r)
  {
    if (r.marks == null)
    {
      marks = null;
    }
    else
    {
      try
      {
        //marks = (Hashtable)r.marks.clone();
        marks = new int[r.marks.length];
        for (int i = 0; i < marks.length; i++)
        {
          marks[i] = r.marks[i];
        }
        //marks = (int[])r.marks.clone();
      }
      catch (Throwable t)
      {}
    }
    didMatch_ = r.didMatch_;
    src = r.src;
    charsMatched_ = r.charsMatched_;
    matchFrom_ = r.matchFrom_;
    numSubs_ = r.numSubs_;
  }

  public Object clone()
  {
    return new RegRes(this);
  }

  public boolean equals(RegRes r)
  {
    if (charsMatched_ != r.charsMatched_
        || matchFrom_ != r.matchFrom_
        || didMatch_ != r.didMatch_
        || numSubs_ != r.numSubs_
        || !src.unwrap().equals(r.src.unwrap()))
    {
      return false;
    }
    if (marks == null && r.marks != null)
    {
      return false;
    }
    if (marks != null && r.marks == null)
    {
      return false;
    }
    for (int i = 1; i <= numSubs_; i++)
    {
      if (matchedFrom(i) != r.matchedFrom(i))
      {
        return false;
      }
      else if (charsMatched(i) != r.charsMatched(i))
      {
        return false;
      }
    }
    return true;
  }

  /** Obtains the match if successful, null otherwise.*/
  public String stringMatched()
  {
    int mf = matchedFrom(), cm = charsMatched();
    return!didMatch_ || mf < 0 || cm < 0 ? null :
        src.substring(mf, mf + cm);
  }

  /** Obtains the position backreference number i begins to match, or
       -1 if backreference i was not matched. */
  public int matchedFrom(int i)
  {
    if (marks == null || i > numSubs_)
    {
      return -1;
    }
    //Integer in=(Integer)marks.get("left"+i);
    //return in == null ? -1 : in.intValue();
    return marks[i];
  }

  /** Obtains the number of characters matched by backreference i, or
       -1 if backreference i was not matched. */
  public int charsMatched(int i)
  {
    if (marks == null || i > numSubs_ || !didMatch_)
    {
      return -1;
    }
    //Integer in = (Integer)marks.get("right"+i);
    //int i2 = in==null ? -1 : in.intValue();
    int mf = matchedFrom(i);
    return mf < 0 ? -1 : marks[i + numSubs_] - matchedFrom(i);
  }

  /** This is either equal to matchedFrom(i)+charsMatched(i) if the match
      was successful, or -1 if it was not. */
  public int matchedTo(int i)
  {
    if (marks == null || i > numSubs_ || !didMatch_)
    {
      return -1;
    }
    return marks[i + numSubs_];
  }

  /** Obtains a substring matching the nth set
              of parenthesis from the pattern. See
              numSubs(void), or null if the nth backrefence did
              not match. */
  public String stringMatched(int i)
  {
    int mf = matchedFrom(i), cm = charsMatched(i);
    return!didMatch_ || mf < 0 || cm < 0 ? null :
        src.substring(mf, mf + cm);
  }

  /** This returns the part of the string that preceeds the match,
       or null if the match failed.*/
  public String left()
  {
    int mf = matchedFrom();
    return!didMatch_ || (mf < 0) ? null : src.substring(0, mf);
  }

  /** This returns the part of the string that follows the ith
              backreference, or null if the backreference did not match. */
  public String left(int i)
  {
    int mf = matchedFrom(i);
    return!didMatch_ || (mf < 0) ? null : src.substring(0, mf);
  }

  /** This returns the part of the string that follows the match,
       or null if the backreference did not match.*/
  public String right()
  {
    int mf = matchedFrom(), cm = charsMatched();
    return!didMatch_ || mf < 0 || cm < 0 ? null : src.substring(mf +
        cm, src.length());
  }

  /** This returns the string to the right of the ith backreference,
       or null if the backreference did not match. */
  public String right(int i)
  {
    int mf = matchedFrom(i), cm = charsMatched(i);
    return!didMatch_ || mf < 0 || cm < 0 ? null :
        src.substring(mf + cm, src.length());
  }

  /** After a successful match, this returns the location of
              the first matching character, or -1 if the match failed.*/
  public int matchedFrom()
  {
    return!didMatch_ ? -1 : matchFrom_;
  }

  /** After a successful match, this returns the number of
              characters in the match, or -1 if the match failed. */
  public int charsMatched()
  {
    return!didMatch_ || matchFrom_ < 0 ? -1 : charsMatched_;
  }

  /** This is matchedFrom()+charsMatched() after a successful match,
      or -1 otherwise. */
  public int matchedTo()
  {
    return!didMatch_ ? -1 : matchFrom_ + charsMatched_;
  }

  /** This returns the number of
              backreferences (parenthesis) in the pattern,
              i.e. the pattern "(ab)" has
              one, the pattern "(a)(b)" has two, etc. */
  public int numSubs()
  {
    return numSubs_;
  }

  /** Contains true if the last match was successful. */
  public boolean didMatch()
  {
    return didMatch_;
  }

  /** An older name for matchedFrom. */
  public int matchFrom()
  {
    return matchedFrom();
  }

  /** An older name for stringMatched(). */
  public String substring()
  {
    return stringMatched();
  }

  /** An older name for matchedFrom. */
  public int matchFrom(int i)
  {
    return matchedFrom(i);
  }

  /** An older name for stringMatched. */
  public String substring(int i)
  {
    return stringMatched(i);
  }
}