bam-entropy/BamAlignmentIterator.cpp at master · nishill/bam-entropy · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
// BamAlignmnetIterator.cpp
// A class implementation for the ConstBamAlignmentIterator.h

#include <cstdio>
#include <cstring>
#include <cctype>
#include <iomanip>
#include <string>
#include <iostream>
#include <fstream>
#include <vector>
#include <iterator>
#include <stdexcept>
#include "BamAlignmentIterator.h"
using namespace std;

#include "api/BamReader.h"
#include "api/BamWriter.h"
#include "api/BamAux.h"
#include "api/SamSequence.h"
#include "api/SamSequenceDictionary.h"
using namespace BamTools;


// BamAlignmentReader() constructor
BamAlignmentReader :: BamAlignmentReader ( const string & fileName ) :
    m_fileName ( fileName ){}

// BamAlignmentReader::begin()
ConstBamAlignmentIterator BamAlignmentReader::begin() const{
    return ConstBamAlignmentIterator ( m_fileName );
}

// BamAlignmentReader::end()
ConstBamAlignmentIterator BamAlignmentReader::end() const{
    return ConstBamAlignmentIterator ();
}

// ConstBamAlignmentIterator() default constructor
ConstBamAlignmentIterator::ConstBamAlignmentIterator() :
    m_alignmentSeqIdx ( 0 ),
    m_idx ( 0 ),
    m_eoa ( true ){}

// ConstBamAlignmentIterator() constructor w/ fileName
ConstBamAlignmentIterator::ConstBamAlignmentIterator ( const string & fileName ) :
    m_alignmentSeqIdx ( 0 ),
    m_idx ( 0 ),
    m_eoa ( false )
{
    m_bamReader.Open ( fileName );
    bool success = m_bamReader.GetNextAlignment ( m_alignment );
    if ( ! success || m_idx >= m_alignment.AlignedBases.size() ) {
        m_eoa = true;
    }
    m_alignmentSeqIdx++;
}

// ConstBamAlignmentIterator::operator++()
ConstBamAlignmentIterator& ConstBamAlignmentIterator::operator++(int){
    if ( !m_eoa ) {
        if ( m_idx + 1u < m_alignment.AlignedBases.size () ) {
            m_idx++;
        }
        else {
            bool success = m_bamReader.GetNextAlignment ( m_alignment );
            if ( !success || m_idx >= m_alignment.AlignedBases.size () ) {
               m_eoa = true;
            }
            m_alignmentSeqIdx++;
            m_idx = 0;
        }
    }
    return *this;
}

// ConstBamAlignmentIterator::Value::operator*()
ConstBamAlignmentIterator::Value
    ConstBamAlignmentIterator::operator*() const {

    return ConstBamAlignmentIterator::Value (
                m_alignment.AlignedBases[m_idx],
                m_alignment.Qualities[m_idx] );
}

// ConstBamAlignmentIterator::operator==()
bool ConstBamAlignmentIterator::operator==
		( const ConstBamAlignmentIterator & rhs ) const {
    if ( m_eoa != rhs.m_eoa ) {
        return false;
    }
    else if ( !m_eoa) {
        if (m_idx != rhs.m_idx) {
            return false;
        }
        if ( m_alignmentSeqIdx != rhs.m_alignmentSeqIdx ) {
           return false;
        }
    }
    return true;
}

// ConstBamAlignmentIterator::operator!=()
bool ConstBamAlignmentIterator::operator!=
		( const ConstBamAlignmentIterator& rhs) const {
    return ! this->operator == ( rhs);
}