X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Futil%2FStringUtils.java;h=ad1c0f7b7ab33bd658c70e3511bb3a72b87b9929;hb=9b3219d225131af5a165553f206ebf8da304ee23;hp=c55d467ca1f7f93d540f5c7dcd1158c95f735b9a;hpb=fddf3084802b37e5cee17829e32692a4aac3e60d;p=jalview.git

diff --git a/src/jalview/util/StringUtils.java b/src/jalview/util/StringUtils.java
index c55d467..ad1c0f7 100644
--- a/src/jalview/util/StringUtils.java
+++ b/src/jalview/util/StringUtils.java
@@ -1,13 +1,35 @@
+/*
+ * 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 <http://www.gnu.org/licenses/>.
+ * 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 Pattern DELIMITERS_PATTERN = Pattern
+          .compile(".*='[^']*(?!')");
 
   private static final boolean DEBUG = false;
 
@@ -25,11 +47,10 @@ public class StringUtils
    *          the character to insert
    */
   public static final char[] insertCharAt(char[] in, int position,
-          int count,
-          char ch)
+          int count, char ch)
   {
     char[] tmp = new char[in.length + count];
-  
+
     if (position >= in.length)
     {
       System.arraycopy(in, 0, tmp, 0, in.length);
@@ -39,20 +60,19 @@ public class StringUtils
     {
       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);
+      System.arraycopy(in, position, tmp, index, in.length - position);
     }
-  
+
     return tmp;
   }
 
@@ -230,4 +250,121 @@ public class StringUtils
     }
     return "" + separator;
   }
+  
+  /**
+   * Parses the input line to a map of name / value(s) pairs. For example the
+   * line <br>
+   * Notes=Fe-S;Method=manual curation; source = Pfam; Notes = Metal <br>
+   * if parsed with delimiter=";" and separators {' ', '='} <br>
+   * would return a map with { Notes={Fe=S, Metal}, Method={manual curation},
+   * source={Pfam}} <br>
+   * 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<String, List<String>> parseNameValuePairs(String line,
+          String delimiter, char[] separators)
+  {
+    Map<String, List<String>> map = new HashMap<String, List<String>>();
+    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<String> vals = map.get(key);
+        if (vals == null)
+        {
+          vals = new ArrayList<String>();
+          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<String> 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;
+  }
 }