/*

 * reserved comment block

 * DO NOT REMOVE OR ALTER!

 */

/*

 * Copyright 1999-2004 The Apache Software Foundation.

 *

 * 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.

 */

/*

 * $Id: ExsltStrings.java,v 1.1.2.1 2005/08/01 02:08:48 jeffsuttor Exp $

 */

package com.sun.org.apache.xalan.internal.lib;

import java.util.StringTokenizer;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.FactoryConfigurationError;

import javax.xml.parsers.ParserConfigurationException;

import com.sun.org.apache.xpath.internal.NodeSet;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.w3c.dom.Text;

/**

 * This class contains EXSLT strings extension functions.

 *

 * It is accessed by specifying a namespace URI as follows:

 * <pre>

 *    xmlns:str="http://exslt.org/strings"

 * </pre>

 * The documentation for each function has been copied from the relevant

 * EXSLT Implementer page.

 *

 * @see <a href="http://www.exslt.org/">EXSLT</a>

 * @xsl.usage general

 */

public class ExsltStrings extends ExsltBase

{

  /**

   * The str:align function aligns a string within another string.

   * <p>

   * The first argument gives the target string to be aligned. The second argument gives

   * the padding string within which it is to be aligned.

   * <p>

   * If the target string is shorter than the padding string then a range of characters

   * in the padding string are repaced with those in the target string. Which characters

   * are replaced depends on the value of the third argument, which gives the type of

   * alignment. It can be one of 'left', 'right' or 'center'. If no third argument is

   * given or if it is not one of these values, then it defaults to left alignment.

   * <p>

   * With left alignment, the range of characters replaced by the target string begins

   * with the first character in the padding string. With right alignment, the range of

   * characters replaced by the target string ends with the last character in the padding

   * string. With center alignment, the range of characters replaced by the target string

   * is in the middle of the padding string, such that either the number of unreplaced

   * characters on either side of the range is the same or there is one less on the left

   * than there is on the right.

   * <p>

   * If the target string is longer than the padding string, then it is truncated to be

   * the same length as the padding string and returned.

   *

   * @param targetStr The target string

   * @param paddingStr The padding string

   * @param type The type of alignment

   *

   * @return The string after alignment

   */

  public static String align(String targetStr, String paddingStr, String type)

  {

    if (targetStr.length() >= paddingStr.length())

      return targetStr.substring(0, paddingStr.length());

    if (type.equals("right"))

    {

      return paddingStr.substring(0, paddingStr.length() - targetStr.length()) + targetStr;

    }

    else if (type.equals("center"))

    {

      int startIndex = (paddingStr.length() - targetStr.length()) / 2;

      return paddingStr.substring(0, startIndex) + targetStr + paddingStr.substring(startIndex + targetStr.length());

    }

    // Default is left

    else

    {

      return targetStr + paddingStr.substring(targetStr.length());

    }

  }

  /**

   * See above

   */

  public static String align(String targetStr, String paddingStr)

  {

    return align(targetStr, paddingStr, "left");

  }

  /**

   * The str:concat function takes a node set and returns the concatenation of the

   * string values of the nodes in that node set. If the node set is empty, it returns

   * an empty string.

   *

   * @param nl A node set

   * @return The concatenation of the string values of the nodes in that node set

   */

  public static String concat(NodeList nl)

  {

    StringBuffer sb = new StringBuffer();

    for (int i = 0; i < nl.getLength(); i++)

    {

      Node node = nl.item(i);

      String value = toString(node);

      if (value != null && value.length() > 0)

        sb.append(value);

    }

    return sb.toString();

  }

  /**

   * The str:padding function creates a padding string of a certain length.

   * The first argument gives the length of the padding string to be created.

   * The second argument gives a string to be used to create the padding. This

   * string is repeated as many times as is necessary to create a string of the

   * length specified by the first argument; if the string is more than a character

   * long, it may have to be truncated to produce the required length. If no second

   * argument is specified, it defaults to a space (' '). If the second argument is

   * an empty string, str:padding returns an empty string.

   *

   * @param length The length of the padding string to be created

   * @param pattern The string to be used as pattern

   *

   * @return A padding string of the given length

   */

  public static String padding(double length, String pattern)

  {

    if (pattern == null || pattern.length() == 0)

      return "";

    StringBuffer sb = new StringBuffer();

    int len = (int)length;

    int numAdded = 0;

    int index = 0;

    while (numAdded < len)

    {

      if (index == pattern.length())

        index = 0;

      sb.append(pattern.charAt(index));

      index++;

      numAdded++;

    }

    return sb.toString();

  }

  /**

   * See above

   */

