Added GVCF mode for VariantContext type determination (#1544)

* Added GVCF mode for VariantContext type determination

- Usually, NON_REF alleles will be considered SYMBOLIC. Therefore, if a VariantContext contains the alleles `A*,C,<NON_REF>`, the resulting type would be MIXED. For GVCF files, however, it would be helpful that this would be considered a SNP.
- Default behavior will not change, only if true is passed for the optional ignoreNonRef argument to getType()
- Added unit tests

* Moderate refactoring of VariantContext type determination

- This was necessary because the type caching needs to distinguish between ignoreNonRef being true or false
- Changed return type of `determineType` and `determinePolymorphicType` from `void` to `VariantContext.Type`, otherwise multiple code branches would be necessary depending on which caching variable to set
- Added unit test to catch if the cache separation works

Author: michaelgatzen

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

@@ -243,6 +243,9 @@ public class VariantContext implements HtsRecord, Feature, Serializable {
     /** The type (cached for performance reasons) of this context */
     protected Type type = null;
 
+    /** The type of this context, cached separately if ignoreNonRef is true */
+    protected Type typeIgnoringNonRef = null;
+
     /** A set of the alleles segregating in this context */
     protected final List<Allele> alleles;
 
@@ -666,10 +669,29 @@ public enum Type {
      * @return the type of this VariantContext
      **/
     public Type getType() {
-        if ( type == null )
-            determineType();
+        return getType(false);
+    }
 
-        return type;
+    /**
+     * Determines (if necessary) and returns the type of this variation by examining the alleles it contains.
+     *
+     * @param ignoreNonRef If set to true, symbolic NON_REF alleles will not be considered for the type determination,
+     *                     which is required for handling GVCF files.
+     * @return the type of this VariantContext
+     **/
+    public Type getType(final boolean ignoreNonRef) {
+        // Make sure we use the correct cached result
+        if (ignoreNonRef) {
+            if (typeIgnoringNonRef == null) {
+                typeIgnoringNonRef = determineType(ignoreNonRef);
+            }
+            return typeIgnoringNonRef;
+        } else {
+            if (type == null) {
+                type = determineType(ignoreNonRef);
+            }
+            return type;
+        }
     }
 
     /**
@@ -1430,30 +1452,34 @@ private void validateStop() {
     //
     // ---------------------------------------------------------------------------------------------------------
 
-    private void determineType() {
-        if ( type == null ) {
-            switch ( getNAlleles() ) {
-                case 0:
-                    throw new IllegalStateException("Unexpected error: requested type of VariantContext with no alleles!" + this);
-                case 1:
-                    // note that this doesn't require a reference allele.  You can be monomorphic independent of having a
-                    // reference allele
-                    type = Type.NO_VARIATION;
-                    break;
-                default:
-                    determinePolymorphicType();
-            }
+    private Type determineType(final boolean ignoreNonRef) {
+        switch ( getNAlleles() ) {
+            case 0:
+                throw new IllegalStateException("Unexpected error: requested type of VariantContext with no alleles!" + this);
+            case 1:
+                // note that this doesn't require a reference allele.  You can be monomorphic independent of having a
+                // reference allele
+                return Type.NO_VARIATION;
+            default:
+                return determinePolymorphicType(ignoreNonRef);
         }
     }
 
-    private void determinePolymorphicType() {
-        type = null;
+    private Type determinePolymorphicType(final boolean ignoreNonRef) {
+        Type type = null;
+        boolean nonRefAlleleFound = false;
 
         // do a pairwise comparison of all alleles against the reference allele
         for ( Allele allele : alleles ) {
             if ( allele == REF )
                 continue;
 
+            // If we see a NON_REF allele and need to ignore it, skip this allele, but signal that we have seen one
+            if (ignoreNonRef && allele.isNonRefAllele()) {
+                nonRefAlleleFound = true;
+                continue;
+            }
+
             // find the type of this allele relative to the reference
             Type biallelicType = typeOfBiallelicVariant(REF, allele);
 
@@ -1463,10 +1489,15 @@ private void determinePolymorphicType() {
             }
             // if the type of this allele is different from that of a previous one, assign it the MIXED type and quit
             else if ( biallelicType != type ) {
-                type = Type.MIXED;
-                return;
+                return Type.MIXED;
             }
         }
+        // If all alt alleles are NON_REF alleles and ignoreNonRef is true, type will still be null. Therefore, if we
+        // have only seen NON_REFs, choose SYMBOLIC
+        if (type == null && nonRefAlleleFound) {
+            return Type.NO_VARIATION;
+        }
+        return type;
     }
 
     private static Type typeOfBiallelicVariant(Allele ref, Allele allele) {

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

@@ -104,72 +104,198 @@ public void testDetermineTypes() {
         Allele TA = Allele.create("TA");
         Allele TC = Allele.create("TC");
         Allele symbolic = Allele.create("<FOO>");
+        Allele nonRef = Allele.create(Allele.NON_REF_STRING, false);
 
         // test REF
         List<Allele> alleles = Arrays.asList(Tref);
+        List<Allele> allelesWithNonRef = new ArrayList<>(alleles);
+        allelesWithNonRef.add(Allele.NON_REF_ALLELE);
         VariantContext vc = snpBuilder.alleles(alleles).stop(snpLocStop).make();
-        Assert.assertEquals(vc.getType(), VariantContext.Type.NO_VARIATION);
+        VariantContext vcWithNonRef = snpBuilder.alleles(allelesWithNonRef).stop(snpLocStop).make();
+        VariantContext.Type expectedType = VariantContext.Type.NO_VARIATION;
+        Assert.assertEquals(vc.getType(), expectedType);
+        Assert.assertEquals(vcWithNonRef.getType(true), expectedType);
 
         // test SNPs
         alleles = Arrays.asList(Tref, A);
+        allelesWithNonRef = new ArrayList<>(alleles);
+        allelesWithNonRef.add(Allele.NON_REF_ALLELE);
         vc = snpBuilder.alleles(alleles).stop(snpLocStop).make();
-        Assert.assertEquals(vc.getType(), VariantContext.Type.SNP);
+        vcWithNonRef = snpBuilder.alleles(allelesWithNonRef).stop(snpLocStop).make();
+        expectedType = VariantContext.Type.SNP;
+        Assert.assertEquals(vc.getType(), expectedType);
+        Assert.assertEquals(vcWithNonRef.getType(true), expectedType);
 
         alleles = Arrays.asList(Tref, A, C);
+        allelesWithNonRef = new ArrayList<>(alleles);
+        allelesWithNonRef.add(Allele.NON_REF_ALLELE);
         vc = snpBuilder.alleles(alleles).stop(snpLocStop).make();
-        Assert.assertEquals(vc.getType(), VariantContext.Type.SNP);
+        vcWithNonRef = snpBuilder.alleles(allelesWithNonRef).stop(snpLocStop).make();
+        expectedType = VariantContext.Type.SNP;
+        Assert.assertEquals(vc.getType(), expectedType);
+        Assert.assertEquals(vcWithNonRef.getType(true), expectedType);
 
         // test MNPs
         alleles = Arrays.asList(ACref, TA);
+        allelesWithNonRef = new ArrayList<>(alleles);
+        allelesWithNonRef.add(Allele.NON_REF_ALLELE);
         vc = snpBuilder.alleles(alleles).stop(snpLocStop+1).make();
-        Assert.assertEquals(vc.getType(), VariantContext.Type.MNP);
+        vcWithNonRef = snpBuilder.alleles(allelesWithNonRef).stop(snpLocStop).make();
+        expectedType = VariantContext.Type.MNP;
+        Assert.assertEquals(vc.getType(), expectedType);
+        Assert.assertEquals(vcWithNonRef.getType(true), expectedType);
 
         alleles = Arrays.asList(ATCref, CAT, Allele.create("GGG"));
+        allelesWithNonRef = new ArrayList<>(alleles);
+        allelesWithNonRef.add(Allele.NON_REF_ALLELE);
         vc = basicBuilder.alleles(alleles).stop(snpLocStop+2).make();
-        Assert.assertEquals(vc.getType(), VariantContext.Type.MNP);
+        vcWithNonRef = basicBuilder.alleles(allelesWithNonRef).stop(snpLocStop).make();
+        expectedType = VariantContext.Type.MNP;
+        Assert.assertEquals(vc.getType(), expectedType);
+        Assert.assertEquals(vcWithNonRef.getType(true), expectedType);
 
         // test INDELs
         alleles = Arrays.asList(Aref, ATC);
+        allelesWithNonRef = new ArrayList<>(alleles);
+        allelesWithNonRef.add(Allele.NON_REF_ALLELE);
         vc = basicBuilder.alleles(alleles).stop(snpLocStop).make();
-        Assert.assertEquals(vc.getType(), VariantContext.Type.INDEL);
+        vcWithNonRef = basicBuilder.alleles(allelesWithNonRef).stop(snpLocStop).make();
+        expectedType = VariantContext.Type.INDEL;
+        Assert.assertEquals(vc.getType(), expectedType);
+        Assert.assertEquals(vcWithNonRef.getType(true), expectedType);
 
         alleles = Arrays.asList(ATCref, A);
+        allelesWithNonRef = new ArrayList<>(alleles);
+        allelesWithNonRef.add(Allele.NON_REF_ALLELE);
         vc = basicBuilder.alleles(alleles).stop(snpLocStop+2).make();
-        Assert.assertEquals(vc.getType(), VariantContext.Type.INDEL);
+        vcWithNonRef = basicBuilder.alleles(allelesWithNonRef).stop(snpLocStop).make();
+        expectedType = VariantContext.Type.INDEL;
+        Assert.assertEquals(vc.getType(), expectedType);
+        Assert.assertEquals(vcWithNonRef.getType(true), expectedType);
 
         alleles = Arrays.asList(Tref, TA, TC);
+        allelesWithNonRef = new ArrayList<>(alleles);
+        allelesWithNonRef.add(Allele.NON_REF_ALLELE);
         vc = basicBuilder.alleles(alleles).stop(snpLocStop).make();
-        Assert.assertEquals(vc.getType(), VariantContext.Type.INDEL);
+        vcWithNonRef = basicBuilder.alleles(allelesWithNonRef).stop(snpLocStop).make();
+        expectedType = VariantContext.Type.INDEL;
+        Assert.assertEquals(vc.getType(), expectedType);
+        Assert.assertEquals(vcWithNonRef.getType(true), expectedType);
 
         alleles = Arrays.asList(ATCref, A, AC);
+        allelesWithNonRef = new ArrayList<>(alleles);
+        allelesWithNonRef.add(Allele.NON_REF_ALLELE);
         vc = basicBuilder.alleles(alleles).stop(snpLocStop+2).make();
-        Assert.assertEquals(vc.getType(), VariantContext.Type.INDEL);
+        vcWithNonRef = basicBuilder.alleles(allelesWithNonRef).stop(snpLocStop).make();
+        expectedType = VariantContext.Type.INDEL;
+        Assert.assertEquals(vc.getType(), expectedType);
+        Assert.assertEquals(vcWithNonRef.getType(true), expectedType);
 
         alleles = Arrays.asList(ATCref, A, Allele.create("ATCTC"));
+        allelesWithNonRef = new ArrayList<>(alleles);
+        allelesWithNonRef.add(Allele.NON_REF_ALLELE);
         vc = basicBuilder.alleles(alleles).stop(snpLocStop+2).make();
-        Assert.assertEquals(vc.getType(), VariantContext.Type.INDEL);
+        vcWithNonRef = basicBuilder.alleles(allelesWithNonRef).stop(snpLocStop).make();
+        expectedType = VariantContext.Type.INDEL;
+        Assert.assertEquals(vc.getType(), expectedType);
+        Assert.assertEquals(vcWithNonRef.getType(true), expectedType);
 
         // test MIXED
         alleles = Arrays.asList(TAref, T, TC);
+        allelesWithNonRef = new ArrayList<>(alleles);
+        allelesWithNonRef.add(Allele.NON_REF_ALLELE);
         vc = basicBuilder.alleles(alleles).stop(snpLocStop+1).make();
-        Assert.assertEquals(vc.getType(), VariantContext.Type.MIXED);
+        vcWithNonRef = basicBuilder.alleles(allelesWithNonRef).stop(snpLocStop).make();
+        expectedType = VariantContext.Type.MIXED;
+        Assert.assertEquals(vc.getType(), expectedType);
+        Assert.assertEquals(vcWithNonRef.getType(true), expectedType);
 
         alleles = Arrays.asList(TAref, T, AC);
+        allelesWithNonRef = new ArrayList<>(alleles);
+        allelesWithNonRef.add(Allele.NON_REF_ALLELE);
         vc = basicBuilder.alleles(alleles).stop(snpLocStop+1).make();
-        Assert.assertEquals(vc.getType(), VariantContext.Type.MIXED);
+        vcWithNonRef = basicBuilder.alleles(allelesWithNonRef).stop(snpLocStop).make();
+        expectedType = VariantContext.Type.MIXED;
+        Assert.assertEquals(vc.getType(), expectedType);
+        Assert.assertEquals(vcWithNonRef.getType(true), expectedType);
 
         alleles = Arrays.asList(ACref, ATC, AT);
+        allelesWithNonRef = new ArrayList<>(alleles);
+        allelesWithNonRef.add(Allele.NON_REF_ALLELE);
         vc = basicBuilder.alleles(alleles).stop(snpLocStop+1).make();
-        Assert.assertEquals(vc.getType(), VariantContext.Type.MIXED);
+        vcWithNonRef = basicBuilder.alleles(allelesWithNonRef).stop(snpLocStop).make();
+        expectedType = VariantContext.Type.MIXED;
+        Assert.assertEquals(vc.getType(), expectedType);
+        Assert.assertEquals(vcWithNonRef.getType(true), expectedType);
 
         alleles = Arrays.asList(Aref, T, symbolic);
+        allelesWithNonRef = new ArrayList<>(alleles);
+        allelesWithNonRef.add(Allele.NON_REF_ALLELE);
         vc = basicBuilder.alleles(alleles).stop(snpLocStop).make();
-        Assert.assertEquals(vc.getType(), VariantContext.Type.MIXED);
+        vcWithNonRef = basicBuilder.alleles(allelesWithNonRef).stop(snpLocStop).make();
+        expectedType = VariantContext.Type.MIXED;
+        Assert.assertEquals(vc.getType(), expectedType);
+        Assert.assertEquals(vcWithNonRef.getType(true), expectedType);
 
         // test SYMBOLIC
         alleles = Arrays.asList(Tref, symbolic);
+        allelesWithNonRef = new ArrayList<>(alleles);
+        allelesWithNonRef.add(Allele.NON_REF_ALLELE);
         vc = basicBuilder.alleles(alleles).stop(snpLocStop).make();
-        Assert.assertEquals(vc.getType(), VariantContext.Type.SYMBOLIC);
+        vcWithNonRef = basicBuilder.alleles(allelesWithNonRef).stop(snpLocStop).make();
+        expectedType = VariantContext.Type.SYMBOLIC;
+        Assert.assertEquals(vc.getType(), expectedType);
+        Assert.assertEquals(vcWithNonRef.getType(true), expectedType);
+    }
+
+    @Test
+    public void testDetermineTypesIgnoringNonRef() {
+        Allele AT = Allele.create("AT");
+        Allele TC = Allele.create("TC");
+        Allele symbolic = Allele.create("<FOO>");
+
+        List<Allele> alleles = Arrays.asList(Allele.REF_A, Allele.NON_REF_ALLELE);
+        VariantContext vc = basicBuilder.alleles(alleles).stop(snpLocStop).make();
+        Assert.assertEquals(vc.getType(false), VariantContext.Type.SYMBOLIC);
+
+        alleles = Arrays.asList(Allele.REF_A, Allele.NON_REF_ALLELE, symbolic);
+        vc = basicBuilder.alleles(alleles).stop(snpLocStop).make();
+        Assert.assertEquals(vc.getType(false), VariantContext.Type.SYMBOLIC);
+
+        alleles = Arrays.asList(Allele.REF_A, Allele.NON_REF_ALLELE, symbolic);
+        vc = basicBuilder.alleles(alleles).stop(snpLocStop).make();
+        Assert.assertEquals(vc.getType(true), VariantContext.Type.SYMBOLIC);
+
+        alleles = Arrays.asList(Allele.REF_A, Allele.NON_REF_ALLELE);
+        vc = basicBuilder.alleles(alleles).stop(snpLocStop).make();
+        Assert.assertEquals(vc.getType(true), VariantContext.Type.NO_VARIATION);
+
+        alleles = Arrays.asList(Allele.REF_A, Allele.ALT_C, Allele.NON_REF_ALLELE);
+        vc = basicBuilder.alleles(alleles).stop(snpLocStop).make();
+        Assert.assertEquals(vc.getType(true), VariantContext.Type.SNP);
+
+        alleles = Arrays.asList(Allele.REF_A, Allele.NON_REF_ALLELE, Allele.ALT_C);
+        vc = basicBuilder.alleles(alleles).stop(snpLocStop).make();
+        Assert.assertEquals(vc.getType(true), VariantContext.Type.SNP);
+
+        alleles = Arrays.asList(Allele.REF_A, AT, Allele.NON_REF_ALLELE);
+        vc = basicBuilder.alleles(alleles).stop(snpLocStop).make();
+        Assert.assertEquals(vc.getType(true), VariantContext.Type.INDEL);
+
+        alleles = Arrays.asList(Allele.REF_A, Allele.ALT_C, TC, Allele.NON_REF_ALLELE);
+        vc = basicBuilder.alleles(alleles).stop(snpLocStop).make();
+        Assert.assertEquals(vc.getType(true), VariantContext.Type.MIXED);
+
+        alleles = Arrays.asList(Allele.REF_A, Allele.ALT_C, symbolic, Allele.NON_REF_ALLELE);
+        vc = basicBuilder.alleles(alleles).stop(snpLocStop).make();
+        Assert.assertEquals(vc.getType(true), VariantContext.Type.MIXED);
+
+        // Assure that the caching of the variant type is not persistent between ignoreNonRef being true and false
+        alleles = Arrays.asList(Allele.REF_A, Allele.ALT_C, Allele.NON_REF_ALLELE);
+        vc = basicBuilder.alleles(alleles).stop(snpLocStop).make();
+        Assert.assertEquals(vc.getType(), VariantContext.Type.MIXED);
+        Assert.assertEquals(vc.getType(true), VariantContext.Type.SNP);
+        Assert.assertEquals(vc.getType(), VariantContext.Type.MIXED);
     }
 
     @Test