GrowingBuffer.cpp

   1 /**
   2  * © 2008 by David ‘Bombe’ Roden <bombe@pterodactylus.net>
   3  */
   4
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <stddef.h>
   8 #include "GrowingBuffer.h"
   9
  10 GrowingBuffer::GrowingBuffer(size_t initialSize) {
  11         this->data = malloc(1024);
  12         this->size = 1024;
  13         this->limit = 0;
  14         this->position = 0;
  15 }
  16
  17 GrowingBuffer::~GrowingBuffer() {
  18         if (this->data) {
  19                 free(this->data);
  20         }
  21 }
  22
  23 size_t GrowingBuffer::getPosition() {
  24         return position;
  25 }
  26
  27 size_t GrowingBuffer::getLimit() {
  28         return limit;
  29 }
  30
  31 size_t GrowingBuffer::getSize() {
  32         return size;
  33 }
  34
  35 void GrowingBuffer::seek(size_t position) {
  36         this->position = (position > limit) ? limit : position;
  37 }
  38
  39 void* GrowingBuffer::read(void* buffer, size_t length) {
  40         size_t bytesToCopy = (length > (limit - position)) ? (limit - position) : length;
  41         memcpy(buffer, (ptrdiff_t*) data + position, bytesToCopy);
  42         position += bytesToCopy;
  43         return buffer;
  44 }
  45
  46 void GrowingBuffer::write(const void* buffer, size_t length) {
  47         if (length > (size - position)) {
  48                 int newSize = size;
  49                 do {
  50                         newSize *= 2;
  51                 } while (length > (newSize - position));
  52                 void* newData = malloc(newSize);
  53                 memcpy(newData, data, position);
  54                 free(data);
  55                 data = newData;
  56         }
  57         memcpy((ptrdiff_t*) data + position, buffer, length);
  58 }
  59
  60 void GrowingBuffer::cut() {
  61         memcpy(data, (ptrdiff_t*) data + position, position);
  62         limit = position;
  63         position = 0;
  64 }
  65
  66 void GrowingBuffer::truncate() {
  67         limit = position;
  68 }
  69
  70 void GrowingBuffer::clear() {
  71         position = 0;
  72         limit = 0;
  73 }
  74
  75 void GrowingBuffer::resize(double factor) {
  76         if (factor < 1.0) {
  77                 factor = 1.0;
  78         }
  79         if (size != (limit * factor)) {
  80                 void* newData = malloc((size_t) (limit * factor));
  81                 memcpy(newData, data, limit);
  82                 free(data);
  83                 data = newData;
  84         }
  85 }
  86