/*
* Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
* Copyright (C) $$Year-Rel$$ The Jalview Authors
*
* This file is part of Jalview.
*
* Jalview is free software: you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation, either version 3
* of the License, or (at your option) any later version.
*
* Jalview 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Jalview. If not, see .
* The Jalview Authors are detailed in the 'AUTHORS' file.
*/
package jalview.util;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
public class StringUtils
{
private static final Pattern DELIMITERS_PATTERN = Pattern
.compile(".*='[^']*(?!')");
private static final boolean DEBUG = false;
/**
* Returns a new character array, after inserting characters into the given
* character array.
*
* @param in
* the character array to insert into
* @param position
* the 0-based position for insertion
* @param count
* the number of characters to insert
* @param ch
* the character to insert
*/
public static final char[] insertCharAt(char[] in, int position,
int count, char ch)
{
char[] tmp = new char[in.length + count];
if (position >= in.length)
{
System.arraycopy(in, 0, tmp, 0, in.length);
position = in.length;
}
else
{
System.arraycopy(in, 0, tmp, 0, position);
}
int index = position;
while (count > 0)
{
tmp[index++] = ch;
count--;
}
if (position < in.length)
{
System.arraycopy(in, position, tmp, index, in.length - position);
}
return tmp;
}
/**
* Delete
*
* @param in
* @param from
* @param to
* @return
*/
public static final char[] deleteChars(char[] in, int from, int to)
{
if (from >= in.length || from < 0)
{
return in;
}
char[] tmp;
if (to >= in.length)
{
tmp = new char[from];
System.arraycopy(in, 0, tmp, 0, from);
to = in.length;
}
else
{
tmp = new char[in.length - to + from];
System.arraycopy(in, 0, tmp, 0, from);
System.arraycopy(in, to, tmp, from, in.length - to);
}
return tmp;
}
/**
* Returns the last part of 'input' after the last occurrence of 'token'. For
* example to extract only the filename from a full path or URL.
*
* @param input
* @param token
* a delimiter which must be in regular expression format
* @return
*/
public static String getLastToken(String input, String token)
{
if (input == null)
{
return null;
}
if (token == null)
{
return input;
}
String[] st = input.split(token);
return st[st.length - 1];
}
/**
* Parses the input string into components separated by the delimiter. Unlike
* String.split(), this method will ignore occurrences of the delimiter which
* are nested within single quotes in name-value pair values, e.g. a='b,c'.
*
* @param input
* @param delimiter
* @return elements separated by separator
*/
public static String[] separatorListToArray(String input, String delimiter)
{
int seplen = delimiter.length();
if (input == null || input.equals("") || input.equals(delimiter))
{
return null;
}
List jv = new ArrayList();
int cp = 0, pos, escape;
boolean wasescaped = false, wasquoted = false;
String lstitem = null;
while ((pos = input.indexOf(delimiter, cp)) >= cp)
{
escape = (pos > 0 && input.charAt(pos - 1) == '\\') ? -1 : 0;
if (wasescaped || wasquoted)
{
// append to previous pos
jv.set(jv.size() - 1,
lstitem = lstitem + delimiter
+ input.substring(cp, pos + escape));
}
else
{
jv.add(lstitem = input.substring(cp, pos + escape));
}
cp = pos + seplen;
wasescaped = escape == -1;
// last separator may be in an unmatched quote
wasquoted = DELIMITERS_PATTERN.matcher(lstitem).matches();
}
if (cp < input.length())
{
String c = input.substring(cp);
if (wasescaped || wasquoted)
{
// append final separator
jv.set(jv.size() - 1, lstitem + delimiter + c);
}
else
{
if (!c.equals(delimiter))
{
jv.add(c);
}
}
}
if (jv.size() > 0)
{
String[] v = jv.toArray(new String[jv.size()]);
jv.clear();
if (DEBUG)
{
System.err.println("Array from '" + delimiter
+ "' separated List:\n" + v.length);
for (int i = 0; i < v.length; i++)
{
System.err.println("item " + i + " '" + v[i] + "'");
}
}
return v;
}
if (DEBUG)
{
System.err.println("Empty Array from '" + delimiter
+ "' separated List");
}
return null;
}
/**
* Returns a string which contains the list elements delimited by the
* separator. Null items are ignored. If the input is null or has length zero,
* a single delimiter is returned.
*
* @param list
* @param separator
* @return concatenated string
*/
public static String arrayToSeparatorList(String[] list, String separator)
{
StringBuffer v = new StringBuffer();
if (list != null && list.length > 0)
{
for (int i = 0, iSize = list.length; i < iSize; i++)
{
if (list[i] != null)
{
if (v.length() > 0)
{
v.append(separator);
}
// TODO - escape any separator values in list[i]
v.append(list[i]);
}
}
if (DEBUG)
{
System.err.println("Returning '" + separator
+ "' separated List:\n");
System.err.println(v);
}
return v.toString();
}
if (DEBUG)
{
System.err.println("Returning empty '" + separator
+ "' separated List\n");
}
return "" + separator;
}
/**
* Parses the input line to a map of name / value(s) pairs. For example the
* line
* Notes=Fe-S;Method=manual curation; source = Pfam; Notes = Metal
* if parsed with delimiter=";" and separators {' ', '='}
* would return a map with { Notes={Fe=S, Metal}, Method={manual curation},
* source={Pfam}}
* Note the name/value strings are trimmed of leading / trailing spaces; the
* first separator encountered is used
*
* @param line
* @param delimiter
* the major delimiter between name-value pairs
* @param separators
* one or more separators used between name and value
* @return the name-values map (which may be empty but never null)
*/
public static Map> parseNameValuePairs(String line,
String delimiter, char[] separators)
{
Map> map = new HashMap>();
if (line == null || line.trim().length() == 0)
{
return map;
}
for (String pair : line.trim().split(delimiter))
{
pair = pair.trim();
if (pair.length() == 0)
{
continue;
}
int sepPos = -1;
for (char sep : separators)
{
int pos = pair.indexOf(sep);
if (pos > -1 && (sepPos == -1 || pos < sepPos))
{
sepPos = pos;
}
}
if (sepPos == -1)
{
// no name=value detected
continue;
}
String key = pair.substring(0, sepPos).trim();
String value = pair.substring(sepPos + 1).trim();
if (value.length() > 0)
{
List vals = map.get(key);
if (vals == null)
{
vals = new ArrayList();
map.put(key, vals);
}
vals.add(value);
}
}
return map;
}
/**
* Converts a list to a string with a delimiter before each term except the
* first. Returns an empty string given a null or zero-length argument. This
* can be replaced with StringJoiner in Java 8.
*
* @param terms
* @param delim
* @return
*/
public static String listToDelimitedString(List terms,
String delim)
{
StringBuilder sb = new StringBuilder(32);
if (terms != null && !terms.isEmpty())
{
boolean appended = false;
for (String term : terms)
{
if (appended)
{
sb.append(delim);
}
appended = true;
sb.append(term);
}
}
return sb.toString();
}
/**
* Convenience method to parse a string to an integer, returning 0 if the
* input is null or not a valid integer
*
* @param s
* @return
*/
public static int parseInt(String s)
{
int result = 0;
if (s != null && s.length() > 0)
{
try
{
result = Integer.parseInt(s);
} catch (NumberFormatException ex)
{
}
}
return result;
}
}