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