GATKSamRecord now produced by SAMFileReaders by default

-- Removed all of the unnecessary caching operations in GATKSAMRecord
-- GATKSAMRecord renamed to GATKSamRecord for consistency

public/java/src/org/broadinstitute/sting/gatk/datasources/reads/SAMDataSource.java

@@ -647,7 +647,9 @@ public class SAMDataSource {
                                                         BAQ.QualityMode qmode,
                                                         IndexedFastaSequenceFile refReader,
                                                         byte defaultBaseQualities) {
-        wrappedIterator = new ReadFormattingIterator(wrappedIterator, useOriginalBaseQualities, defaultBaseQualities);
+        if ( useOriginalBaseQualities || defaultBaseQualities >= 0 )
+            // only wrap if we are replacing the original qualitiies or using a default base quality
+            wrappedIterator = new ReadFormattingIterator(wrappedIterator, useOriginalBaseQualities, defaultBaseQualities);
 
         // NOTE: this (and other filtering) should be done before on-the-fly sorting
         //  as there is no reason to sort something that we will end of throwing away

public/java/src/org/broadinstitute/sting/gatk/iterators/ReadFormattingIterator.java

@@ -2,7 +2,6 @@ package org.broadinstitute.sting.gatk.iterators;
 
 import net.sf.samtools.SAMRecord;
 import org.apache.log4j.Logger;
-import org.broadinstitute.sting.utils.sam.GATKSAMRecord;
 
 /**
  * An iterator which does post-processing of a read, including potentially wrapping
@@ -78,7 +77,30 @@ public class ReadFormattingIterator implements StingSAMIterator {
      *         no next exists.
      */
     public SAMRecord next() {
-        return new GATKSAMRecord(wrappedIterator.next(), useOriginalBaseQualities, defaultBaseQualities);
+        SAMRecord rec = wrappedIterator.next();
+
+        // if we are using default quals, check if we need them, and add if necessary.
+        // 1. we need if reads are lacking or have incomplete quality scores
+        // 2. we add if defaultBaseQualities has a positive value
+        if (defaultBaseQualities >= 0) {
+            byte reads [] = rec.getReadBases();
+            byte quals [] = rec.getBaseQualities();
+            if (quals == null || quals.length < reads.length) {
+                byte new_quals [] = new byte [reads.length];
+                for (int i=0; i<reads.length; i++)
+                    new_quals[i] = defaultBaseQualities;
+                rec.setBaseQualities(new_quals);
+            }
+        }
+
+        // if we are using original quals, set them now if they are present in the record
+        if ( useOriginalBaseQualities ) {
+            byte[] originalQuals = rec.getOriginalBaseQualities();
+            if ( originalQuals != null )
+                rec.setBaseQualities(originalQuals);
+        }
+
+        return rec;
     }
 
     /**

public/java/src/org/broadinstitute/sting/gatk/walkers/genotyper/IndelGenotypeLikelihoodsCalculationModel.java

@@ -30,18 +30,16 @@ import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
 import org.broadinstitute.sting.gatk.contexts.AlignmentContextUtils;
 import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
 import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
-import org.broadinstitute.sting.gatk.walkers.indels.HaplotypeIndelErrorModel;
 import org.broadinstitute.sting.gatk.walkers.indels.PairHMMIndelErrorModel;
 import org.broadinstitute.sting.utils.BaseUtils;
 import org.broadinstitute.sting.utils.GenomeLoc;
 import org.broadinstitute.sting.utils.Haplotype;
-import org.broadinstitute.sting.utils.collections.Pair;
 import org.broadinstitute.sting.utils.exceptions.StingException;
 import org.broadinstitute.sting.utils.pileup.ExtendedEventPileupElement;
 import org.broadinstitute.sting.utils.pileup.PileupElement;
 import org.broadinstitute.sting.utils.pileup.ReadBackedExtendedEventPileup;
 import org.broadinstitute.sting.utils.pileup.ReadBackedPileup;
-import org.broadinstitute.sting.utils.sam.GATKSAMRecord;
+import org.broadinstitute.sting.utils.sam.GATKSamRecord;
 import org.broadinstitute.sting.utils.sam.ReadUtils;
 import org.broadinstitute.sting.utils.variantcontext.Allele;
 import org.broadinstitute.sting.utils.variantcontext.VariantContext;
@@ -127,7 +125,7 @@ public class IndelGenotypeLikelihoodsCalculationModel extends GenotypeLikelihood
 
             for ( ExtendedEventPileupElement p : indelPileup.toExtendedIterable() ) {
                 //SAMRecord read = p.getRead();
-                 GATKSAMRecord read = ReadUtils.hardClipAdaptorSequence(p.getRead());
+                 GATKSamRecord read = ReadUtils.hardClipAdaptorSequence(p.getRead());
                 if (read == null)
                     continue;     
                 if(ReadUtils.is454Read(read)) {

public/java/src/org/broadinstitute/sting/gatk/walkers/recalibration/CountCovariatesWalker.java

@@ -41,7 +41,7 @@ import org.broadinstitute.sting.utils.collections.NestedHashMap;
 import org.broadinstitute.sting.utils.exceptions.DynamicClassResolutionException;
 import org.broadinstitute.sting.utils.exceptions.UserException;
 import org.broadinstitute.sting.utils.pileup.PileupElement;
-import org.broadinstitute.sting.utils.sam.GATKSAMRecord;
+import org.broadinstitute.sting.utils.sam.GATKSamRecord;
 
 import java.io.PrintStream;
 import java.util.ArrayList;
@@ -352,7 +352,7 @@ public class CountCovariatesWalker extends LocusWalker<CountCovariatesWalker.Cou
         if( tracker.getValues(knownSites).size() == 0 ) { // If something here is in one of the knownSites tracks then skip over it, otherwise proceed
             // For each read at this locus
             for( final PileupElement p : context.getBasePileup() ) {
-                final GATKSAMRecord gatkRead = (GATKSAMRecord) p.getRead();
+                final GATKSamRecord gatkRead = (GATKSamRecord) p.getRead();
                 int offset = p.getOffset();
 
                 if( gatkRead.containsTemporaryAttribute( SKIP_RECORD_ATTRIBUTE  ) ) {
@@ -445,7 +445,7 @@ public class CountCovariatesWalker extends LocusWalker<CountCovariatesWalker.Cou
      * @param offset The offset in the read for this locus
      * @param refBase The reference base at this locus
      */
-    private void updateDataFromRead(CountedData counter, final GATKSAMRecord gatkRead, final int offset, final byte refBase) {
+    private void updateDataFromRead(CountedData counter, final GATKSamRecord gatkRead, final int offset, final byte refBase) {
         final Object[][] covars = (Comparable[][]) gatkRead.getTemporaryAttribute(COVARS_ATTRIBUTE);
         final Object[] key = covars[offset];
 

public/java/src/org/broadinstitute/sting/gatk/walkers/recalibration/RecalDataManager.java

@@ -35,7 +35,7 @@ import org.broadinstitute.sting.utils.collections.NestedHashMap;
 import org.broadinstitute.sting.utils.exceptions.ReviewedStingException;
 import org.broadinstitute.sting.utils.exceptions.UserException;
 import org.broadinstitute.sting.utils.sam.AlignmentUtils;
-import org.broadinstitute.sting.utils.sam.GATKSAMRecord;
+import org.broadinstitute.sting.utils.sam.GATKSamRecord;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -243,7 +243,7 @@ public class RecalDataManager {
                 // There is no readGroup so defaulting to these values
                 readGroup = new SAMReadGroupRecord( RAC.DEFAULT_READ_GROUP );
                 readGroup.setPlatform( RAC.DEFAULT_PLATFORM );
-                ((GATKSAMRecord)read).setReadGroup( readGroup );
+                ((GATKSamRecord)read).setReadGroup( readGroup );
             } else {
                 throw new UserException.MalformedBAM(read, "The input .bam file contains reads with no read group. First observed at read with name = " + read.getReadName() );
             }
@@ -253,7 +253,7 @@ public class RecalDataManager {
             final String oldPlatform = readGroup.getPlatform();
             readGroup = new SAMReadGroupRecord( RAC.FORCE_READ_GROUP );
             readGroup.setPlatform( oldPlatform );
-            ((GATKSAMRecord)read).setReadGroup( readGroup );
+            ((GATKSamRecord)read).setReadGroup( readGroup );
         }
 
         if( RAC.FORCE_PLATFORM != null && (readGroup.getPlatform() == null || !readGroup.getPlatform().equals(RAC.FORCE_PLATFORM))) {
@@ -572,7 +572,7 @@ public class RecalDataManager {
      * value for the ith position in the read and the jth covariate in
      * reqeustedCovariates list.
      */
-     public static Comparable[][] computeCovariates(final GATKSAMRecord gatkRead, final List<Covariate> requestedCovariates) {
+     public static Comparable[][] computeCovariates(final GATKSamRecord gatkRead, final List<Covariate> requestedCovariates) {
          //compute all covariates for this read
          final List<Covariate> requestedCovariatesRef = requestedCovariates;
          final int numRequestedCovariates = requestedCovariatesRef.size();

public/java/src/org/broadinstitute/sting/gatk/walkers/recalibration/TableRecalibrationWalker.java

@@ -39,7 +39,7 @@ import org.broadinstitute.sting.utils.classloader.PluginManager;
 import org.broadinstitute.sting.utils.collections.NestedHashMap;
 import org.broadinstitute.sting.utils.exceptions.DynamicClassResolutionException;
 import org.broadinstitute.sting.utils.exceptions.UserException;
-import org.broadinstitute.sting.utils.sam.GATKSAMRecord;
+import org.broadinstitute.sting.utils.sam.GATKSamRecord;
 import org.broadinstitute.sting.utils.text.TextFormattingUtils;
 import org.broadinstitute.sting.utils.text.XReadLines;
 
@@ -398,7 +398,7 @@ public class TableRecalibrationWalker extends ReadWalker<SAMRecord, SAMFileWrite
 
         //compute all covariate values for this read
         final Comparable[][] covariateValues_offset_x_covar =
-            RecalDataManager.computeCovariates((GATKSAMRecord) read, requestedCovariates);
+            RecalDataManager.computeCovariates((GATKSamRecord) read, requestedCovariates);
 
         // For each base in the read
         for( int offset = 0; offset < read.getReadLength(); offset++ ) {

public/java/src/org/broadinstitute/sting/utils/sam/GATKSAMRecord.java

@@ -1,12 +1,8 @@
 package org.broadinstitute.sting.utils.sam;
 
 import net.sf.samtools.*;
-import org.broadinstitute.sting.utils.exceptions.ReviewedStingException;
-import org.broadinstitute.sting.utils.exceptions.UserException;
 
-import java.lang.reflect.Method;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 
 /**
@@ -26,70 +22,35 @@ import java.util.Map;
  *                        done.  Hopefully SAMRecord will become an interface and
  *                        this will eventually be fixed.
  */
-public class GATKSAMRecord extends SAMRecord {
+public class GATKSamRecord extends BAMRecord {
-
-    // the underlying SAMRecord which we are wrapping
-    private final SAMRecord mRecord;
-
     // the SAMRecord data we're caching
     private String mReadString = null;
     private SAMReadGroupRecord mReadGroup = null;
-    private boolean mNegativeStrandFlag;
-    private boolean mUnmappedFlag;
-    private Boolean mSecondOfPairFlag = null;
 
     // because some values can be null, we don't want to duplicate effort
     private boolean retrievedReadGroup = false;
 
-    /** A private cache for the reduced read quality.  Null indicates the value hasn't be fetched yet or isn't available */
-    private boolean lookedUpReducedReadQuality = false;
-    private Integer reducedReadQuality;
-
     // These temporary attributes were added here to make life easier for
     // certain algorithms by providing a way to label or attach arbitrary data to
     // individual GATKSAMRecords.
     // These attributes exist in memory only, and are never written to disk.
     private Map<Object, Object> temporaryAttributes;
 
-    public GATKSAMRecord(SAMRecord record, boolean useOriginalBaseQualities, byte defaultBaseQualities) {
+    public GATKSamRecord(final SAMFileHeader header,
-        super(null); // it doesn't matter - this isn't used
+                         final int referenceSequenceIndex,
-        if ( record == null )
+                         final int alignmentStart,
-            throw new IllegalArgumentException("The SAMRecord argument cannot be null");
+                         final short readNameLength,
-        mRecord = record;
+                         final short mappingQuality,
-
+                         final int indexingBin,
-        mNegativeStrandFlag = mRecord.getReadNegativeStrandFlag();
+                         final int cigarLen,
-        mUnmappedFlag = mRecord.getReadUnmappedFlag();
+                         final int flags,
-
+                         final int readLen,
-        // because attribute methods are declared to be final (and we can't overload them),
+                         final int mateReferenceSequenceIndex,
-        // we need to actually set all of the attributes here
+                         final int mateAlignmentStart,
-        List<SAMTagAndValue> attributes = record.getAttributes();
+                         final int insertSize,
-        for ( SAMTagAndValue attribute : attributes )
+                         final byte[] variableLengthBlock) {
-            setAttribute(attribute.tag, attribute.value);
+        super(header, referenceSequenceIndex, alignmentStart, readNameLength, mappingQuality, indexingBin, cigarLen,
-
+                flags, readLen, mateReferenceSequenceIndex, mateAlignmentStart, insertSize, variableLengthBlock);
-        // if we are using default quals, check if we need them, and add if necessary.
-        // 1. we need if reads are lacking or have incomplete quality scores
-        // 2. we add if defaultBaseQualities has a positive value
-        if (defaultBaseQualities >= 0) {
-            byte reads [] = record.getReadBases();
-            byte quals [] = record.getBaseQualities();
-            if (quals == null || quals.length < reads.length) {
-                byte new_quals [] = new byte [reads.length];
-                for (int i=0; i<reads.length; i++)
-                    new_quals[i] = defaultBaseQualities;
-                record.setBaseQualities(new_quals);
-            }
-        }
-
-        // if we are using original quals, set them now if they are present in the record
-        if ( useOriginalBaseQualities ) {
-            byte[] originalQuals = mRecord.getOriginalBaseQualities();
-            if ( originalQuals != null )
-                mRecord.setBaseQualities(originalQuals);
-        }
-
-        // sanity check that the lengths of the base and quality strings are equal
-        if ( getBaseQualities().length  != getReadLength() )
-            throw new UserException.MalformedBAM(this, String.format("Error: the number of base qualities does not match the number of bases in %s.", mRecord.getReadName()));
     }
 
     ///////////////////////////////////////////////////////////////////////////////
@@ -98,18 +59,18 @@ public class GATKSAMRecord extends SAMRecord {
 
     public String getReadString() {
         if ( mReadString == null )
-            mReadString = mRecord.getReadString();
+            mReadString = super.getReadString();
         return mReadString;
     }
 
     public void setReadString(String s) {
-        mRecord.setReadString(s);
+        super.setReadString(s);
         mReadString = s;
     }
 
     public SAMReadGroupRecord getReadGroup() {
         if ( !retrievedReadGroup ) {
-            SAMReadGroupRecord tempReadGroup = mRecord.getReadGroup();
+            SAMReadGroupRecord tempReadGroup = super.getReadGroup();
             mReadGroup = (tempReadGroup == null ? tempReadGroup : new GATKSAMReadGroupRecord(tempReadGroup));
             retrievedReadGroup = true;
         }
@@ -120,38 +81,6 @@ public class GATKSAMRecord extends SAMRecord {
         mReadGroup = record;
     }
 
-    public boolean getReadUnmappedFlag() {
-        return mUnmappedFlag;
-    }
-
-    public void setReadUnmappedFlag(boolean b) {
-        mRecord.setReadUnmappedFlag(b);
-        mUnmappedFlag = b;
-    }
-
-    public boolean getReadNegativeStrandFlag() {
-        return mNegativeStrandFlag;
-    }
-
-    public void setReadNegativeStrandFlag(boolean b) {
-        mRecord.setReadNegativeStrandFlag(b);
-        mNegativeStrandFlag = b;
-    }
-
-    public boolean getSecondOfPairFlag() {
-        if( mSecondOfPairFlag == null ) {
-            //not done in constructor because this method can't be called for
-            //all SAMRecords.
-            mSecondOfPairFlag = mRecord.getSecondOfPairFlag();
-        }
-        return mSecondOfPairFlag;
-    }
-
-    public void setSecondOfPairFlag(boolean b) {
-        mRecord.setSecondOfPairFlag(b);
-        mSecondOfPairFlag = b;
-    }
-
     /**
      * Checks whether an attribute has been set for the given key.
      *
@@ -205,269 +134,14 @@ public class GATKSAMRecord extends SAMRecord {
         return null;
     }
 
-    /**
-     * Removes the attribute that has the given key.
-     *
-     * Temporary attributes provide a way to label or attach arbitrary data to
-     * individual GATKSAMRecords. These attributes exist in memory only,
-     * and are never written to disk.
-     *
-     * @param key key
-     * @return The value that was associated with this key, or null.
-     */
-    public Object removeTemporaryAttribute(Object key) {
-         if(temporaryAttributes != null) {
-             return temporaryAttributes.remove(key);
-         }
-         return null;
-    }
-
-    /////////////////////////////////////////////////////////////////////////////////
-    // *** The following methods just call the appropriate method in the record ***//
-    /////////////////////////////////////////////////////////////////////////////////
-
-    public String getReadName() { return mRecord.getReadName(); }
-
-    public int getReadNameLength() { return mRecord.getReadNameLength(); }
-
-    public void setReadName(String s) { mRecord.setReadName(s); }
-
-    public byte[] getReadBases() { return mRecord.getReadBases(); }
-
-    public void setReadBases(byte[] bytes) { mRecord.setReadBases(bytes); }
-
-    public int getReadLength() { return mRecord.getReadLength(); }
-
-    public byte[] getBaseQualities() { return mRecord.getBaseQualities(); }
-
-    public void setBaseQualities(byte[] bytes) { mRecord.setBaseQualities(bytes); }
-
-    public String getBaseQualityString() { return mRecord.getBaseQualityString(); }
-
-    public void setBaseQualityString(String s) { mRecord.setBaseQualityString(s); }
-
-    public byte[] getOriginalBaseQualities() { return mRecord.getOriginalBaseQualities(); }
-
-    public void setOriginalBaseQualities(byte[] bytes) { mRecord.setOriginalBaseQualities(bytes); }
-
-    public String getReferenceName() { return mRecord.getReferenceName(); }
-
-    public void setReferenceName(String s) { mRecord.setReferenceName(s); }
-
-    public Integer getReferenceIndex() { return mRecord.getReferenceIndex(); }
-
-    public void setReferenceIndex(int i) { mRecord.setReferenceIndex(i); }
-
-    public String getMateReferenceName() { return mRecord.getMateReferenceName(); }
-
-    public void setMateReferenceName(String s) { mRecord.setMateReferenceName(s); }
-
-    public Integer getMateReferenceIndex() { return mRecord.getMateReferenceIndex(); }
-
-    public void setMateReferenceIndex(int i) { mRecord.setMateReferenceIndex(i); }
-
-    public int getAlignmentStart() { return mRecord.getAlignmentStart(); }
-
-    public void setAlignmentStart(int i) { mRecord.setAlignmentStart(i); }
-
-    public int getAlignmentEnd() { return mRecord.getAlignmentEnd(); }
-
-    public int getUnclippedStart() { return mRecord.getUnclippedStart(); }
-
-    public int getUnclippedEnd() { return mRecord.getUnclippedEnd(); }
-
-    public void setAlignmentEnd(int i) { mRecord.setAlignmentEnd(i); }
-
-    public int getMateAlignmentStart() { return mRecord.getMateAlignmentStart(); }
-
-    public void setMateAlignmentStart(int i) { mRecord.setMateAlignmentStart(i); }
-
-    public int getInferredInsertSize() { return mRecord.getInferredInsertSize(); }
-
-    public void setInferredInsertSize(int i) { mRecord.setInferredInsertSize(i); }
-
-    public int getMappingQuality() { return mRecord.getMappingQuality(); }
-
-    public void setMappingQuality(int i) { mRecord.setMappingQuality(i); }
-
-    public String getCigarString() { return mRecord.getCigarString(); }
-
-    public void setCigarString(String s) { mRecord.setCigarString(s); }
-
-    public Cigar getCigar() { return mRecord.getCigar(); }
-
-    public int getCigarLength() { return mRecord.getCigarLength(); }
-
-    public void setCigar(Cigar cigar) { mRecord.setCigar(cigar); }
-
-    public int getFlags() { return mRecord.getFlags(); }
-
-    public void setFlags(int i) { mRecord.setFlags(i); }
-
-    public boolean getReadPairedFlag() { return mRecord.getReadPairedFlag(); }
-
-    public boolean getProperPairFlag() { return mRecord.getProperPairFlag(); }
-
-    public boolean getMateUnmappedFlag() { return mRecord.getMateUnmappedFlag(); }
-
-    public boolean getMateNegativeStrandFlag() { return mRecord.getMateNegativeStrandFlag(); }
-
-    public boolean getFirstOfPairFlag() { return mRecord.getFirstOfPairFlag(); }
-
-    public boolean getNotPrimaryAlignmentFlag() { return mRecord.getNotPrimaryAlignmentFlag(); }
-
-    public boolean getReadFailsVendorQualityCheckFlag() { return mRecord.getReadFailsVendorQualityCheckFlag(); }
-
-    public boolean getDuplicateReadFlag() { return mRecord.getDuplicateReadFlag(); }
-
-    public void setReadPairedFlag(boolean b) { mRecord.setReadPairedFlag(b); }
-
-    public void setProperPairFlag(boolean b) { mRecord.setProperPairFlag(b); }
-
-    public void setMateUnmappedFlag(boolean b) { mRecord.setMateUnmappedFlag(b); }
-
-    public void setMateNegativeStrandFlag(boolean b) { mRecord.setMateNegativeStrandFlag(b); }
-
-    public void setFirstOfPairFlag(boolean b) { mRecord.setFirstOfPairFlag(b); }
-
-    public void setNotPrimaryAlignmentFlag(boolean b) { mRecord.setNotPrimaryAlignmentFlag(b); }
-
-    public void setReadFailsVendorQualityCheckFlag(boolean b) { mRecord.setReadFailsVendorQualityCheckFlag(b); }
-
-    public void setDuplicateReadFlag(boolean b) { mRecord.setDuplicateReadFlag(b); }
-
-    public net.sf.samtools.SAMFileReader.ValidationStringency getValidationStringency() { return mRecord.getValidationStringency(); }
-
-    public void setValidationStringency(net.sf.samtools.SAMFileReader.ValidationStringency validationStringency) { mRecord.setValidationStringency(validationStringency); }
-
-    public Object getAttribute(final String tag) { return mRecord.getAttribute(tag); }
-
-    public Integer getIntegerAttribute(final String tag) {
-        if ( tag == ReadUtils.REDUCED_READ_QUALITY_TAG ) {
-            if ( ! lookedUpReducedReadQuality ) {
-                lookedUpReducedReadQuality = true;
-                reducedReadQuality = mRecord.getIntegerAttribute(tag);
-            }
-            return reducedReadQuality;
-        } else {
-            return mRecord.getIntegerAttribute(tag);
-        }
-    }
-
-    public Short getShortAttribute(final String tag) { return mRecord.getShortAttribute(tag); }
-
-    public Byte getByteAttribute(final String tag) { return mRecord.getByteAttribute(tag); }
-
-    public String getStringAttribute(final String tag) { return mRecord.getStringAttribute(tag); }
-
-    public Character getCharacterAttribute(final String tag) { return mRecord.getCharacterAttribute(tag); }
-
-    public Float getFloatAttribute(final String tag) { return mRecord.getFloatAttribute(tag); }
-
-    public byte[] getByteArrayAttribute(final String tag) { return mRecord.getByteArrayAttribute(tag); }
-
-    protected Object getAttribute(final short tag) {
-        Object attribute;
-        try {
-            Method method = mRecord.getClass().getDeclaredMethod("getAttribute",Short.TYPE);
-            method.setAccessible(true);
-            attribute = method.invoke(mRecord,tag);
-        }
-        catch(Exception ex) {
-            throw new ReviewedStingException("Unable to invoke getAttribute method",ex);
-        }
-        return attribute;
-    }
-
-    public void setAttribute(final String tag, final Object value) { mRecord.setAttribute(tag,value); }
-
-    protected void setAttribute(final short tag, final Object value) {
-        try {
-            Method method = mRecord.getClass().getDeclaredMethod("setAttribute",Short.TYPE,Object.class);
-            method.setAccessible(true);
-            method.invoke(mRecord,tag,value);
-        }
-        catch(Exception ex) {
-            throw new ReviewedStingException("Unable to invoke setAttribute method",ex);
-        }
-    }
-
-    public void clearAttributes() { mRecord.clearAttributes(); }
-
-    protected void setAttributes(final SAMBinaryTagAndValue attributes) {
-        try {
-            Method method = mRecord.getClass().getDeclaredMethod("setAttributes",SAMBinaryTagAndValue.class);
-            method.setAccessible(true);
-            method.invoke(mRecord,attributes);
-        }
-        catch(Exception ex) {
-            throw new ReviewedStingException("Unable to invoke setAttributes method",ex);
-        }
-   }
-
-    protected SAMBinaryTagAndValue getBinaryAttributes() {
-        SAMBinaryTagAndValue binaryAttributes;
-        try {
-            Method method = mRecord.getClass().getDeclaredMethod("getBinaryAttributes");
-            method.setAccessible(true);
-            binaryAttributes = (SAMBinaryTagAndValue)method.invoke(mRecord);
-        }
-        catch(Exception ex) {
-            throw new ReviewedStingException("Unable to invoke getBinaryAttributes method",ex);
-        }
-        return binaryAttributes;
-    }
-
-    public List<SAMTagAndValue> getAttributes() { return mRecord.getAttributes(); }
-
-    public SAMFileHeader getHeader() { return mRecord.getHeader(); }
-
-    public void setHeader(SAMFileHeader samFileHeader) { mRecord.setHeader(samFileHeader); }
-
-    public byte[] getVariableBinaryRepresentation() { return mRecord.getVariableBinaryRepresentation(); }
-
-    public int getAttributesBinarySize() { return mRecord.getAttributesBinarySize(); }
-
-    public String format() { return mRecord.format(); }
-
-    public List<AlignmentBlock> getAlignmentBlocks() { return mRecord.getAlignmentBlocks(); }
-
-    public List<SAMValidationError> validateCigar(long l) { return mRecord.validateCigar(l); }
-
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
 
         // note -- this forbids a GATKSAMRecord being equal to its underlying SAMRecord
-        if (!(o instanceof GATKSAMRecord)) return false;
+        if (!(o instanceof GATKSamRecord)) return false;
 
         // note that we do not consider the GATKSAMRecord internal state at all
-        return mRecord.equals(((GATKSAMRecord)o).mRecord);
+        return super.equals(o);
-    }
-
-    public int hashCode() { return mRecord.hashCode(); }
-
-    public List<SAMValidationError> isValid() { return mRecord.isValid(); }
-
-    public Object clone() throws CloneNotSupportedException { return mRecord.clone(); }
-
-    public String toString() { return mRecord.toString(); }
-
-    public SAMFileSource getFileSource() { return mRecord.getFileSource(); }
-
-    /**
-     * Sets a marker providing the source reader for this file and the position in the file from which the read originated.
-     * @param fileSource source of the given file.
-     */
-    @Override
-    protected void setFileSource(final SAMFileSource fileSource) {
-        try {
-            Method method = SAMRecord.class.getDeclaredMethod("setFileSource",SAMFileSource.class);
-            method.setAccessible(true);
-            method.invoke(mRecord,fileSource);
-        }
-        catch(Exception ex) {
-            throw new ReviewedStingException("Unable to invoke setFileSource method",ex);
-        }
     }
 }

public/java/src/org/broadinstitute/sting/utils/sam/GATKSamRecordFactory.java

@@ -57,18 +57,18 @@ public class GATKSamRecordFactory implements SAMRecordFactory {
                                      final int mateAlignmentStart,
                                      final int insertSize,
                                      final byte[] variableLengthBlock) {
-        return new BAMRecord(header,
+        return new GATKSamRecord(header,
-                             referenceSequenceIndex,
+                referenceSequenceIndex,
-                             alignmentStart,
+                alignmentStart,
-                             readNameLength,
+                readNameLength,
-                             mappingQuality,
+                mappingQuality,
-                             indexingBin,
+                indexingBin,
-                             cigarLen,
+                cigarLen,
-                             flags,
+                flags,
-                             readLen,
+                readLen,
-                             mateReferenceSequenceIndex,
+                mateReferenceSequenceIndex,
-                             mateAlignmentStart,
+                mateAlignmentStart,
-                             insertSize,
+                insertSize,
-                             variableLengthBlock);
+                variableLengthBlock);
     }
 }

public/java/src/org/broadinstitute/sting/utils/sam/ReadUtils.java

@@ -274,10 +274,10 @@ public class ReadUtils {
      * @param adaptorLength  length of adaptor sequence
      * @return a new read with adaptor sequence hard-clipped out or null if read is fully clipped
      */
-    public static GATKSAMRecord hardClipAdaptorSequence(final SAMRecord rec, int adaptorLength) {
+    public static GATKSamRecord hardClipAdaptorSequence(final SAMRecord rec, int adaptorLength) {
 
         Pair<Integer, Integer> adaptorBoundaries = getAdaptorBoundaries(rec, adaptorLength);
-        GATKSAMRecord result = (GATKSAMRecord)rec;
+        GATKSamRecord result = (GATKSamRecord)rec;
 
         if ( adaptorBoundaries != null ) {
             if ( rec.getReadNegativeStrandFlag() && adaptorBoundaries.second >= rec.getAlignmentStart() && adaptorBoundaries.first < rec.getAlignmentEnd() )
@@ -290,7 +290,7 @@ public class ReadUtils {
     }
 
     // return true if the read needs to be completely clipped
-    private static GATKSAMRecord hardClipStartOfRead(SAMRecord oldRec, int stopPosition) {
+    private static GATKSamRecord hardClipStartOfRead(SAMRecord oldRec, int stopPosition) {
 
         if ( stopPosition >= oldRec.getAlignmentEnd() ) {
             // BAM representation issue -- we can't clip away all bases in a read, just leave it alone and let the filter deal with it
@@ -298,9 +298,9 @@ public class ReadUtils {
             return null;
         }
 
-        GATKSAMRecord rec;
+        GATKSamRecord rec;
         try {
-            rec = (GATKSAMRecord)oldRec.clone();
+            rec = (GATKSamRecord)oldRec.clone();
         } catch (Exception e) {
             return null;
         }
@@ -370,7 +370,7 @@ public class ReadUtils {
         return rec;
     }
 
-    private static GATKSAMRecord hardClipEndOfRead(SAMRecord oldRec, int startPosition) {
+    private static GATKSamRecord hardClipEndOfRead(SAMRecord oldRec, int startPosition) {
 
         if ( startPosition <= oldRec.getAlignmentStart() ) {
             // BAM representation issue -- we can't clip away all bases in a read, just leave it alone and let the filter deal with it
@@ -378,9 +378,9 @@ public class ReadUtils {
             return null;
         }
 
-        GATKSAMRecord rec;
+        GATKSamRecord rec;
         try {
-            rec = (GATKSAMRecord)oldRec.clone();
+            rec = (GATKSamRecord)oldRec.clone();
         } catch (Exception e) {
             return null;
         }
@@ -598,7 +598,7 @@ public class ReadUtils {
      * @param rec  original SAM record
      * @return a new read with adaptor sequence hard-clipped out or null if read is fully clipped
      */
-    public static GATKSAMRecord hardClipAdaptorSequence(final SAMRecord rec) {
+    public static GATKSamRecord hardClipAdaptorSequence(final SAMRecord rec) {
         return hardClipAdaptorSequence(rec, DEFAULT_ADAPTOR_SIZE);
     }