remove caching of alleles in AbstractVCFCodec

src/main/java/htsjdk/variant/variantcontext/Allele.java

@@ -294,16 +294,44 @@ public static boolean wouldBeNoCallAllele(final byte[] bases) {
 
     /**
      * @param bases  bases representing an allele
-     * @return true if the bases represent a symbolic allele
+     * @return true if the bases represent a symbolic allele, including breakpoints and breakends
      */
     public static boolean wouldBeSymbolicAllele(final byte[] bases) {
     	if ( bases.length <= 1 )
             return false;
         else {
-            final String strBases = new String(bases);
-            return (bases[0] == '<' || bases[bases.length-1] == '>') || // symbolic or large insertion
-            		(bases[0] == '.' || bases[bases.length-1] == '.') || // single breakend
-                    (strBases.contains("[") || strBases.contains("]")); // mated breakend
+            return bases[0] == '<' || bases[bases.length - 1] == '>' ||
+                    wouldBeBreakpoint(bases) ||
+                    wouldBeSingleBreakend(bases);
+        }
+    }
+
+    /**
+     * @param bases  bases representing an allele
+     * @return true if the bases represent a symbolic allele in breakpoint notation, (ex: G]17:198982] or ]13:123456]T )
+     */
+    public static boolean wouldBeBreakpoint(final byte[] bases) {
+        if ( bases.length <= 1 )
+            return false;
+        else {
+            for (int i = 0; i < bases.length; i++) {
+                final byte base = bases[i];
+                if (base == '[' || base == ']') {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+    /**
+     * @param bases  bases representing an allele
+     * @return true if the bases represent a symbolic allele in single breakend notation (ex: .A or A. )
+     */
+    public static boolean wouldBeSingleBreakend(final byte[] bases) {
+        if ( bases.length <= 1 )
+            return false;
+        else {
+            return bases[0] == '.' || bases[bases.length - 1] == '.';
         }
     }
 
@@ -408,19 +436,26 @@ public static Allele create(final Allele allele, final boolean ignoreRefState) {
     //
     // ---------------------------------------------------------------------------------------------------------
 
-    // Returns true if this is the NO_CALL allele
+    /** @return true if this is the NO_CALL allele */
     public boolean isNoCall()           { return isNoCall; }
     // Returns true if this is not the NO_CALL allele
     public boolean isCalled()           { return ! isNoCall(); }
 
-    // Returns true if this Allele is the reference allele
+    /** @return true if this Allele is the reference allele */
     public boolean isReference()        { return isRef; }
-    // Returns true if this Allele is not the reference allele
+
+    /** @return true if this Allele is not the reference allele */
     public boolean isNonReference()     { return ! isReference(); }
 
-    // Returns true if this Allele is symbolic (i.e. no well-defined base sequence)
+    /** @return true if this Allele is symbolic (i.e. no well-defined base sequence), this includes breakpoints and breakends */
     public boolean isSymbolic()         { return isSymbolic; }
 
+    /** @return true if this Allele is a breakpoint ( ex: G]17:198982] or ]13:123456]T ) */
+    public boolean isBreakpoint()         { return wouldBeBreakpoint(bases); }
+
+    /** @return true if this Allele is a single breakend (ex: .A or A.) */
+    public boolean isSingleBreakend()         { return wouldBeSingleBreakend(bases); }
+
     // Returns a nice string representation of this object
     public String toString() {
         return ( isNoCall() ? NO_CALL_STRING : getDisplayString() ) + (isReference() ? "*" : "");

src/main/java/htsjdk/variant/vcf/AbstractVCFCodec.java

@@ -64,7 +64,7 @@
 public abstract class AbstractVCFCodec extends AsciiFeatureCodec<VariantContext> implements NameAwareCodec {
     public final static int MAX_ALLELE_SIZE_BEFORE_WARNING = (int)Math.pow(2, 20);
 
-    protected final static int NUM_STANDARD_FIELDS = 8;  // INFO is the 8th column
+    protected final static int NUM_STANDARD_FIELDS = 8;  // INFO is the 8th
 
     // we have to store the list of strings that make up the header until they're needed
     protected VCFHeader header = null;
@@ -332,12 +332,12 @@ else if ( parts[2].equals(VCFConstants.EMPTY_ID_FIELD) )
         else
             builder.id(parts[2]);
 
-        final String ref = getCachedString(parts[3].toUpperCase());
-        final String alts = getCachedString(parts[4]);
+        final String ref = parts[3].toUpperCase();
+        final String alts = parts[4];
         builder.log10PError(parseQual(parts[5]));
 
         final List<String> filters = parseFilters(getCachedString(parts[6]));
-        if ( filters != null ) builder.filters(new HashSet<String>(filters));
+        if ( filters != null ) builder.filters(new HashSet<>(filters));
         final Map<String, Object> attrs = parseInfo(parts[7]);
         builder.attributes(attrs);
 
@@ -577,7 +577,7 @@ private static void checkAllele(String allele, boolean isRef, int lineNo) {
             System.err.println(String.format("Allele detected with length %d exceeding max size %d at approximately line %d, likely resulting in degraded VCF processing performance", allele.length(), MAX_ALLELE_SIZE_BEFORE_WARNING, lineNo));
         }
 
-        if ( isSymbolicAllele(allele) ) {
+        if (Allele.wouldBeSymbolicAllele(allele.getBytes())) {
             if ( isRef ) {
                 generateException("Symbolic alleles not allowed as reference allele: " + allele, lineNo);
             }
@@ -609,18 +609,6 @@ private static String generateExceptionTextForBadAlleleBases(final String allele
         return "unparsable vcf record with allele " + allele;
     }
 
-    /**
-     * return true if this is a symbolic allele (e.g. <SOMETAG>) or
-     * structural variation breakend (with [ or ]), otherwise false
-     * @param allele the allele to check
-     * @return true if the allele is a symbolic allele, otherwise false
-     */
-    private static boolean isSymbolicAllele(String allele) {
-        return (allele != null && allele.length() > 2 &&
-                ((allele.startsWith("<") && allele.endsWith(">")) ||
-                        (allele.contains("[") || allele.contains("]"))));
-    }
-
     /**
      * parse a single allele, given the allele list
      * @param alleles the alleles available

src/test/java/htsjdk/variant/variantcontext/AlleleUnitTest.java

@@ -277,4 +277,38 @@ public void testExtend() {
         Assert.assertEquals("ATCGA", Allele.extend(Allele.create("AT"), "CGA".getBytes()).toString());
         Assert.assertEquals("ATCGA", Allele.extend(Allele.create("ATC"), "GA".getBytes()).toString());
     }
+    @Test
+    public void testWouldBeSymbolic() {
+        Assert.assertTrue(Allele.wouldBeSymbolicAllele("<DEL>".getBytes()));
+        Assert.assertTrue(Allele.wouldBeSymbolicAllele("AAAAAA[chr1:1234[".getBytes()));
+        Assert.assertTrue(Allele.wouldBeSymbolicAllele("AAAAAA]chr1:1234]".getBytes()));
+        Assert.assertTrue(Allele.wouldBeSymbolicAllele("A.".getBytes()));
+        Assert.assertTrue(Allele.wouldBeSymbolicAllele(".A".getBytes()));
+        Assert.assertFalse(Allele.wouldBeSymbolicAllele("AA".getBytes()));
+        Assert.assertFalse(Allele.wouldBeSymbolicAllele("A".getBytes()));
+    }
+    @Test
+    public void testWouldBeBreakpoint() {
+        Assert.assertTrue(Allele.wouldBeBreakpoint("G]17:198982]".getBytes()));
+        Assert.assertTrue(Allele.wouldBeBreakpoint("]13:123456]T".getBytes()));
+        Assert.assertFalse(Allele.wouldBeBreakpoint("<DEL>".getBytes()));
+        Assert.assertTrue(Allele.wouldBeBreakpoint("AAAAAA[chr1:1234[".getBytes()));
+        Assert.assertTrue(Allele.wouldBeBreakpoint("AAAAAA]chr1:1234]".getBytes()));
+        Assert.assertFalse(Allele.wouldBeBreakpoint("A.".getBytes()));
+        Assert.assertFalse(Allele.wouldBeBreakpoint(".A".getBytes()));
+        Assert.assertFalse(Allele.wouldBeBreakpoint("AA".getBytes()));
+        Assert.assertFalse(Allele.wouldBeBreakpoint("A".getBytes()));
+    }
+    @Test
+    public void testWouldBeBreakend() {
+        Assert.assertFalse(Allele.wouldBeSingleBreakend("G]17:198982]".getBytes()));
+        Assert.assertFalse(Allele.wouldBeSingleBreakend("]13:123456]T".getBytes()));
+        Assert.assertFalse(Allele.wouldBeSingleBreakend("<DEL>".getBytes()));
+        Assert.assertFalse(Allele.wouldBeSingleBreakend("AAAAAA[chr1:1234[".getBytes()));
+        Assert.assertFalse(Allele.wouldBeSingleBreakend("AAAAAA]chr1:1234]".getBytes()));
+        Assert.assertTrue(Allele.wouldBeSingleBreakend("A.".getBytes()));
+        Assert.assertTrue(Allele.wouldBeSingleBreakend(".A".getBytes()));
+        Assert.assertFalse(Allele.wouldBeSingleBreakend("AA".getBytes()));
+        Assert.assertFalse(Allele.wouldBeSingleBreakend("A".getBytes()));
+    }
 }