patternformatter.java

MoMELog是J2ME的日志框架。它是非常简单的

   * @see momelog.Formatter#format(momelog.LogEvent, java.lang.StringBuffer)
   */
  public synchronized void format(LogEvent event, StringBuffer buffer)
  {
    for (int i = 0; i < this.patternParts.length; i++)
    {
      Object part = this.patternParts[i];
      if (part instanceof String)
        buffer.append((String) part);
      else ((FormatterRecord) part).format(event, buffer);
    }
  }

  /**
   * Sets conversion pattern to the specified value. After this method returns,
   * all new logging events are formatted using given conversion pattern.
   * 
   * @param pattern
   *          conversion pattern to set.
   * @throws IllegalArgumentException
   *           if given conversion pattern is of invalid format.
   */
  public synchronized void setPattern(String pattern)
  {
    if (pattern == null)
      pattern = DEFAULT_PATTERN;
    int l = pattern.length();
    Vector strs = new Vector();
    int oldPos = 0;
    for (int pos = pattern.indexOf('%'); pos >= 0 && ++pos < l; pos = pattern
        .indexOf('%', pos))
    {
      char c = pattern.charAt(pos);
      if (c != '%')
      {
        if (pos - oldPos > 1)
          strs.addElement(pattern.substring(oldPos, pos - 1));
        FormatterRecord fr = new FormatterRecord();;
        if (c == '-')
        {
          fr.left = false;
          if (++pos < l)
            c = pattern.charAt(pos);
        }

        for (; ++pos < l && c >= '0' && c <= '9'; c = pattern.charAt(pos))
          fr.min = fr.min * 10 + (c - '0');

        if (c == '.')
        {
          c = pattern.charAt(pos);
          for (; ++pos < l && c >= '0' && c <= '9'; c = pattern.charAt(pos))
            fr.max = fr.max * 10 + (c - '0');
        }
        switch (c)
        {
        case 'm':
          fr.type = RECORD_MESSAGE;
          break;
        case 'c':
          fr.type = RECORD_CATEGORY;
          break;
        case 'C':
          fr.type = RECORD_FINAL_CATEGORY;
          break;
        case 'e':
          fr.type = RECORD_ERROR;
          break;
        case 't':
          fr.type = RECORD_TIMESTAMP;
          break;
        case 'h':
          fr.type = RECORD_THREADNAME;
          break;
        }
        if (fr.type == RECORD_UNKNOWN)
          throw new IllegalArgumentException(
              "Unknown pattern formatting character '" + c + "' at " + pos);
        oldPos = pos;
        strs.addElement(fr);
      } else
      {
        if (++pos > oldPos)
          strs.addElement(pattern.substring(oldPos, pos - 1));
        oldPos = pos;
      }
    }
    if (oldPos < l)
      strs.addElement(pattern.substring(oldPos));
    Object[] res = new Object[strs.size()];
    strs.copyInto(res);
    synchronized (this)
    {
      this.patternParts = res;
      notify();
    }
  }

  /**
   * Configures {@link PatternFormatter} instance from given character sequence.
   * Character sequence should consist of lines separated by {@code new-line}
   * character. Each line should contain name-value pair separated by equal
   * sign ({@code =}). Spaces around property name are allowed and ignored.
   * Spaces around property value are allowed and significant.
   * </p>
   * <p>
   * {@link PatternFormatter} supports the only property - {@code pattern}. If
   * this property is specified more than one time, the last occurrence
   * prevails.
   * </p>
   * <table width="100%" border="1" cellpadding="2" cellspacing="0"> <col
   * width="15%"> <col width="*"> <col width="15%">
   * <tr valign="top">
   * <td>
   * <p>
   * <strong>Property Name</strong>
   * </p>
   * </td>
   * <td>
   * <p>
   * <strong>Description</strong>
   * </p>
   * </td>
   * <td>
   * <p>
   * <strong>Default Value</strong>
   * </p>
   * </td>
   * </tr>
   * <tr>
   * <td>
   * <p align="left">
   * <strong>&quot;pattern&quot;</strong>
   * </p>
   * </td>
   * <td>
   * <p align="left">
   * Designates conversion pattern to be used. Spaces around property value are
   * significant (property value is not trimmed.).
   * </p>
   * <p>
   * <em>Since version 1.0</em>
   * </p>
   * </td>
   * <td>
   * <p align="center">
   * {@code "%C> %m %e (%t)"}
   * </p>
   * </td>
   * </tr>
   * </table>
   * <p>
   * For example following configuration file snippet
   * </p>
   * 
   * <pre>
   *  #marker &lt;EOL&gt; is just the end of line. It is shown to emphasize trailing spaces.
   *  formatter.pattern =  %.5C:%m %e (%7t) [%h] <em>&lt;EOL&gt;</em>
   * </pre>
   * 
   * <p>
   * sets pattern to {@code "  %.5C:%m %e (%7t) [%h] "} (spaces around property
   * value are significant).
   * </p>
   */
  public void configure(char[] lines, int offset, int length)
  {

    if (length < 0)
      throw new IllegalArgumentException("length: " + length + " < 0");
    if (offset < 0 || offset > lines.length)
      throw new ArrayIndexOutOfBoundsException("offset: "
          + Integer.toString(offset));
    if ((length += offset) > lines.length)
      length = lines.length;

    if (length > offset)
      for (int lineEnd = offset; lineEnd < length; offset = ++lineEnd)
      {
        for (; offset < length
            && (lines[offset] == ' ' || lines[offset] == '\t'); offset++);

        for (lineEnd = offset; lineEnd < length && lines[lineEnd] != '\n'; lineEnd++);

        int nameEnd = offset;
        boolean notValid = true;
        for (; nameEnd < lineEnd && (notValid = (lines[nameEnd] != '=')); nameEnd++);

        if (!notValid)
        {
          int vStart = (nameEnd--) + 1;
          for (; nameEnd >= offset
              && (lines[nameEnd] == ' ' || lines[nameEnd] == '\t'); nameEnd--);
          String name = String.valueOf(lines, offset, ++nameEnd - offset);

          try
          {
            if (name.equals("pattern"))
              setPattern(String.valueOf(lines, vStart, lineEnd - vStart));
            else System.err.println("ERROR: Unknown property " + name + " of "
                + PatternFormatter.class.getName() + ". Ignored.");
          } catch (Throwable e)
          {
            String message = e.getMessage();
            if (message != null && message.length() > 0)
              message = ": " + message;
            System.err.println("ERROR: Invalid value \""
                + String.valueOf(lines, vStart, lineEnd - vStart)
                + "\" of property " + name + " of "
                + PatternFormatter.class.getName() + message + ". Ignored.");
          }
        } else System.err.println("ERROR: Invalid properties line "
            + "\"formatter." + String.valueOf(lines, offset, lineEnd - offset)
            + "\" of " + PatternFormatter.class.getName() + ". Ignored.");
      }
  }

  /**
   * Class that represents conversion specifier.
   * 
   * @author Sergio Morozov
   * @version 1.0
   */
  class FormatterRecord
  {

    private static final char PAD_CHAR = ' ';

    private static final String UNKNOWN_VALUE = "???";

    private static final String EMPTY_VALUE = "";

    int type = RECORD_UNKNOWN;

    int min = 0;

    int max = 0;

    boolean left = true;

    /**
     * Converts property designated by this {@link FormatterRecord} of given
     * logging event to the string and appends it to the specified
     * {@link StringBuffer}.
     * 
     * @param event
     *          logging event property of which to convert.
     * @param sb
     *          {@link StringBuffer}, where to append formatted string.
     */
    protected void format(LogEvent event, StringBuffer sb)
    {
      String patternPart = "";
      if (event != null)
      {
        switch (this.type)
        {
        case RECORD_CATEGORY:
          patternPart = event.getCategory();
          if (patternPart == null)
            patternPart = UNKNOWN_VALUE;
          break;
        case RECORD_FINAL_CATEGORY:
          patternPart = event.getCategory();
          if (patternPart != null)
          {
            int i = patternPart.lastIndexOf('.');
            if (i >= 0)
              patternPart = patternPart.substring(++i);
          } else patternPart = UNKNOWN_VALUE;
          break;
        case RECORD_MESSAGE:
          patternPart = event.getMessage();
          if (patternPart == null)
            patternPart = EMPTY_VALUE;
          break;
        case RECORD_ERROR:
          Throwable error = event.getThrowable();
          patternPart = error != null ? error.toString() : EMPTY_VALUE;
          break;
        case RECORD_TIMESTAMP:
          patternPart = Long.toString(event.getTimestamp());
          break;
        case RECORD_THREADNAME:
          patternPart = event.getThreadName();
          break;
        }
        int l = patternPart.length();
        int padd = 0;
        if (this.max > 0 && l > this.max)
          patternPart = patternPart.substring(l - this.max, l);
        else if (this.min > 0)
          padd = this.min - l;
        if (!this.left)
          sb.append(patternPart);
        for (int i = padd; i > 0; i--)
          sb.append(PAD_CHAR);
        if (this.left)
          sb.append(patternPart);
      }
    }
  }
}