better Block subclass hierarchy

samtools · Dec 3, 2018 · b3ff8ed · b3ff8ed
1 parent 679b5a4
commit b3ff8ed
Show file tree

Hide file tree

Showing 15 changed files with 338 additions and 265 deletions.
diff --git a/src/main/java/htsjdk/samtools/cram/build/ContainerFactory.java b/src/main/java/htsjdk/samtools/cram/build/ContainerFactory.java
@@ -24,6 +24,7 @@
 import htsjdk.samtools.cram.encoding.writer.CramRecordWriter;
 import htsjdk.samtools.cram.io.DefaultBitOutputStream;
 import htsjdk.samtools.cram.io.ExposedByteArrayOutputStream;
+import htsjdk.samtools.cram.structure.block.ExternalDataBlock;
 import htsjdk.samtools.cram.structure.block.Block;
 import htsjdk.samtools.cram.structure.CompressionHeader;
 import htsjdk.samtools.cram.structure.Container;
@@ -169,13 +170,13 @@ private static Slice buildSlice(final List<CramCompressionRecord> records,
         writer.writeCramCompressionRecords(records, slice.alignmentStart);
 
         bitOutputStream.close();
-        slice.coreBlock = Block.buildNewCoreBlock(bitBAOS.toByteArray());
+        slice.coreBlock = Block.uncompressedCoreBlock(bitBAOS.toByteArray());
 
         slice.external = new HashMap<>();
         for (final Integer key : map.keySet()) {
             final ExternalCompressor compressor = header.externalCompressors.get(key);
             final byte[] rawData = map.get(key).toByteArray();
-            final Block externalBlock = Block.buildNewExternalBlock(key, compressor, rawData);
+            final ExternalDataBlock externalBlock = new ExternalDataBlock(key, compressor, rawData);
             slice.external.put(key, externalBlock);
         }
 

diff --git a/src/main/java/htsjdk/samtools/cram/build/CramIO.java b/src/main/java/htsjdk/samtools/cram/build/CramIO.java
@@ -29,6 +29,7 @@
 import htsjdk.samtools.cram.structure.ContainerIO;
 import htsjdk.samtools.cram.structure.CramHeader;
 import htsjdk.samtools.cram.structure.Slice;
+import htsjdk.samtools.cram.structure.block.FileHeaderBlock;
 import htsjdk.samtools.seekablestream.SeekableFileStream;
 import htsjdk.samtools.seekablestream.SeekableStream;
 import htsjdk.samtools.util.BufferedLineReader;
@@ -248,7 +249,7 @@ private static long writeContainerForSamFileHeader(final int major, final SAMFil
         final int length = Math.max(1024, data.length + data.length / 2);
         final byte[] blockContent = new byte[length];
         System.arraycopy(data, 0, blockContent, 0, Math.min(data.length, length));
-        final Block block = Block.buildNewFileHeaderBlock(blockContent);
+        final FileHeaderBlock block = Block.uncompressedFileHeaderBlock(blockContent);
 
         final Container container = new Container();
         container.blockCount = 1;
@@ -327,7 +328,7 @@ public static boolean replaceCramHeader(final File file, final CramHeader newHea
         final long pos = countingInputStream.getCount();
         countingInputStream.close();
 
-        final Block block = Block.buildNewFileHeaderBlock(toByteArray(newHeader.getSamFileHeader()));
+        final FileHeaderBlock block = Block.uncompressedFileHeaderBlock(toByteArray(newHeader.getSamFileHeader()));
         final ExposedByteArrayOutputStream byteArrayOutputStream = new ExposedByteArrayOutputStream();
         block.write(newHeader.getVersion().major, byteArrayOutputStream);
         if (byteArrayOutputStream.size() > c.containerByteSize) {

diff --git a/src/main/java/htsjdk/samtools/cram/compression/ExternalCompressor.java b/src/main/java/htsjdk/samtools/cram/compression/ExternalCompressor.java
@@ -1,7 +1,7 @@
 package htsjdk.samtools.cram.compression;
 
-import htsjdk.samtools.cram.compression.rans.RANS.ORDER;
 import htsjdk.samtools.cram.structure.block.BlockCompressionMethod;
+import htsjdk.samtools.cram.compression.rans.RANS.ORDER;
 
 import java.io.IOException;
 

diff --git a/src/main/java/htsjdk/samtools/cram/structure/ContainerIO.java b/src/main/java/htsjdk/samtools/cram/structure/ContainerIO.java
@@ -6,6 +6,7 @@
 import htsjdk.samtools.cram.io.ExposedByteArrayOutputStream;
 import htsjdk.samtools.cram.structure.block.Block;
 import htsjdk.samtools.cram.structure.block.BlockContentType;
+import htsjdk.samtools.cram.structure.block.CompressionHeaderBlock;
 import htsjdk.samtools.util.Log;
 import org.apache.commons.compress.utils.CountingOutputStream;
 
@@ -80,11 +81,7 @@ private static Container readContainer(final int major, final InputStream inputS
             return container;
         }
 
-        final Block block = Block.read(major, inputStream);
-        if (block.getContentType() != BlockContentType.COMPRESSION_HEADER)
-            throw new RuntimeException("Content type does not match: " + block.getContentType().name());
-        container.header = new CompressionHeader();
-        container.header.read(block.getUncompressedContent());
+        container.header = CompressionHeaderBlock.readAsCompressionHeader(major, inputStream);
 
         howManySlices = Math.min(container.landmarks.length, howManySlices);
 
@@ -167,7 +164,7 @@ public static int writeContainer(final Version version, final Container containe
 
         final ExposedByteArrayOutputStream byteArrayOutputStream = new ExposedByteArrayOutputStream();
 
-        final Block block = Block.buildNewCompressionHeaderBlock(container.header.toByteArray());
+        final CompressionHeaderBlock block = Block.uncompressedCompressionHeaderBlock(container.header.toByteArray());
         block.write(version.major, byteArrayOutputStream);
         container.blockCount = 1;
 

diff --git a/src/main/java/htsjdk/samtools/cram/structure/Slice.java b/src/main/java/htsjdk/samtools/cram/structure/Slice.java
@@ -22,7 +22,9 @@
 import htsjdk.samtools.cram.encoding.reader.MultiRefSliceAlignmentSpanReader;
 import htsjdk.samtools.cram.io.BitInputStream;
 import htsjdk.samtools.cram.io.DefaultBitInputStream;
-import htsjdk.samtools.cram.structure.block.Block;
+import htsjdk.samtools.cram.structure.block.CoreDataBlock;
+import htsjdk.samtools.cram.structure.block.ExternalDataBlock;
+import htsjdk.samtools.cram.structure.block.SliceHeaderBlock;
 import htsjdk.samtools.util.Log;
 import htsjdk.samtools.util.SequenceUtil;
 
@@ -54,10 +56,10 @@ public class Slice {
     public byte[] refMD5 = new byte[16];
 
     // content associated with ids:
-    public Block headerBlock;
-    public Block coreBlock;
-    public Block embeddedRefBlock;
-    public Map<Integer, Block> external;
+    public SliceHeaderBlock headerBlock;
+    public CoreDataBlock coreBlock;
+    public ExternalDataBlock embeddedRefBlock;
+    public Map<Integer, ExternalDataBlock> external;
 
     // for indexing purposes:
     public int offset = -1;

diff --git a/src/main/java/htsjdk/samtools/cram/structure/SliceIO.java b/src/main/java/htsjdk/samtools/cram/structure/SliceIO.java
@@ -18,12 +18,13 @@
 package htsjdk.samtools.cram.structure;
 
 import htsjdk.samtools.*;
+import htsjdk.samtools.cram.CRAMException;
 import htsjdk.samtools.cram.common.CramVersions;
 import htsjdk.samtools.cram.io.CramIntArray;
 import htsjdk.samtools.cram.io.ITF8;
 import htsjdk.samtools.cram.io.InputStreamUtils;
 import htsjdk.samtools.cram.io.LTF8;
-import htsjdk.samtools.cram.structure.block.Block;
+import htsjdk.samtools.cram.structure.block.*;
 import htsjdk.samtools.util.BinaryCodec;
 import htsjdk.samtools.util.Log;
 
@@ -37,27 +38,24 @@
 class SliceIO {
     private static final Log log = Log.getInstance(SliceIO.class);
 
-    private static void readSliceHeadBlock(final int major, final Slice slice, final InputStream inputStream) throws IOException {
-        slice.headerBlock = Block.read(major, inputStream);
-        parseSliceHeaderBlock(major, slice);
-    }
+    private static void readSliceHeader(final int major, final Slice slice, final InputStream readInputStream) throws IOException {
+        slice.headerBlock = SliceHeaderBlock.read(major, readInputStream);
 
-    private static void parseSliceHeaderBlock(final int major, final Slice slice) throws IOException {
-        final InputStream inputStream = new ByteArrayInputStream(slice.headerBlock.getUncompressedContent());
+        final InputStream parseInputStream = new ByteArrayInputStream(slice.headerBlock.getUncompressedContent());
 
-        slice.sequenceId = ITF8.readUnsignedITF8(inputStream);
-        slice.alignmentStart = ITF8.readUnsignedITF8(inputStream);
-        slice.alignmentSpan = ITF8.readUnsignedITF8(inputStream);
-        slice.nofRecords = ITF8.readUnsignedITF8(inputStream);
-        slice.globalRecordCounter = LTF8.readUnsignedLTF8(inputStream);
-        slice.nofBlocks = ITF8.readUnsignedITF8(inputStream);
+        slice.sequenceId = ITF8.readUnsignedITF8(parseInputStream);
+        slice.alignmentStart = ITF8.readUnsignedITF8(parseInputStream);
+        slice.alignmentSpan = ITF8.readUnsignedITF8(parseInputStream);
+        slice.nofRecords = ITF8.readUnsignedITF8(parseInputStream);
+        slice.globalRecordCounter = LTF8.readUnsignedLTF8(parseInputStream);
+        slice.nofBlocks = ITF8.readUnsignedITF8(parseInputStream);
 
-        slice.contentIDs = CramIntArray.array(inputStream);
-        slice.embeddedRefBlockContentID = ITF8.readUnsignedITF8(inputStream);
+        slice.contentIDs = CramIntArray.array(parseInputStream);
+        slice.embeddedRefBlockContentID = ITF8.readUnsignedITF8(parseInputStream);
         slice.refMD5 = new byte[16];
-        InputStreamUtils.readFully(inputStream, slice.refMD5, 0, slice.refMD5.length);
+        InputStreamUtils.readFully(parseInputStream, slice.refMD5, 0, slice.refMD5.length);
 
-        final byte[] bytes = InputStreamUtils.readFully(inputStream);
+        final byte[] bytes = InputStreamUtils.readFully(parseInputStream);
 
         if (major >= CramVersions.CRAM_v3.major) {
             slice.sliceTags = BinaryTagCodec.readTags(bytes, 0, bytes.length, ValidationStringency.DEFAULT_STRINGENCY);
@@ -112,11 +110,14 @@ private static void readSliceBlocks(final int major, final Slice slice, final In
 
             switch (block.getContentType()) {
                 case CORE:
-                    slice.coreBlock = block;
+                    slice.coreBlock = (CoreDataBlock) block;
                     break;
                 case EXTERNAL:
-                    if (slice.embeddedRefBlockContentID == block.getContentId()) slice.embeddedRefBlock = block;
-                    slice.external.put(block.getContentId(), block);
+                    final ExternalDataBlock extBlock = (ExternalDataBlock) block;
+                    if (slice.embeddedRefBlockContentID == extBlock.getContentId()) {
+                        slice.embeddedRefBlock = extBlock;
+                    }
+                    slice.external.put(extBlock.getContentId(), extBlock);
                     break;
 
                 default:
@@ -136,16 +137,16 @@ public static void write(final int major, final Slice slice, final OutputStream
                 slice.contentIDs[i] = id;
         }
 
-        slice.headerBlock = Block.buildNewSliceHeaderBlock(createSliceHeaderBlockContent(major, slice));
+        slice.headerBlock = Block.uncompressedSliceHeaderBlock(createSliceHeaderBlockContent(major, slice));
         slice.headerBlock.write(major, outputStream);
 
         slice.coreBlock.write(major, outputStream);
-        for (final Block block : slice.external.values())
+        for (final ExternalDataBlock block : slice.external.values())
             block.write(major, outputStream);
     }
 
     public static void read(final int major, final Slice slice, final InputStream inputStream) throws IOException {
-        readSliceHeadBlock(major, slice, inputStream);
+        readSliceHeader(major, slice, inputStream);
         readSliceBlocks(major, slice, inputStream);
     }
 }