Data Type Java

/**
 * The utillib library.
 * More information is available at http://www.jinchess.com/.
 * Copyright (C) 2002-2003 Alexander Maryanovsky.
 * All rights reserved.
 *
 * The utillib library is free software; you can redistribute
 * it and/or modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * The utillib library is distributed in the hope that it will
 * be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser
 * General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with utillib library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
import java.util.StringTokenizer;
/**
 * A utility class which provides many useful text manipulation methods.
 */
public class TextUtilities{
  
  /**
   * Pads the beginning of the given String with the given character until it's
   * length characters long. If the given String's size is already
   * length or larger, the given string is returned as is.
   */
  public static String padStart(String s, char c, int length){
    if (s.length()>=length)
      return s;
    StringBuffer buf = new StringBuffer(s);
    for (int i=s.length();i      buf.insert(0,c);
    return buf.toString();
  }
  /**
   * Pads the end of the given String with the given character until it's
   * length characters long. If the given String's size is already
   * length or larger, the given string is returned as is.
   */
  public static String padEnd(String s, char c, int length){
    if (s.length()>=length)
      return s;
    StringBuffer buf = new StringBuffer(s);
    for (int i=s.length();i      buf.append(c);
    return buf.toString();
  }
  /**
   * Pads the given String on both sides equally (if possible) with the given 
   * character until it's length characters long. If the given 
   * String's size is already length or larger, the given 
   * string is returned as is.
   */
  public static String padSides(String s, char c, int length){
    if (s.length()>=length)
      return s;
    StringBuffer buf = new StringBuffer(s);
    for (int i=s.length();i      buf.insert(0,c);
      buf.append(c);
    }
    if (buf.length()      buf.insert(0,c);
    return buf.toString();
  }
  
  
  
  /**
   * Trims the specified string on the right only.
   */
   
   public static String trimRight(String s){
     StringBuffer buf = new StringBuffer(s);
     int length = buf.length();
     while (Character.isWhitespace(buf.charAt(length - 1)))
       buf.setLength(--length);
     
     return buf.toString();
   }
  /**
   * Trims the specified string on the left only.
   */
   
   public static String trimLeft(String s){
     int i = 0;
     while (Character.isWhitespace(s.charAt(i)))
       i++;
     
     return s.substring(i);
   }
  /**
   * 

Returns a substring of the given StringBuffer's string which consists of
   * the characters from the beginning of it until the first occurrence of the
   * given delimiter string or if the delimiter doesn't occur, until the end
   * of the string. The StringBuffer is modified so it no longer contains those
   * characters or the delimiter.
   * 

Examples:
   * 


       *   
  • nextToken(new StringBuffer("abcdefgh"), "de") returns "abc" and
       *       the StringBuffer is modified to represent the string "fgh".
       *   
  • nextToken(new StringBuffer("abcdefgh"), "a") returns an empty string
       *       and the StringBuffer is modified to represent the string "bcdefgh".
       *   
  • nextToken(new StringBuffer("abcdefgh"), "k") returns "abcdefgh" and
       *       the StringBuffer is modified to represent an empty string.
       * 

   */
  public static String nextToken(StringBuffer buf, String delimiter){
    String bufStr = buf.toString();
    int delimIndex = bufStr.indexOf(delimiter);
    if (delimIndex==-1){
      buf.setLength(0);
      return bufStr;
    }
      
    String str = bufStr.substring(0,delimIndex);
    buf.reverse();
    buf.setLength(buf.length()-delimIndex-delimiter.length());
    buf.reverse();
    return str;
  }
  /**
   * Returns an array of the tokens produced by the specified string with the
   * specified delimiter characters.
   */
  public static String [] getTokens(String text, String delimiters){
    StringTokenizer tokenizer = new StringTokenizer(text, delimiters);
    String [] tokens = new String[tokenizer.countTokens()];
    for (int i = 0; i < tokens.length; i++)
      tokens[i] = tokenizer.nextToken();
    return tokens;
  }
  /**
   * Parses the specified list of integers delimited by the specified
   * delimiters.
   */
  public static int [] parseIntList(String text, String delimiters){
    StringTokenizer tokenizer = new StringTokenizer(text, delimiters);
    int [] tokens = new int[tokenizer.countTokens()];
    for (int i = 0; i < tokens.length; i++)
      tokens[i] = Integer.parseInt(tokenizer.nextToken());
    return tokens;
  }
  
  
  
  /**
   * Translates the specified resource name into the context of the specified
   * class. Basically, this method returns the name of the resource you need to
   * use when loading via a classloader, if via the specified class you would
   * load it simply with Class.getResource(resourceName).
   */
   
  public static String translateResource(Class c, String resourceName){
    String path = c.getName();
    int dotIndex = path.lastIndexOf('.');
    if (dotIndex != -1){
      path = path.substring(0, dotIndex);
      path = path.replace('.', '/') + '/' + resourceName;
    }
    else
      return resourceName;
    
    return path;
  }
  
  
  
  /**
   * Breaks the specified text into lines no longer than the specified length,
   * without breaking words. The breaking is done by inserting newlines at
   * appropriate locations. Note that if there are words longer than
   * maxLength, they will not be broken.
   */
  
  public static String breakIntoLines(String text, int maxLength){
    StringBuffer buf = new StringBuffer(text);
    text = text + " "; // Fake an extra space at the end to simplify the algorithm 
    
    int lastNewline = -1; // The index of the last newline
    int lastSpace = -1; // The index of the last space
    int curSpace; // The index of the current space
    
    while ((curSpace = text.indexOf(' ', lastSpace + 1)) != -1){
      if ((curSpace - lastNewline - 1 > maxLength) && (lastSpace > lastNewline)){
        // lastSpace == lastNewline means the current word is longer than maxLength
        buf.setCharAt(lastSpace, '\n');
        lastNewline = lastSpace;
      }
    
      lastSpace = curSpace;
    }
  
    return buf.toString();
  }
}