b5ab40df65c9c121000b017044ee344eb3e84b0d
[jalview.git] / StringUtils.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21 package jalview.util;
22
23 import java.util.ArrayList;
24 import java.util.List;
25 import java.util.regex.Pattern;
26
27 public class StringUtils
28 {
29   private static final Pattern DELIMITERS_PATTERN = Pattern
30           .compile(".*='[^']*(?!')");
31
32   private static final boolean DEBUG = false;
33
34   /**
35    * Returns a new character array, after inserting characters into the given
36    * character array.
37    * 
38    * @param in
39    *          the character array to insert into
40    * @param position
41    *          the 0-based position for insertion
42    * @param count
43    *          the number of characters to insert
44    * @param ch
45    *          the character to insert
46    */
47   public static final char[] insertCharAt(char[] in, int position,
48           int count, char ch)
49   {
50     char[] tmp = new char[in.length + count];
51
52     if (position >= in.length)
53     {
54       System.arraycopy(in, 0, tmp, 0, in.length);
55       position = in.length;
56     }
57     else
58     {
59       System.arraycopy(in, 0, tmp, 0, position);
60     }
61
62     int index = position;
63     while (count > 0)
64     {
65       tmp[index++] = ch;
66       count--;
67     }
68
69     if (position < in.length)
70     {
71       System.arraycopy(in, position, tmp, index, in.length - position);
72     }
73
74     return tmp;
75   }
76
77   /**
78    * Delete
79    * 
80    * @param in
81    * @param from
82    * @param to
83    * @return
84    */
85   public static final char[] deleteChars(char[] in, int from, int to)
86   {
87     if (from >= in.length || from < 0)
88     {
89       return in;
90     }
91
92     char[] tmp;
93
94     if (to >= in.length)
95     {
96       tmp = new char[from];
97       System.arraycopy(in, 0, tmp, 0, from);
98       to = in.length;
99     }
100     else
101     {
102       tmp = new char[in.length - to + from];
103       System.arraycopy(in, 0, tmp, 0, from);
104       System.arraycopy(in, to, tmp, from, in.length - to);
105     }
106     return tmp;
107   }
108
109   /**
110    * Returns the last part of 'input' after the last occurrence of 'token'. For
111    * example to extract only the filename from a full path or URL.
112    * 
113    * @param input
114    * @param token
115    *          a delimiter which must be in regular expression format
116    * @return
117    */
118   public static String getLastToken(String input, String token)
119   {
120     if (input == null)
121     {
122       return null;
123     }
124     if (token == null)
125     {
126       return input;
127     }
128     String[] st = input.split(token);
129     return st[st.length - 1];
130   }
131
132   /**
133    * Parses the input string into components separated by the delimiter. Unlike
134    * String.split(), this method will ignore occurrences of the delimiter which
135    * are nested within single quotes in name-value pair values, e.g. a='b,c'.
136    * 
137    * @param input
138    * @param delimiter
139    * @return elements separated by separator
140    */
141   public static String[] separatorListToArray(String input, String delimiter)
142   {
143     int seplen = delimiter.length();
144     if (input == null || input.equals("") || input.equals(delimiter))
145     {
146       return null;
147     }
148     List<String> jv = new ArrayList<String>();
149     int cp = 0, pos, escape;
150     boolean wasescaped = false, wasquoted = false;
151     String lstitem = null;
152     while ((pos = input.indexOf(delimiter, cp)) >= cp)
153     {
154       escape = (pos > 0 && input.charAt(pos - 1) == '\\') ? -1 : 0;
155       if (wasescaped || wasquoted)
156       {
157         // append to previous pos
158         jv.set(jv.size() - 1,
159                 lstitem = lstitem + delimiter
160                         + input.substring(cp, pos + escape));
161       }
162       else
163       {
164         jv.add(lstitem = input.substring(cp, pos + escape));
165       }
166       cp = pos + seplen;
167       wasescaped = escape == -1;
168       // last separator may be in an unmatched quote
169       wasquoted = DELIMITERS_PATTERN.matcher(lstitem).matches();
170     }
171     if (cp < input.length())
172     {
173       String c = input.substring(cp);
174       if (wasescaped || wasquoted)
175       {
176         // append final separator
177         jv.set(jv.size() - 1, lstitem + delimiter + c);
178       }
179       else
180       {
181         if (!c.equals(delimiter))
182         {
183           jv.add(c);
184         }
185       }
186     }
187     if (jv.size() > 0)
188     {
189       String[] v = jv.toArray(new String[jv.size()]);
190       jv.clear();
191       if (DEBUG)
192       {
193         System.err.println("Array from '" + delimiter
194                 + "' separated List:\n" + v.length);
195         for (int i = 0; i < v.length; i++)
196         {
197           System.err.println("item " + i + " '" + v[i] + "'");
198         }
199       }
200       return v;
201     }
202     if (DEBUG)
203     {
204       System.err.println("Empty Array from '" + delimiter
205               + "' separated List");
206     }
207     return null;
208   }
209
210   /**
211    * Returns a string which contains the list elements delimited by the
212    * separator. Null items are ignored. If the input is null or has length zero,
213    * a single delimiter is returned.
214    * 
215    * @param list
216    * @param separator
217    * @return concatenated string
218    */
219   public static String arrayToSeparatorList(String[] list, String separator)
220   {
221     StringBuffer v = new StringBuffer();
222     if (list != null && list.length > 0)
223     {
224       for (int i = 0, iSize = list.length; i < iSize; i++)
225       {
226         if (list[i] != null)
227         {
228           if (v.length() > 0)
229           {
230             v.append(separator);
231           }
232           // TODO - escape any separator values in list[i]
233           v.append(list[i]);
234         }
235       }
236       if (DEBUG)
237       {
238         System.err.println("Returning '" + separator
239                 + "' separated List:\n");
240         System.err.println(v);
241       }
242       return v.toString();
243     }
244     if (DEBUG)
245     {
246       System.err.println("Returning empty '" + separator
247               + "' separated List\n");
248     }
249     return "" + separator;
250   }
251
252   /**
253    * Converts a list to a string with a delimiter before each term except the
254    * first. Returns an empty string given a null or zero-length argument. This
255    * can be replaced with StringJoiner in Java 8.
256    * 
257    * @param terms
258    * @param delim
259    * @return
260    */
261   public static String listToDelimitedString(List<String> terms,
262           String delim)
263   {
264     StringBuilder sb = new StringBuilder(32);
265     if (terms != null && !terms.isEmpty())
266     {
267       boolean appended = false;
268       for (String term : terms)
269       {
270         if (appended)
271         {
272           sb.append(delim);
273         }
274         appended = true;
275         sb.append(term);
276       }
277     }
278     return sb.toString();
279   }
280
281   /**
282    * Convenience method to parse a string to an integer, returning 0 if the
283    * input is null or not a valid integer
284    * 
285    * @param s
286    * @return
287    */
288   public static int parseInt(String s)
289   {
290     int result = 0;
291     if (s != null && s.length() > 0)
292     {
293       try
294       {
295         result = Integer.parseInt(s);
296       } catch (NumberFormatException ex)
297       {
298       }
299     }
300     return result;
301   }
302
303   /**
304    * Compares two versions formatted as e.g. "3.4.5" and returns -1, 0 or 1 as
305    * the first version precedes, is equal to, or follows the second
306    * 
307    * @param v1
308    * @param v2
309    * @return
310    */
311   public static int compareVersions(String v1, String v2)
312   {
313     return compareVersions(v1, v2, null);
314   }
315
316   /**
317    * Compares two versions formatted as e.g. "3.4.5b1" and returns -1, 0 or 1 as
318    * the first version precedes, is equal to, or follows the second
319    * 
320    * @param v1
321    * @param v2
322    * @param pointSeparator
323    *          a string used to delimit point increments in sub-tokens of the
324    *          version
325    * @return
326    */
327   public static int compareVersions(String v1, String v2,
328           String pointSeparator)
329   {
330     if (v1 == null || v2 == null)
331     {
332       return 0;
333     }
334     String[] toks1 = v1.split("\\.");
335     String[] toks2 = v2.split("\\.");
336     int i = 0;
337     for (; i < toks1.length; i++)
338     {
339       if (i >= toks2.length)
340       {
341         /*
342          * extra tokens in v1
343          */
344         return 1;
345       }
346       String tok1 = toks1[i];
347       String tok2 = toks2[i];
348       if (pointSeparator != null)
349       {
350         /*
351          * convert e.g. 5b2 into decimal 5.2 for comparison purposes
352          */
353         tok1 = tok1.replace(pointSeparator, ".");
354         tok2 = tok2.replace(pointSeparator, ".");
355       }
356       try
357       {
358         float f1 = Float.valueOf(tok1);
359         float f2 = Float.valueOf(tok2);
360         int comp = Float.compare(f1, f2);
361         if (comp != 0)
362         {
363           return comp;
364         }
365       } catch (NumberFormatException e)
366       {
367         System.err.println("Invalid version format found: "
368                 + e.getMessage());
369         return 0;
370       }
371     }
372
373     if (i < toks2.length)
374     {
375       /*
376        * extra tokens in v2 
377        */
378       return -1;
379     }
380
381     /*
382      * same length, all tokens match
383      */
384     return 0;
385   }
386
387   /**
388    * Converts the string to all lower-case except the first character which is
389    * upper-cased
390    * 
391    * @param s
392    * @return
393    */
394   public static String toSentenceCase(String s)
395   {
396     if (s == null)
397     {
398       return s;
399     }
400     if (s.length() <= 1)
401     {
402       return s.toUpperCase();
403     }
404     return s.substring(0, 1).toUpperCase() + s.substring(1).toLowerCase();
405   }
406 }