733 lines
24 KiB
Java
733 lines
24 KiB
Java
/*
|
|
* The Broad Institute
|
|
* SOFTWARE COPYRIGHT NOTICE AGREEMENT
|
|
* This software and its documentation are copyright 2008 by the
|
|
* Broad Institute/Massachusetts Institute of Technology. All rights are reserved.
|
|
*
|
|
* This software is supplied without any warranty or guaranteed support whatsoever.
|
|
* Neither the Broad Institute nor MIT can be responsible for its use, misuse,
|
|
* or functionality.
|
|
*/
|
|
package edu.mit.broad.sam;
|
|
|
|
|
|
import edu.mit.broad.sam.util.StringUtil;
|
|
|
|
import java.util.*;
|
|
|
|
/**
|
|
* Java binding for a SAM file record.
|
|
*/
|
|
public class SAMRecord
|
|
{
|
|
public static final int UNKNOWN_MAPPING_QUALITY = 255;
|
|
public static final int NO_MAPPING_QUALITY = 0;
|
|
public static final String NO_ALIGNMENT_REFERENCE_NAME = "*";
|
|
public static final String NO_ALIGNMENT_CIGAR = "*";
|
|
public static final int NO_ALIGNMENT_START = 0;
|
|
public static final byte[] NULL_SEQUENCE = "*".getBytes();
|
|
public static final byte[] NULL_QUALS = "*".getBytes();
|
|
private static final int READ_PAIRED_FLAG = 0x1;
|
|
private static final int PROPER_PAIR_FLAG = 0x2;
|
|
private static final int READ_UNMAPPED_FLAG = 0x4;
|
|
private static final int MATE_UNMAPPED_FLAG = 0x8;
|
|
private static final int READ_STRAND_FLAG = 0x10;
|
|
private static final int MATE_STRAND_FLAG = 0x20;
|
|
private static final int FIRST_OF_PAIR_FLAG = 0x40;
|
|
private static final int SECOND_OF_PAIR_FLAG = 0x80;
|
|
private static final int NOT_PRIMARY_ALIGNMENT_FLAG = 0x100;
|
|
private static final int READ_FAILS_VENDOR_QUALITY_CHECK_FLAG = 0x200;
|
|
private static final int DUPLICATE_READ_FLAG = 0x400;
|
|
|
|
|
|
private String mReadName = null;
|
|
private byte[] mReadBases = NULL_SEQUENCE;
|
|
private byte[] mBaseQualities = NULL_QUALS;
|
|
private String mReferenceName = NO_ALIGNMENT_REFERENCE_NAME;
|
|
private int mAlignmentStart = NO_ALIGNMENT_START;
|
|
private int mMappingQuality = NO_MAPPING_QUALITY;
|
|
private String mCigarString = NO_ALIGNMENT_CIGAR;
|
|
private Cigar mCigar = null;
|
|
private List<AlignmentBlock> mAlignmentBlocks = null;
|
|
private int mFlags = 0;
|
|
private String mMateReferenceName = NO_ALIGNMENT_REFERENCE_NAME;
|
|
private int mMateAlignmentStart = 0;
|
|
private int mInferredInsertSize = 0;
|
|
private Map<String, Object> mAttributes = null;
|
|
private Integer mReferenceIndex = null;
|
|
private Integer mMateReferenceIndex = null;
|
|
private Integer mIndexingBin = null;
|
|
|
|
// Optional, but handy for looking of reference indices
|
|
private SAMFileHeader mHeader = null;
|
|
|
|
|
|
public SAMRecord() {
|
|
}
|
|
|
|
public String getReadName() {
|
|
return mReadName;
|
|
}
|
|
|
|
/**
|
|
* This method is preferred over getReadName().length(), because for BAMRecord
|
|
* it may be faster.
|
|
* @return length not including a null terminator
|
|
*/
|
|
public int getReadNameLength() {
|
|
return mReadName.length();
|
|
}
|
|
|
|
public void setReadName(final String value) {
|
|
mReadName = value;
|
|
}
|
|
|
|
public String getReadString() {
|
|
return StringUtil.bytesToString(getReadBases());
|
|
}
|
|
|
|
public void setReadString(final String value) {
|
|
mReadBases = StringUtil.stringToBytes(value);
|
|
}
|
|
|
|
// Read bases, as bytes
|
|
public byte[] getReadBases() {
|
|
return mReadBases;
|
|
}
|
|
|
|
public void setReadBases(final byte[] value) {
|
|
mReadBases = value;
|
|
}
|
|
|
|
/**
|
|
* This method is preferred over getReadBases().length, because for BAMRecord it may be faster.
|
|
* @return number of bases in the read
|
|
*/
|
|
public int getReadLength() {
|
|
return getReadBases().length;
|
|
}
|
|
|
|
// Base qualities, encoded as a FASTQ string
|
|
public String getBaseQualityString() {
|
|
return SAMUtils.phredToFastq(getBaseQualities());
|
|
}
|
|
|
|
public void setBaseQualityString(final String value) {
|
|
setBaseQualities(SAMUtils.fastqToPhred(value));
|
|
}
|
|
|
|
public byte[] getBaseQualities() {
|
|
return mBaseQualities;
|
|
}
|
|
|
|
public void setBaseQualities(final byte[] value) {
|
|
mBaseQualities = value;
|
|
}
|
|
|
|
public String getReferenceName() {
|
|
return mReferenceName;
|
|
}
|
|
|
|
public void setReferenceName(final String value) {
|
|
mReferenceName = value;
|
|
mReferenceIndex = null;
|
|
}
|
|
|
|
public Integer getReferenceIndex(final SAMFileHeader header) {
|
|
if (mReferenceIndex == null) {
|
|
if (mReferenceName == null) {
|
|
mReferenceIndex = -1;
|
|
} else if (NO_ALIGNMENT_REFERENCE_NAME.equals(mReferenceName)) {
|
|
mReferenceIndex = -1;
|
|
} else {
|
|
mReferenceIndex = header.getSequenceIndex(mReferenceName);
|
|
}
|
|
}
|
|
return mReferenceIndex;
|
|
}
|
|
|
|
public Integer getReferenceIndex() {
|
|
return getReferenceIndex(mHeader);
|
|
}
|
|
|
|
|
|
public void setReferenceIndex(final int referenceIndex, final SAMFileHeader header) {
|
|
mReferenceIndex = referenceIndex;
|
|
if (mReferenceIndex == -1) {
|
|
mReferenceName = NO_ALIGNMENT_REFERENCE_NAME;
|
|
} else {
|
|
mReferenceName = header.getSequence(referenceIndex).getSequenceName();
|
|
}
|
|
}
|
|
|
|
public void setReferenceIndex(final int referenceIndex) {
|
|
setReferenceIndex(referenceIndex, mHeader);
|
|
}
|
|
|
|
|
|
public String getMateReferenceName() {
|
|
return mMateReferenceName;
|
|
}
|
|
|
|
public void setMateReferenceName(final String mateReferenceName) {
|
|
this.mMateReferenceName = mateReferenceName;
|
|
mMateReferenceIndex = null;
|
|
}
|
|
|
|
public Integer getMateReferenceIndex(final SAMFileHeader header) {
|
|
if (mMateReferenceIndex == null) {
|
|
if (mMateReferenceName == null) {
|
|
mMateReferenceIndex = -1;
|
|
} else if (NO_ALIGNMENT_REFERENCE_NAME.equals(mMateReferenceName)){
|
|
mMateReferenceIndex = -1;
|
|
} else {
|
|
mMateReferenceIndex = header.getSequenceIndex(mMateReferenceName);
|
|
}
|
|
}
|
|
return mMateReferenceIndex;
|
|
}
|
|
|
|
public Integer getMateReferenceIndex() {
|
|
return getMateReferenceIndex(mHeader);
|
|
}
|
|
|
|
public void setMateReferenceIndex(final int referenceIndex, final SAMFileHeader header) {
|
|
mMateReferenceIndex = referenceIndex;
|
|
if (mMateReferenceIndex == -1) {
|
|
mMateReferenceName = NO_ALIGNMENT_REFERENCE_NAME;
|
|
} else {
|
|
mMateReferenceName = header.getSequence(referenceIndex).getSequenceName();
|
|
}
|
|
}
|
|
|
|
public void setMateReferenceIndex(final int referenceIndex) {
|
|
setMateReferenceIndex(referenceIndex, mHeader);
|
|
}
|
|
|
|
|
|
public int getAlignmentStart() {
|
|
return mAlignmentStart;
|
|
}
|
|
|
|
public void setAlignmentStart(final int value) {
|
|
mAlignmentStart = value;
|
|
}
|
|
|
|
public int getAlignmentEnd() {
|
|
final byte[] readBases = getReadBases();
|
|
if (mAlignmentStart == NO_ALIGNMENT_START || Arrays.equals(NULL_SEQUENCE, readBases) || readBases == null) {
|
|
return -1;
|
|
}
|
|
return mAlignmentStart + getCigar().getReferenceLength() - 1;
|
|
}
|
|
|
|
/**
|
|
* Returns the alignment start adjusted for clipped bases. For example if the read
|
|
* has an alignment start of 100 but the first 4 bases were clipped (hard or soft clipped)
|
|
* then this method will return 96.
|
|
*/
|
|
public int getUnclippedStart() {
|
|
int pos = getAlignmentStart();
|
|
|
|
for (final CigarElement cig : getCigar().getCigarElements()) {
|
|
final CigarOperator op = cig.getOperator();
|
|
if (op == CigarOperator.SOFT_CLIP || op == CigarOperator.HARD_CLIP) {
|
|
pos -= cig.getLength();
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return pos;
|
|
}
|
|
|
|
/**
|
|
* Returns the alignment end adjusted for clipped bases. For example if the read
|
|
* has an alignment end of 100 but the last 7 bases were clipped (hard or soft clipped)
|
|
* then this method will return 107.
|
|
*/
|
|
public int getUnclippedEnd() {
|
|
int pos = getAlignmentEnd();
|
|
List<CigarElement> cigs = getCigar().getCigarElements();
|
|
for (int i=cigs.size() - 1; i>=0; --i) {
|
|
final CigarElement cig = cigs.get(i);
|
|
final CigarOperator op = cig.getOperator();
|
|
|
|
if (op == CigarOperator.SOFT_CLIP || op == CigarOperator.HARD_CLIP) {
|
|
pos += cig.getLength();
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return pos;
|
|
}
|
|
|
|
public void setAlignmentEnd(final int value) {
|
|
throw new UnsupportedOperationException("Not supported: setAlignmentEnd");
|
|
}
|
|
|
|
public int getMateAlignmentStart() {
|
|
return mMateAlignmentStart;
|
|
}
|
|
|
|
public void setMateAlignmentStart(final int mateAlignmentStart) {
|
|
this.mMateAlignmentStart = mateAlignmentStart;
|
|
}
|
|
|
|
public int getInferredInsertSize() {
|
|
return mInferredInsertSize;
|
|
}
|
|
|
|
public void setInferredInsertSize(final int inferredInsertSize) {
|
|
this.mInferredInsertSize = inferredInsertSize;
|
|
}
|
|
|
|
public int getMappingQuality() {
|
|
return mMappingQuality;
|
|
}
|
|
|
|
public void setMappingQuality(final int value) {
|
|
mMappingQuality = value;
|
|
}
|
|
|
|
public String getCigarString() {
|
|
if (mCigarString == null && getCigar() != null) {
|
|
mCigarString = TextCigarCodec.getSingleton().encode(getCigar());
|
|
}
|
|
return mCigarString;
|
|
}
|
|
|
|
public void setCigarString(final String value) {
|
|
mCigarString = value;
|
|
mCigar = null;
|
|
}
|
|
|
|
public Cigar getCigar() {
|
|
if (mCigar == null && mCigarString != null) {
|
|
mCigar = TextCigarCodec.getSingleton().decode(mCigarString);
|
|
}
|
|
return mCigar;
|
|
}
|
|
|
|
/**
|
|
* This method is preferred over getCigar().getNumElements(), because for BAMRecord it may be faster.
|
|
* @return number of cigar elements (number + operator) in the cigar string
|
|
*/
|
|
public int getCigarLength() {
|
|
return getCigar().numCigarElements();
|
|
}
|
|
|
|
public void setCigar(final Cigar cigar) {
|
|
this.mCigar = cigar;
|
|
mCigarString = null;
|
|
}
|
|
|
|
public int getFlags() {
|
|
return mFlags;
|
|
}
|
|
|
|
public void setFlags(final int value) {
|
|
mFlags = value;
|
|
}
|
|
|
|
/**
|
|
* the read is paired in sequencing, no matter whether it is mapped in a pair
|
|
*/
|
|
public boolean getReadPairedFlag() {
|
|
return (mFlags & READ_PAIRED_FLAG) != 0;
|
|
}
|
|
|
|
private void requireReadPaired() {
|
|
if (!getReadPairedFlag()) {
|
|
throw new IllegalStateException("Inappropriate call if not paired read");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* the read is mapped in a proper pair (depends on the protocol, normally inferred during alignment)
|
|
*/
|
|
public boolean getProperPairFlag() {
|
|
requireReadPaired();
|
|
return (mFlags & PROPER_PAIR_FLAG) != 0;
|
|
}
|
|
|
|
/**
|
|
* the query sequence itself is unmapped
|
|
*/
|
|
public boolean getReadUnmappedFlag() {
|
|
return (mFlags & READ_UNMAPPED_FLAG) != 0;
|
|
}
|
|
|
|
/**
|
|
* the mate is unmapped
|
|
*/
|
|
public boolean getMateUnmappedFlag() {
|
|
requireReadPaired();
|
|
return (mFlags & MATE_UNMAPPED_FLAG) != 0;
|
|
}
|
|
|
|
/**
|
|
* strand of the query (false for forward; true for reverse strand)
|
|
*/
|
|
public boolean getReadNegativeStrandFlag() {
|
|
return (mFlags & READ_STRAND_FLAG) != 0;
|
|
}
|
|
|
|
/**
|
|
* strand of the mate (false for forward; true for reverse strand)
|
|
*/
|
|
public boolean getMateNegativeStrandFlag() {
|
|
requireReadPaired();
|
|
return (mFlags & MATE_STRAND_FLAG) != 0;
|
|
}
|
|
|
|
/**
|
|
* the read is the first read in a pair
|
|
*/
|
|
public boolean getFirstOfPairFlag() {
|
|
requireReadPaired();
|
|
return (mFlags & FIRST_OF_PAIR_FLAG) != 0;
|
|
}
|
|
|
|
/**
|
|
* the read is the second read in a pair
|
|
*/
|
|
public boolean getSecondOfPairFlag() {
|
|
requireReadPaired();
|
|
return (mFlags & SECOND_OF_PAIR_FLAG) != 0;
|
|
}
|
|
|
|
/**
|
|
* the alignment is not primary (a read having split hits may have multiple primary alignment records)
|
|
*/
|
|
public boolean getNotPrimaryAlignmentFlag() {
|
|
return (mFlags & NOT_PRIMARY_ALIGNMENT_FLAG) != 0;
|
|
}
|
|
|
|
/**
|
|
* the read fails platform/vendor quality checks
|
|
*/
|
|
public boolean getReadFailsVendorQualityCheckFlag() {
|
|
return (mFlags & READ_FAILS_VENDOR_QUALITY_CHECK_FLAG) != 0;
|
|
}
|
|
|
|
/**
|
|
* the read is either a PCR duplicate or an optical duplicate
|
|
*/
|
|
public boolean getDuplicateReadFlag() {
|
|
return (mFlags & DUPLICATE_READ_FLAG) != 0;
|
|
}
|
|
|
|
/**
|
|
* the read is paired in sequencing, no matter whether it is mapped in a pair
|
|
*/
|
|
public void setReadPairedFlag(final boolean flag) {
|
|
setFlag(flag, READ_PAIRED_FLAG);
|
|
}
|
|
|
|
/**
|
|
* the read is mapped in a proper pair (depends on the protocol, normally inferred during alignment)
|
|
*/
|
|
public void setProperPairFlag(final boolean flag) {
|
|
setFlag(flag, PROPER_PAIR_FLAG);
|
|
}
|
|
|
|
/**
|
|
* the query sequence itself is unmapped
|
|
*/
|
|
public void setReadUmappedFlag(final boolean flag) {
|
|
setFlag(flag, READ_UNMAPPED_FLAG);
|
|
}
|
|
|
|
/**
|
|
* the mate is unmapped
|
|
*/
|
|
public void setMateUnmappedFlag(final boolean flag) {
|
|
setFlag(flag, MATE_UNMAPPED_FLAG);
|
|
}
|
|
|
|
/**
|
|
* strand of the query (false for forward; true for reverse strand)
|
|
*/
|
|
public void setReadNegativeStrandFlag(final boolean flag) {
|
|
setFlag(flag, READ_STRAND_FLAG);
|
|
}
|
|
|
|
/**
|
|
* strand of the mate (false for forward; true for reverse strand)
|
|
*/
|
|
public void setMateNegativeStrandFlag(final boolean flag) {
|
|
setFlag(flag, MATE_STRAND_FLAG);
|
|
}
|
|
|
|
/**
|
|
* the read is the first read in a pair
|
|
*/
|
|
public void setFirstOfPairFlag(final boolean flag) {
|
|
setFlag(flag, FIRST_OF_PAIR_FLAG);
|
|
}
|
|
|
|
/**
|
|
* the read is the second read in a pair
|
|
*/
|
|
public void setSecondOfPairFlag(final boolean flag) {
|
|
setFlag(flag, SECOND_OF_PAIR_FLAG);
|
|
}
|
|
|
|
/**
|
|
* the alignment is not primary (a read having split hits may have multiple primary alignment records)
|
|
*/
|
|
public void setNotPrimaryAlignmentFlag(final boolean flag) {
|
|
setFlag(flag, NOT_PRIMARY_ALIGNMENT_FLAG);
|
|
}
|
|
|
|
/**
|
|
* the read fails platform/vendor quality checks
|
|
*/
|
|
public void setReadFailsVendorQualityCheckFlag(final boolean flag) {
|
|
setFlag(flag, READ_FAILS_VENDOR_QUALITY_CHECK_FLAG);
|
|
}
|
|
|
|
/**
|
|
* the read is either a PCR duplicate or an optical duplicate
|
|
*/
|
|
public void setDuplicateReadFlag(final boolean flag) {
|
|
setFlag(flag, DUPLICATE_READ_FLAG);
|
|
}
|
|
|
|
private void setFlag(final boolean flag, final int bit) {
|
|
if (flag) {
|
|
mFlags |= bit;
|
|
} else {
|
|
mFlags &= ~bit;
|
|
}
|
|
}
|
|
|
|
public Object getAttribute(final String key) {
|
|
if (mAttributes == null) {
|
|
return null;
|
|
}
|
|
return mAttributes.get(key);
|
|
}
|
|
|
|
public void setAttribute(final String key, final Object value) {
|
|
if (mAttributes == null) {
|
|
mAttributes = new LinkedHashMap<String, Object>();
|
|
}
|
|
mAttributes.put(key, value);
|
|
}
|
|
|
|
public Set<Map.Entry<String, Object>> getAttributes() {
|
|
if (mAttributes == null) {
|
|
return null;
|
|
}
|
|
return mAttributes.entrySet();
|
|
}
|
|
|
|
public Integer getIndexingBin() {
|
|
return mIndexingBin;
|
|
}
|
|
|
|
public void setIndexingBin(final Integer mIndexingBin) {
|
|
this.mIndexingBin = mIndexingBin;
|
|
}
|
|
|
|
public SAMFileHeader getHeader() {
|
|
return mHeader;
|
|
}
|
|
|
|
public void setHeader(final SAMFileHeader mHeader) {
|
|
this.mHeader = mHeader;
|
|
}
|
|
|
|
/**
|
|
* If this record has a valid binary representation of the variable-length portion of a binary record stored,
|
|
* return that byte array, otherwise return null. This will never be true for SAMRecords. It will be true
|
|
* for BAMRecords that have not been eagerDecoded(), and for which none of the data in the variable-length
|
|
* portion has been changed.
|
|
*/
|
|
public byte[] getVariableBinaryRepresentation() {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Depending on the concrete implementation, the binary file size of attributes may be known without
|
|
* computing them all.
|
|
* @return binary file size of attribute, if known, else -1
|
|
*/
|
|
public int getAttributesBinarySize() {
|
|
return -1;
|
|
}
|
|
|
|
public String format() {
|
|
final StringBuilder buffer = new StringBuilder();
|
|
addField(buffer, getReadName(), null, null);
|
|
addField(buffer, getFlags(), null, null);
|
|
addField(buffer, getReferenceName(), null, "*");
|
|
addField(buffer, getAlignmentStart(), 0, "*");
|
|
addField(buffer, getMappingQuality(), 0, "0");
|
|
addField(buffer, getCigarString(), null, "*");
|
|
addField(buffer, getMateReferenceName(), null, "*");
|
|
addField(buffer, getMateAlignmentStart(), 0, "*");
|
|
addField(buffer, getInferredInsertSize(), 0, "*");
|
|
addField(buffer, getReadString(), null, "*");
|
|
addField(buffer, getBaseQualityString(), null, "*");
|
|
if (mAttributes != null) {
|
|
for (final Map.Entry<String, Object> entry : getAttributes()) {
|
|
addField(buffer, formatTagValue(entry.getKey(), entry.getValue()));
|
|
}
|
|
}
|
|
return buffer.toString();
|
|
}
|
|
|
|
private void addField(final StringBuilder buffer, final Object value, final Object defaultValue, final String defaultString) {
|
|
if (safeEquals(value, defaultValue)) {
|
|
addField(buffer, defaultString);
|
|
} else if (value == null) {
|
|
addField(buffer, "");
|
|
} else {
|
|
addField(buffer, value.toString());
|
|
}
|
|
}
|
|
|
|
private void addField(final StringBuilder buffer, final String field) {
|
|
if (buffer.length() > 0) {
|
|
buffer.append('\t');
|
|
}
|
|
buffer.append(field);
|
|
}
|
|
|
|
private String formatTagValue(final String key, final Object value) {
|
|
if (value == null || value instanceof String) {
|
|
return key + ":Z:" + value;
|
|
} else if (value instanceof Integer) {
|
|
return key + ":i:" + value;
|
|
} else if (value instanceof Character) {
|
|
return key + ":A:" + value;
|
|
} else if (value instanceof Float) {
|
|
return key + ":f:" + value;
|
|
} else if (value instanceof byte[]) {
|
|
return key + ":H:" + SAMUtils.bytesToHexString((byte[]) value);
|
|
} else {
|
|
throw new RuntimeException("Unexpected value type for key " + key +
|
|
": " + value);
|
|
}
|
|
}
|
|
|
|
private boolean safeEquals(final Object o1, final Object o2) {
|
|
if (o1 == o2) {
|
|
return true;
|
|
} else if (o1 == null || o2 == null) {
|
|
return false;
|
|
} else {
|
|
return o1.equals(o2);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Force all lazily-initialized data members to be initialized. If a subclass overrides this method,
|
|
* typically it should also call super method.
|
|
*/
|
|
protected void eagerDecode() {
|
|
getCigar();
|
|
getCigarString();
|
|
}
|
|
|
|
/**
|
|
* Returns blocks of the read sequence that have been aligned directly to the
|
|
* reference sequence. Note that clipped portions of the read and inserted and
|
|
* deleted bases (vs. the reference) are not represented in the alignment blocks.
|
|
*/
|
|
public List<AlignmentBlock> getAlignmentBlocks() {
|
|
if (this.mAlignmentBlocks != null) return this.mAlignmentBlocks;
|
|
|
|
final Cigar cigar = getCigar();
|
|
if (cigar == null) return Collections.emptyList();
|
|
|
|
|
|
this.mAlignmentBlocks = new ArrayList<AlignmentBlock>();
|
|
int readBase = 1;
|
|
int refBase = getAlignmentStart();
|
|
|
|
for (final CigarElement e : cigar.getCigarElements()) {
|
|
switch (e.getOperator()) {
|
|
case H : break; // ignore hard clips
|
|
case P : break; // ignore pads
|
|
case S : readBase += e.getLength(); break; // soft clip read bases
|
|
case N : refBase += e.getLength(); break; // reference skip
|
|
case D : refBase += e.getLength(); break;
|
|
case I : readBase += e.getLength(); break;
|
|
case M :
|
|
final int length = e.getLength();
|
|
this.mAlignmentBlocks.add(new AlignmentBlock(readBase, refBase, length));
|
|
readBase += length;
|
|
refBase += length;
|
|
break;
|
|
default : throw new IllegalStateException("Case statement didn't deal with cigar op: " + e.getOperator());
|
|
}
|
|
}
|
|
|
|
return this.mAlignmentBlocks;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(final Object o) {
|
|
if (this == o) return true;
|
|
if (!(o instanceof SAMRecord)) return false;
|
|
|
|
final SAMRecord samRecord = (SAMRecord) o;
|
|
eagerDecode();
|
|
samRecord.eagerDecode();
|
|
|
|
if (mAlignmentStart != samRecord.mAlignmentStart) return false;
|
|
if (mFlags != samRecord.mFlags) return false;
|
|
if (mInferredInsertSize != samRecord.mInferredInsertSize) return false;
|
|
if (mMappingQuality != samRecord.mMappingQuality) return false;
|
|
if (mMateAlignmentStart != samRecord.mMateAlignmentStart) return false;
|
|
if (mAttributes != null ? !mAttributes.equals(samRecord.mAttributes) : samRecord.mAttributes != null)
|
|
return false;
|
|
if (!Arrays.equals(mBaseQualities, samRecord.mBaseQualities)) return false;
|
|
if (mCigar != null ? !mCigar.equals(samRecord.mCigar) : samRecord.mCigar != null)
|
|
return false;
|
|
if (mIndexingBin != null ? !mIndexingBin.equals(samRecord.mIndexingBin) : samRecord.mIndexingBin != null)
|
|
return false;
|
|
if (mMateReferenceIndex != null ? !mMateReferenceIndex.equals(samRecord.mMateReferenceIndex) : samRecord.mMateReferenceIndex != null)
|
|
return false;
|
|
if (mMateReferenceName != null ? !mMateReferenceName.equals(samRecord.mMateReferenceName) : samRecord.mMateReferenceName != null)
|
|
return false;
|
|
if (!Arrays.equals(mReadBases, samRecord.mReadBases)) return false;
|
|
if (mReadName != null ? !mReadName.equals(samRecord.mReadName) : samRecord.mReadName != null) return false;
|
|
if (mReferenceIndex != null ? !mReferenceIndex.equals(samRecord.mReferenceIndex) : samRecord.mReferenceIndex != null)
|
|
return false;
|
|
if (mReferenceName != null ? !mReferenceName.equals(samRecord.mReferenceName) : samRecord.mReferenceName != null)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
eagerDecode();
|
|
int result = mReadName != null ? mReadName.hashCode() : 0;
|
|
result = 31 * result + (mReadBases != null ? Arrays.hashCode(mReadBases) : 0);
|
|
result = 31 * result + (mBaseQualities != null ? Arrays.hashCode(mBaseQualities) : 0);
|
|
result = 31 * result + (mReferenceName != null ? mReferenceName.hashCode() : 0);
|
|
result = 31 * result + mAlignmentStart;
|
|
result = 31 * result + mMappingQuality;
|
|
result = 31 * result + (mCigarString != null ? mCigarString.hashCode() : 0);
|
|
result = 31 * result + mFlags;
|
|
result = 31 * result + (mMateReferenceName != null ? mMateReferenceName.hashCode() : 0);
|
|
result = 31 * result + mMateAlignmentStart;
|
|
result = 31 * result + mInferredInsertSize;
|
|
result = 31 * result + (mAttributes != null ? mAttributes.hashCode() : 0);
|
|
result = 31 * result + (mReferenceIndex != null ? mReferenceIndex.hashCode() : 0);
|
|
result = 31 * result + (mMateReferenceIndex != null ? mMateReferenceIndex.hashCode() : 0);
|
|
result = 31 * result + (mIndexingBin != null ? mIndexingBin.hashCode() : 0);
|
|
return result;
|
|
}
|
|
}
|
|
|