net.sf.jasperreports.engine.util.JRStringUtil Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jasperreports Show documentation
Show all versions of jasperreports Show documentation
Free Java Reporting Library
/*
* JasperReports - Free Java Reporting Library.
* Copyright (C) 2001 - 2019 TIBCO Software Inc. All rights reserved.
* http://www.jaspersoft.com
*
* Unless you have purchased a commercial license agreement from Jaspersoft,
* the following license terms apply:
*
* This program is part of JasperReports.
*
* JasperReports 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 3 of the License, or
* (at your option) any later version.
*
* JasperReports 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 JasperReports. If not, see
");
isEncodeSpace = false;
break;
default :
isEncodeSpace = false;
break;
}
}
if (last < length)
{
ret.append(text.substring(last));
}
return ret.toString();
}
/**
* Takes a name and returns the same if it is a Java identifier;
* else it substitutes the illegal characters so that it can be an identifier
*
* @param name
*/
public static String getJavaIdentifier(String name)
{
if (isValidJavaIdentifier(name))
{
return name;
}
StringBuilder sb = new StringBuilder(name.length() + 5);
char[] literalChars = new char[name.length()];
name.getChars(0, literalChars.length, literalChars, 0);
for (int i = 0; i < literalChars.length; i++)
{
if (i == 0 && !Character.isJavaIdentifierStart(literalChars[i]))
{
sb.append(JAVA_IDENTIFIER_PREFIX);
sb.append((int)literalChars[i]);
}
else if (i != 0 && !Character.isJavaIdentifierPart(literalChars[i]))
{
sb.append((int)literalChars[i]);
}
else
{
sb.append(literalChars[i]);
}
}
return sb.toString();
}
/**
* Checks if the input is a valid Java identifier
* @param literal
* @author Gaganis Giorgos ([email protected])
*/
private static boolean isValidJavaIdentifier(String literal)
{
boolean result = true;
char[] literalChars = new char[literal.length()];
literal.getChars(0, literalChars.length, literalChars, 0);
for (int i = 0; i < literalChars.length; i++)
{
if (i == 0 && !Character.isJavaIdentifierStart(literalChars[i]))
{
result = false;
break;
}
if (i != 0 && !Character.isJavaIdentifierPart(literalChars[i]))
{
result = false;
break;
}
}
return result;
}
/**
* Escapes a text so that it can be used as a Java String literal.
*
* @param text the text
* @return the text with escaped quotes and backslashes
*/
public static String escapeJavaStringLiteral(String text)
{
if (text == null)
{
return text;
}
StringBuilder sb = new StringBuilder();
StringTokenizer tkzer = new StringTokenizer(text, "\\\"\n\r\t", true);
while(tkzer.hasMoreTokens())
{
String token = tkzer.nextToken();
//TODO optimize ifs?
if ("\\".equals(token))
{
sb.append("\\\\");
}
else if ("\"".equals(token))
{
sb.append("\\\"");
}
else if ("\n".equals(token))
{
sb.append("\\n");
}
else if ("\r".equals(token))
{
sb.append("\\r");
}
else if ("\t".equals(token))
{
sb.append("\\t");
}
else
{
sb.append(token);
}
}
return sb.toString();
}
/**
* Escapes a text so that it can be used as a Java String literal.
*
* @param input
*/
public static String escapeJavaScript(String input) {
if (input == null) {
return input;
}
StringBuilder filtered = new StringBuilder(input.length());
char prevChar = '\u0000';
char c;
for (int i = 0; i < input.length(); i++) {
c = input.charAt(i);
if (c == '"') {
filtered.append("\\\"");
}
else if (c == '\'') {
filtered.append("\\'");
}
else if (c == '\\') {
filtered.append("\\\\");
}
else if (c == '/') {
filtered.append("\\/");
}
else if (c == '\t') {
filtered.append("\\t");
}
else if (c == '\n') {
if (prevChar != '\r') {
filtered.append("\\n");
}
}
else if (c == '\r') {
filtered.append("\\n");
}
else if (c == '\f') {
filtered.append("\\f");
}
else {
filtered.append(c);
}
prevChar = c;
}
return filtered.toString();
}
/**
* Escapes a Java String so that it can be used as a JavaScript String literal.
*
* @param input
*/
public static String escapeString4JavaScript(String input) {
if (input == null) {
return input;
}
StringBuilder filtered = new StringBuilder(input.length());
char prevChar = '\u0000';
char c;
for (int i = 0; i < input.length(); i++) {
c = input.charAt(i);
if (c == '"') {
filtered.append("\\\"");
}
else if (c == '\\') {
filtered.append("\\\\");
}
else if (c == '/') {
filtered.append("\\/");
}
else if (c == '\t') {
filtered.append("\\t");
}
else if (c == '\n') {
if (prevChar != '\r') {
filtered.append("\\n");
}
}
else if (c == '\r') {
filtered.append("\\n");
}
else if (c == '\f') {
filtered.append("\\f");
}
else {
filtered.append(c);
}
prevChar = c;
}
return filtered.toString();
}
/**
*
*/
public static List getTabIndexes(String text)
{
List tabIndexes = null;
if (text != null)
{
int index = text.indexOf('\t');
// returning null if no tabs
if (index >= 0)
{
tabIndexes = new ArrayList();
do
{
tabIndexes.add(index);
index = text.indexOf('\t', index + 1);
}
while (index >= 0);
}
}
return tabIndexes;
}
/**
*
*/
public static List split(String[] srcArray, String delimiterRegExp)
{
List tokens = null;
if (srcArray != null)
{
tokens = new ArrayList();
for(int i = 0; i < srcArray.length; i++)
{
if (srcArray[i] == null)
{
tokens.add(null);
}
else
{
String[] currentTokensArray = srcArray[i].split(delimiterRegExp);
for(int j = 0; j < currentTokensArray.length; j++)
{
tokens.add(currentTokensArray[j].trim());
}
}
}
}
return tokens;
}
/**
*
*/
public static String getString(Object value)
{
return value == null ? null : value.toString();
}
/**
* Escapes a text to be used for a JSON string value.
*
* @param text the text to escape for JSON
* @return the escaped text if not null
*/
public static String escapeJSONString(String text)
{
if (text == null)
{
return null;
}
// using Jackson's string quote method
char[] escapedChars = JsonStringEncoder.getInstance().quoteAsString(text);
if (text.contentEquals(CharBuffer.wrap(escapedChars)))
{
// nothing changed
return text;
}
return String.valueOf(escapedChars);
}
public static String getCSSClass(String name)
{
if (name == null || name.isEmpty())
{
return name;
}
Matcher matcher = PATTERN_CSS_INVALID_CHARACTER.matcher(name);
StringBuffer sb = null;
while (matcher.find()) {
if (sb == null) {
sb = new StringBuffer(name.length() + 4);
}
String text = matcher.group();
String replacement = cssClassReplacement(text);
matcher.appendReplacement(sb, replacement);
}
String cssClass;
if (sb == null)
{
cssClass = name;
}
else
{
matcher.appendTail(sb);
cssClass = sb.toString();
}
if (!Character.isLetter(cssClass.charAt(0)))
{
cssClass = 'c' + cssClass;
}
return cssClass;
}
protected static String cssClassReplacement(String text)
{
try
{
byte[] bytes = text.getBytes("UTF-8");
char[] chars = new char[bytes.length * 2 + 1];
chars[0] = '-';
for (int i = 0; i < bytes.length; i++)
{
int code = bytes[i] & 0xff;
chars[2 * i + 1] = HEX_DIGITS[code >>> 4];
chars[2 * i + 2] = HEX_DIGITS[code & 0xf];
}
return new String(chars);
}
catch (UnsupportedEncodingException e)
{
throw new JRRuntimeException(e);
}
}
public static String getLetterNumeral(int number, boolean isUpperCase)
{
String romanNumeral = "";
int tmpNumber = number;
while (tmpNumber > 0)
{
int modulo = (tmpNumber - 1) % 26;
romanNumeral = (char)(modulo + 'A') + romanNumeral;
tmpNumber = (tmpNumber - modulo) / 26;
}
return isUpperCase ? romanNumeral : romanNumeral.toLowerCase();
}
/**
* @param number an integer value between 1 and 3999
* @param isUpperCase specifies whether the result should be made of upper case characters
* @return the Roman numeral representation of this number
*/
public static String getRomanNumeral(int number, boolean isUpperCase)
{
if(number < 1 || number > 3999)
{
throw
new JRRuntimeException(
EXCEPTION_MESSAGE_KEY_NUMBER_OUTSIDE_BOUNDS,
new Object[]{number});
}
String strNumber = ("0000"+String.valueOf(number)).substring(String.valueOf(number).length());
String result = THOUSAND_DIGITS[strNumber.charAt(0) - '0']
+ HUNDRED_DIGITS[strNumber.charAt(1) - '0']
+ TEN_DIGITS[strNumber.charAt(2) - '0']
+ UNIT_DIGITS[strNumber.charAt(3) - '0'];
return isUpperCase ? result : result.toLowerCase();
}
private JRStringUtil()
{
}
}