org.apache.velocity.util.StringUtils Maven / Gradle / Ivy
package org.apache.velocity.util;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
/**
* This class provides some methods for dynamically
* invoking methods in objects, and some string
* manipulation methods used by torque. The string
* methods will soon be moved into the turbine
* string utilities class.
*
* @author Jason van Zyl
* @author Daniel Rall
* @version $Id: StringUtils.java 685685 2008-08-13 21:43:27Z nbubna $
*/
public class StringUtils
{
/**
* Line separator for the OS we are operating on.
*/
private static final String EOL = System.getProperty("line.separator");
/**
* Concatenates a list of objects as a String.
*
* @param list The list of objects to concatenate.
* @return A text representation of the concatenated objects.
*/
public String concat(List list)
{
StringBuffer sb = new StringBuffer();
int size = list.size();
for (int i = 0; i < size; i++)
{
sb.append(list.get(i).toString());
}
return sb.toString();
}
/**
* Return a package name as a relative path name
*
* @param pckge package name to convert to a directory.
* @return String directory path.
*/
static public String getPackageAsPath(String pckge)
{
return pckge.replace( '.', File.separator.charAt(0) ) + File.separator;
}
/**
*
* Remove underscores from a string and replaces first
* letters with capitals. Other letters are changed to lower case.
*
*
*
* For example foo_bar becomes FooBar
* but foo_barBar becomes FooBarbar.
*
*
* @param data string to remove underscores from.
* @return String
* @deprecated Use the org.apache.commons.util.StringUtils class
* instead. Using its firstLetterCaps() method in conjunction
* with a StringTokenizer will achieve the same result.
*/
static public String removeUnderScores (String data)
{
String temp = null;
StringBuffer out = new StringBuffer();
temp = data;
StringTokenizer st = new StringTokenizer(temp, "_");
while (st.hasMoreTokens())
{
String element = (String) st.nextElement();
out.append ( firstLetterCaps(element));
}
return out.toString();
}
/**
*
* 'Camels Hump' replacement of underscores.
*
*
*
* Remove underscores from a string but leave the capitalization of the
* other letters unchanged.
*
*
*
* For example foo_barBar becomes FooBarBar.
*
*
* @param data string to hump
* @return String
*/
static public String removeAndHump (String data)
{
return removeAndHump(data,"_");
}
/**
*
* 'Camels Hump' replacement.
*
*
*
* Remove one string from another string but leave the capitalization of the
* other letters unchanged.
*
*
*
* For example, removing "_" from foo_barBar becomes FooBarBar.
*
*
* @param data string to hump
* @param replaceThis string to be replaced
* @return String
*/
static public String removeAndHump (String data,String replaceThis)
{
String temp = null;
StringBuffer out = new StringBuffer();
temp = data;
StringTokenizer st = new StringTokenizer(temp, replaceThis);
while (st.hasMoreTokens())
{
String element = (String) st.nextElement();
out.append ( capitalizeFirstLetter(element));
}//while
return out.toString();
}
/**
*
* Makes the first letter caps and the rest lowercase.
*
*
*
* For example fooBar becomes Foobar.
*
*
* @param data capitalize this
* @return String
*/
static public String firstLetterCaps ( String data )
{
String firstLetter = data.substring(0,1).toUpperCase();
String restLetters = data.substring(1).toLowerCase();
return firstLetter + restLetters;
}
/**
*
* Capitalize the first letter but leave the rest as they are.
*
*
*
* For example fooBar becomes FooBar.
*
*
* @param data capitalize this
* @return String
*/
static public String capitalizeFirstLetter ( String data )
{
String firstLetter = data.substring(0,1).toUpperCase();
String restLetters = data.substring(1);
return firstLetter + restLetters;
}
/**
* Create a string array from a string separated by delim
*
* @param line the line to split
* @param delim the delimter to split by
* @return a string array of the split fields
*/
public static String [] split(String line, String delim)
{
List list = new ArrayList();
StringTokenizer t = new StringTokenizer(line, delim);
while (t.hasMoreTokens())
{
list.add(t.nextToken());
}
return (String []) list.toArray(new String[list.size()]);
}
/**
* Chop i characters off the end of a string.
* This method assumes that any EOL characters in String s
* and the platform EOL will be the same.
* A 2 character EOL will count as 1 character.
*
* @param s String to chop.
* @param i Number of characters to chop.
* @return String with processed answer.
*/
public static String chop(String s, int i)
{
return chop(s, i, EOL);
}
/**
* Chop i characters off the end of a string.
* A 2 character EOL will count as 1 character.
*
* @param s String to chop.
* @param i Number of characters to chop.
* @param eol A String representing the EOL (end of line).
* @return String with processed answer.
*/
public static String chop(String s, int i, String eol)
{
if ( i == 0 || s == null || eol == null )
{
return s;
}
int length = s.length();
/*
* if it is a 2 char EOL and the string ends with
* it, nip it off. The EOL in this case is treated like 1 character
*/
if ( eol.length() == 2 && s.endsWith(eol ))
{
length -= 2;
i -= 1;
}
if ( i > 0)
{
length -= i;
}
if ( length < 0)
{
length = 0;
}
return s.substring( 0, length);
}
/**
* @param argStr
* @param vars
* @return Substituted String.
*/
public static StringBuffer stringSubstitution( String argStr,
Hashtable vars )
{
return stringSubstitution( argStr, (Map) vars );
}
/**
* Perform a series of substitutions. The substitions
* are performed by replacing $variable in the target
* string with the value of provided by the key "variable"
* in the provided hashtable.
*
* @param argStr target string
* @param vars name/value pairs used for substitution
* @return String target string with replacements.
*/
public static StringBuffer stringSubstitution(String argStr,
Map vars)
{
StringBuffer argBuf = new StringBuffer();
for (int cIdx = 0 ; cIdx < argStr.length();)
{
char ch = argStr.charAt(cIdx);
switch (ch)
{
case '$':
StringBuffer nameBuf = new StringBuffer();
for (++cIdx ; cIdx < argStr.length(); ++cIdx)
{
ch = argStr.charAt(cIdx);
if (ch == '_' || Character.isLetterOrDigit(ch))
nameBuf.append(ch);
else
break;
}
if (nameBuf.length() > 0)
{
String value =
(String) vars.get(nameBuf.toString());
if (value != null)
{
argBuf.append(value);
}
}
break;
default:
argBuf.append(ch);
++cIdx;
break;
}
}
return argBuf;
}
/**
* Read the contents of a file and place them in
* a string object.
*
* @param file path to file.
* @return String contents of the file.
*/
public static String fileContentsToString(String file)
{
String contents = "";
File f = null;
try
{
f = new File(file);
if (f.exists())
{
FileReader fr = null;
try
{
fr = new FileReader(f);
char[] template = new char[(int) f.length()];
fr.read(template);
contents = new String(template);
}
catch (Exception e)
{
e.printStackTrace();
}
finally
{
if (fr != null)
{
fr.close();
}
}
}
}
catch (Exception e)
{
e.printStackTrace();
}
return contents;
}
/**
* Remove/collapse multiple newline characters.
*
* @param argStr string to collapse newlines in.
* @return String
*/
public static String collapseNewlines(String argStr)
{
char last = argStr.charAt(0);
StringBuffer argBuf = new StringBuffer();
for (int cIdx = 0 ; cIdx < argStr.length(); cIdx++)
{
char ch = argStr.charAt(cIdx);
if (ch != '\n' || last != '\n')
{
argBuf.append(ch);
last = ch;
}
}
return argBuf.toString();
}
/**
* Remove/collapse multiple spaces.
*
* @param argStr string to remove multiple spaces from.
* @return String
*/
public static String collapseSpaces(String argStr)
{
char last = argStr.charAt(0);
StringBuffer argBuf = new StringBuffer();
for (int cIdx = 0 ; cIdx < argStr.length(); cIdx++)
{
char ch = argStr.charAt(cIdx);
if (ch != ' ' || last != ' ')
{
argBuf.append(ch);
last = ch;
}
}
return argBuf.toString();
}
/**
* Replaces all instances of oldString with newString in line.
* Taken from the Jive forum package.
*
* @param line original string.
* @param oldString string in line to replace.
* @param newString replace oldString with this.
* @return String string with replacements.
*/
public static final String sub(String line, String oldString,
String newString)
{
int i = 0;
if ((i = line.indexOf(oldString, i)) >= 0)
{
char [] line2 = line.toCharArray();
char [] newString2 = newString.toCharArray();
int oLength = oldString.length();
StringBuffer buf = new StringBuffer(line2.length);
buf.append(line2, 0, i).append(newString2);
i += oLength;
int j = i;
while ((i = line.indexOf(oldString, i)) > 0)
{
buf.append(line2, j, i - j).append(newString2);
i += oLength;
j = i;
}
buf.append(line2, j, line2.length - j);
return buf.toString();
}
return line;
}
/**
* Returns the output of printStackTrace as a String.
*
* @param e A Throwable.
* @return A String.
*/
public static final String stackTrace(Throwable e)
{
String foo = null;
try
{
// And show the Error Screen.
ByteArrayOutputStream ostr = new ByteArrayOutputStream();
e.printStackTrace( new PrintWriter(ostr,true) );
foo = ostr.toString();
}
catch (Exception f)
{
// Do nothing.
}
return foo;
}
/**
* Return a context-relative path, beginning with a "/", that represents
* the canonical version of the specified path after ".." and "." elements
* are resolved out. If the specified path attempts to go outside the
* boundaries of the current context (i.e. too many ".." path elements
* are present), return null instead.
*
* @param path Path to be normalized
* @return String normalized path
*/
public static final String normalizePath(String path)
{
// Normalize the slashes and add leading slash if necessary
String normalized = path;
if (normalized.indexOf('\\') >= 0)
{
normalized = normalized.replace('\\', '/');
}
if (!normalized.startsWith("/"))
{
normalized = "/" + normalized;
}
// Resolve occurrences of "//" in the normalized path
while (true)
{
int index = normalized.indexOf("//");
if (index < 0)
break;
normalized = normalized.substring(0, index) +
normalized.substring(index + 1);
}
// Resolve occurrences of "%20" in the normalized path
while (true)
{
int index = normalized.indexOf("%20");
if (index < 0)
break;
normalized = normalized.substring(0, index) + " " +
normalized.substring(index + 3);
}
// Resolve occurrences of "/./" in the normalized path
while (true)
{
int index = normalized.indexOf("/./");
if (index < 0)
break;
normalized = normalized.substring(0, index) +
normalized.substring(index + 2);
}
// Resolve occurrences of "/../" in the normalized path
while (true)
{
int index = normalized.indexOf("/../");
if (index < 0)
break;
if (index == 0)
return (null); // Trying to go outside our context
int index2 = normalized.lastIndexOf('/', index - 1);
normalized = normalized.substring(0, index2) +
normalized.substring(index + 3);
}
// Return the normalized path that we have completed
return (normalized);
}
/**
* If state is true then return the trueString, else
* return the falseString.
*
* @param state
* @param trueString
* @param falseString
* @return Selected result.
*/
public String select(boolean state, String trueString, String falseString)
{
if (state)
{
return trueString;
}
else
{
return falseString;
}
}
/**
* Check to see if all the string objects passed
* in are empty.
*
* @param list A list of {@link java.lang.String} objects.
* @return Whether all strings are empty.
*/
public boolean allEmpty(List list)
{
int size = list.size();
for (int i = 0; i < size; i++)
{
if (list.get(i) != null && list.get(i).toString().length() > 0)
{
return false;
}
}
return true;
}
/**
* Trim all strings in a List. Changes the strings in the existing list.
* @param list
* @return List of trimmed strings.
* @since 1.5
*/
public static List trimStrings(List list)
{
if (list == null)
return null;
int sz = list.size();
for (int i = 0; i < sz; i++)
list.set(i,nullTrim((String) list.get(i)));
return list;
}
/**
* Trim the string, but pass a null through.
* @param s
* @return List of trimmed Strings.
* @since 1.5
*/
public static String nullTrim(String s)
{
if (s == null)
{
return null;
}
else
{
return s.trim();
}
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy