Split SDK from server code and add build/packaging infrastructure.

matthew_swift

03.04.2009 39db72786ec179e67e3c1c0c71a2e93672999ea5

 sdk/build-tools/org/opends/build/tools/MessagePropertyKey.java

@@ -27,239 +27,190 @@

package org.opends.build.tools;

import org.opends.messages.Category;
import org.opends.messages.Severity;

import java.util.EnumSet;

/**
 * OpenDS messages defined in properties files must be defined
 * with the ordinal and in most cases category and severity encoded
 * in the message key.  This class helps with generating and
 * parsing of these keys.
 *
 * Keys must be of the form
 *
 *   CATEGORY_SEVERITY_DESCRIPTION_ORDINAL
 *
 * OpenDS messages defined in properties files must be defined with the
 * ordinal and in most cases category and severity encoded in the
 * message key. This class helps with generating and parsing of these
 * keys. Keys must be of the form CATEGORY_SEVERITY_DESCRIPTION_ORDINAL
 * where:
 * <ul>
 * <li>
 * CATEGORY is the string representation of one of the
 * <code>Category</code> enums.
 * </li>
 * <li>
 * SEVERITY is the long or abbreviated form of one of
 * the <code>Severity</code> enums.
 * </li>
 * <li>
 * DESCRIPTION is an uppercase string containing characters
 * and the underscore character for describing the purpose
 * of the message.
 * </li>
 * <li>
 * ORDINAL is an integer that makes the message unique witin
 * the property file.
 * </li>
 * <li>CATEGORY is the string representation of one of the
 * <code>Category</code> enums.</li>
 * <li>SEVERITY is the long or abbreviated form of one of the
 * <code>Severity</code> enums.</li>
 * <li>DESCRIPTION is an uppercase string containing characters and the
 * underscore character for describing the purpose of the message.</li>
 * <li>ORDINAL is an integer that makes the message unique witin the
 * property file.</li>
 * </ul>
 *
 */
