();
QueryInterval previous = inputIntervals[0];
for (int i = 1; i < inputIntervals.length; ++i) {
final QueryInterval next = inputIntervals[i];
if (previous.abuts(next) || previous.overlaps(next)) {
final int newEnd = ((previous.end == 0 || next.end == 0) ? 0 : Math.max(previous.end, next.end));
previous = new QueryInterval(previous.referenceIndex, previous.start, newEnd);
} else {
unique.add(previous);
previous = next;
}
}
if (previous != null) unique.add(previous);
return unique.toArray(EMPTY_QUERY_INTERVAL_ARRAY);
}
}
htsjdk-2.0.1/src/java/htsjdk/samtools/ReservedTagConstants.java 0000664 0000000 0000000 00000006410 12630347571 0024625 0 ustar 00root root 0000000 0000000 /*
* The MIT License
*
* Copyright (c) 2009 The Broad Institute
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package htsjdk.samtools;
/**
* Constants for tags used in our SAM/BAM files
*/
public class ReservedTagConstants {
public static final String READ_GROUP_ID = SAMTag.RG.name(); // Specified in the SAM spec doc
public static final String PROGRAM_GROUP_ID = SAMTag.PG.name(); // Specified in the SAM spec doc
/** Present and set to 1 if a read is a noise read. */
public static final String XN = "XN";
/** Number of nucleotide differences (Specified in the SAM spec doc) */
public static final String NM = SAMTag.NM.name();
/** The sum of the mismatched qualities. */
public static final String XQ = "XQ";
/**
* The name of an attribute which stores the 1-based index of the start of
* sequence within a read (in original orientation) that should be clipped
* or trimmed before alignment and downstream use.
* The region to be clipped extends from this position to the end of the read.
*/
public static final String XT = "XT";
/** The original sequence before 454 cafie and homopolymer correction */
public static final String XS = "XS";
/** The Four54 edit string of 454 cafie and homopolymer corrections
*
* editString ::= {base operator position [- position]}* ; // Cafie needs 2 positions
* base ::= A | T | G | C | N ; // N only for undercall
* operator ::= o | u | c ; // o = Overcall, u = Undercall, c = Cafie.
* position is 0 based position of the correction (assuming forward strand) . Cafie positions are to-from.
* For example: XF :Z:Gc4-6Nu11Co15 means a cafie correction moved a G from position 6 to 4,
* an N was inserted for an undercall at position 11, and a C was removed as an overcall at position 15
*/
public static final String XF = "XF";
/** The original pred quality scores before modifications such as 454 cafie and homopolymer correction */
public static final String OQ = SAMTag.OQ.name();
/** The original cigar before indel cleaning, or 454 cafie and homopolymer correction */
public static final String OC = "OC";
}
htsjdk-2.0.1/src/java/htsjdk/samtools/SAMBinaryTagAndUnsignedArrayValue.java 0000664 0000000 0000000 00000004422 12630347571 0027053 0 ustar 00root root 0000000 0000000 /*
* The MIT License
*
* Copyright (c) 2009 The Broad Institute
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package htsjdk.samtools;
/**
* Simple extension to SAMBinaryTagAndValue in order to distinguish unsigned array values, because
* signedness cannot be determined by introspection of value.
*
* @author alecw@broadinstitute.org
*/
public class SAMBinaryTagAndUnsignedArrayValue extends SAMBinaryTagAndValue {
public SAMBinaryTagAndUnsignedArrayValue(final short tag, final Object value) {
super(tag, value);
}
/** Creates and returns a shallow copy of the list of tag/values. */
@Override
public SAMBinaryTagAndValue copy() {
final SAMBinaryTagAndValue retval = new SAMBinaryTagAndUnsignedArrayValue(this.tag, this.value);
if (next != null) retval.next = next.copy();
return retval;
}
/** Creates and returns a deep copy of the list of tag/values. */
@Override
public SAMBinaryTagAndValue deepCopy() {
final SAMBinaryTagAndValue retval = new SAMBinaryTagAndUnsignedArrayValue(this.tag, cloneValue());
if (next != null) {
retval.next = next.deepCopy();
}
return retval;
}
@Override
public boolean isUnsignedArray() {
return true;
}
}
htsjdk-2.0.1/src/java/htsjdk/samtools/SAMBinaryTagAndValue.java 0000664 0000000 0000000 00000014414 12630347571 0024361 0 ustar 00root root 0000000 0000000 /*
* The MIT License
*
* Copyright (c) 2009 The Broad Institute
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package htsjdk.samtools;
import java.io.Serializable;
/**
* Holds a SAMRecord attribute and the tagname (in binary form) for that attribute.
* SAMRecord stores tag name and value in this form, because much String creation is avoided this way.
* See SAMTagUtil to convert the tag to String form.
*
* Values associated with attribute tags must be of a type that implements {@link Serializable} or else
* serialization will fail.
*
* @author alecw@broadinstitute.org
*/
public class SAMBinaryTagAndValue implements Serializable {
public static final long serialVersionUID = 1L;
public final short tag;
public final Object value;
protected SAMBinaryTagAndValue next = null;
/**
* @param tag tagname (in binary form) for this attribute
* @param value value for this attribute (must be of a type that implements {@link Serializable} or else serialization will fail)
* Cannot be null.
*/
public SAMBinaryTagAndValue(final short tag, final Object value) {
if (null == value) {
throw new IllegalArgumentException("SAMBinaryTagAndValue value may not be null");
}
this.tag = tag;
this.value = value;
}
@Override public boolean equals(final Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
return typeSafeEquals((SAMBinaryTagAndValue) o);
}
/** Type safe equals method that recurses down the list looking for equality. */
private boolean typeSafeEquals(final SAMBinaryTagAndValue that) {
if (this.tag != that.tag) return false;
if ((this.value == null) ? that.value == null : this.value.equals(that.value)) {
if (this.next == null) return that.next == null;
else return this.next.equals(that.next);
}
else {
return false;
}
}
@Override
public int hashCode() {
int result = (int) tag;
result = 31 * result + value.hashCode();
return result;
}
/** Creates and returns a shallow copy of the list of tag/values. */
public SAMBinaryTagAndValue copy() {
final SAMBinaryTagAndValue retval = new SAMBinaryTagAndValue(this.tag, this.value);
if (next != null) {
retval.next = next.copy();
}
return retval;
}
/** Creates and returns a deep copy of the list of tag/values. */
public SAMBinaryTagAndValue deepCopy() {
final SAMBinaryTagAndValue retval = new SAMBinaryTagAndValue(this.tag, cloneValue());
if (next != null) {
retval.next = next.deepCopy();
}
return retval;
}
/* Create and return a clone of value object */
protected Object cloneValue() {
Object valueClone;
if (value instanceof byte[]) {
valueClone = ((byte[]) value).clone();
}
else if (value instanceof short[]) {
valueClone = ((short[]) value).clone();
}
else if (value instanceof int[]) {
valueClone = ((int[]) value).clone();
}
else if (value instanceof float[]) {
valueClone = ((float[]) value).clone();
}
else {
// otherwise, the api limits the remaining possible value types to
// immutable (String or boxed primitive) types
valueClone = value;
}
return valueClone;
}
// The methods below are for implementing a light-weight, single-direction linked list
public SAMBinaryTagAndValue getNext() { return this.next; }
/** Inserts at item into the ordered list of attributes and returns the head of the list/sub-list */
public SAMBinaryTagAndValue insert(final SAMBinaryTagAndValue attr) {
if (attr == null) return this;
if (attr.next != null) throw new IllegalStateException("Can only insert single tag/value combinations.");
if (attr.tag < this.tag) {
// attr joins the list ahead of this element
attr.next = this;
return attr;
}
else if (this.tag == attr.tag) {
// attr replaces this in the list
attr.next = this.next;
return attr;
}
else if (this.next == null) {
// attr gets stuck on the end
this.next = attr;
return this;
}
else {
// attr gets inserted somewhere in the tail
this.next = this.next.insert(attr);
return this;
}
}
/** Removes a tag from the list and returns the new head of the list/sub-list. */
public SAMBinaryTagAndValue remove(final short tag) {
if (this.tag == tag) return this.next;
else {
if (this.next != null) this.next = this.next.remove(tag);
return this;
}
}
/** Returns the SAMBinaryTagAndValue that contains the required tag, or null if not contained. */
public SAMBinaryTagAndValue find(final short tag) {
if (this.tag == tag) return this;
else if (this.tag > tag || this.next == null) return null;
else return this.next.find(tag);
}
public boolean isUnsignedArray() {
return false;
}
}
htsjdk-2.0.1/src/java/htsjdk/samtools/SAMException.java 0000664 0000000 0000000 00000003033 12630347571 0023012 0 ustar 00root root 0000000 0000000 /*
* The MIT License
*
* Copyright (c) 2009 The Broad Institute
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package htsjdk.samtools;
/**
* @author alecw@broadinstitute.org
*/
public class SAMException extends RuntimeException {
public SAMException() {
}
public SAMException(final String s) {
super(s);
}
public SAMException(final String s, final Throwable throwable) {
super(s, throwable);
}
public SAMException(final Throwable throwable) {
super(throwable);
}
}
htsjdk-2.0.1/src/java/htsjdk/samtools/SAMFileHeader.java 0000664 0000000 0000000 00000034364 12630347571 0023057 0 ustar 00root root 0000000 0000000 /*
* The MIT License
*
* Copyright (c) 2009 The Broad Institute
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package htsjdk.samtools;
import htsjdk.samtools.util.StringLineReader;
import java.io.StringWriter;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Header information from a SAM or BAM file.
*/
public class SAMFileHeader extends AbstractSAMHeaderRecord
{
public static final String VERSION_TAG = "VN";
public static final String SORT_ORDER_TAG = "SO";
public static final String GROUP_ORDER_TAG = "GO";
public static final String CURRENT_VERSION = "1.5";
public static final Set ACCEPTABLE_VERSIONS =
new HashSet(Arrays.asList("1.0", "1.3", "1.4", "1.5"));
/**
* These tags are of known type, so don't need a type field in the text representation.
*/
public static final Set STANDARD_TAGS =
new HashSet(Arrays.asList(VERSION_TAG, SORT_ORDER_TAG, GROUP_ORDER_TAG));
Set getStandardTags() {
return STANDARD_TAGS;
}
/**
* Ways in which a SAM or BAM may be sorted.
*/
public enum SortOrder {
unsorted(null),
queryname(SAMRecordQueryNameComparator.class),
coordinate(SAMRecordCoordinateComparator.class),
duplicate(SAMRecordDuplicateComparator.class); // NB: this is not in the SAM spec!
private final Class comparator;
SortOrder(final Class comparatorClass) {
this.comparator = comparatorClass;
}
/**
* @return Comparator class to sort in the specified order, or null if unsorted.
*/
public Class getComparator() {
return comparator;
}
/**
* @return Comparator to sort in the specified order, or null if unsorted.
*/
public SAMRecordComparator getComparatorInstance() {
if (comparator != null) {
try {
final Constructor ctor = comparator.getConstructor();
return ctor.newInstance();
}
catch (Exception e) {
throw new IllegalStateException("Could not instantiate a comparator for sort order: " +
this.name(), e);
}
}
return null;
}
}
public enum GroupOrder {
none, query, reference
}
private List mReadGroups =
new ArrayList();
private List mProgramRecords = new ArrayList();
private final Map mReadGroupMap =
new HashMap();
private final Map mProgramRecordMap = new HashMap();
private SAMSequenceDictionary mSequenceDictionary = new SAMSequenceDictionary();
final private List mComments = new ArrayList();
private String textHeader;
private final List mValidationErrors = new ArrayList();
public SAMFileHeader() {
setAttribute(VERSION_TAG, CURRENT_VERSION);
}
public String getVersion() {
return (String) getAttribute("VN");
}
public String getCreator() {
return (String) getAttribute("CR");
}
public SAMSequenceDictionary getSequenceDictionary() {
return mSequenceDictionary;
}
public List getReadGroups() {
return Collections.unmodifiableList(mReadGroups);
}
/**
* Look up sequence record by name.
*/
public SAMSequenceRecord getSequence(final String name) {
return mSequenceDictionary.getSequence(name);
}
/**
* Look up read group record by name.
*/
public SAMReadGroupRecord getReadGroup(final String name) {
return mReadGroupMap.get(name);
}
/**
* Replace entire sequence dictionary. The given sequence dictionary is stored, not copied.
*/
public void setSequenceDictionary(final SAMSequenceDictionary sequenceDictionary) {
mSequenceDictionary = sequenceDictionary;
}
public void addSequence(final SAMSequenceRecord sequenceRecord) {
mSequenceDictionary.addSequence(sequenceRecord);
}
/**
* Look up a sequence record by index. First sequence in the header is the 0th.
* @return The corresponding sequence record, or null if the index is out of range.
*/
public SAMSequenceRecord getSequence(final int sequenceIndex) {
return mSequenceDictionary.getSequence(sequenceIndex);
}
/**
*
* @return Sequence index for the given sequence name, or -1 if the name is not found.
*/
public int getSequenceIndex(final String sequenceName) {
return mSequenceDictionary.getSequenceIndex(sequenceName);
}
/**
* Replace entire list of read groups. The given list is stored, not copied.
*/
public void setReadGroups(final List readGroups) {
mReadGroups = readGroups;
mReadGroupMap.clear();
for (final SAMReadGroupRecord readGroupRecord : readGroups) {
mReadGroupMap.put(readGroupRecord.getReadGroupId(), readGroupRecord);
}
}
public void addReadGroup(final SAMReadGroupRecord readGroup) {
if (mReadGroupMap.containsKey(readGroup.getReadGroupId())) {
throw new IllegalArgumentException("Read group with group id " +
readGroup.getReadGroupId() + " already exists in SAMFileHeader!");
}
mReadGroups.add(readGroup);
mReadGroupMap.put(readGroup.getReadGroupId(), readGroup);
}
public List getProgramRecords() {
return Collections.unmodifiableList(mProgramRecords);
}
public void addProgramRecord(final SAMProgramRecord programRecord) {
if (mProgramRecordMap.containsKey(programRecord.getProgramGroupId())) {
throw new IllegalArgumentException("Program record with group id " +
programRecord.getProgramGroupId() + " already exists in SAMFileHeader!");
}
this.mProgramRecords.add(programRecord);
this.mProgramRecordMap.put(programRecord.getProgramGroupId(), programRecord);
}
public SAMProgramRecord getProgramRecord(final String pgId) {
return this.mProgramRecordMap.get(pgId);
}
/**
* Replace entire list of program records
* @param programRecords This list is used directly, not copied.
*/
public void setProgramRecords(final List programRecords) {
this.mProgramRecords = programRecords;
this.mProgramRecordMap.clear();
for (final SAMProgramRecord programRecord : this.mProgramRecords) {
this.mProgramRecordMap.put(programRecord.getProgramGroupId(), programRecord);
}
}
/**
* @return a new SAMProgramRecord with an ID guaranteed to not exist in this SAMFileHeader
*/
public SAMProgramRecord createProgramRecord() {
for (int i = 0; i < Integer.MAX_VALUE; ++i) {
final String s = Integer.toString(i);
if (!this.mProgramRecordMap.containsKey(s)) {
final SAMProgramRecord ret = new SAMProgramRecord(s);
addProgramRecord(ret);
return ret;
}
}
throw new IllegalStateException("Surprising number of SAMProgramRecords");
}
public SortOrder getSortOrder() {
final String so = getAttribute("SO");
if (so == null || so.equals("unknown")) {
return SortOrder.unsorted;
}
return SortOrder.valueOf((String) so);
}
public void setSortOrder(final SortOrder so) {
setAttribute("SO", so.name());
}
public GroupOrder getGroupOrder() {
if (getAttribute("GO") == null) {
return GroupOrder.none;
}
return GroupOrder.valueOf((String)getAttribute("GO"));
}
public void setGroupOrder(final GroupOrder go) {
setAttribute("GO", go.name());
}
/**
* If this SAMHeader was read from a file, this property contains the header
* as it appeared in the file, otherwise it is null. Note that this is not a toString()
* operation. Changes to the SAMFileHeader object after reading from the file are not reflected in this value.
*
* In addition this value is only set if one of the following is true:
* - The size of the header is < 1,048,576 characters (1MB ascii, 2MB unicode)
* - There are either validation or parsing errors associated with the header
*
* Invalid header lines may appear in value but are not stored in the SAMFileHeader object.
*/
public String getTextHeader() {
return textHeader;
}
public void setTextHeader(final String textHeader) {
this.textHeader = textHeader;
}
public List getComments() {
return Collections.unmodifiableList(mComments);
}
public void addComment(String comment) {
if (!comment.startsWith(SAMTextHeaderCodec.COMMENT_PREFIX)) {
comment = SAMTextHeaderCodec.COMMENT_PREFIX + comment;
}
mComments.add(comment);
}
/**
* Replace existing comments with the contents of the given collection.
*/
public void setComments(final Collection comments) {
mComments.clear();
for (final String comment : comments) {
addComment(comment);
}
}
public List getValidationErrors() {
return Collections.unmodifiableList(mValidationErrors);
}
public void addValidationError(final SAMValidationError error) {
mValidationErrors.add(error);
}
/**
* Replace list of validation errors with the elements of the given list.
*/
public void setValidationErrors(final Collection errors) {
mValidationErrors.clear();
mValidationErrors.addAll(errors);
}
@Override
public boolean equals(final Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
final SAMFileHeader that = (SAMFileHeader) o;
if (!attributesEqual(that)) return false;
if (mProgramRecords != null ? !mProgramRecords.equals(that.mProgramRecords) : that.mProgramRecords != null)
return false;
if (mReadGroups != null ? !mReadGroups.equals(that.mReadGroups) : that.mReadGroups != null) return false;
if (mSequenceDictionary != null ? !mSequenceDictionary.equals(that.mSequenceDictionary) : that.mSequenceDictionary != null)
return false;
return true;
}
@Override
public int hashCode() {
int result = attributesHashCode();
result = 31 * result + (mSequenceDictionary != null ? mSequenceDictionary.hashCode() : 0);
result = 31 * result + (mReadGroups != null ? mReadGroups.hashCode() : 0);
result = 31 * result + (mProgramRecords != null ? mProgramRecords.hashCode() : 0);
return result;
}
public final SAMFileHeader clone() {
final SAMTextHeaderCodec codec = new SAMTextHeaderCodec();
codec.setValidationStringency(ValidationStringency.SILENT);
final StringWriter stringWriter = new StringWriter();
codec.encode(stringWriter, this);
return codec.decode(new StringLineReader(stringWriter.toString()), "SAMFileHeader.clone");
}
/** Little class to generate program group IDs */
public static class PgIdGenerator {
private int recordCounter;
private final Set idsThatAreAlreadyTaken = new HashSet();
public PgIdGenerator(final SAMFileHeader header) {
for (final SAMProgramRecord pgRecord : header.getProgramRecords()) {
idsThatAreAlreadyTaken.add(pgRecord.getProgramGroupId());
}
recordCounter = idsThatAreAlreadyTaken.size();
}
public String getNonCollidingId(final String recordId) {
if (!idsThatAreAlreadyTaken.contains(recordId)) {
// don't remap 1st record. If there are more records
// with this id, they will be remapped in the 'else'.
idsThatAreAlreadyTaken.add(recordId);
++recordCounter;
return recordId;
} else {
String newId;
// Below we tack on one of roughly 1.7 million possible 4 digit base36 at random. We do this because
// our old process of just counting from 0 upward and adding that to the previous id led to 1000s of
// calls idsThatAreAlreadyTaken.contains() just to resolve 1 collision when merging 1000s of similarly
// processed bams.
while (idsThatAreAlreadyTaken.contains(newId = recordId + "." + SamFileHeaderMerger.positiveFourDigitBase36Str(recordCounter++)))
;
idsThatAreAlreadyTaken.add(newId);
return newId;
}
}
}
}
htsjdk-2.0.1/src/java/htsjdk/samtools/SAMFileReader.java 0000664 0000000 0000000 00000105054 12630347571 0023064 0 ustar 00root root 0000000 0000000 /*
* The MIT License
*
* Copyright (c) 2009 The Broad Institute
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package htsjdk.samtools;
import htsjdk.samtools.seekablestream.SeekableBufferedStream;
import htsjdk.samtools.seekablestream.SeekableHTTPStream;
import htsjdk.samtools.seekablestream.SeekableStream;
import htsjdk.samtools.util.BlockCompressedInputStream;
import htsjdk.samtools.util.BlockCompressedStreamConstants;
import htsjdk.samtools.util.CloseableIterator;
import htsjdk.samtools.util.CloserUtil;
import htsjdk.samtools.util.IOUtil;
import htsjdk.samtools.util.RuntimeIOException;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.zip.GZIPInputStream;
/**
* Class for reading and querying SAM/BAM files. Delegates to appropriate concrete implementation.
*
* @see SamReaderFactory
*/
@Deprecated
public class SAMFileReader implements SamReader, SamReader.Indexing {
private static ValidationStringency defaultValidationStringency = ValidationStringency.DEFAULT_STRINGENCY;
public static ValidationStringency getDefaultValidationStringency() {
return defaultValidationStringency;
}
/**
* Set validation stringency for all subsequently-created SAMFileReaders. This is the only way to
* change the validation stringency for SAM header.
* NOTE: Programs that change this should make sure to have a try/finally clause wrapping the work that
* they do, so that the original stringency can be restored after the program's work is done. This facilitates
* calling a program that is usually run stand-alone from another program, without messing up the original
* validation stringency.
*/
public static void setDefaultValidationStringency(final ValidationStringency defaultValidationStringency) {
SAMFileReader.defaultValidationStringency = defaultValidationStringency;
}
/**
* Returns the SAMSequenceDictionary from the provided FASTA.
*/
public static SAMSequenceDictionary getSequenceDictionary(final File dictionaryFile) {
final SAMFileReader samFileReader = new SAMFileReader(dictionaryFile);
final SAMSequenceDictionary dict = samFileReader.getFileHeader().getSequenceDictionary();
CloserUtil.close(dictionaryFile);
return dict;
}
private boolean mIsBinary = false;
private BAMIndex mIndex = null;
private SAMRecordFactory samRecordFactory = new DefaultSAMRecordFactory();
private ReaderImplementation mReader = null;
private File samFile = null;
private static class EmptySamIterator implements CloseableIterator {
@Override
public boolean hasNext() {
return false;
}
@Override
public SAMRecord next() {
throw new NoSuchElementException("next called on empty iterator");
}
@Override
public void remove() {
throw new UnsupportedOperationException("Not supported: remove");
}
@Override
public void close() {
//no-op
}
}
/**
* Prepare to read a SAM or BAM file. Indexed lookup not allowed because reading from InputStream.
*/
public SAMFileReader(final InputStream stream) {
this(stream, false);
}
/**
* Prepare to read a SAM or BAM file. If the given file is a BAM, and has a companion BAI index file
* that is named according to the convention, it will be found and opened, and indexed query will be allowed.
*/
public SAMFileReader(final File file) {
this(file, null, false);
}
/**
* Prepare to read a SAM or BAM file. If the given file is a BAM, and an index is present, indexed query
* will be allowed.
*
* @param file SAM or BAM to read.
* @param indexFile Index file that is companion to BAM, or null if no index file, or if index file
* should be found automatically.
*/
public SAMFileReader(final File file, final File indexFile) {
this(file, indexFile, false);
}
/**
* Read a SAM or BAM file. Indexed lookup not allowed because reading from InputStream.
*
* @param stream input SAM or BAM. This is buffered internally so caller need not buffer.
* @param eagerDecode if true, decode SAM record entirely when reading it.
*/
public SAMFileReader(final InputStream stream, final boolean eagerDecode) {
init(stream, null, null, eagerDecode, defaultValidationStringency);
}
/**
* Read a SAM or BAM file, possibly with an index file if present.
* If the given file is a BAM, and an index is present, indexed query will be allowed.
*
* @param file SAM or BAM.
* @param eagerDecode if true, decode SAM record entirely when reading it.
*/
public SAMFileReader(final File file, final boolean eagerDecode) {
this(file, null, eagerDecode);
}
/**
* Read a SAM or BAM file, possibly with an index file. If the given file is a BAM, and an index is present,
* indexed query will be allowed.
*
* @param file SAM or BAM.
* @param indexFile Location of index file, or null in order to use the default index file (if present).
* @param eagerDecode eagerDecode if true, decode SAM record entirely when reading it.
*/
public SAMFileReader(final File file, final File indexFile, final boolean eagerDecode) {
init(null, file, indexFile, eagerDecode, defaultValidationStringency);
}
/**
* Read a BAM file by http
* indexed query will be allowed.
*
* @param url BAM.
* @param indexFile Location of index file, or null if indexed access not required.
* @param eagerDecode eagerDecode if true, decode SAM record entirely when reading it.
*/
public SAMFileReader(final URL url, final File indexFile, final boolean eagerDecode) {
init(new SeekableBufferedStream(new SeekableHTTPStream(url)),
indexFile, eagerDecode, defaultValidationStringency);
}
/**
* Read a BAM file via caller-supplied mechanism. Indexed query will be allowed, but
* index file must be provided in that case.
*
* @param strm BAM -- If the stream is not buffered, caller should wrap in SeekableBufferedStream for
* better performance.
* @param indexFile Location of index file, or null indexed access not required.
* @param eagerDecode if true, decode SAM record entirely when reading it.
*/
public SAMFileReader(final SeekableStream strm, final File indexFile, final boolean eagerDecode) {
init(strm, indexFile, eagerDecode, defaultValidationStringency);
}
/**
* @param strm BAM -- If the stream is not buffered, caller should wrap in SeekableBufferedStream for
* better performance.
*/
public SAMFileReader(final SeekableStream strm, final SeekableStream indexStream, final boolean eagerDecode) {
init(strm, indexStream, eagerDecode, defaultValidationStringency);
}
public void close() {
if (mReader != null) {
mReader.close();
}
mReader = null;
mIndex = null;
}
/**
* If true, writes the source of every read into the source SAMRecords.
*
* @param enabled true to write source information into each SAMRecord.
*/
public void enableFileSource(final boolean enabled) {
mReader.enableFileSource(this, enabled);
}
/**
* If true, uses the caching version of the index reader.
*
* @param enabled true to write source information into each SAMRecord.
*/
public void enableIndexCaching(final boolean enabled) {
if (mIndex != null)
throw new SAMException("Unable to turn on index caching; index file has already been loaded.");
mReader.enableIndexCaching(enabled);
}
/**
* If false, disable the use of memory mapping for accessing index files (default behavior is to use memory mapping).
* This is slower but more scalable when accessing large numbers of BAM files sequentially.
*
* @param enabled True to use memory mapping, false to use regular I/O.
*/
public void enableIndexMemoryMapping(final boolean enabled) {
if (mIndex != null) {
throw new SAMException("Unable to change index memory mapping; index file has already been loaded.");
}
mReader.enableIndexMemoryMapping(enabled);
}
/**
* Only meaningful for BAM file readers - enables or disables checking of checksums on uncompressed
* data during decompression. Enabling this will increase decompression time by 15-30%.
*/
public void enableCrcChecking(final boolean enabled) {
this.mReader.enableCrcChecking(enabled);
}
/**
* Override the default SAMRecordFactory class used to instantiate instances of SAMRecord and BAMRecord.
*/
public void setSAMRecordFactory(final SAMRecordFactory factory) {
this.samRecordFactory = factory;
this.mReader.setSAMRecordFactory(factory);
}
/**
* @return True if this is a BAM reader.
*/
public boolean isBinary() {
return mIsBinary;
}
/**
* @return true if ths is a BAM file, and has an index
*/
public boolean hasIndex() {
return mReader.hasIndex();
}
@Override
public Indexing indexing() {
return this;
}
/**
* Retrieves the index for the given file type. Ensure that the index is of the specified type.
*
* @return An index of the given type.
*/
public BAMIndex getIndex() {
return mReader.getIndex();
}
/**
* Returns true if the supported index is browseable, meaning the bins in it can be traversed
* and chunk data inspected and retrieved.
*
* @return True if the index supports the BrowseableBAMIndex interface. False otherwise.
*/
public boolean hasBrowseableIndex() {
return hasIndex() && getIndex() instanceof BrowseableBAMIndex;
}
/**
* Gets an index tagged with the BrowseableBAMIndex interface. Throws an exception if no such
* index is available.
*
* @return An index with a browseable interface, if possible.
* @throws SAMException if no such index is available.
*/
public BrowseableBAMIndex getBrowseableIndex() {
final BAMIndex index = getIndex();
if (!(index instanceof BrowseableBAMIndex))
throw new SAMException("Cannot return index: index created by BAM is not browseable.");
return BrowseableBAMIndex.class.cast(index);
}
public SAMFileHeader getFileHeader() {
return mReader.getFileHeader();
}
@Override
public Type type() {
return mReader.type();
}
@Override
public String getResourceDescription() {
return this.toString();
}
/**
* Control validation of SAMRecords as they are read from file.
* In order to control validation stringency for SAM Header, call SAMFileReader.setDefaultValidationStringency
* before constructing a SAMFileReader.
*/
public void setValidationStringency(final ValidationStringency validationStringency) {
mReader.setValidationStringency(validationStringency);
}
/**
* Iterate through file in order. For a SAMFileReader constructed from an InputStream, and for any SAM file,
* a 2nd iteration starts where the 1st one left off. For a BAM constructed from a File, each new iteration
* starts at the first record.
*
* Only a single open iterator on a SAM or BAM file may be extant at any one time. If you want to start
* a second iteration, the first one must be closed first.
*/
public SAMRecordIterator iterator() {
return new AssertingIterator(mReader.getIterator());
}
/**
* Iterate through the given chunks in the file.
*
* @param chunks List of chunks for which to retrieve data.
* @return An iterator over the given chunks.
*/
public SAMRecordIterator iterator(final SAMFileSpan chunks) {
return new AssertingIterator(mReader.getIterator(chunks));
}
/**
* Gets a pointer spanning all reads in the BAM file.
*
* @return Unbounded pointer to the first record, in chunk format.
*/
public SAMFileSpan getFilePointerSpanningReads() {
return mReader.getFilePointerSpanningReads();
}
/**
* Iterate over records that match the given interval. Only valid to call this if hasIndex() == true.
*
* Only a single open iterator on a given SAMFileReader may be extant at any one time. If you want to start
* a second iteration, the first one must be closed first. You can use a second SAMFileReader to iterate
* in parallel over the same underlying file.
*
* Note that indexed lookup is not perfectly efficient in terms of disk I/O. I.e. some SAMRecords may be read
* and then discarded because they do not match the interval of interest.
*
* Note that an unmapped read will be returned by this call if it has a coordinate for the purpose of sorting that
* is in the query region.
*
* @param sequence Reference sequence of interest.
* @param start 1-based, inclusive start of interval of interest. Zero implies start of the reference sequence.
* @param end 1-based, inclusive end of interval of interest. Zero implies end of the reference sequence.
* @param contained If true, each SAMRecord returned is will have its alignment completely contained in the
* interval of interest. If false, the alignment of the returned SAMRecords need only overlap the interval of interest.
* @return Iterator over the SAMRecords matching the interval.
*/
public SAMRecordIterator query(final String sequence, final int start, final int end, final boolean contained) {
final int referenceIndex = getFileHeader().getSequenceIndex(sequence);
final CloseableIterator currentIterator;
if (referenceIndex == -1) {
currentIterator = new EmptySamIterator();
} else {
final QueryInterval[] queryIntervals = {new QueryInterval(referenceIndex, start, end)};
currentIterator = mReader.query(queryIntervals, contained);
}
return new AssertingIterator(currentIterator);
}
/**
* Iterate over records that overlap the given interval. Only valid to call this if hasIndex() == true.
*
* Only a single open iterator on a given SAMFileReader may be extant at any one time. If you want to start
* a second iteration, the first one must be closed first.
*
* Note that indexed lookup is not perfectly efficient in terms of disk I/O. I.e. some SAMRecords may be read
* and then discarded because they do not match the interval of interest.
*
* Note that an unmapped read will be returned by this call if it has a coordinate for the purpose of sorting that
* is in the query region.
*
* @param sequence Reference sequence of interest.
* @param start 1-based, inclusive start of interval of interest. Zero implies start of the reference sequence.
* @param end 1-based, inclusive end of interval of interest. Zero implies end of the reference sequence.
* @return Iterator over the SAMRecords overlapping the interval.
*/
public SAMRecordIterator queryOverlapping(final String sequence, final int start, final int end) {
return query(sequence, start, end, false);
}
/**
* Iterate over records that are contained in the given interval. Only valid to call this if hasIndex() == true.
*
* Only a single open iterator on a given SAMFileReader may be extant at any one time. If you want to start
* a second iteration, the first one must be closed first.
*
* Note that indexed lookup is not perfectly efficient in terms of disk I/O. I.e. some SAMRecords may be read
* and then discarded because they do not match the interval of interest.
*
* Note that an unmapped read will be returned by this call if it has a coordinate for the purpose of sorting that
* is in the query region.
*
* @param sequence Reference sequence of interest.
* @param start 1-based, inclusive start of interval of interest. Zero implies start of the reference sequence.
* @param end 1-based, inclusive end of interval of interest. Zero implies end of the reference sequence.
* @return Iterator over the SAMRecords contained in the interval.
*/
public SAMRecordIterator queryContained(final String sequence, final int start, final int end) {
return query(sequence, start, end, true);
}
/**
* Iterate over records that match one of the given intervals. This may be more efficient than querying
* each interval separately, because multiple reads of the same SAMRecords is avoided.
*
* Only valid to call this if hasIndex() == true.
*
* Only a single open iterator on a given SAMFileReader may be extant at any one time. If you want to start
* a second iteration, the first one must be closed first. You can use a second SAMFileReader to iterate
* in parallel over the same underlying file.
*
* Note that indexed lookup is not perfectly efficient in terms of disk I/O. I.e. some SAMRecords may be read
* and then discarded because they do not match an interval of interest.
*
* Note that an unmapped read will be returned by this call if it has a coordinate for the purpose of sorting that
* is in the query region.
*
* @param intervals Intervals to be queried. The intervals must be optimized, i.e. in order, with overlapping
* and abutting intervals merged. This can be done with {@link htsjdk.samtools.QueryInterval#optimizeIntervals}
* @param contained If true, each SAMRecord returned is will have its alignment completely contained in one of the
* intervals of interest. If false, the alignment of the returned SAMRecords need only overlap one of
* the intervals of interest.
* @return Iterator over the SAMRecords matching the interval.
*/
public SAMRecordIterator query(final QueryInterval[] intervals, final boolean contained) {
return new AssertingIterator(mReader.query(intervals, contained));
}
/**
* Iterate over records that overlap any of the given intervals. This may be more efficient than querying
* each interval separately, because multiple reads of the same SAMRecords is avoided.
*
* Only valid to call this if hasIndex() == true.
*
* Only a single open iterator on a given SAMFileReader may be extant at any one time. If you want to start
* a second iteration, the first one must be closed first.
*
* Note that indexed lookup is not perfectly efficient in terms of disk I/O. I.e. some SAMRecords may be read
* and then discarded because they do not match the interval of interest.
*
* Note that an unmapped read will be returned by this call if it has a coordinate for the purpose of sorting that
* is in the query region.
*
* @param intervals Intervals to be queried. The intervals must be optimized, i.e. in order, with overlapping
* and abutting intervals merged. This can be done with {@link htsjdk.samtools.QueryInterval#optimizeIntervals}
* @return Iterator over the SAMRecords overlapping any of the intervals.
*/
public SAMRecordIterator queryOverlapping(final QueryInterval[] intervals) {
return query(intervals, false);
}
/**
* Iterate over records that are contained in the given interval. This may be more efficient than querying
* each interval separately, because multiple reads of the same SAMRecords is avoided.
*
* Only valid to call this if hasIndex() == true.
*
* Only a single open iterator on a given SAMFileReader may be extant at any one time. If you want to start
* a second iteration, the first one must be closed first.
*
* Note that indexed lookup is not perfectly efficient in terms of disk I/O. I.e. some SAMRecords may be read
* and then discarded because they do not match the interval of interest.
*
* Note that an unmapped read will be returned by this call if it has a coordinate for the purpose of sorting that
* is in the query region.
*
* @param intervals Intervals to be queried. The intervals must be optimized, i.e. in order, with overlapping
* and abutting intervals merged. This can be done with {@link htsjdk.samtools.QueryInterval#optimizeIntervals}
* @return Iterator over the SAMRecords contained in any of the intervals.
*/
public SAMRecordIterator queryContained(final QueryInterval[] intervals) {
return query(intervals, true);
}
public SAMRecordIterator queryUnmapped() {
return new AssertingIterator(mReader.queryUnmapped());
}
/**
* Iterate over records that map to the given sequence and start at the given position. Only valid to call this if hasIndex() == true.
*
* Only a single open iterator on a given SAMFileReader may be extant at any one time. If you want to start
* a second iteration, the first one must be closed first.
*
* Note that indexed lookup is not perfectly efficient in terms of disk I/O. I.e. some SAMRecords may be read
* and then discarded because they do not match the interval of interest.
*
* Note that an unmapped read will be returned by this call if it has a coordinate for the purpose of sorting that
* matches the arguments.
*
* @param sequence Reference sequence of interest.
* @param start Alignment start of interest.
* @return Iterator over the SAMRecords with the given alignment start.
*/
public SAMRecordIterator queryAlignmentStart(final String sequence, final int start) {
return new AssertingIterator(mReader.queryAlignmentStart(sequence, start));
}
/**
* Fetch the mate for the given read. Only valid to call this if hasIndex() == true.
* This will work whether the mate has a coordinate or not, so long as the given read has correct
* mate information. This method iterates over the SAM file, so there may not be an unclosed
* iterator on the SAM file when this method is called.
*
* Note that it is not possible to call queryMate when iterating over the SAMFileReader, because queryMate
* requires its own iteration, and there cannot be two simultaneous iterations on the same SAMFileReader. The
* work-around is to open a second SAMFileReader on the same input file, and call queryMate on the second
* reader.
*
* @param rec Record for which mate is sought. Must be a paired read.
* @return rec's mate, or null if it cannot be found.
*/
public SAMRecord queryMate(final SAMRecord rec) {
if (!rec.getReadPairedFlag()) {
throw new IllegalArgumentException("queryMate called for unpaired read.");
}
if (rec.getFirstOfPairFlag() == rec.getSecondOfPairFlag()) {
throw new IllegalArgumentException("SAMRecord must be either first and second of pair, but not both.");
}
final boolean firstOfPair = rec.getFirstOfPairFlag();
final CloseableIterator it;
if (rec.getMateReferenceIndex() == SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX) {
it = queryUnmapped();
} else {
it = queryAlignmentStart(rec.getMateReferenceName(), rec.getMateAlignmentStart());
}
try {
SAMRecord mateRec = null;
while (it.hasNext()) {
final SAMRecord next = it.next();
if (!next.getReadPairedFlag()) {
if (rec.getReadName().equals(next.getReadName())) {
throw new SAMFormatException("Paired and unpaired reads with same name: " + rec.getReadName());
}
continue;
}
if (firstOfPair) {
if (next.getFirstOfPairFlag()) continue;
} else {
if (next.getSecondOfPairFlag()) continue;
}
if (rec.getReadName().equals(next.getReadName())) {
if (mateRec != null) {
throw new SAMFormatException("Multiple SAMRecord with read name " + rec.getReadName() +
" for " + (firstOfPair ? "second" : "first") + " end.");
}
mateRec = next;
}
}
return mateRec;
} finally {
it.close();
}
}
private void init(final SeekableStream strm, final File indexFile, final boolean eagerDecode,
final ValidationStringency validationStringency) {
try {
if (streamLooksLikeBam(strm)) {
mIsBinary = true;
mReader = new BAMFileReader(strm, indexFile, eagerDecode, validationStringency, this.samRecordFactory);
} else {
throw new SAMFormatException("Unrecognized file format: " + strm);
}
setValidationStringency(validationStringency);
} catch (final IOException e) {
throw new RuntimeIOException(e);
}
}
private void init(final SeekableStream strm, final SeekableStream indexStream, final boolean eagerDecode,
final ValidationStringency validationStringency) {
try {
if (streamLooksLikeBam(strm)) {
mIsBinary = true;
mReader = new BAMFileReader(strm, indexStream, eagerDecode, validationStringency, this.samRecordFactory);
} else {
throw new SAMFormatException("Unrecognized file format: " + strm);
}
setValidationStringency(validationStringency);
} catch (final IOException e) {
throw new RuntimeIOException(e);
}
}
// Its too expensive to examine the remote file to determine type.
// Rely on file extension.
private boolean streamLooksLikeBam(final SeekableStream strm) {
String source = strm.getSource();
if (source == null) return true;
source = source.toLowerCase();
//Source will typically be a file path or URL
//If it's a URL we require one of the query parameters to be bam file
return source.endsWith(".bam") || source.contains(".bam?") || source.contains(".bam&") || source.contains(".bam%26");
}
private void init(final InputStream stream, File file, final File indexFile, final boolean eagerDecode,
final ValidationStringency validationStringency) {
if (stream != null && file != null) throw new IllegalArgumentException("stream and file are mutually exclusive");
this.samFile = file;
try {
BufferedInputStream bufferedStream;
// Buffering is required because mark() and reset() are called on the input stream.
final int bufferSize = Math.max(Defaults.BUFFER_SIZE, BlockCompressedStreamConstants.MAX_COMPRESSED_BLOCK_SIZE);
if (file != null) bufferedStream = new BufferedInputStream(new FileInputStream(file), bufferSize);
else bufferedStream = IOUtil.toBufferedStream(stream);
if (isBAMFile(bufferedStream)) {
mIsBinary = true;
if (file == null || !file.isFile()) {
// Handle case in which file is a named pipe, e.g. /dev/stdin or created by mkfifo
mReader = new BAMFileReader(bufferedStream, indexFile, eagerDecode, validationStringency, this.samRecordFactory);
} else {
bufferedStream.close();
mReader = new BAMFileReader(file, indexFile, eagerDecode, validationStringency, this.samRecordFactory);
}
} else if (BlockCompressedInputStream.isValidFile(bufferedStream)) {
mIsBinary = false;
mReader = new SAMTextReader(new BlockCompressedInputStream(bufferedStream), validationStringency, this.samRecordFactory);
} else if (isGzippedSAMFile(bufferedStream)) {
mIsBinary = false;
mReader = new SAMTextReader(new GZIPInputStream(bufferedStream), validationStringency, this.samRecordFactory);
} else if (SamStreams.isCRAMFile(bufferedStream)) {
if (file == null || !file.isFile()) {
file = null;
} else {
bufferedStream.close();
bufferedStream = null;
}
mReader = new CRAMFileReader(file, bufferedStream);
} else if (isSAMFile(bufferedStream)) {
if (indexFile != null) {
bufferedStream.close();
throw new RuntimeException("Cannot use index file with textual SAM file");
}
mIsBinary = false;
mReader = new SAMTextReader(bufferedStream, file, validationStringency, this.samRecordFactory);
} else {
bufferedStream.close();
throw new SAMFormatException("Unrecognized file format");
}
setValidationStringency(validationStringency);
mReader.setSAMRecordFactory(this.samRecordFactory);
} catch (final IOException e) {
throw new RuntimeIOException(e);
}
}
/**
* @param stream stream.markSupported() must be true
* @return true if this looks like a BAM file.
*/
private boolean isBAMFile(final InputStream stream)
throws IOException {
if (!BlockCompressedInputStream.isValidFile(stream)) {
return false;
}
final int buffSize = BlockCompressedStreamConstants.MAX_COMPRESSED_BLOCK_SIZE;
stream.mark(buffSize);
final byte[] buffer = new byte[buffSize];
readBytes(stream, buffer, 0, buffSize);
stream.reset();
final byte[] magicBuf = new byte[4];
final int magicLength = readBytes(new BlockCompressedInputStream(new ByteArrayInputStream(buffer)), magicBuf, 0, 4);
return magicLength == BAMFileConstants.BAM_MAGIC.length && Arrays.equals(BAMFileConstants.BAM_MAGIC, magicBuf);
}
private static int readBytes(final InputStream stream, final byte[] buffer, final int offset, final int length)
throws IOException {
int bytesRead = 0;
while (bytesRead < length) {
final int count = stream.read(buffer, offset + bytesRead, length - bytesRead);
if (count <= 0) {
break;
}
bytesRead += count;
}
return bytesRead;
}
/**
* Attempts to check whether the file is a gzipped sam file. Returns true if it
* is and false otherwise.
*/
private boolean isGzippedSAMFile(final BufferedInputStream stream) {
if (!stream.markSupported()) {
throw new IllegalArgumentException("Cannot test a stream that doesn't support marking.");
}
stream.mark(8000);
try {
final GZIPInputStream gunzip = new GZIPInputStream(stream);
final int ch = gunzip.read();
return true;
} catch (final IOException ioe) {
return false;
} finally {
try {
stream.reset();
} catch (final IOException ioe) {
throw new IllegalStateException("Could not reset stream.");
}
}
}
private boolean isSAMFile(final InputStream stream) {
// For now, assume every non-binary file is a SAM text file.
return true;
}
@Override
public String toString() {
if (this.samFile == null) {
return getClass().getSimpleName() + "{initialized with stream}";
} else {
return getClass().getSimpleName() + "{" + this.samFile.getAbsolutePath() + "}";
}
}
/**
* Convenience method to create a QueryInterval
*
* @param sequence sequence of interest, must exist in sequence dictionary
* @param start 1-based start position, must be >= 1
* @param end 1-based end position.
* @throws java.lang.IllegalArgumentException if sequence not found in sequence dictionary, or start position < 1
*/
public QueryInterval makeQueryInterval(final String sequence, int start, int end) {
int referenceIndex = getFileHeader().getSequenceIndex(sequence);
if (referenceIndex < 0) {
throw new IllegalArgumentException(String.format("Sequence '%s' not found in sequence dictionary", sequence));
}
if (start < 1) {
throw new IllegalArgumentException("Start position must be >= 1");
}
return new QueryInterval(referenceIndex, start, end);
}
/**
* Convenience method to create a QueryInterval that goes from start to end of given sequence.
*
* @param sequence sequence of interest, must exist in sequence dictionary
* @param start 1-based start position, must be >= 1
* @throws java.lang.IllegalArgumentException if sequence not found in sequence dictionary, or start position < 1
*/
public QueryInterval makeQueryInterval(final String sequence, int start) {
return makeQueryInterval(sequence, start, 0);
}
}
htsjdk-2.0.1/src/java/htsjdk/samtools/SAMFileSource.java 0000664 0000000 0000000 00000004236 12630347571 0023122 0 ustar 00root root 0000000 0000000 /*
* The MIT License
*
* Copyright (c) 2010 The Broad Institute
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package htsjdk.samtools;
/**
* Represents the origin of a SAM record.
*
* @author mhanna
* @version 0.1
*/
public class SAMFileSource {
/**
* The reader originating this SAM record.
*/
private SamReader mReader;
/**
* The point on disk from which a record originates.
*/
private SAMFileSpan mFilePointer;
/**
* Create a new SAMFileSource with the given reader and file pointer.
* @param reader reader.
* @param filePointer File pointer.
*/
public SAMFileSource(final SamReader reader, final SAMFileSpan filePointer) {
this.mReader = reader;
this.mFilePointer = filePointer;
}
/**
* Retrieves the reader from which this read was initially retrieved.
* @return The reader.
*/
public SamReader getReader() {
return mReader;
}
/**
* A pointer to the region on disk from which the read originated.
* @return A pointer within the file.
*/
public SAMFileSpan getFilePointer() {
return mFilePointer;
}
}
htsjdk-2.0.1/src/java/htsjdk/samtools/SAMFileSpan.java 0000664 0000000 0000000 00000004025 12630347571 0022557 0 ustar 00root root 0000000 0000000 /*
* The MIT License
*
* Copyright (c) 2009 The Broad Institute
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package htsjdk.samtools;
/**
* A interface representing a collection of (possibly) discontinuous segments in the
* BAM file, possibly representing the results of an index query.
*/
public interface SAMFileSpan extends Cloneable {
/**
* Gets a pointer over the data immediately following this span.
* @return The a pointer to data immediately following this span.
*/
public SAMFileSpan getContentsFollowing();
/**
* Remove all pointers in this file span before the given file span starts.
* @param fileSpan The filespan before which to eliminate.
* @return The portion of the chunk list after the given chunk.
*/
public SAMFileSpan removeContentsBefore(final SAMFileSpan fileSpan);
/**
* Does this file span point to any data, or is it completely empty?
* @return True if the file span is empty, false otherwise.
*/
public boolean isEmpty();
}
htsjdk-2.0.1/src/java/htsjdk/samtools/SAMFileTruncatedReader.java 0000664 0000000 0000000 00000003500 12630347571 0024727 0 ustar 00root root 0000000 0000000 package htsjdk.samtools;
import java.io.File;
import java.util.NoSuchElementException;
/**
* A truncated form of a SAMFileReader that iterates over a limited number of records.
*
* @author mccowan@broadinstitute.org
*/
@Deprecated
public class SAMFileTruncatedReader extends SAMFileReader {
private class TruncatedIterator implements SAMRecordIterator {
final SAMRecordIterator i;
final long max;
long currentRecord = 0;
TruncatedIterator(final SAMRecordIterator i, final long max) {
this.i = i;
this.max = max;
}
public boolean hasNext() {
return i.hasNext() && max != currentRecord;
}
public SAMRecord next() {
if (this.hasNext()) {
currentRecord += 1;
return i.next();
} else {
throw new NoSuchElementException();
}
}
public void remove() {
i.remove();
}
public void close() {
i.close();
}
public SAMRecordIterator assertSorted(final SAMFileHeader.SortOrder sortOrder) {
return i.assertSorted(sortOrder);
}
}
private final long maxRecordsToIterate;
/**
* @param input The SAM file
* @param max The maximum number of records to read from the file via iterator() methods
*/
public SAMFileTruncatedReader(final File input, final long max) {
super(input);
this.maxRecordsToIterate = max;
}
@Override
public SAMRecordIterator iterator() {
return new TruncatedIterator(super.iterator(), maxRecordsToIterate);
}
@Override
public SAMRecordIterator iterator(final SAMFileSpan chunks) {
return new TruncatedIterator(super.iterator(chunks), maxRecordsToIterate);
}
}
htsjdk-2.0.1/src/java/htsjdk/samtools/SAMFileWriter.java 0000664 0000000 0000000 00000003422 12630347571 0023132 0 ustar 00root root 0000000 0000000 /*
* The MIT License
*
* Copyright (c) 2009 The Broad Institute
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package htsjdk.samtools;
import java.io.Closeable;
import htsjdk.samtools.util.ProgressLoggerInterface;
/**
* Interface for SAMText and BAM file writers. Clients need not care which they write to,
* once the object is constructed.
*/
public interface SAMFileWriter extends Closeable {
void addAlignment(SAMRecord alignment);
SAMFileHeader getFileHeader();
/**
* Sets a ProgressLogger on this writer. This is useful when pulling, for instance, from a
* SortingCollection.
*/
void setProgressLogger(final ProgressLoggerInterface progress);
/**
* Must be called to flush or file will likely be defective.
*/
void close();
}
htsjdk-2.0.1/src/java/htsjdk/samtools/SAMFileWriterFactory.java 0000664 0000000 0000000 00000047325 12630347571 0024474 0 ustar 00root root 0000000 0000000 /*
* The MIT License
*
* Copyright (c) 2009 The Broad Institute
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package htsjdk.samtools;
import htsjdk.samtools.cram.ref.ReferenceSource;
import htsjdk.samtools.util.BlockCompressedOutputStream;
import htsjdk.samtools.util.IOUtil;
import htsjdk.samtools.util.Log;
import htsjdk.samtools.util.Md5CalculatingOutputStream;
import htsjdk.samtools.util.RuntimeIOException;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* Create a writer for writing SAM, BAM, or CRAM files.
*/
public class SAMFileWriterFactory {
private final static Log log = Log.getInstance(SAMFileWriterFactory.class);
private static boolean defaultCreateIndexWhileWriting = Defaults.CREATE_INDEX;
private boolean createIndex = defaultCreateIndexWhileWriting;
private static boolean defaultCreateMd5File = Defaults.CREATE_MD5;
private boolean createMd5File = defaultCreateMd5File;
private boolean useAsyncIo = Defaults.USE_ASYNC_IO;
private int asyncOutputBufferSize = AsyncSAMFileWriter.DEFAULT_QUEUE_SIZE;
private int bufferSize = Defaults.BUFFER_SIZE;
private File tmpDir;
private Integer maxRecordsInRam;
/**
* Sets the default for whether to create md5Files for BAM files this factory.
*/
public static void setDefaultCreateMd5File(final boolean createMd5File) {
defaultCreateMd5File = createMd5File;
}
/**
* Sets whether to create md5Files for BAMs from this factory.
*/
public SAMFileWriterFactory setCreateMd5File(final boolean createMd5File) {
this.createMd5File = createMd5File;
return this;
}
/**
* Sets the default for subsequent SAMFileWriterFactories
* that do not specify whether to create an index.
* If a BAM (not SAM) file is created, the setting is true, and the file header specifies coordinate order,
* then a BAM index file will be written along with the BAM file.
*
* @param setting whether to attempt to create a BAM index while creating the BAM file
*/
public static void setDefaultCreateIndexWhileWriting(final boolean setting) {
defaultCreateIndexWhileWriting = setting;
}
/**
* Convenience method allowing newSAMFileWriterFactory().setCreateIndex(true);
* Equivalent to SAMFileWriterFactory.setDefaultCreateIndexWhileWriting(true); newSAMFileWriterFactory();
* If a BAM or CRAM (not SAM) file is created, the setting is true, and the file header specifies coordinate order,
* then a BAM index file will be written along with the BAM file.
*
* @param setting whether to attempt to create a BAM index while creating the BAM file.
* @return this factory object
*/
public SAMFileWriterFactory setCreateIndex(final boolean setting) {
this.createIndex = setting;
return this;
}
/**
* Before creating a writer that is not presorted, this method may be called in order to override
* the default number of SAMRecords stored in RAM before spilling to disk
* (c.f. SAMFileWriterImpl.MAX_RECORDS_IN_RAM). When writing very large sorted SAM files, you may need
* call this method in order to avoid running out of file handles. The RAM available to the JVM may need
* to be increased in order to hold the specified number of records in RAM. This value affects the number
* of records stored in subsequent calls to one of the make...() methods.
*
* @param maxRecordsInRam Number of records to store in RAM before spilling to temporary file when
* creating a sorted SAM or BAM file.
*/
public SAMFileWriterFactory setMaxRecordsInRam(final int maxRecordsInRam) {
this.maxRecordsInRam = maxRecordsInRam;
return this;
}
/**
* Turn on or off the use of asynchronous IO for writing output SAM and BAM files. If true then
* each SAMFileWriter creates a dedicated thread which is used for compression and IO activities.
*/
public SAMFileWriterFactory setUseAsyncIo(final boolean useAsyncIo) {
this.useAsyncIo = useAsyncIo;
return this;
}
/**
* If and only if using asynchronous IO then sets the maximum number of records that can be buffered per
* SAMFileWriter before producers will block when trying to write another SAMRecord.
*/
public SAMFileWriterFactory setAsyncOutputBufferSize(final int asyncOutputBufferSize) {
this.asyncOutputBufferSize = asyncOutputBufferSize;
return this;
}
/**
* Controls size of write buffer.
* Default value: [[htsjdk.samtools.Defaults#BUFFER_SIZE]]
*/
public SAMFileWriterFactory setBufferSize(final int bufferSize) {
this.bufferSize = bufferSize;
return this;
}
/**
* Set the temporary directory to use when sort data.
*
* @param tmpDir Path to the temporary directory
*/
public SAMFileWriterFactory setTempDirectory(final File tmpDir) {
this.tmpDir = tmpDir;
return this;
}
/**
* Create a BAMFileWriter that is ready to receive SAMRecords. Uses default compression level.
*
* @param header entire header. Sort order is determined by the sortOrder property of this arg.
* @param presorted if true, SAMRecords must be added to the SAMFileWriter in order that agrees with header.sortOrder.
* @param outputFile where to write the output.
*/
public SAMFileWriter makeBAMWriter(final SAMFileHeader header, final boolean presorted, final File outputFile) {
return makeBAMWriter(header, presorted, outputFile, BlockCompressedOutputStream.getDefaultCompressionLevel());
}
/**
* Create a BAMFileWriter that is ready to receive SAMRecords.
*
* @param header entire header. Sort order is determined by the sortOrder property of this arg.
* @param presorted if true, SAMRecords must be added to the SAMFileWriter in order that agrees with header.sortOrder.
* @param outputFile where to write the output.
* @param compressionLevel Override default compression level with the given value, between 0 (fastest) and 9 (smallest).
*/
public SAMFileWriter makeBAMWriter(final SAMFileHeader header, final boolean presorted, final File outputFile,
final int compressionLevel) {
try {
final boolean createMd5File = this.createMd5File && IOUtil.isRegularPath(outputFile);
if (this.createMd5File && !createMd5File) {
log.warn("Cannot create MD5 file for BAM because output file is not a regular file: " + outputFile.getAbsolutePath());
}
OutputStream os = IOUtil.maybeBufferOutputStream(new FileOutputStream(outputFile, false), bufferSize);
if (createMd5File) os = new Md5CalculatingOutputStream(os, new File(outputFile.getAbsolutePath() + ".md5"));
final BAMFileWriter ret = new BAMFileWriter(os, outputFile, compressionLevel);
final boolean createIndex = this.createIndex && IOUtil.isRegularPath(outputFile);
if (this.createIndex && !createIndex) {
log.warn("Cannot create index for BAM because output file is not a regular file: " + outputFile.getAbsolutePath());
}
if (this.tmpDir != null) ret.setTempDirectory(this.tmpDir);
initializeBAMWriter(ret, header, presorted, createIndex);
if (this.useAsyncIo) return new AsyncSAMFileWriter(ret, this.asyncOutputBufferSize);
else return ret;
} catch (final IOException ioe) {
throw new RuntimeIOException("Error opening file: " + outputFile.getAbsolutePath());
}
}
private void initializeBAMWriter(final BAMFileWriter writer, final SAMFileHeader header, final boolean presorted, final boolean createIndex) {
writer.setSortOrder(header.getSortOrder(), presorted);
if (maxRecordsInRam != null) {
writer.setMaxRecordsInRam(maxRecordsInRam);
}
writer.setHeader(header);
if (createIndex && writer.getSortOrder().equals(SAMFileHeader.SortOrder.coordinate)) {
writer.enableBamIndexConstruction();
}
}
/**
* Create a SAMTextWriter that is ready to receive SAMRecords.
*
* @param header entire header. Sort order is determined by the sortOrder property of this arg.
* @param presorted if true, SAMRecords must be added to the SAMFileWriter in order that agrees with header.sortOrder.
* @param outputFile where to write the output.
*/
public SAMFileWriter makeSAMWriter(final SAMFileHeader header, final boolean presorted, final File outputFile) {
try {
final SAMTextWriter ret = this.createMd5File
? new SAMTextWriter(new Md5CalculatingOutputStream(new FileOutputStream(outputFile, false),
new File(outputFile.getAbsolutePath() + ".md5")))
: new SAMTextWriter(outputFile);
ret.setSortOrder(header.getSortOrder(), presorted);
if (maxRecordsInRam != null) {
ret.setMaxRecordsInRam(maxRecordsInRam);
}
ret.setHeader(header);
if (this.useAsyncIo) return new AsyncSAMFileWriter(ret, this.asyncOutputBufferSize);
else return ret;
} catch (final IOException ioe) {
throw new RuntimeIOException("Error opening file: " + outputFile.getAbsolutePath());
}
}
/**
* Create a SAMTextWriter for writing to a stream that is ready to receive SAMRecords.
* This method does not support the creation of an MD5 file
*
* @param header entire header. Sort order is determined by the sortOrder property of this arg.
* @param presorted if true, SAMRecords must be added to the SAMFileWriter in order that agrees with header.sortOrder.
* @param stream the stream to write records to. Note that this method does not buffer the stream, so the
* caller must buffer if desired. Note that PrintStream is buffered.
*/
public SAMFileWriter makeSAMWriter(final SAMFileHeader header, final boolean presorted, final OutputStream stream) {
return initWriter(header, presorted, false, new SAMTextWriter(stream));
}
/**
* Create a BAMFileWriter for writing to a stream that is ready to receive SAMRecords.
* This method does not support the creation of an MD5 file
*
* @param header entire header. Sort order is determined by the sortOrder property of this arg.
* @param presorted if true, SAMRecords must be added to the SAMFileWriter in order that agrees with header.sortOrder.
* @param stream the stream to write records to. Note that this method does not buffer the stream, so the
* caller must buffer if desired. Note that PrintStream is buffered.
*/
public SAMFileWriter makeBAMWriter(final SAMFileHeader header, final boolean presorted, final OutputStream stream) {
return initWriter(header, presorted, true, new BAMFileWriter(stream, null));
}
/**
* Initialize SAMTextWriter or a BAMFileWriter and possibly wrap in AsyncSAMFileWriter
*
* @param header entire header. Sort order is determined by the sortOrder property of this arg.
* @param presorted if true, SAMRecords must be added to the SAMFileWriter in order that agrees with header.sortOrder.
* @param binary do we want to generate a BAM or a SAM
* @param writer SAM or BAM writer to initialize and maybe wrap.
*/
private SAMFileWriter initWriter(final SAMFileHeader header, final boolean presorted, final boolean binary,
final SAMFileWriterImpl writer) {
writer.setSortOrder(header.getSortOrder(), presorted);
if (maxRecordsInRam != null) {
writer.setMaxRecordsInRam(maxRecordsInRam);
}
writer.setHeader(header);
if (this.useAsyncIo) return new AsyncSAMFileWriter(writer, this.asyncOutputBufferSize);
else return writer;
}
/**
* Create either a SAM or a BAM writer based on examination of the outputFile extension.
*
* @param header entire header. Sort order is determined by the sortOrder property of this arg.
* @param presorted presorted if true, SAMRecords must be added to the SAMFileWriter in order that agrees with header.sortOrder.
* @param outputFile where to write the output. Must end with .sam or .bam.
* @return SAM or BAM writer based on file extension of outputFile.
*/
public SAMFileWriter makeSAMOrBAMWriter(final SAMFileHeader header, final boolean presorted, final File outputFile) {
final String filename = outputFile.getName();
if (filename.endsWith(BamFileIoUtils.BAM_FILE_EXTENSION)) {
return makeBAMWriter(header, presorted, outputFile);
}
if (filename.endsWith(".sam")) {
return makeSAMWriter(header, presorted, outputFile);
}
return makeBAMWriter(header, presorted, outputFile);
}
/**
*
* Create a SAM, BAM or CRAM writer based on examination of the outputFile extension.
*
* @param header header. Sort order is determined by the sortOrder property of this arg.
* @param presorted if true, SAMRecords must be added to the SAMFileWriter in order that agrees with header.sortOrder.
* @param outputFile where to write the output. Must end with .sam, .bam or .cram.
* @param referenceFasta reference sequence file
* @return SAMFileWriter appropriate for the file type specified in outputFile
*
*/
public SAMFileWriter makeWriter(final SAMFileHeader header, final boolean presorted, final File outputFile, final File referenceFasta) {
if (outputFile.getName().endsWith(SamReader.Type.CRAM_TYPE.fileExtension())) {
return makeCRAMWriter(header, presorted, outputFile, referenceFasta);
}
else {
return makeSAMOrBAMWriter(header, presorted, outputFile);
}
}
/**
* Create a CRAMFileWriter on an output stream. Requires the input to be presorted to match the sort order defined
* by the input header.
*
* Note: does not honor factory settings for CREATE_MD5, CREATE_INDEX, USE_ASYNC_IO.
*
* @param header entire header. Sort order is determined by the sortOrder property of this arg.
* @param stream where to write the output.
* @param referenceFasta reference sequence file
* @return CRAMFileWriter
*/
public CRAMFileWriter makeCRAMWriter(final SAMFileHeader header, final OutputStream stream, final File referenceFasta) {
// create the CRAMFileWriter directly without propagating factory settings
final CRAMFileWriter writer = new CRAMFileWriter(stream, new ReferenceSource(referenceFasta), header, null);
setCRAMWriterDefaults(writer);
return writer;
}
/**
* Create a CRAMFileWriter on an output file. Requires input record to be presorted to match the
* sort order defined by the input header.
*
* Note: does not honor factory settings for USE_ASYNC_IO.
*
* @param header entire header. Sort order is determined by the sortOrder property of this arg.
* @param outputFile where to write the output. Must end with .sam, .bam or .cram.
* @param referenceFasta reference sequence file
* @return CRAMFileWriter
*
*/
public CRAMFileWriter makeCRAMWriter(final SAMFileHeader header, final File outputFile, final File referenceFasta) {
return createCRAMWriterWithSettings(header, true, outputFile, referenceFasta);
}
/**
* Create a CRAMFileWriter on an output file.
*
* Note: does not honor factory setting for USE_ASYNC_IO.
*
* @param header entire header. Sort order is determined by the sortOrder property of this arg.
* @param presorted if true, SAMRecords must be added to the SAMFileWriter in order that agrees with header.sortOrder.
* @param outputFile where to write the output. Must end with .sam, .bam or .cram.
* @param referenceFasta reference sequence file
* @return CRAMFileWriter
*
*/
public CRAMFileWriter makeCRAMWriter(final SAMFileHeader header, final boolean presorted, final File outputFile, final File referenceFasta) {
return createCRAMWriterWithSettings(header, presorted, outputFile, referenceFasta);
}
/**
* Create a CRAMFileWriter on an output file based on factory settings.
*
* Note: does not honor the factory setting for USE_ASYNC_IO.
*
* @param header entire header. Sort order is determined by the sortOrder property of this arg.
* @param presorted if true, SAMRecords must be added to the SAMFileWriter in order that agrees with header.sortOrder.
* @param outputFile where to write the output. Must end with .sam, .bam or .cram.
* @param referenceFasta reference sequence file
* @return CRAMFileWriter
*/
private CRAMFileWriter createCRAMWriterWithSettings(
final SAMFileHeader header,
final boolean presorted,
final File outputFile,
final File referenceFasta) {
OutputStream cramOS = null;
OutputStream indexOS = null ;
if (createIndex) {
if (!IOUtil.isRegularPath(outputFile)) {
log.warn("Cannot create index for CRAM because output file is not a regular file: " + outputFile.getAbsolutePath());
}
else {
try {
final File indexFile = new File(outputFile.getAbsolutePath() + BAMIndex.BAMIndexSuffix) ;
indexOS = new FileOutputStream(indexFile) ;
}
catch (final IOException ioe) {
throw new RuntimeIOException("Error creating index file for: " + outputFile.getAbsolutePath()+ BAMIndex.BAMIndexSuffix);
}
}
}
try {
cramOS = IOUtil.maybeBufferOutputStream(new FileOutputStream(outputFile, false), bufferSize);
}
catch (final IOException ioe) {
throw new RuntimeIOException("Error creating CRAM file: " + outputFile.getAbsolutePath());
}
CRAMFileWriter writer = new CRAMFileWriter(
createMd5File ? new Md5CalculatingOutputStream(cramOS, new File(outputFile.getAbsolutePath() + ".md5")) : cramOS,
indexOS,
presorted,
new ReferenceSource(referenceFasta),
header,
outputFile.getAbsolutePath());
setCRAMWriterDefaults(writer);
return writer;
}
// Set the default CRAM writer preservation parameters
private void setCRAMWriterDefaults(CRAMFileWriter writer) {
writer.setPreserveReadNames(true);
writer.setCaptureAllTags(true);
}
}
htsjdk-2.0.1/src/java/htsjdk/samtools/SAMFileWriterImpl.java 0000664 0000000 0000000 00000022416 12630347571 0023760 0 ustar 00root root 0000000 0000000 /*
* The MIT License
*
* Copyright (c) 2009 The Broad Institute
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package htsjdk.samtools;
import htsjdk.samtools.util.ProgressLoggerInterface;
import htsjdk.samtools.util.SortingCollection;
import java.io.File;
import java.io.StringWriter;
/**
* Base class for implementing SAM writer with any underlying format.
* Mostly this manages accumulation & sorting of SAMRecords when appropriate,
* and produces the text version of the header, since that seems to be a popular item
* in both text and binary file formats.
*/
public abstract class SAMFileWriterImpl implements SAMFileWriter
{
private static int DEAFULT_MAX_RECORDS_IN_RAM = 500000;
private int maxRecordsInRam = DEAFULT_MAX_RECORDS_IN_RAM;
private SAMFileHeader.SortOrder sortOrder;
private SAMFileHeader header;
private SortingCollection alignmentSorter;
private File tmpDir = new File(System.getProperty("java.io.tmpdir"));
private ProgressLoggerInterface progressLogger = null;
private boolean isClosed = false;
// If true, records passed to addAlignment are already in the order specified by sortOrder
private boolean presorted;
// For validating presorted records.
private SAMSortOrderChecker sortOrderChecker;
/**
* When writing records that are not presorted, specify the number of records stored in RAM
* before spilling to disk. This method sets the default value for all SamFileWriterImpl
* instances. Must be called before the constructor is called.
* @param maxRecordsInRam
*/
public static void setDefaultMaxRecordsInRam(final int maxRecordsInRam) {
DEAFULT_MAX_RECORDS_IN_RAM = maxRecordsInRam;
}
/**
* When writing records that are not presorted, this number determines the
* number of records stored in RAM before spilling to disk.
* @return DEAFULT_MAX_RECORDS_IN_RAM
*/
public static int getDefaultMaxRecordsInRam() {
return DEAFULT_MAX_RECORDS_IN_RAM;
}
/**
* Sets the progress logger used by this implementation. Setting this lets this writer emit log
* messages as SAM records in a SortingCollection are being written to disk.
*/
public void setProgressLogger(final ProgressLoggerInterface progress) {
this.progressLogger = progress;
}
/**
* Must be called before calling setHeader(). SortOrder value in the header passed
* to setHeader() is ignored. If setSortOrder is not called, default is SortOrder.unsorted.
*/
public void setSortOrder(final SAMFileHeader.SortOrder sortOrder, final boolean presorted) {
if (header != null) {
throw new IllegalStateException("Cannot call SAMFileWriterImpl.setSortOrder after setHeader for " +
getFilename());
}
this.sortOrder = sortOrder;
this.presorted = presorted;
}
/**
* Must be called after calling setHeader().
*/
protected SAMFileHeader.SortOrder getSortOrder() {
return this.sortOrder;
}
/**
* When writing records that are not presorted, specify the number of records stored in RAM
* before spilling to disk. Must be called before setHeader().
* @param maxRecordsInRam
*/
void setMaxRecordsInRam(final int maxRecordsInRam) {
if (this.header != null) {
throw new IllegalStateException("setMaxRecordsInRam must be called before setHeader()");
}
this.maxRecordsInRam = maxRecordsInRam;
}
/**
* When writing records that are not presorted, specify the path of the temporary directory
* for spilling to disk. Must be called before setHeader().
* @param tmpDir path to the temporary directory
*/
void setTempDirectory(final File tmpDir) {
if (tmpDir!=null) {
this.tmpDir = tmpDir;
}
}
/**
* Must be called before addAlignment. Header cannot be null.
*/
public void setHeader(final SAMFileHeader header)
{
if (null == header) {
throw new IllegalArgumentException("A non-null SAMFileHeader is required for a writer");
}
this.header = header;
if (sortOrder == null) {
sortOrder = SAMFileHeader.SortOrder.unsorted;
}
header.setSortOrder(sortOrder);
final StringWriter headerTextBuffer = new StringWriter();
new SAMTextHeaderCodec().encode(headerTextBuffer, header);
final String headerText = headerTextBuffer.toString();
writeHeader(headerText);
if (presorted) {
if (sortOrder.equals(SAMFileHeader.SortOrder.unsorted)) {
presorted = false;
} else {
sortOrderChecker = new SAMSortOrderChecker(sortOrder);
}
} else if (!sortOrder.equals(SAMFileHeader.SortOrder.unsorted)) {
alignmentSorter = SortingCollection.newInstance(SAMRecord.class,
new BAMRecordCodec(header), makeComparator(), maxRecordsInRam, tmpDir);
}
}
public SAMFileHeader getFileHeader() {
return header;
}
private SAMRecordComparator makeComparator() {
switch (sortOrder) {
case coordinate:
return new SAMRecordCoordinateComparator();
case queryname:
return new SAMRecordQueryNameComparator();
case duplicate:
return new SAMRecordDuplicateComparator();
case unsorted:
return null;
}
throw new IllegalStateException("sortOrder should not be null");
}
/**
* Add an alignment record to be emitted by the writer.
*
* @param alignment Must not be null. If the alignment record's SAMFileHeader is null, the record will be
* updated to the header used by this writer, which will in turn cause any unresolved reference and
* mate reference indices to be resolved against the new header's sequence dictionary.
*/
public void addAlignment(final SAMRecord alignment)
{
if (null == alignment.getHeader()) {
alignment.setHeader(header); // re-establish the record header and attempt to resolve reference index values
}
if (sortOrder.equals(SAMFileHeader.SortOrder.unsorted)) {
writeAlignment(alignment);
} else if (presorted) {
assertPresorted(alignment);
writeAlignment(alignment);
} else {
alignmentSorter.add(alignment);
}
}
private void assertPresorted(final SAMRecord alignment) {
final SAMRecord prev = sortOrderChecker.getPreviousRecord();
if (!sortOrderChecker.isSorted(alignment)) {
throw new IllegalArgumentException("Alignments added out of order in SAMFileWriterImpl.addAlignment for " +
getFilename() + ". Sort order is " + this.sortOrder + ". Offending records are at ["
+ sortOrderChecker.getSortKey(prev) + "] and ["
+ sortOrderChecker.getSortKey(alignment) + "]");
}
}
/**
* Must be called or else file will likely be defective.
*/
public final void close()
{
if (!isClosed) {
if (alignmentSorter != null) {
for (final SAMRecord alignment : alignmentSorter) {
writeAlignment(alignment);
if (progressLogger != null) progressLogger.record(alignment);
}
alignmentSorter.cleanup();
}
finish();
}
isClosed = true;
}
/**
* Writes the record to disk. Sort order has been taken care of by the time
* this method is called. The record must hava a non-null SAMFileHeader.
* @param alignment
*/
abstract protected void writeAlignment(SAMRecord alignment);
/**
* Write the header to disk. Header object is available via getHeader().
* @param textHeader for convenience if the implementation needs it.
*/
abstract protected void writeHeader(String textHeader);
/**
* Do any required flushing here.
*/
abstract protected void finish();
/**
* For producing error messages.
* @return Output filename, or null if there isn't one.
*/
abstract protected String getFilename();
}
htsjdk-2.0.1/src/java/htsjdk/samtools/SAMFlag.java 0000664 0000000 0000000 00000007745 12630347571 0021743 0 ustar 00root root 0000000 0000000 /*
* The MIT License
*
* Author: Pierre Lindenbaum PhD @yokofakun
* Institut du Thorax - Nantes - France
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package htsjdk.samtools;
import java.util.HashSet;
import java.util.Set;
/**
* SAM flags as enum, to be used in GUI, menu, etc...
*/
public enum SAMFlag {
READ_PAIRED( 0x1, "Template having multiple segments in sequencing"),
PROPER_PAIR( 0x2, "Each segment properly aligned according to the aligner"),
READ_UNMAPPED( 0x4, "Segment unmapped"),
MATE_UNMAPPED( 0x8, "Next segment in the template unmapped"),
READ_REVERSE_STRAND( 0x10, "SEQ being reverse complemented"),
MATE_REVERSE_STRAND( 0x20, "SEQ of the next segment in the template being reverse complemented"),
FIRST_OF_PAIR( 0x40, "The first segment in the template"),
SECOND_OF_PAIR( 0x80, "The last segment in the template"),
NOT_PRIMARY_ALIGNMENT( 0x100, "Secondary alignment"),
READ_FAILS_VENDOR_QUALITY_CHECK(0x200, "Not passing quality controls"),
DUPLICATE_READ( 0x400, "PCR or optical duplicate"),
SUPPLEMENTARY_ALIGNMENT( 0x800, "Supplementary alignment")
;
/* visible for the package, to be used by SAMRecord */
final int flag;
private final String description;
SAMFlag(int flag,String description) {
this.flag = flag;
this.description = description;
}
/** @return this flag as an int */
public int intValue() {
return flag;
}
/** @return a human label for this SAMFlag */
public String getLabel() {
return name().toLowerCase().replace('_', ' ');
}
/** @return a human description for this SAMFlag */
public String getDescription() {
return this.description;
}
/** @return the SAMFlag for the value 'flag' or null if it was not found */
public static SAMFlag valueOf(int flag) {
for (SAMFlag f : values()) {
if (flag == f.flag)
return f;
}
return null;
}
/** @return find SAMFlag the flag by name, or null if it was not found */
public static SAMFlag findByName(String flag)
{
for (SAMFlag f : values()) {
if (f.name().equals(flag))
return f;
}
return null;
}
/** @returns true if the bit for is set for flag */
public boolean isSet(int flag) {
return (this.flag & flag) != 0;
}
/** @returns true if the bit for is not set for flag */
public boolean isUnset(int flag) {
return !isSet(flag);
}
/** @returns the java.util.Set of SAMFlag for 'flag' */
public static Set getFlags(int flag) {
Set set = new HashSet();
for (SAMFlag f : values()) {
if (f.isSet(flag))
set.add(f);
}
return set;
}
}
htsjdk-2.0.1/src/java/htsjdk/samtools/SAMFormatException.java 0000664 0000000 0000000 00000003135 12630347571 0024166 0 ustar 00root root 0000000 0000000 /*
* The MIT License
*
* Copyright (c) 2009 The Broad Institute
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package htsjdk.samtools;
/**
* Thrown when a SAM file being read or decoded (text or binary) looks bad.
*/
public class SAMFormatException extends SAMException {
public SAMFormatException() {
}
public SAMFormatException(final String s) {
super(s);
}
public SAMFormatException(final String s, final Throwable throwable) {
super(s, throwable);
}
public SAMFormatException(final Throwable throwable) {
super(throwable);
}
}
htsjdk-2.0.1/src/java/htsjdk/samtools/SAMHeaderRecordComparator.java 0000664 0000000 0000000 00000004565 12630347571 0025446 0 ustar 00root root 0000000 0000000 package htsjdk.samtools;
/**
* The MIT License
*
* Copyright (c) 2014 The Broad Institute
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
import java.util.Comparator;
/**
* Provides ordering based on SAM header records' attribute values. Provide the list of attributes to use
* in the comparison to the constructor. Null attribute values (i.e., those attributes not present in the
* record) sort behind those that have values.
*/
public class SAMHeaderRecordComparator implements Comparator {
private final String[] attributes;
public SAMHeaderRecordComparator(final String... attributes) {
this.attributes = attributes;
}
@Override
public int compare(final T left, final T right) {
for (final String attribute : attributes) {
final String leftValue = left.getAttribute(attribute);
final String rightValue = right.getAttribute(attribute);
if (leftValue == null) {
// Fastest comparison possible; two empty values are
// equivalent, so move along to the next attribute
if (rightValue == null) continue;
// Otherwise left < right, since right has a value
else return -1;
}
// left is not null; if right is, left > right
if (rightValue == null) return 1;
final int compare = leftValue.compareTo(rightValue);
if (compare != 0) return compare;
}
return 0;
}
}
htsjdk-2.0.1/src/java/htsjdk/samtools/SAMLineParser.java 0000664 0000000 0000000 00000041217 12630347571 0023126 0 ustar 00root root 0000000 0000000 /*
* The MIT License
*
* Copyright (c) 2012 The Broad Institute
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package htsjdk.samtools;
import htsjdk.samtools.util.StringUtil;
import java.io.File;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
/**
* this class enables creation of a SAMRecord object from a String in SAM text format.
*/
public class SAMLineParser {
// From SAM specification
private static final int QNAME_COL = 0;
private static final int FLAG_COL = 1;
private static final int RNAME_COL = 2;
private static final int POS_COL = 3;
private static final int MAPQ_COL = 4;
private static final int CIGAR_COL = 5;
private static final int MRNM_COL = 6;
private static final int MPOS_COL = 7;
private static final int ISIZE_COL = 8;
private static final int SEQ_COL = 9;
private static final int QUAL_COL = 10;
private static final int NUM_REQUIRED_FIELDS = 11;
// Read string must contain only these characters
private static final Pattern VALID_BASES = Pattern
.compile("^[acmgrsvtwyhkdbnACMGRSVTWYHKDBN.=]+$");
/**
* Allocate this once rather than for every line as a performance
* optimization. The size is arbitrary -- merely large enough to handle the
* maximum number of fields we might expect from a reasonable SAM file.
*/
private final String[] mFields = new String[10000];
/**
* Add information about the origin (reader and position) to SAM records.
*/
private final SamReader mParentReader;
private final SAMRecordFactory samRecordFactory;
private final ValidationStringency validationStringency;
private final SAMFileHeader mFileHeader;
private final File mFile;
private final TextTagCodec tagCodec = new TextTagCodec();
private int currentLineNumber;
private String currentLine;
//
// Constructors
//
/**
* Public constructor. Use the default SAMRecordFactory and stringency.
*
* @param samFileHeader SAM file header
*/
public SAMLineParser(final SAMFileHeader samFileHeader) {
this(new DefaultSAMRecordFactory(),
ValidationStringency.DEFAULT_STRINGENCY, samFileHeader,
null, null);
}
/**
* Public constructor. Use the default SAMRecordFactory and stringency.
*
* @param samFileHeader SAM file header
* @param samFileReader SAM file reader For passing to SAMRecord.setFileSource, may be null.
* @param samFile SAM file being read (for error message only, may be null)
*/
public SAMLineParser(final SAMFileHeader samFileHeader,
final SamReader samFileReader, final File samFile) {
this(new DefaultSAMRecordFactory(),
ValidationStringency.DEFAULT_STRINGENCY, samFileHeader,
samFileReader, samFile);
}
/**
* Public constructor.
*
* @param samRecordFactory SamRecord Factory
* @param validationStringency validation stringency
* @param samFileHeader SAM file header
* @param samFileReader SAM file reader For passing to SAMRecord.setFileSource, may be null.
* @param samFile SAM file being read (for error message only, may be null)
*/
public SAMLineParser(final SAMRecordFactory samRecordFactory,
final ValidationStringency validationStringency,
final SAMFileHeader samFileHeader, final SamReader samFileReader,
final File samFile) {
if (samRecordFactory == null)
throw new NullPointerException("The SamRecordFactory must be set");
if (validationStringency == null)
throw new NullPointerException("The validationStringency must be set");
if (samFileHeader == null)
throw new NullPointerException("The mFileHeader must be set");
this.samRecordFactory = samRecordFactory;
this.validationStringency = validationStringency;
this.mFileHeader = samFileHeader;
// Can be null
this.mParentReader = samFileReader;
// Can be null
this.mFile = samFile;
}
/**
* Get the File header.
*
* @return the SAM file header
*/
public SAMFileHeader getFileHeader() {
return this.mFileHeader;
}
/**
* Get validation stringency.
*
* @return validation stringency
*/
public ValidationStringency getValidationStringency() {
return this.validationStringency;
}
private int parseInt(final String s, final String fieldName) {
final int ret;
try {
ret = Integer.parseInt(s);
} catch (NumberFormatException e) {
throw reportFatalErrorParsingLine("Non-numeric value in "
+ fieldName + " column");
}
return ret;
}
private void validateReferenceName(final String rname, final String fieldName) {
if (rname.equals("=")) {
if (fieldName.equals("MRNM")) {
return;
}
reportErrorParsingLine("= is not a valid value for "
+ fieldName + " field.");
}
if (this.mFileHeader.getSequenceDictionary().size() != 0) {
if (this.mFileHeader.getSequence(rname) == null) {
reportErrorParsingLine(fieldName
+ " '" + rname + "' not found in any SQ record");
}
}
}
/**
* Parse a SAM line.
*
* @param line line to parse
* @return a new SAMRecord object
*/
public SAMRecord parseLine(final String line) {
return parseLine(line, -1);
}
/**
* Parse a SAM line.
*
* @param line line to parse
* @param lineNumber line number in the file. If the line number is not known
* can be <=0.
* @return a new SAMRecord object
*/
public SAMRecord parseLine(final String line, final int lineNumber) {
final String mCurrentLine = line;
this.currentLineNumber = lineNumber;
this.currentLine = line;
final int numFields = StringUtil.split(mCurrentLine, mFields, '\t');
if (numFields < NUM_REQUIRED_FIELDS) {
throw reportFatalErrorParsingLine("Not enough fields");
}
if (numFields == mFields.length) {
reportErrorParsingLine("Too many fields in SAM text record.");
}
for (int i = 0; i < numFields; ++i) {
if (mFields[i].length() == 0) {
reportErrorParsingLine("Empty field at position " + i + " (zero-based)");
}
}
final SAMRecord samRecord =
samRecordFactory.createSAMRecord(this.mFileHeader);
samRecord.setValidationStringency(this.validationStringency);
if (mParentReader != null)
samRecord.setFileSource(new SAMFileSource(mParentReader, null));
samRecord.setHeader(this.mFileHeader);
samRecord.setReadName(mFields[QNAME_COL]);
final int flags = parseInt(mFields[FLAG_COL], "FLAG");
samRecord.setFlags(flags);
String rname = mFields[RNAME_COL];
if (!rname.equals("*")) {
rname = SAMSequenceRecord.truncateSequenceName(rname);
validateReferenceName(rname, "RNAME");
samRecord.setReferenceName(rname);
} else if (!samRecord.getReadUnmappedFlag()) {
reportErrorParsingLine("RNAME is not specified but flags indicate mapped");
}
final int pos = parseInt(mFields[POS_COL], "POS");
final int mapq = parseInt(mFields[MAPQ_COL], "MAPQ");
final String cigar = mFields[CIGAR_COL];
if (!SAMRecord.NO_ALIGNMENT_REFERENCE_NAME.equals(samRecord
.getReferenceName())) {
if (pos == 0) {
reportErrorParsingLine("POS must be non-zero if RNAME is specified");
}
if (!samRecord.getReadUnmappedFlag() && cigar.equals("*")) {
reportErrorParsingLine("CIGAR must not be '*' if RNAME is specified");
}
} else {
if (pos != 0) {
reportErrorParsingLine("POS must be zero if RNAME is not specified");
}
if (mapq != 0) {
reportErrorParsingLine("MAPQ must be zero if RNAME is not specified");
}
if (!cigar.equals("*")) {
reportErrorParsingLine("CIGAR must be '*' if RNAME is not specified");
}
}
samRecord.setAlignmentStart(pos);
samRecord.setMappingQuality(mapq);
samRecord.setCigarString(cigar);
String mateRName = mFields[MRNM_COL];
if (mateRName.equals("*")) {
if (samRecord.getReadPairedFlag() && !samRecord.getMateUnmappedFlag()) {
reportErrorParsingLine("MRNM not specified but flags indicate mate mapped");
}
} else {
if (!samRecord.getReadPairedFlag()) {
reportErrorParsingLine("MRNM specified but flags indicate unpaired");
}
if (!"=".equals(mateRName)) {
mateRName = SAMSequenceRecord.truncateSequenceName(mateRName);
}
validateReferenceName(mateRName, "MRNM");
if (mateRName.equals("=")) {
if (samRecord.getReferenceName() == null) {
reportErrorParsingLine("MRNM is '=', but RNAME is not set");
}
samRecord.setMateReferenceName(samRecord.getReferenceName());
} else {
samRecord.setMateReferenceName(mateRName);
}
}
final int matePos = parseInt(mFields[MPOS_COL], "MPOS");
final int isize = parseInt(mFields[ISIZE_COL], "ISIZE");
if (!samRecord.getMateReferenceName().equals(
SAMRecord.NO_ALIGNMENT_REFERENCE_NAME)) {
if (matePos == 0) {
reportErrorParsingLine("MPOS must be non-zero if MRNM is specified");
}
} else {
if (matePos != 0) {
reportErrorParsingLine("MPOS must be zero if MRNM is not specified");
}
if (isize != 0) {
reportErrorParsingLine("ISIZE must be zero if MRNM is not specified");
}
}
samRecord.setMateAlignmentStart(matePos);
samRecord.setInferredInsertSize(isize);
if (!mFields[SEQ_COL].equals("*")) {
validateReadBases(mFields[SEQ_COL]);
samRecord.setReadString(mFields[SEQ_COL]);
} else {
samRecord.setReadBases(SAMRecord.NULL_SEQUENCE);
}
if (!mFields[QUAL_COL].equals("*")) {
if (samRecord.getReadBases() == SAMRecord.NULL_SEQUENCE) {
reportErrorParsingLine("QUAL should not be specified if SEQ is not specified");
}
if (samRecord.getReadString().length() != mFields[QUAL_COL].length()) {
reportErrorParsingLine("length(QUAL) != length(SEQ)");
}
samRecord.setBaseQualityString(mFields[QUAL_COL]);
} else {
samRecord.setBaseQualities(SAMRecord.NULL_QUALS);
}
for (int i = NUM_REQUIRED_FIELDS; i < numFields; ++i) {
parseTag(samRecord, mFields[i]);
}
// Only call samRecord.isValid() if errors would be reported since the validation
// is quite expensive in and of itself.
if (this.validationStringency != ValidationStringency.SILENT) {
final List validationErrors = samRecord.isValid();
if (validationErrors != null) {
for (final SAMValidationError errorMessage : validationErrors) {
reportErrorParsingLine(errorMessage.getMessage());
}
}
}
return samRecord;
}
private void validateReadBases(final String bases) {
/*
* Using regex is slow, so check for invalid characters via
* isValidReadBase(), which hopefully the JIT will optimize. if
* (!VALID_BASES.matcher(bases).matches()) {
* reportErrorParsingLine("Invalid character in read bases"); }
*/
for (int i = 0; i < bases.length(); ++i) {
if (!isValidReadBase(bases.charAt(i))) {
reportErrorParsingLine("Invalid character in read bases");
return;
}
}
}
private boolean isValidReadBase(final char base) {
switch (base) {
case 'a':
case 'c':
case 'm':
case 'g':
case 'r':
case 's':
case 'v':
case 't':
case 'w':
case 'y':
case 'h':
case 'k':
case 'd':
case 'b':
case 'n':
case 'A':
case 'C':
case 'M':
case 'G':
case 'R':
case 'S':
case 'V':
case 'T':
case 'W':
case 'Y':
case 'H':
case 'K':
case 'D':
case 'B':
case 'N':
case '.':
case '=':
return true;
default:
return false;
}
}
private void parseTag(final SAMRecord samRecord, final String tag) {
Map.Entry