src/api/internal/io/ByteArray_p.cpp

   1 #include "api/internal/io/ByteArray_p.h"
   2 using namespace BamTools;
   3 using namespace BamTools::Internal;
   4
   5 #include <iostream> // debug
   6
   7 #include <cstdlib>
   8 #include <cstring>
   9 using namespace std;
  10
  11 // --------------------------
  12 // ByteArray implementation
  13 // --------------------------
  14
  15 ByteArray::ByteArray(void)
  16     : m_data()
  17 { }
  18
  19 ByteArray::ByteArray(const string& value)
  20     : m_data(value.begin(), value.end())
  21 { }
  22
  23 ByteArray::ByteArray(const vector<char>& value)
  24     : m_data(value)
  25 { }
  26
  27 ByteArray::ByteArray(const char* value, size_t n) {
  28     const string s(value, n);
  29     m_data.assign(s.begin(), s.end());
  30 }
  31
  32 ByteArray::ByteArray(const ByteArray& other)
  33     : m_data(other.m_data)
  34 { }
  35
  36 ByteArray::~ByteArray(void) { }
  37
  38 ByteArray& ByteArray::operator=(const ByteArray& other) {
  39     m_data = other.m_data;
  40     return *this;
  41 }
  42
  43 void ByteArray::Clear(void) {
  44     m_data.clear();
  45 }
  46
  47 const char* ByteArray::ConstData(void) const {
  48     return &m_data[0];
  49 }
  50
  51 char* ByteArray::Data(void) {
  52     return &m_data[0];
  53 }
  54
  55 const char& ByteArray::operator[](size_t i) const {
  56     return m_data[i];
  57 }
  58
  59 char& ByteArray::operator[](size_t i) {
  60     return m_data[i];
  61 }
  62
  63 size_t ByteArray::IndexOf(const char c, const size_t from, const size_t to) const {
  64     const size_t size = ( (to == 0 ) ? m_data.size() : to );
  65     for ( size_t i = from; i < size; ++i ) {
  66         if ( m_data.at(i) == c )
  67             return i;
  68     }
  69     return m_data.size();
  70 }
  71
  72 ByteArray& ByteArray::Remove(size_t from, size_t n) {
  73
  74     // if 'from' outside range, just return
  75     const size_t originalSize = m_data.size();
  76     if ( from >= originalSize )
  77         return *this;
  78
  79     // if asked to clip from 'from' to end (or beyond), simply resize
  80     if ( from + n >= originalSize )
  81         Resize(from);
  82
  83     // otherwise, shift data & resize
  84     else {
  85         memmove( &m_data[from], &m_data[from+n], (originalSize-from-n) );
  86         Resize(originalSize - n);
  87     }
  88
  89     // return reference to modified byte array
  90     return *this;
  91 }
  92
  93 void ByteArray::Resize(size_t n) {
  94     m_data.resize(n, 0);
  95 }
  96
  97 size_t ByteArray::Size(void) const {
  98     return m_data.size();
  99 }
 100
 101 void ByteArray::Squeeze(void) {
 102     vector<char> t(m_data);
 103     t.swap(m_data);
 104 }