update CramCompressionRecord.isPlaced() to make it APDelta-aware

src/main/java/htsjdk/samtools/CRAMContainerStreamWriter.java

@@ -379,8 +379,8 @@ protected void flushContainer() throws IllegalArgumentException, IllegalAccessEx
                     while (last.next != null) last = last.next;
 
                     if (cramRecord.isFirstSegment() && last.isLastSegment()) {
-
-                        final int templateLength = CramNormalizer.computeInsertSize(cramRecord, last);
+                        final boolean coordinateSorted = (samFileHeader.getSortOrder() == SAMFileHeader.SortOrder.unsorted);
+                        final int templateLength = CramNormalizer.computeInsertSize(cramRecord, last, coordinateSorted);
 
                         if (cramRecord.templateSize == templateLength) {
                             last = cramRecord.next;

src/main/java/htsjdk/samtools/cram/build/CramNormalizer.java

@@ -94,7 +94,7 @@ public void normalize(final ArrayList<CramCompressionRecord> records,
             for (final CramCompressionRecord record : records) {
                 if (record.previous != null) continue;
                 if (record.next == null) continue;
-                restoreMateInfo(record);
+                restoreMateInfo(record, header.getSortOrder() == SAMFileHeader.SortOrder.coordinate);
             }
         }
 
@@ -137,7 +137,8 @@ public void normalize(final ArrayList<CramCompressionRecord> records,
         restoreQualityScores(defaultQualityScore, records);
     }
 
-    private static void restoreMateInfo(final CramCompressionRecord record) {
+    private static void restoreMateInfo(final CramCompressionRecord record,
+                                        final boolean coordinateSorted) {
         if (record.next == null) {
 
             return;
@@ -155,7 +156,7 @@ private static void restoreMateInfo(final CramCompressionRecord record) {
 //        record.setFirstSegment(true);
 //        last.setLastSegment(true);
 
-        final int templateLength = computeInsertSize(record, last);
+        final int templateLength = computeInsertSize(record, last, coordinateSorted);
         record.templateSize = templateLength;
         last.templateSize = -templateLength;
     }
@@ -326,19 +327,21 @@ private static byte getByteOrDefault(final byte[] array, final int pos,
      *
      * @param firstEnd  first mate of the pair
      * @param secondEnd second mate of the pair
+     * @param coordinateSorted do these records have APDelta set?
      * @return template length
      */
     public static int computeInsertSize(final CramCompressionRecord firstEnd,
-                                        final CramCompressionRecord secondEnd) {
+                                        final CramCompressionRecord secondEnd,
+                                        final boolean coordinateSorted) {
         if (firstEnd.isSegmentUnmapped() || secondEnd.isSegmentUnmapped()) {
             return 0;
         }
         if (firstEnd.sequenceId != secondEnd.sequenceId) {
             return 0;
         }
 
-        final int firstEnd5PrimePosition = firstEnd.isNegativeStrand() ? firstEnd.getAlignmentEnd() : firstEnd.alignmentStart;
-        final int secondEnd5PrimePosition = secondEnd.isNegativeStrand() ? secondEnd.getAlignmentEnd() : secondEnd.alignmentStart;
+        final int firstEnd5PrimePosition = firstEnd.isNegativeStrand() ? firstEnd.getAlignmentEnd(coordinateSorted) : firstEnd.alignmentStart;
+        final int secondEnd5PrimePosition = secondEnd.isNegativeStrand() ? secondEnd.getAlignmentEnd(coordinateSorted) : secondEnd.alignmentStart;
 
         final int adjustment = (secondEnd5PrimePosition >= firstEnd5PrimePosition) ? +1 : -1;
         return secondEnd5PrimePosition - firstEnd5PrimePosition + adjustment;

src/main/java/htsjdk/samtools/cram/structure/CramCompressionRecord.java

@@ -152,13 +152,22 @@ public String toString() {
         return stringBuilder.toString();
     }
 
-    public int getAlignmentSpan() {
-        if (alignmentSpan < 0) calculateAlignmentBoundaries();
+    public int getAlignmentSpan(final boolean APDelta) {
+        if (alignmentSpan < 0) {
+            calculateAlignmentBoundaries(APDelta);
+        }
         return alignmentSpan;
     }
 
-    void calculateAlignmentBoundaries() {
-        if (isSegmentUnmapped()) {
+    public int getAlignmentEnd(final boolean APDelta) {
+        if (alignmentEnd < 0) {
+            calculateAlignmentBoundaries(APDelta);
+        }
+        return alignmentEnd;
+    }
+
+    void calculateAlignmentBoundaries(final boolean APDelta) {
+        if (! isPlaced(APDelta)) {
             alignmentSpan = 0;
             alignmentEnd = SAMRecord.NO_ALIGNMENT_START;
         } else if (readFeatures == null || readFeatures.isEmpty()) {
@@ -189,11 +198,6 @@ void calculateAlignmentBoundaries() {
         }
     }
 
-    public int getAlignmentEnd() {
-        if (alignmentEnd < 0) calculateAlignmentBoundaries();
-        return alignmentEnd;
-    }
-
     public boolean isMultiFragment() {
         return (flags & MULTI_FRAGMENT_FLAG) != 0;
     }
@@ -207,7 +211,7 @@ public void setMultiFragment(final boolean multiFragment) {
      * Unmapped records may be stored in the same {@link Slice}s and {@link Container}s as mapped
      * records if they are placed.
      *
-     * @see #isPlaced()
+     * @see #isPlaced(boolean)
      * @return true if the record is unmapped
      */
     public boolean isSegmentUnmapped() {
@@ -220,15 +224,20 @@ public void setSegmentUnmapped(final boolean segmentUnmapped) {
 
     /**
      * Does this record have a valid placement/alignment location? This is independent of mapping status.
-     * It must have both a valid reference sequence ID and alignment start position to qualify.
-     * Unplaced reads may only be stored in Unmapped or Multiple Reference {@link Slice}s and {@link Container}s.
+     * It must have a valid reference sequence ID to qualify, as well as a valid alignment start position
+     * in the case of absolute (non-APDelta) position storage.
      *
      * @see #isSegmentUnmapped()
      * @return true if the record is placed
      */
-    public boolean isPlaced() {
-        return sequenceId != SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX &&
-                alignmentStart != SAMRecord.NO_ALIGNMENT_START;
+    public boolean isPlaced(final boolean APDelta) {
+        // if an absolute alignment start coordinate is required but we have none, it's unplaced
+        if (! APDelta && alignmentStart == SAMRecord.NO_ALIGNMENT_START) {
+            return false;
+        }
+
+        // it's also unplaced if we have no reference
+        return sequenceId != SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX;
     }
 
     public boolean isFirstSegment() {

src/main/java/htsjdk/samtools/cram/structure/Slice.java

@@ -388,7 +388,7 @@ public static Slice buildSlice(final List<CramCompressionRecord> records,
             // Unmapped: all records are unmapped and unplaced
 
             final CramCompressionRecord firstRecord = records.get(0);
-            slice.sequenceId = firstRecord.isPlaced() ?
+            slice.sequenceId = firstRecord.isPlaced(header.APDelta) ?
                     firstRecord.sequenceId :
                     SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX;
 
@@ -398,19 +398,19 @@ public static Slice buildSlice(final List<CramCompressionRecord> records,
                 hasher.add(record);
 
                 // flip an unmapped slice to multi-ref if the record is placed
-                if (slice.isUnmapped() && record.isPlaced()) {
+                if (slice.isUnmapped() && record.isPlaced(header.APDelta)) {
                     slice.sequenceId = MULTI_REFERENCE;
                 }
                 else if (slice.isMappedSingleRef()) {
                     // flip a single-ref slice to multi-ref if the record is unplaced or on a different ref
-                    if (!record.isPlaced() || slice.sequenceId != record.sequenceId) {
+                    if (!record.isPlaced(header.APDelta) || slice.sequenceId != record.sequenceId) {
                         slice.sequenceId = MULTI_REFERENCE;
                     }
                     else {
                         // calculate single ref slice alignment
 
                         minAlStart = Math.min(record.alignmentStart, minAlStart);
-                        maxAlEnd = Math.max(record.getAlignmentEnd(), maxAlEnd);
+                        maxAlEnd = Math.max(record.getAlignmentEnd(header.APDelta), maxAlEnd);
                     }
                 }
             }

src/test/java/htsjdk/samtools/cram/structure/CramCompressionRecordTest.java

@@ -4,6 +4,7 @@
 import htsjdk.samtools.SAMRecord;
 import htsjdk.samtools.cram.encoding.readfeatures.*;
 import org.testng.Assert;
+import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
 import java.util.ArrayList;
@@ -12,19 +13,24 @@
  * Created by vadim on 28/09/2015.
  */
 public class CramCompressionRecordTest extends HtsjdkTest {
-    @Test
-    public void test_getAlignmentEnd() {
+    @DataProvider(name = "tf")
+    private Object[][] tf() {
+        return new Object[][] { {true}, {false}};
+    }
+
+    @Test(dataProvider = "tf")
+    public void test_getAlignmentEnd(final boolean APDelta) {
         CramCompressionRecord r = new CramCompressionRecord();
         r.alignmentStart = 1;
         r.setSegmentUnmapped(true);
-        Assert.assertEquals(r.getAlignmentEnd(), SAMRecord.NO_ALIGNMENT_START);
+        Assert.assertEquals(r.getAlignmentEnd(APDelta), SAMRecord.NO_ALIGNMENT_START);
 
         r = new CramCompressionRecord();
         int readLength = 100;
         r.alignmentStart = 1;
         r.readLength = readLength;
         r.setSegmentUnmapped(false);
-        Assert.assertEquals(r.getAlignmentEnd(), r.readLength + r.alignmentStart - 1);
+        Assert.assertEquals(r.getAlignmentEnd(APDelta), r.readLength + r.alignmentStart - 1);
 
         r = new CramCompressionRecord();
         r.alignmentStart = 1;
@@ -33,7 +39,7 @@ public void test_getAlignmentEnd() {
         r.readFeatures = new ArrayList<>();
         String softClip = "AAA";
         r.readFeatures.add(new SoftClip(1, softClip.getBytes()));
-        Assert.assertEquals(r.getAlignmentEnd(), r.readLength + r.alignmentStart - 1 - softClip.length());
+        Assert.assertEquals(r.getAlignmentEnd(APDelta), r.readLength + r.alignmentStart - 1 - softClip.length());
 
         r = new CramCompressionRecord();
         r.alignmentStart = 1;
@@ -42,7 +48,7 @@ public void test_getAlignmentEnd() {
         r.readFeatures = new ArrayList<>();
         int deletionLength = 5;
         r.readFeatures.add(new Deletion(1, deletionLength));
-        Assert.assertEquals(r.getAlignmentEnd(), r.readLength + r.alignmentStart - 1 + deletionLength);
+        Assert.assertEquals(r.getAlignmentEnd(APDelta), r.readLength + r.alignmentStart - 1 + deletionLength);
 
         r = new CramCompressionRecord();
         r.alignmentStart = 1;
@@ -51,38 +57,50 @@ public void test_getAlignmentEnd() {
         r.readFeatures = new ArrayList<>();
         String insertion = "CCCCCCCCCC";
         r.readFeatures.add(new Insertion(1, insertion.getBytes()));
-        Assert.assertEquals(r.getAlignmentEnd(), r.readLength + r.alignmentStart - 1 - insertion.length());
-
+        Assert.assertEquals(r.getAlignmentEnd(APDelta), r.readLength + r.alignmentStart - 1 - insertion.length());
 
         r = new CramCompressionRecord();
         r.alignmentStart = 1;
         r.readLength = readLength;
         r.setSegmentUnmapped(false);
         r.readFeatures = new ArrayList<>();
         r.readFeatures.add(new InsertBase(1, (byte) 'A'));
-        Assert.assertEquals(r.getAlignmentEnd(), r.readLength + r.alignmentStart - 1 - 1);
+        Assert.assertEquals(r.getAlignmentEnd(APDelta), r.readLength + r.alignmentStart - 1 - 1);
+    }
+
+    @DataProvider(name = "placedTests")
+    private Object[][] placedTests() {
+        return new Object[][] {
+                // APDelta = false.  Must have a valid Start as well as a Reference
+                {false, false, false, false},
+                // APDelta = true.  Must have a valid Reference.  Invalid Start is OK because we use the Delta instead
+                {true, false, false, true}
+        };
     }
 
-    @Test
-    public void test_isPlaced() {
+    @Test(dataProvider = "placedTests")
+    public void test_isPlaced(final boolean APDelta,
+                              final boolean noRefExpectation,
+                              final boolean bothExpectation,
+                              final boolean noStartExpectation) {
         final CramCompressionRecord r = new CramCompressionRecord();
 
         // it's only Placed if both of these are valid
 
         r.sequenceId = 5;
         r.alignmentStart = 10;
-        Assert.assertTrue(r.isPlaced());
+        Assert.assertTrue(r.isPlaced(APDelta));
 
         r.sequenceId = SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX;
-        Assert.assertFalse(r.isPlaced());
+        Assert.assertEquals(r.isPlaced(APDelta), noRefExpectation);
 
         r.alignmentStart = SAMRecord.NO_ALIGNMENT_START;
-        Assert.assertFalse(r.isPlaced());
+        Assert.assertEquals(r.isPlaced(APDelta), bothExpectation);
 
         r.sequenceId = 3;
-        Assert.assertFalse(r.isPlaced());
+        Assert.assertEquals(r.isPlaced(APDelta), noStartExpectation);
 
         r.alignmentStart = 15;
-        Assert.assertTrue(r.isPlaced());
+        Assert.assertTrue(r.isPlaced(APDelta));
     }
 }