MessageParamParser

/*
 * Copyright 2007-2011 smartics, Kronseder & Reiner GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package de.smartics.exceptions.i18n.message;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import de.smartics.exceptions.i18n.app.ParseExceptionCode;

/**
 * This class provides methods to parse message parameter.
 *
 * @author <a href="mailto:robert.reiner@smartics.de">Robert Reiner</a>
 * @version $Revision:591 $
 */
public final class MessageParamParser
{
  // ********************************* Fields *********************************

  // --- constants ------------------------------------------------------------

  // --- members --------------------------------------------------------------

  // ****************************** Initializer *******************************

  // ****************************** Constructors ******************************

  /**
   * Utility class.
   */
  private MessageParamParser()
  {
  }

  // ****************************** Inner Classes *****************************

  /**
   * Contains the index information for one message parameter.
   */
  public static final class MessageParamInfo
  {
    // ******************************** Fields ********************************

    // --- constants ----------------------------------------------------------

    // --- members ------------------------------------------------------------

    /**
     * The index of the placeholder the information should be written to.
     */
    private final int index;

    /**
     * The OGNL path to the value inside the value to use.
     */
    private final String ognlPath;

    // ***************************** Initializer ******************************

    // ***************************** Constructors *****************************

    /**
     * Default constructor.
     *
     * @param index the index of the placeholder the information should be
     *          written to.
     * @param ognlPath the OGNL path to the value inside the value to use.
     */
    public MessageParamInfo(final int index, final String ognlPath)
    {
      this.index = index;
      this.ognlPath = ognlPath;
    }

    // ***************************** Inner Classes ****************************

    // ******************************** Methods *******************************

    // --- init ---------------------------------------------------------------

    // --- get&set ------------------------------------------------------------

    /**
     * Returns the index of the placeholder the information should be written
     * to.
     *
     * @return the index of the placeholder the information should be written
     *         to.
     */
    public int getIndex()
    {
      return index;
    }

    /**
     * Returns the OGNL path to the value inside the value to use.
     *
     * @return the OGNL path to the value inside the value to use.
     */
    public String getOgnlPath()
    {
      return ognlPath;
    }

    // --- business -----------------------------------------------------------

    // --- object basics ------------------------------------------------------
  }

  // ********************************* Methods ********************************

  // --- init -----------------------------------------------------------------

  // --- get&set --------------------------------------------------------------

  // --- business -------------------------------------------------------------

  /**
   * Splits the input string into message param informations.
   * <p>
   * The expected format is a comma separated list of
   * <code>index:ognlPath</code> strings. The OGNL path may be missing, in this
   * case the index alone.
   * <p>
   * Example: <code>0:user.name,4,3:user.id</code>.
   * <p>
   * Spaces between tokens are removed.
   * <p>
   * If the input string is <code>null</code> or empty, the empty list is
   * returned.
   *
   * @param input the input string to parse.
   * @return the list of message parameter infos.
   * @throws ParseException if the input is violating the expected syntax.
   */
  public static List<MessageParamInfo> parse(final String input)
    throws ParseException
  {
    if (input == null || "".equals(input.trim()))
    {
      return Collections.<MessageParamInfo> emptyList();
    }
    final List<String> tokens = Helper.split(input);
    final List<MessageParamInfo> infos = new ArrayList<MessageParamInfo>(tokens // NOPMD
        .size());
    for (String token : tokens)
    {
      final byte index;
      final String ognlPath;

      final int i = token.indexOf(':');
      if (i >= 0)
      {
        index = Byte.parseByte(token.substring(0, i).trim()); // NOPMD
        ognlPath = token.substring(i + 1).trim();
        if ("".equals(ognlPath))
        {
          throw new ParseException(ParseExceptionCode.OGNL, token, i + 1);
        }
      }
      else
      {
        index = Byte.parseByte(token);
        ognlPath = null;
      }

      final MessageParamInfo info = new MessageParamInfo(index, ognlPath); // NOPMD
      infos.add(info);
    }

    return infos;
  }

  /**
   * Parses the content of the parent message parameter. The input must follow
   * the following syntax:
   * <p>
   * <code>property=index:ognl-path</code> as in <code>cause=1:message</code>
   * <p>
   * If several properties of a referenced entity are to be displayed at
   * different indices, separate them by commas and the information for
   * different attributes separate by colons (<code>;</code>).
   * <p>
   * <code>cause=1:cause.message,3:message,4:localizedMessage; message=5</code>
   *
   * @param input the input string to parse.
   * @return the parsed information. The key of the map is the name of the
   *         attribute, the value is the index information for that attribute.
   * @throws ParseException if the input is violating the expected syntax.
   */
  public static Map<String, List<MessageParamInfo>> parseParentMessageParam(
      final String input) throws ParseException
  {
    if (input == null || "".equals(input.trim()))
    {
      return Collections.emptyMap();
    }

    final Map<String, List<MessageParamInfo>> map =
        new HashMap<String, List<MessageParamInfo>>(// NOPMD
            3);
    final List<String> tokens = Helper.split(input, ";");
    int currentParsingPosition = 0; // NOPMD
    for (String token : tokens)
    {
      parseToken(input, map, token, currentParsingPosition);
      currentParsingPosition = currentParsingPosition + token.length();
    }

    return map;
  }

  /**
   * Parses the given token and throws an exception if it cannot be parsed.
   *
   * @param input the input string is only used as exception information in case
   *          an exception is thrown.
   * @param map if the token is successfully parsed, the information is set to
   *          this map.
   * @param token the token to be analyzed. There should be a key and a value
   *          separated by the equal character ("<code>=</code>").
   * @param currentParsingPosition the current parsing position in the input
   *          string. This information is only passed to the exception in case
   *          one is thrown.
   * @throws ParseException if the token cannot be parsed.
   */
  private static void parseToken(final String input,
      final Map<String, List<MessageParamInfo>> map, final String token,
      final int currentParsingPosition) throws ParseException
  {
    final int index = token.indexOf('=');
    if (index != -1)
    {
      final String attributeName = token.substring(0, index).trim();
      if ("".equals(attributeName))
      {
        throw new ParseException(
            ParseExceptionCode.MISSING_PARENT_PROPERTY_ATTRIBUTE, input,
            currentParsingPosition + index);
      }
      final String subInput = token.substring(index + 1);
      if ("".equals(subInput))
      {
        throw new ParseException(
            ParseExceptionCode.MISSING_PARENT_PROPERTY_INDEX, input,
            currentParsingPosition + index + 1);
      }
      final List<MessageParamInfo> info = parse(subInput);
      map.put(attributeName, info);
    }
    else
    {
      throw new ParseException(
          ParseExceptionCode.MISSING_PARENT_PROPERTY_SEPARATOR, input,
          currentParsingPosition);
    }
  }

  // --- object basics --------------------------------------------------------

}