JAL-2722 unit test

[jalview.git] / src / jalview / analysis / Rna.java

diff --git a/src/jalview/analysis/Rna.java b/src/jalview/analysis/Rna.java
index f497f0e..94544e7 100644 (file)
--- a/src/jalview/analysis/Rna.java
+++ b/src/jalview/analysis/Rna.java
@@ -48,7 +48,21 @@ public class Rna
    */
   public static boolean isOpeningParenthesis(char c)
   {
-    return ('A' <= c && c <= 'Z' || c == '(' || c == '[' || c == '{' || c == '<');
+    return ('A' <= c && c <= 'Z' || c == '(' || c == '[' || c == '{'
+            || c == '<');
+  }
+
+  /**
+   * Answers true if the string is a valid open pair rna secondary structure
+   * symbol. Currently accepts A-Z, ([{<
+   * 
+   * @param s
+   * @return
+   */
+  public static boolean isOpeningParenthesis(String s)
+  {
+    return s != null && s.length() == 1
+            && isOpeningParenthesis(s.charAt(0));
   }
 
   /**
@@ -60,7 +74,21 @@ public class Rna
    */
   public static boolean isClosingParenthesis(char c)
   {
-    return ('a' <= c && c <= 'z' || c == ')' || c == ']' || c == '}' || c == '>');
+    return ('a' <= c && c <= 'z' || c == ')' || c == ']' || c == '}'
+            || c == '>');
+  }
+
+  /**
+   * Answers true if the string is a valid close pair rna secondary structure
+   * symbol. Currently accepts a-z, )]}>
+   * 
+   * @param s
+   * @return
+   */
+  public static boolean isClosingParenthesis(String s)
+  {
+    return s != null && s.length() == 1
+            && isClosingParenthesis(s.charAt(0));
   }
 
   /**
@@ -133,8 +161,8 @@ public class Rna
         if (!stacks.containsKey(opening))
         {
           throw new WUSSParseException(MessageManager.formatMessage(
-                  "exception.mismatched_unseen_closing_char",
-                  new String[] { String.valueOf(base) }), i);
+                  "exception.mismatched_unseen_closing_char", new String[]
+                  { String.valueOf(base) }), i);
         }
 
         Stack<Integer> stack = stacks.get(opening);
@@ -142,8 +170,8 @@ public class Rna
         {
           // error whilst parsing i'th position. pass back
           throw new WUSSParseException(MessageManager.formatMessage(
-                  "exception.mismatched_closing_char",
-                  new String[] { String.valueOf(base) }), i);
+                  "exception.mismatched_closing_char", new String[]
+                  { String.valueOf(base) }), i);
         }
         int temp = stack.pop();
 
@@ -161,9 +189,9 @@ public class Rna
          * i (length of input string)
          */
         throw new WUSSParseException(MessageManager.formatMessage(
-                "exception.mismatched_opening_char",
-                new String[] { String.valueOf(opening),
-                    String.valueOf(stack.pop()) }), i);
+                "exception.mismatched_opening_char", new String[]
+                { String.valueOf(opening), String.valueOf(stack.pop()) }),
+                i);
       }
     }
     return pairs;
@@ -298,6 +326,18 @@ public class Rna
   }
 
   /**
+   * Answers true if the string is a recognised symbol for RNA secondary
+   * structure. Currently accepts a-z, A-Z, ()[]{}<>.
+   * 
+   * @param s
+   * @return
+   */
+  public static boolean isRnaSecondaryStructureSymbol(String s)
+  {
+    return isOpeningParenthesis(s) || isClosingParenthesis(s);
+  }
+
+  /**
    * Translates a string to RNA secondary structure representation. Returns the
    * string with any non-SS characters changed to spaces. Accepted characters
    * are a-z, A-Z, and (){}[]<> brackets.
@@ -321,8 +361,8 @@ public class Rna
   }
 
   /**
-   * Answers true if the base-pair is either a canonical (A-T/U, C-G) or a
-   * wobble (G-T/U) pair (either way round), else false
+   * Answers true if the base-pair is either a Watson-Crick (A:T/U, C:G) or a
+   * wobble (G:T/U) pair (either way round), else false
    * 
    * @param first
    * @param second
@@ -338,7 +378,7 @@ public class Rna
     {
       second -= 32;
     }
-  
+
     switch (first)
     {
     case 'A':
@@ -379,6 +419,62 @@ public class Rna
   }
 
   /**
+   * Answers true if the base-pair is Watson-Crick - (A:T/U or C:G, either way
+   * round), else false
+   * 
+   * @param first
+   * @param second
+   * @return
+   */
+  public static boolean isCanonicalPair(char first, char second)
+  {
+
+    if (first > 'Z')
+    {
+      first -= 32;
+    }
+    if (second > 'Z')
+    {
+      second -= 32;
+    }
+
+    switch (first)
+    {
+    case 'A':
+      switch (second)
+      {
+      case 'T':
+      case 'U':
+        return true;
+      }
+      break;
+    case 'G':
+      switch (second)
+      {
+      case 'C':
+        return true;
+      }
+      break;
+    case 'C':
+      switch (second)
+      {
+      case 'G':
+        return true;
+      }
+      break;
+    case 'T':
+    case 'U':
+      switch (second)
+      {
+      case 'A':
+        return true;
+      }
+      break;
+    }
+    return false;
+  }
+
+  /**
    * Returns the matching close pair symbol for the given opening symbol.
    * Currently returns a-z for A-Z, or )]}> for ([{<, or the input symbol if it
    * is not a valid opening symbol.