package com.ora.jsp.util;
import java.text.*;
import java.util.*;
/**
* This class contains a number of static methods that can be used to
* validate the format of Strings, typically received as input from
* a user, and to format values as Strings that can be used in
* HTML output without causing interpretation problems.
*
* @author Hans Bergsten, Gefion software <hans@gefionsoftware.com>
* @version 1.0
*/
public class StringFormat {
// Static format objects
private static SimpleDateFormat dateFormat = new SimpleDateFormat();
private static DecimalFormat numberFormat = new DecimalFormat();
/**
* Returns true if the specified date string represents a valid
* date in the specified format.
*
* @param dateString a String representing a date/time.
* @param dateFormatPattern a String specifying the format to be used
* when parsing the dateString. The pattern is expressed with the
* pattern letters defined for the java.text.SimpleDateFormat class.
* @return true if valid, false otherwise
*/
public static boolean isValidDate(String dateString, String dateFormatPattern) {
Date validDate = null;
synchronized (dateFormat) {
try {
dateFormat.applyPattern(dateFormatPattern);
dateFormat.setLenient(false);
validDate = dateFormat.parse(dateString);
}
catch (ParseException e) {
// Ignore and return null
}
}
return validDate != null;
}
/**
* Returns true if the specified number string represents a valid
* integer in the specified range.
*
* @param numberString a String representing an integer
* @param min the minimal value in the valid range
* @param min the maximal value in the valid range
* @return true if valid, false otherwise
*/
public static boolean isValidInteger(String numberString, int min, int max) {
Integer validInteger = null;
try {
Number aNumber = numberFormat.parse(numberString);
int anInt = aNumber.intValue();
if (anInt >= min && anInt <= max) {
validInteger = new Integer(anInt);
}
}
catch (ParseException e) {
// Ignore and return null
}
return validInteger != null;
}
/**
* Returns true if the email string contains an at sign ("@") and
* at least one dot ("."), i.e. "hans@gefionsoftware.com" is accepted
* but "hans@gefionsoftware" is not. Note! This rule is not always
* correct (e.g. on an intranet it may be okay with just a name) and
* does not gurantee a valid Internet email address but it takes
* care of the most obvious Internet mail address format errors.
*
* @param emailAddrString a String representing an email address
* @return true if valid, false otherwise
*/
public static boolean isValidEmailAddr(String emailAddrString) {
boolean isValid = false;
if (emailAddrString != null &&
emailAddrString.indexOf("@") != -1 &&
emailAddrString.indexOf(".") != -1) {
isValid = true;
}
return isValid;
}
/**
* Returns true if the specified string matches a string in the set
* of provided valid strings, ignoring case if specified.
*
* @param value the String validate
* @param validStrings an array of valid Strings
* @param ignoreCase if true, case is ignored when comparing the value
* to the set of validStrings
* @return true if valid, false otherwise
*/
public static boolean isValidString(String value, String[] validStrings,
boolean ignoreCase) {
boolean isValid = false;
for (int i = 0; validStrings != null && i < validStrings.length; i++) {
if (ignoreCase) {
if (validStrings[i].equalsIgnoreCase(value)) {
isValid = true;
break;
}
}
else {
if (validStrings[i].equals(value)) {
isValid = true;
break;
}
}
}
return isValid;
}
/**
* Returns the specified string converted to a format suitable for
* HTML. All signle-quote, double-quote, greater-than, less-than and
* ampersand characters are replaces with their corresponding HTML
* Character Entity code.
*
* @param in the String to convert
* @return the converted String
*/
public static String toHTMLString(String in) {
StringBuffer out = new StringBuffer();
for (int i = 0; in != null && i < in.length(); i++) {
char c = in.charAt(i);
if (c == '\'') {
out.append("'");
}
else if (c == '\"') {
out.append(""");
}
else if (c == '<') {
out.append("<");
}
else if (c == '>') {
out.append(">");
}
else if (c == '&') {
out.append("&");
}
else {
out.append(c);
}
}
return out.toString();
}
/**
* Converts a String to a Date, using the specified pattern.
* (see java.text.SimpleDateFormat for pattern description)
*
* @param dateString the String to convert
* @param dateFormatPattern the pattern
* @return the corresponding Date
* @exception ParseException, if the String doesn't match the pattern
*/
public static Date toDate(String dateString, String dateFormatPattern)
throws ParseException {
Date date = null;
if (dateFormatPattern == null) {
dateFormatPattern = "yyyy-MM-dd";
}
synchronized (dateFormat) {
dateFormat.applyPattern(dateFormatPattern);
dateFormat.setLenient(false);
date = dateFormat.parse(dateString);
}
return date;
}
/**
* Converts a String to a Number, using the specified pattern.
* (see java.text.NumberFormat for pattern description)
*
* @param numString the String to convert
* @param numFormatPattern the pattern
* @return the corresponding Number
* @exception ParseException, if the String doesn't match the pattern
*/
public static Number toNumber(String numString, String numFormatPattern)
throws ParseException {
Number number = null;
if (numFormatPattern == null) {
numFormatPattern = "######.##";
}
synchronized (numberFormat) {
numberFormat.applyPattern(numFormatPattern);
number = numberFormat.parse(numString);
}
return number;
}
/**
* Replaces one string with another throughout a source string.
*
* @param in the source String
* @param from the sub String to replace
* @param to the sub String to replace with
* @return a new String with all occurences of from replaced by to
*/
public static String replaceInString(String in, String from, String to) {
if (in == null || from == null || to == null) {
return in;
}
StringBuffer newValue = new StringBuffer();
char[] inChars = in.toCharArray();
int inLen = inChars.length;
char[] fromChars = from.toCharArray();
int fromLen = fromChars.length;
for (int i = 0; i < inLen; i++) {
if (inChars[i] == fromChars[0] && (i + fromLen) <= inLen) {
boolean isEqual = true;
for (int j = 1; j < fromLen; j++) {
if (inChars[i + j] != fromChars[j]) {
isEqual = false;
break;
}
}
if (isEqual) {
newValue.append(to);
i += fromLen - 1;
}
else {
newValue.append(inChars[i]);
}
}
else {
newValue.append(inChars[i]);
}
}
return newValue.toString();
}
}
|