src/api/SamSequenceDictionary.cpp

   1 // ***************************************************************************
   2 // SamSequenceDictionary.cpp (c) 2010 Derek Barnett
   3 // Marth Lab, Department of Biology, Boston College
   4 // All rights reserved.
   5 // ---------------------------------------------------------------------------
   6 // Last modified: 23 December 2010 (DB)
   7 // ---------------------------------------------------------------------------
   8 // Provides container operations for collection of sequence entries
   9 // *************************************************************************
  10
  11 #include <api/SamSequenceDictionary.h>
  12 using namespace BamTools;
  13
  14 #include <iostream>
  15 using namespace std;
  16
  17 // ctor
  18 SamSequenceDictionary::SamSequenceDictionary(void) { }
  19
  20 // copy ctor
  21 SamSequenceDictionary::SamSequenceDictionary(const SamSequenceDictionary& other)
  22     : m_data(other.m_data)
  23 { }
  24
  25 // dtor
  26 SamSequenceDictionary::~SamSequenceDictionary(void) {
  27     m_data.clear();
  28 }
  29
  30 // adds sequence if not already in container
  31 void SamSequenceDictionary::Add(const SamSequence& sequence) {
  32     if ( IsEmpty() || !Contains(sequence) )
  33         m_data.push_back(sequence);
  34 }
  35
  36 // overload to support std::string
  37 void SamSequenceDictionary::Add(const string& sequenceName) {
  38     Add( SamSequence(sequenceName) );
  39 }
  40
  41 // add multiple sequences
  42 void SamSequenceDictionary::Add(const vector<SamSequence>& sequences) {
  43     vector<SamSequence>::const_iterator rgIter = sequences.begin();
  44     vector<SamSequence>::const_iterator rgEnd  = sequences.end();
  45     for ( ; rgIter!= rgEnd; ++rgIter )
  46         Add(*rgIter);
  47 }
  48
  49 // overload to support std::string
  50 void SamSequenceDictionary::Add(const vector<string>& sequenceNames) {
  51     vector<string>::const_iterator rgIter = sequenceNames.begin();
  52     vector<string>::const_iterator rgEnd  = sequenceNames.end();
  53     for ( ; rgIter!= rgEnd; ++rgIter )
  54         Add(*rgIter);
  55 }
  56
  57 // returns iterator to container begin
  58 SamSequenceIterator SamSequenceDictionary::Begin(void) {
  59     return m_data.begin();
  60 }
  61
  62 // returns const_iterator to container begin
  63 SamSequenceConstIterator SamSequenceDictionary::Begin(void) const {
  64     return m_data.begin();
  65 }
  66
  67 // clear sequence container
  68 void SamSequenceDictionary::Clear(void) {
  69     m_data.clear();
  70 }
  71
  72 // explicit request for const_iterator to container begin
  73 SamSequenceConstIterator SamSequenceDictionary::ConstBegin(void) const {
  74     return m_data.begin();
  75 }
  76
  77 // explicit request for const_iterator to container end
  78 SamSequenceConstIterator SamSequenceDictionary::ConstEnd(void) const {
  79     return m_data.end();
  80 }
  81
  82 // returns true if container contains a sequence with this ID tag
  83 bool SamSequenceDictionary::Contains(const string& sequenceName) const {
  84     return ( IndexOf(sequenceName) != (int)m_data.size() );
  85 }
  86
  87 bool SamSequenceDictionary::Contains(const SamSequence& seq) const {
  88     return ( IndexOf(seq) != (int)m_data.size() );
  89 }
  90
  91 // returns iterator to container end
  92 SamSequenceIterator SamSequenceDictionary::End(void) {
  93     return m_data.end();
  94 }
  95
  96 // returns const_iterator to container begin
  97 SamSequenceConstIterator SamSequenceDictionary::End(void) const {
  98     return m_data.end();
  99 }
 100
 101 // returns vector index of sequence if found
 102 // returns vector::size() (invalid index) if not found
 103 int SamSequenceDictionary::IndexOf(const SamSequence& sequence) const {
 104     SamSequenceConstIterator begin = ConstBegin();
 105     SamSequenceConstIterator iter  = begin;
 106     SamSequenceConstIterator end   = ConstEnd();
 107     for ( ; iter != end; ++iter )
 108         if ( *iter == sequence ) break;
 109     return distance( begin, iter );
 110 }
 111
 112 // overload to support std::string
 113 int SamSequenceDictionary::IndexOf(const string& sequenceName) const {
 114     return IndexOf( SamSequence(sequenceName) );
 115 }
 116
 117 // returns true if container is empty
 118 bool SamSequenceDictionary::IsEmpty(void) const {
 119     return m_data.empty();
 120 }
 121
 122 // removes sequence (if it exists)
 123 void SamSequenceDictionary::Remove(const SamSequence& sequence) {
 124     if ( Contains(sequence) )
 125         m_data.erase( m_data.begin() + IndexOf(sequence) );
 126 }
 127
 128 // overlaod to support std::string
 129 void SamSequenceDictionary::Remove(const string& sequenceName) {
 130     Remove( SamSequence(sequenceName) );
 131 }
 132
 133 // remove multiple sequences
 134 void SamSequenceDictionary::Remove(const vector<SamSequence>& sequences) {
 135     vector<SamSequence>::const_iterator rgIter = sequences.begin();
 136     vector<SamSequence>::const_iterator rgEnd  = sequences.end();
 137     for ( ; rgIter!= rgEnd; ++rgIter )
 138         Remove(*rgIter);
 139 }
 140
 141 // overload to support std::string
 142 void SamSequenceDictionary::Remove(const vector<string>& sequenceNames) {
 143     vector<string>::const_iterator rgIter = sequenceNames.begin();
 144     vector<string>::const_iterator rgEnd  = sequenceNames.end();
 145     for ( ; rgIter!= rgEnd; ++rgIter )
 146         Remove(*rgIter);
 147 }
 148
 149 // returns size of container (number of current sequences)
 150 int SamSequenceDictionary::Size(void) const {
 151     return m_data.size();
 152 }
 153
 154 // retrieves the SamSequence object associated with this name
 155 // if sequenceName is unknown, a new SamSequence is created with this name (and invalid length 0)
 156 // and a reference to this new sequence entry is returned (like std::map)
 157 SamSequence& SamSequenceDictionary::operator[](const std::string& sequenceName) {
 158
 159     // look up sequence ID
 160     int index = IndexOf(sequenceName);
 161
 162     // if found, return sequence at index
 163     if ( index != (int)m_data.size() )
 164         return m_data[index];
 165
 166     // otherwise, append new sequence and return reference
 167     else {
 168         SamSequence seq(sequenceName);
 169         seq.Length = "0";
 170         m_data.push_back(seq);
 171         return m_data.back();
 172     }
 173 }
 174