// TODO: move this class to GenerateMessageFile when DirectoryServer
// no longer needs to support dumpMessages()
public class MessagePropertyKey
        implements Comparable<MessagePropertyKey> {

  private Category category;

  private Severity severity;
public class MessagePropertyKey implements
    Comparable<MessagePropertyKey>
{

  private String description;

  private Integer ordinal;



  /**
   * Creates a message property key from a string value.
   * @param keyString from properties file
   * @param includesCategory when true expects ordinals to be encoded
   *        in the keystring; when false the mandate is relaxed
   * @param includesSeverity when true expects ordinals to be encoded
   *        in the keystring; when false the mandate is relaxed
   * @param includesOrdinal when true expects ordinals to be encoded
   *        in the keystring; when false the mandate is relaxed
   *
   * @param keyString
   *          from properties file
   * @param includesOrdinal
   *          when true expects ordinals to be encoded in the keystring;
   *          when false the mandate is relaxed
   * @return MessagePropertyKey created from string
   */
  static public MessagePropertyKey parseString(
          String keyString,
          boolean includesCategory,
          boolean includesSeverity,
          boolean includesOrdinal) {
  static public MessagePropertyKey parseString(String keyString,
      boolean includesOrdinal)
  {

    Category category = null;
    Severity severity = null;
    String description;
    Integer ordinal = null;

    String k = keyString;
    for (Category c : EnumSet.allOf(Category.class)) {
      String cName = c.name();
      if (k.startsWith(cName)) {
        category = c;
        if ('_' != k.charAt(cName.length())) {
          throw new IllegalArgumentException(
                  "Error processing " + keyString + ".  Category must be " +
                          "separated from the rest of the " +
                          "key with an '_' character");
        }
        k = k.substring(cName.length() + 1);
        break;
      }
    }
    if (category == null && includesCategory) {
      throw new IllegalArgumentException("Category not included in key " +
              keyString);
    }

    for (Severity s : EnumSet.allOf(Severity.class)) {
      String sName = s.propertyKeyFormName();
      if (k.startsWith(sName)) {
        severity = s;
        if ('_' != k.charAt(sName.length())) {
          throw new IllegalArgumentException(
                  "Error processing " + keyString + ".  Severity must be " +
                          "separated from the rest of the " +
                          "key with an '_' character");
        }
        k = k.substring(sName.length() + 1);
        break;
      }
    }
    if (severity == null && includesSeverity) {
      throw new IllegalArgumentException("Severity not included in key " +
              keyString);
    }

    if (includesOrdinal) {
    if (includesOrdinal)
    {
      int li = k.lastIndexOf("_");
      if (li != -1) {
      if (li != -1)
      {
        description = k.substring(0, li).toUpperCase();
      } else {
        throw new IllegalArgumentException(
                "Incorrectly formatted key " + keyString);
      }
      else
      {
        throw new IllegalArgumentException("Incorrectly formatted key "
            + keyString);
      }

      try {
      try
      {
        String ordString = k.substring(li + 1);
        ordinal = Integer.parseInt(ordString);
      } catch (Exception nfe) {
        throw new IllegalArgumentException("Error parsing ordinal for key " +
                keyString);
      }
    } else {
      catch (Exception nfe)
      {
        throw new IllegalArgumentException(
            "Error parsing ordinal for key " + keyString);
      }
    }
    else
    {
      description = k;
    }
    return new MessagePropertyKey(category, severity, description, ordinal);
    return new MessagePropertyKey(description, ordinal);
  }



  /**
   * Creates a parameterized instance.
   * @param category of this key
   * @param severity of this key
   * @param description of this key
   * @param ordinal of this key
   *
   * @param description
   *          of this key
   * @param ordinal
   *          of this key
   */
  public MessagePropertyKey(Category category, Severity severity,
                           String description, Integer ordinal) {
    this.category = category;
    this.severity = severity;
  public MessagePropertyKey(String description, Integer ordinal)
  {
    this.description = description;
    this.ordinal = ordinal;
  }

  /**
   * Gets the category of this key.
   * @return Category of this key
   */
  public Category getCategory() {
    return this.category;
  }

  /**
   * Gets the severity of this key.
   * @return Severity of this key
   */
  public Severity getSeverity() {
    return this.severity;
  }

  /**
   * Gets the description of this key.
   *
   * @return description of this key
   */
  public String getDescription() {
  public String getDescription()
  {
    return this.description;
  }



  /**
   * Gets the ordinal of this key.
   *
   * @return ordinal of this key
   */
  public Integer getOrdinal() {
  public Integer getOrdinal()
  {
    return this.ordinal;
  }



  /**
   * Gets the name of the MessageDescriptor as it should appear
   * in the messages file.
   * Gets the name of the MessageDescriptor as it should appear in the
   * messages file.
   *
   * @return name of message descriptor
   */
  public String getMessageDescriptorName() {
    return new StringBuilder()
            .append(this.severity.messageDesciptorName())
            .append("_")
            .append(this.description).toString();
  public String getMessageDescriptorName()
  {
    String name = this.description;

    name = name.replaceFirst("^MILD_WARN", "WARN");
    name = name.replaceFirst("^SEVERE_WARN", "WARN");
    name = name.replaceFirst("^MILD_ERR", "ERR");
    name = name.replaceFirst("^SEVERE_ERR", "ERR");
    name = name.replaceFirst("^FATAL_ERR", "ERR");

    return name;
  }



  /**
   * {@inheritDoc}
   */
  public String toString() {
    return getPropertyKeyName(true, true, true);
  public String toString()
  {
    return getPropertyKeyName(true);
  }



  /**
   * Gets the name of the key as it would appear in a properties file.
   * @param includeCategory in the name
   * @param includeSeverity in the name
   * @param includeOrdinal in the name
   *
   * @param includeOrdinal
   *          in the name
   * @return string representing the property key
   */
  public String getPropertyKeyName(boolean includeCategory,
                                   boolean includeSeverity,
                                   boolean includeOrdinal) {
  public String getPropertyKeyName(boolean includeOrdinal)
  {
    StringBuilder sb = new StringBuilder();
    if (category != null && includeCategory) {
      sb.append(category.name());
      sb.append("_");
    }
    if (severity != null && includeSeverity) {
      sb.append(severity.propertyKeyFormName());
      sb.append("_");
    }
    sb.append(description);
    if (ordinal != null && includeOrdinal) {
    if (ordinal != null && includeOrdinal)
    {
      sb.append("_");
      sb.append(ordinal);
    }
    return sb.toString();
  }



  /**
   * {@inheritDoc}
   */
  public int compareTo(MessagePropertyKey k) {
    if (ordinal == k.ordinal) {
  public int compareTo(MessagePropertyKey k)
  {
    if (ordinal == k.ordinal)
    {
      return description.compareTo(k.description);
    } else {
    }
    else
    {
      return ordinal.compareTo(k.ordinal);
    }
  }