/*
    * Copyright (c) 1998, 2005 Gargoyle Software Inc. All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    *
    * 1. Redistributions of source code must retain the above copyright notice,
    *    this list of conditions and the following disclaimer.
    * 2. Redistributions in binary form must reproduce the above copyright notice,
   *    this list of conditions and the following disclaimer in the documentation
   *    and/or other materials provided with the distribution.
   * 3. The end-user documentation included with the redistribution, if any, must
   *    include the following acknowledgment:
   *
   *       "This product includes software developed by Gargoyle Software Inc.
   *        (http://www.GargoyleSoftware.com/)."
   *
   *    Alternately, this acknowledgment may appear in the software itself, if
   *    and wherever such third-party acknowledgments normally appear.
   * 4. The name "Gargoyle Software" must not be used to endorse or promote
   *    products derived from this software without prior written permission.
   *    For written permission, please contact info@GargoyleSoftware.com.
   * 5. Products derived from this software may not be called "GSBase", nor may
   *    "GSBase" appear in their name, without prior written permission of
   *    Gargoyle Software Inc.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
   * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GARGOYLE
   * SOFTWARE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
   * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
   * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
   * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  package com.gargoylesoftware.base.util;
  
  import java.lang.reflect.Array;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Collection;
  
  /***
   *  A collection of utility methods dealing with strings
   *
   * @version  $Revision: 1.4 $
   * @author  <a href="mailto:mbowler@GargoyleSoftware.com">Mike Bowler</a>
   */
  public class StringUtil {
      // Private constructor to prevent instantiation
      private StringUtil() {
      }
  
  
      /***
       *  Expand each tab character into the specified numbers of spaces.
       *
       * @param  inputString The string to be expanded.
       * @param  numberOfSpaces The number of space characters to be used for each
       *      substitution.
       * @return  The new string with expanded tabs.
       */
      public static String expandTabs( final String inputString,
              final int numberOfSpaces ) {
          // Are there any tabs?
          if( inputString.indexOf( '\t' ) == -1 ) {
              return inputString;
          }
  
          final int inputStringLength = inputString.length();
          final StringBuffer buffer = new StringBuffer( inputStringLength );
  
          final String spaces = nCopies( numberOfSpaces, ' ' );
  
          char c;
          int i;
          for( i = 0; i < inputStringLength; i++ ) {
              c = inputString.charAt( i );
              if( c == '\t' ) {
                  buffer.append( spaces );
              }
              else {
                  buffer.append( c );
              }
          }
          return buffer.toString();
      }
  
  
      /***
       *  Return a string containing the specified number of charToCopy
       *
       * @param  copyCount The number of times to copy the character.
       * @param  charToCopy The character that will be copied.
       * @return  The new string.
       */
      public static String nCopies( final int copyCount,
             final char charToCopy ) {
         final StringBuffer buffer = new StringBuffer( copyCount );
         int i;
         for( i = 0; i < copyCount; i++ ) {
             buffer.append( charToCopy );
         }
         return buffer.toString();
     }
 
 
     /***
      *  Create a string based on all the objects in the array separated by the
      *  separator string.
      *
      * @param  array The items that will be concatenated together
      * @param  separator The separator string.
      * @return  The new concatenated string.
      */
     private static String joinArray( final Object array, final String separator ) {
         assertNotNull("array", array);
         assertNotNull("separator", separator);
 
         final int arrayLength = Array.getLength( array );
 
         if( arrayLength == 0 ) {
             return "";
         }
 
         final StringBuffer buffer = new StringBuffer();
         int i;
 
         buffer.append( Array.get( array, 0 ) );
         for( i = 1; i < arrayLength; i++ ) {
             buffer.append( separator );
             buffer.append( Array.get( array, i ) );
         }
 
         return buffer.toString();
     }
 
 
     /***
      *  Create a string based on all the objects in the array separated by the
      *  separator string.
      *
      * @param  array The items that will be concatenated together
      * @param  separator The separator string.
      * @return  The new concatenated string.
      */
     public static String join( final int array[], final String separator ) {
         return joinArray( array, separator );
     }
 
 
     /***
      *  Create a string based on all the objects in the array separated by the
      *  separator string.
      *
      * @param  array The items that will be concatenated together
      * @param  separator The separator string.
      * @return  The new concatenated string.
      */
     public static String join( final long array[], final String separator ) {
         return joinArray( array, separator );
     }
 
 
     /***
      *  Create a string based on all the objects in the array separated by the
      *  separator string.
      *
      * @param  array The items that will be concatenated together
      * @param  separator The separator string.
      * @return  The new concatenated string.
      */
     public static String join( final float array[], final String separator ) {
         return joinArray( array, separator );
     }
 
 
     /***
      *  Create a string based on all the objects in the array separated by the
      *  separator string.
      *
      * @param  array The items that will be concatenated together
      * @param  separator The separator string.
      * @return  The new concatenated string.
      */
     public static String join( final double array[], final String separator ) {
         return joinArray( array, separator );
     }
 
 
     /***
      *  Create a string based on all the objects in the array separated by the
      *  separator string.
      *
      * @param  array The items that will be concatenated together
      * @param  separator The separator string.
      * @return  The new concatenated string.
      */
 
     public static String join( final byte array[], final String separator ) {
 
         return joinArray( array, separator );
     }
 
 
 
     /***
      *  Create a string based on all the objects in the array separated by the
      *  separator string.
      *
      * @param  array The items that will be concatenated together
      * @param  separator The separator string.
      * @return  The new concatenated string.
      */
     public static String join( final Object array[], final String separator ) {
         return joinArray( array, separator );
     }
 
 
     /***
      *  Create a string based on all the objects in the collection separated by
      *  the separator string.
      *
      * @param  separator The separator string.
      * @param  collection The collection containing the objects to join
      * @return  The new concatenated string.
      */
     public static String join( final Collection collection, final String separator ) {
         return joinArray( collection.toArray(), separator );
     }
 
 
     /***
      *  Split the specified line into two strings, spliting at the first
      *  instance of separator.
      *
      * @param  line The line to be split.
      * @param  separator The separator that will be used to split the string.
      * @return  An array containing the two strings.
      */
 
     public static String[] splitAtFirst( final String line, final String separator ) {
 
         final int index = line.indexOf( separator );
         String first;
         String second;
 
         if( index == -1 ) {
             first = line;
             second = "";
         }
         else {
             first = line.substring( 0, index );
             second = line.substring( index + separator.length() );
         }
 
         return new String[]{first, second};
     }
 
 
     /***
      *  Split the specified line into strings, spliting at each instance of
      *  separator.
      *
      * @param  line The line to be split.
      * @param  separator The separator that will be used to split the string.
      * @return  An array containing the strings
      */
 
     public static String[] split( final String line, final String separator ) {
         assertNotNull("line", line);
         assertNotNull("separator", separator);
 
         if( separator.length() == 0 ) {
             throw new DetailedIllegalArgumentException( "separator", separator, "May not be empty" );
         }
 
         // Special case when the line is empty
 
         if( line.length() == 0 ) {
             return new String[0];
         }
 
         final int separatorLength = separator.length();
         final List list = new ArrayList();
         int previousIndex = 0;
         int index = line.indexOf( separator );
 
         while( index != -1 ) {
             list.add( line.substring( previousIndex, index ) );
             previousIndex = index + separatorLength;
             index = line.indexOf( separator, previousIndex );
         }
 
         list.add( line.substring( previousIndex ) );
 
         final String[] stringArray = new String[list.size()];
         list.toArray( stringArray );
 
         return stringArray;
     }
 
 
     /***
      *  Perform text substitutions in the source string
      *
      * @param  sourceString The original string
      * @param  match The string to replace
      * @param  replace The new content to replace with
      * @return  A new string with all the substitutions done
      */
     public static String replace(
             final String sourceString,
             final String match,
             final String replace ) {
 
         if( match.length() == 0 ) {
             return sourceString;
         }
 
         final StringBuffer buffer = new StringBuffer( sourceString.length() );
 
         int start = 0;
         int end = sourceString.indexOf( match );
         final int matchLength = match.length();
 
         while( end != -1 ) {
             buffer.append( sourceString.substring( start, end ) );
             buffer.append( replace );
             start = end + matchLength;
             end = sourceString.indexOf( match, start );
         }
 
         buffer.append( sourceString.substring( start ) );
 
         return buffer.toString();
     }
 
 
     private static void assertNotNull( final String fieldName, final Object object ) {
         if( object == null ) {
             throw new DetailedNullPointerException(fieldName);
         }
     }
 }