  public static String padding(double length)

  {

    return padding(length, " ");

  }

  /**

   * The str:split function splits up a string and returns a node set of token

   * elements, each containing one token from the string.

   * <p>

   * The first argument is the string to be split. The second argument is a pattern

   * string. The string given by the first argument is split at any occurrence of

   * this pattern. For example:

   * <pre>

   * str:split('a, simple, list', ', ') gives the node set consisting of:

   *

   * <token>a</token>

   * <token>simple</token>

   * <token>list</token>

   * </pre>

   * If the second argument is omitted, the default is the string ' ' (i.e. a space).

   *

   * @param str The string to be split

   * @param pattern The pattern

   *

   * @return A node set of split tokens

   */

  public static NodeList split(String str, String pattern)

  {

    NodeSet resultSet = new NodeSet();

    resultSet.setShouldCacheNodes(true);

    boolean done = false;

    int fromIndex = 0;

    int matchIndex = 0;

    String token = null;

    while (!done && fromIndex < str.length())

    {

      matchIndex = str.indexOf(pattern, fromIndex);

      if (matchIndex >= 0)

      {

        token = str.substring(fromIndex, matchIndex);

        fromIndex = matchIndex + pattern.length();

      }

      else

      {

        done = true;

        token = str.substring(fromIndex);

      }

      Document doc = DocumentHolder.m_doc;

      synchronized (doc)

      {

        Element element = doc.createElement("token");

        Text text = doc.createTextNode(token);

        element.appendChild(text);

        resultSet.addNode(element);

      }

    }

    return resultSet;

  }

  /**

   * See above

   */

  public static NodeList split(String str)

  {

    return split(str, " ");

  }

  /**

   * The str:tokenize function splits up a string and returns a node set of token

   * elements, each containing one token from the string.

   * <p>

   * The first argument is the string to be tokenized. The second argument is a

   * string consisting of a number of characters. Each character in this string is

   * taken as a delimiting character. The string given by the first argument is split

   * at any occurrence of any of these characters. For example:

   * <pre>

   * str:tokenize('2001-06-03T11:40:23', '-T:') gives the node set consisting of:

   *

   * <token>2001</token>

   * <token>06</token>

   * <token>03</token>

   * <token>11</token>

   * <token>40</token>

   * <token>23</token>

   * </pre>

   * If the second argument is omitted, the default is the string '	

 '

   * (i.e. whitespace characters).

   * <p>

   * If the second argument is an empty string, the function returns a set of token

   * elements, each of which holds a single character.

   * <p>

   * Note: This one is different from the tokenize extension function in the Xalan

   * namespace. The one in Xalan returns a set of Text nodes, while this one wraps

   * the Text nodes inside the token Element nodes.

   *

   * @param toTokenize The string to be tokenized

   * @param delims The delimiter string

   *

   * @return A node set of split token elements

   */

  public static NodeList tokenize(String toTokenize, String delims)

  {

    NodeSet resultSet = new NodeSet();

    if (delims != null && delims.length() > 0)

    {

      StringTokenizer lTokenizer = new StringTokenizer(toTokenize, delims);

      Document doc = DocumentHolder.m_doc;

      synchronized (doc)

      {

        while (lTokenizer.hasMoreTokens())

        {

          Element element = doc.createElement("token");

          element.appendChild(doc.createTextNode(lTokenizer.nextToken()));

          resultSet.addNode(element);

        }

      }

    }

    // If the delimiter is an empty string, create one token Element for

    // every single character.

    else

    {

      Document doc = DocumentHolder.m_doc;

      synchronized (doc)

      {

        for (int i = 0; i < toTokenize.length(); i++)

        {

          Element element = doc.createElement("token");

          element.appendChild(doc.createTextNode(toTokenize.substring(i, i+1)));

          resultSet.addNode(element);

        }

      }

    }

    return resultSet;

  }

  /**

   * See above

   */

  public static NodeList tokenize(String toTokenize)

  {

    return tokenize(toTokenize, " \t\n\r");

  }

    /**

     * This class is not loaded until first referenced (see Java Language

     * Specification by Gosling/Joy/Steele, section 12.4.1)

     *

     * The static members are created when this class is first referenced, as a

     * lazy initialization not needing checking against null or any

     * synchronization.

     *

     */

    private static class DocumentHolder

    {

        // Reuse the Document object to reduce memory usage.

        private static final Document m_doc;

        static {

            try

            {

                m_doc =DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();

            }

            catch(ParserConfigurationException pce)

            {

                  throw new com.sun.org.apache.xml.internal.utils.WrappedRuntimeException(pce);

            }

        }

    }

}