*/
-
package org.onap.appc.util;
import com.att.eelf.configuration.EELFLogger;
import com.att.eelf.configuration.EELFManager;
-
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
* This class contains several static helper methods that can be used to perform string manipulation algorithms.
- *
*/
public final class StringHelper {
+
private static final EELFLogger logger = EELFManager.getInstance().getLogger(StringHelper.class);
public static final String DASH = "-";
* meta-characters for this routine (such as period, asterisk, and plus), they will be escaped and matched literally
* in the resulting regular expression returned.
* </p>
- *
+ *
* @param value
* The pattern that we need to convert to a regular expression
* @return The regular expression that is equivalent to the pattern
if (value == null || value.trim().length() == 0) {
return ".*";
}
- boolean appendEOL = false;
- StringBuffer buffer = new StringBuffer(value.trim());
+
+ StringBuilder builder = new StringBuilder(value.trim());
/*
* If there are any period characters, we need to escape them so that they are exactly matched
*/
Pattern pattern = Pattern.compile("\\.");
- Matcher matcher = pattern.matcher(buffer);
+ Matcher matcher = pattern.matcher(builder);
int position = 0;
while (matcher.find(position)) {
- buffer.replace(matcher.start(), matcher.end(), "\\.");
+ builder.replace(matcher.start(), matcher.end(), "\\.");
position = matcher.end() + 1;
}
* them into .* or .
*/
pattern = Pattern.compile("\\*|\\+");
- matcher = pattern.matcher(buffer);
- position = 0;
+ matcher = pattern.matcher(builder);
+
+ /*
+ * If the string contains a .* meta-character sequence anywhere in the middle of the string (i.e., there are
+ * other characters following the .* meta-characters), OR the string ends with the .+ sequence, then we need to
+ * append the "end-of-line" boundary condition to the end of the string to get predictable results.
+ */
+ if (resolveAppendingEOL(builder, matcher)) {
+ builder.append("$");
+ }
+ return builder.toString();
+ }
+
+ private static boolean resolveAppendingEOL(StringBuilder builder, Matcher matcher) {
+ int position = 0;
+ boolean appendEOL = false;
+
while (matcher.find(position)) {
- String metachar = buffer.substring(matcher.start(), matcher.end());
- if (metachar.equals("*")) {
- buffer.replace(matcher.start(), matcher.end(), ".*");
+ String metachar = builder.substring(matcher.start(), matcher.end());
+ if ("*".equals(metachar)) {
+ builder.replace(matcher.start(), matcher.end(), ".*");
position = matcher.end() + 1;
- if (matcher.end() < buffer.length() - 1) {
+ if (matcher.end() < builder.length() - 1) {
appendEOL = true;
}
- } else if (metachar.equals("+")) {
- buffer.replace(matcher.start(), matcher.end(), ".");
+ } else if ("+".equals(metachar)) {
+ builder.replace(matcher.start(), matcher.end(), ".");
position = matcher.end();
- if (matcher.end() == buffer.length()) {
+ if (matcher.end() == builder.length()) {
appendEOL = true;
}
}
}
-
- /*
- * If the string contains a .* meta-character sequence anywhere in the middle of the string (i.e., there are
- * other characters following the .* meta-characters), OR the string ends with the .+ sequence, then we need to
- * append the "end-of-line" boundary condition to the end of the string to get predictable results.
- */
- if (appendEOL) {
- buffer.append("$");
- }
- return buffer.toString();
+ return appendEOL;
}
/**
* Takes a string that may possibly be very long and return a string that is at most maxLength. If the string is
* longer than maxLength, the last three characters will be the ellipses (...) to indicate that the string was
* shortened.
- *
+ *
* @param possiblyLongString
* @param maxLength
* must be at least 4 (one character plus ellipses)
/**
* Determines that a provided string is not null and not empty (length = 0 after trimming)
- *
+ *
* @param theString
* The string to be tested
* @return true if the string IS NOT null and is NOT empty
*/
public static boolean isNotNullNotEmpty(String theString) {
- return ((theString != null) && (!theString.trim().isEmpty()));
+ return theString != null && !theString.trim().isEmpty();
}
/**
* Determines that a provided string IS null or an empty string (length = 0 after trimming)
- *
+ *
* @param theString
* The string to be tested
* @return true if the string IS null OR is empty
*/
public static boolean isNullOrEmpty(String theString) {
- return ((theString == null) || (theString.trim().isEmpty()));
+ return theString == null || theString.trim().isEmpty();
}
/**
* Returns an indication if the first string is equal to the second string, allowing for either or both strings to
* be null.
- *
+ *
* @param a
* The first string to be compared
* @param b
* The second string to be compared
* @return True if both strings are null, or both strings are non-null AND they are equal. False otherwise.
*/
- public static boolean equals(String a, String b) {
- return equals(a, b, false);
+ public static boolean areEqual(String a, String b) {
+ return areEqual(a, b, false);
}
/**
* Returns an indication if the first string is equal to the second string, allowing for either or both strings to
* be null, and ignoring case.
- *
+ *
* @param a
* The first string to be compared
* @param b
* False otherwise.
*/
public static boolean equalsIgnoreCase(String a, String b) {
- return equals(a, b, true);
+ return areEqual(a, b, true);
}
/**
* Compares two strings (allowing either or both to be null), and allowing for optional case sensitive or
* insensitive comparison.
- *
+ *
* @param a
* The first string to be compared
* @param b
* True if the comparison is to be case in-sensitive.
* @return True if both strings are null, or both strings are non-null and they are equal
*/
- private static boolean equals(String a, String b, boolean caseInsensitive) {
+ private static boolean areEqual(String a, String b, boolean caseInsensitive) {
if (a == null && b == null) {
return true;
}
* for example, several objects were named "A test Object", "A test Object1", and "A test Object2", shortening the
* name only from the left does not generate a unique name.
* </p>
- *
+ *
* @param name
* The name to be mangled
* @param minLen
* @return The mangled name, or an empty string if the value is null or an empty string.
*/
public static String mangleName(String name, int minLen, int maxLen) {
- StringBuffer buffer = new StringBuffer(name == null ? "" : name);
+ StringBuilder builder = new StringBuilder(name == null ? "" : name);
Pattern pattern = Pattern.compile("[^a-z0-9]+", Pattern.CASE_INSENSITIVE);
- Matcher matcher = pattern.matcher(buffer);
+ Matcher matcher = pattern.matcher(builder);
int position = 0;
while (matcher.find(position)) {
- buffer.delete(matcher.start(), matcher.end());
+ builder.delete(matcher.start(), matcher.end());
position = matcher.start();
}
- if (buffer.length() < minLen) {
- for (int i = buffer.length(); i <= minLen; i++) {
- buffer.append("A");
+ if (builder.length() < minLen) {
+ for (int i = builder.length(); i <= minLen; i++) {
+ builder.append("A");
}
}
/*
* Remove out of the center of the name to preserve start and end and result in a string of max len
*/
- if (buffer.length() > maxLen) {
- int excess = buffer.length() - maxLen;
+ if (builder.length() > maxLen) {
+ int excess = builder.length() - maxLen;
int left = maxLen / 2;
- buffer.delete(left, excess + left);
+ builder.delete(left, excess + left);
}
- return buffer.toString().toLowerCase();
+ return builder.toString().toLowerCase();
}
/**
* This method will ensure that the string value is trimmed of all leading and trailing whitespace if not null. If
* it is null or an empty string, then it will return null.
* </p>
- *
+ *
* @param value
* The value to be normalized
* @return The normalized (no leading or trailing whitespace) value, or null if the string was null or an empty
/**
* This method is used to strip all carriage returns and line feed characters from a string
- *
+ *
* @param value
* @return The original value less all carriage returns and line feeds
*/
return null;
}
String[] tokens = value.split("\r\n|\n\r|\r|\n");
- StringBuffer buffer = new StringBuffer();
+ StringBuilder builder = new StringBuilder();
for (String token : tokens) {
- buffer.append(token.trim());
+ builder.append(token.trim());
}
- return buffer.toString();
+ return builder.toString();
}
/**
* Converts UNIX-style line endings to DOS-style. Replaces LF with CR+LF as long as the LF does not already exist
* paired with a CR.
- *
+ *
* @param content
* The content to be converted
* @return The converted content.
return null;
}
- StringBuffer buffer = new StringBuffer(content);
+ StringBuilder builder = new StringBuilder(content);
Pattern pattern = Pattern.compile("^(\n)[^\r]|[^\r](\n)[^\r]|[^\r](\n)$");
- Matcher matcher = pattern.matcher(buffer);
+ Matcher matcher = pattern.matcher(builder);
int position = 0;
while (matcher.find(position)) {
int index = matcher.start(1);
index = matcher.start(3);
}
- buffer.replace(index, index + 1, "\r\n");
+ builder.replace(index, index + 1, "\r\n");
position = index + 1;
}
- return buffer.toString();
+ return builder.toString();
}
/**
* This method will convert a string contents to use the UNIX-style line endings. That is, all occurrences of CR
* (Carriage Return) and LF (Line Feed) are reduced to just use LF.
- *
+ *
* @param content
* The buffer to be processed
* @return The converted contents
return null;
}
- StringBuffer buffer = new StringBuffer(content);
+ StringBuilder builder = new StringBuilder(content);
Pattern pattern = Pattern.compile("\r\n|\n\r");
- Matcher matcher = pattern.matcher(buffer);
+ Matcher matcher = pattern.matcher(builder);
int position = 0;
while (matcher.find(position)) {
- buffer.replace(matcher.start(), matcher.end(), "\n");
+ builder.replace(matcher.start(), matcher.end(), "\n");
position = matcher.start();
}
- return buffer.toString();
+ return builder.toString();
}
- /**
+ /**
* This method is used to translate characters in the input sequence that match the characters in the match list to
* the corresponding character in the replacement list. If the replacement list is shorter than the match list, then
* the character from the replacement list is taken as the modulo of the match character position and the length of
* the replacement list.
- *
+ *
* @param sequence
* The input sequence to be processed
* @param match
public static Object translate(String sequence, String match, String replacement) {
if (sequence == null) {
- return sequence;
+ return null;
}
- StringBuffer buffer = new StringBuffer(sequence);
+ StringBuilder builder = new StringBuilder(sequence);
- for (int index = 0; index < buffer.length(); index++) {
- char ch = buffer.charAt(index);
+ for (int index = 0; index < builder.length(); index++) {
+ char ch = builder.charAt(index);
int position = match.indexOf(ch);
if (position == -1) {
if (position >= replacement.length()) {
position %= replacement.length();
}
- buffer.setCharAt(index, replacement.charAt(position));
+ builder.setCharAt(index, replacement.charAt(position));
}
- return buffer.toString();
+ return builder.toString();
}
/**
* Ensures that the name provided is a valid identifier. This means that no spaces are allowed as well as special
* characters. This method translates all spaces and illegal characters to underscores (_).
- *
+ *
* @param name
* The name to be checked and converted to an identifier if needed
* @return The valid identifier from the name
if (name == null || name.length() == 0) {
return name;
}
-
- StringBuffer buffer = new StringBuffer(name);
- for (int index = 0; index < buffer.length(); index++) {
- char ch = buffer.charAt(index);
+ StringBuilder builder = new StringBuilder(name);
+ for (int index = 0; index < builder.length(); index++) {
+ char ch = builder.charAt(index);
if ((index == 0 && !Character.isJavaIdentifierStart(ch)) || (!Character.isJavaIdentifierPart(ch))) {
- buffer.setCharAt(index, '_');
+ builder.setCharAt(index, '_');
}
}
- return buffer.toString();
+ return builder.toString();
+ }
+
+
+ /**
+ * Private constructor to prevent instantiation of this class - All methods are static!
+ */
+ private StringHelper() {
+
}
/**
* This method verifies that the provided string only contains characters from the legal set, and replaces any
* character not in the legal set with the specified replacement character.
- *
+ *
* @param sequence
* The sequence to be verified
* @param legal
*/
public static String verify(String sequence, String legal, char replacement) {
if (sequence == null) {
- return sequence;
+ return null;
}
- StringBuffer buffer = new StringBuffer(sequence);
- for (int index = 0; index < buffer.length(); index++) {
- char ch = buffer.charAt(index);
+ StringBuilder builder = new StringBuilder(sequence);
+ for (int index = 0; index < builder.length(); index++) {
+ char ch = builder.charAt(index);
if (legal.indexOf(ch) == -1) {
- buffer.setCharAt(index, replacement);
+ builder.setCharAt(index, replacement);
}
}
- return buffer.toString();
- }
-
- /**
- * Private constructor to prevent instantiation of this class - All methods are static!
- */
- private StringHelper() {
-
+ return builder.toString();
}
/**
* @return The list of elements formatted as a comma-delimited list
*/
public static String asList(List<String> list) {
- StringBuffer buffer = new StringBuffer();
+ StringBuilder builder = new StringBuilder();
+
if (list != null) {
if (list.size() == 1) {
- buffer.append(list.get(0));
+ builder.append(list.get(0));
} else {
for (String element : list) {
- buffer.append(element);
- buffer.append(", ");
+ builder.append(element);
+ builder.append(", ");
}
- if (buffer.length() > 2) {
- buffer.delete(buffer.length() - 2, buffer.length());
+ if (builder.length() > 2) {
+ builder.delete(builder.length() - 2, builder.length());
}
}
}
- return buffer.toString();
+ return builder.toString();
}
/**
* @return A map expressed as a comma-delimited list of name=value tuples
*/
public static String asList(Map<String, String> map) {
- StringBuffer buffer = new StringBuffer();
+ StringBuilder builder = new StringBuilder();
if (map != null) {
Set<String> keys = map.keySet();
for (String key : keys) {
- buffer.append(String.format("%s=%s, ", key, map.get(key)));
+ builder.append(String.format("%s=%s, ", key, map.get(key)));
}
- if (buffer.length() > 2) {
- buffer.delete(buffer.length() - 2, buffer.length());
+ if (builder.length() > 2) {
+ builder.delete(builder.length() - 2, builder.length());
}
}
- return buffer.toString();
+ return builder.toString();
}
/**
return Double.parseDouble(input);
} catch (NumberFormatException | NullPointerException e) {
// NPE won't happen bc of regex check
- logger.error(e.getMessage());
+ logger.error("Parsing input failed", e);
}
}
Code Review / appc.git / commitdiff