common-buffer.h

/**
 *
 * @copyright Copyright (c) 2019 Joachim Bauch <mail@joachim-bauch.de>
 *
 * @license GNU GPL version 3 or any later version
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */

#include <assert.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

#include "7zTypes.h"

class OutputBuffer {
 public:
  OutputBuffer();
  ~OutputBuffer();

  ISeqOutStream *stream() { return &stream_.vt; };
  const uint8_t *data() const { return data_; }
  size_t size() const { return position_; }

 private:
  static const size_t kInitialSize = 128;

  typedef struct {
    ISeqOutStream vt;
    OutputBuffer *buffer;
  } OutputBufferStream;

  static size_t _Write(const ISeqOutStream *pp, const void *data, size_t size);
  size_t Write(const void *data, size_t size);

  OutputBufferStream stream_;
  uint8_t *data_ = nullptr;
  size_t size_ = 0;
  size_t position_ = 0;
};

OutputBuffer::OutputBuffer() {
  stream_.vt.Write = &OutputBuffer::_Write;
  stream_.buffer = this;
}

OutputBuffer::~OutputBuffer() {
  free(data_);
}

// static
size_t OutputBuffer::_Write(const ISeqOutStream *p, const void *data,
    size_t size) {
  OutputBufferStream *stream = CONTAINER_FROM_VTBL(p, OutputBufferStream, vt);
  return stream->buffer->Write(data, size);
}

size_t OutputBuffer::Write(const void *data, size_t size) {
  size_t available = size_ - position_;
  if (available < size) {
    if (!size_) {
      size_ = kInitialSize;
    }
    while (size_ - position_ < size) {
      size_ *= 2;
    }
    uint8_t *tmp = static_cast<uint8_t*>(malloc(size_));
    assert(tmp);
    if (data_) {
      memcpy(tmp, data_, position_);
      free(data_);
    }
    data_ = tmp;
  }

  memcpy(data_ + position_, data, size);
  position_ += size;
  return size;
}

class OutputByteBuffer {
 public:
  OutputByteBuffer();
  ~OutputByteBuffer();

  IByteOut *stream() { return &stream_.vt; };
  const uint8_t *data() const { return data_; }
  size_t size() const { return position_; }

 private:
  static const size_t kInitialSize = 128;

  typedef struct {
    IByteOut vt;
    OutputByteBuffer *buffer;
  } ByteOutStream;

  static void _Write(const IByteOut *pp, Byte b);
  void Write(Byte b);

  ByteOutStream stream_;
  uint8_t *data_ = nullptr;
  size_t size_ = 0;
  size_t position_ = 0;
};

OutputByteBuffer::OutputByteBuffer() {
  stream_.vt.Write = &OutputByteBuffer::_Write;
  stream_.buffer = this;
}

OutputByteBuffer::~OutputByteBuffer() {
  free(data_);
}

// static
void OutputByteBuffer::_Write(const IByteOut *p, Byte b) {
  ByteOutStream *stream = CONTAINER_FROM_VTBL(p, ByteOutStream, vt);
  stream->buffer->Write(b);
}

void OutputByteBuffer::Write(Byte b) {
  if (size_ == position_) {
    if (!size_) {
      size_ = kInitialSize;
    } else {
      size_ *= 2;
    }
    uint8_t *tmp = static_cast<uint8_t*>(malloc(size_));
    assert(tmp);
    if (data_) {
      memcpy(tmp, data_, position_);
      free(data_);
    }
    data_ = tmp;
  }

  data_[position_++] = b;
}

class InputBuffer {
 public:
  InputBuffer(const uint8_t *data, size_t size);

  ISeqInStream *stream() { return &stream_.vt; };

 private:
  typedef struct {
    ISeqInStream vt;
    InputBuffer *buffer;
  } InputBufferStream;

  static SRes _Read(const ISeqInStream *p, void *data, size_t *size);
  SRes Read(void *data, size_t *size);

  InputBufferStream stream_;
  const uint8_t *data_;
  size_t size_;
};

InputBuffer::InputBuffer(const uint8_t *data, size_t size)
  : data_(data), size_(size) {
  stream_.vt.Read = &InputBuffer::_Read;
  stream_.buffer = this;
}

// static
SRes InputBuffer::_Read(const ISeqInStream *p, void *data, size_t *size) {
  InputBufferStream *stream = CONTAINER_FROM_VTBL(p, InputBufferStream, vt);
  return stream->buffer->Read(data, size);
}

SRes InputBuffer::Read(void *data, size_t *size) {
  if (size_ < *size) {
    *size = size_;
  }
  if (*size > 0) {
    memcpy(data, data_, *size);
    size_ -= *size;
    data_ += *size;
  }
  return SZ_OK;
}

class InputByteBuffer {
 public:
  InputByteBuffer(const uint8_t *data, size_t size);

  IByteIn *stream() { return &stream_.vt; };

 private:
  typedef struct {
    IByteIn vt;
    InputByteBuffer *buffer;
  } ByteInStream;

  static Byte _Read(const IByteIn *p);
  Byte Read();

  ByteInStream stream_;
  const uint8_t *data_;
  size_t size_;
  size_t position_ = 0;
};

InputByteBuffer::InputByteBuffer(const uint8_t *data, size_t size)
  : data_(data), size_(size) {
  stream_.vt.Read = &InputByteBuffer::_Read;
  stream_.buffer = this;
}

// static
Byte InputByteBuffer::_Read(const IByteIn *p) {
  ByteInStream *stream = CONTAINER_FROM_VTBL(p, ByteInStream, vt);
  return stream->buffer->Read();
}

Byte InputByteBuffer::Read() {
  if (size_ == position_) {
    return 0;
  }

  return data_[position_++];
}

class InputLookBuffer {
 public:
  InputLookBuffer(const uint8_t *data, size_t size);

  ILookInStream *stream() { return &stream_.vt; };

 private:
  typedef struct {
    ILookInStream vt;
    InputLookBuffer *buffer;
  } InputLookBufferStream;

  static SRes _Look(const ILookInStream *p, const void **data, size_t *size);
  SRes Look(const void **data, size_t *size);
  static SRes _Skip(const ILookInStream *p, size_t offset);
  SRes Skip(size_t offset);
  static SRes _Read(const ILookInStream *p, void *data, size_t *size);
  SRes Read(void *data, size_t *size);
  static SRes _Seek(const ILookInStream *p, Int64 *pos, ESzSeek origin);
  SRes Seek(Int64 *pos, ESzSeek origin);

  InputLookBufferStream stream_;
  const uint8_t *data_;
  size_t size_;
  size_t position_ = 0;
};

InputLookBuffer::InputLookBuffer(const uint8_t *data, size_t size)
  : data_(data), size_(size) {
  stream_.vt.Look = &InputLookBuffer::_Look;
  stream_.vt.Skip = &InputLookBuffer::_Skip;
  stream_.vt.Read = &InputLookBuffer::_Read;
  stream_.vt.Seek = &InputLookBuffer::_Seek;
  stream_.buffer = this;
}

// static
SRes InputLookBuffer::_Look(const ILookInStream *p, const void **data,
    size_t *size) {
  InputLookBufferStream *stream =
      CONTAINER_FROM_VTBL(p, InputLookBufferStream, vt);
  return stream->buffer->Look(data, size);
}

SRes InputLookBuffer::Look(const void **data, size_t *size) {
  size_t available = size_ - position_;
  if (available < *size) {
    *size = available;
  }
  *data = data_ + position_;
  return SZ_OK;
}

// static
SRes InputLookBuffer::_Skip(const ILookInStream *p, size_t offset) {
  InputLookBufferStream *stream =
      CONTAINER_FROM_VTBL(p, InputLookBufferStream, vt);
  return stream->buffer->Skip(offset);
}

SRes InputLookBuffer::Skip(size_t offset) {
  size_t available = size_ - position_;
  if (offset > available) {
    offset = available;
  }
  position_ += offset;
  return SZ_OK;
}

// static
SRes InputLookBuffer::_Read(const ILookInStream *p, void *data, size_t *size) {
  InputLookBufferStream *stream =
      CONTAINER_FROM_VTBL(p, InputLookBufferStream, vt);
  return stream->buffer->Read(data, size);
}

SRes InputLookBuffer::Read(void *data, size_t *size) {
  size_t available = size_ - position_;
  if (available < *size) {
    *size = available;
  }
  if (*size > 0) {
    memcpy(data, data_ + position_, *size);
    position_ += *size;
  }
  return SZ_OK;
}

// static
SRes InputLookBuffer::_Seek(const ILookInStream *p, Int64 *pos,
    ESzSeek origin) {
  InputLookBufferStream *stream =
      CONTAINER_FROM_VTBL(p, InputLookBufferStream, vt);
  return stream->buffer->Seek(pos, origin);
}

SRes InputLookBuffer::Seek(Int64 *pos, ESzSeek origin) {
  switch (origin) {
    case SZ_SEEK_SET:
      if (*pos > size_) {
        *pos = size_;
      } else if (*pos < 0) {
        *pos = 0;
      }
      position_ = *pos;
      break;
    case SZ_SEEK_CUR:
      if (*pos > size_ || position_ + *pos > size_) {
        *pos = size_;
      } else if (position_ < -*pos) {
        *pos = 0;
      }
      position_ += *pos;
      break;
    case SZ_SEEK_END:
      if (*pos >= 0) {
        *pos = size_;
      } else if (-(*pos) > size_) {
        *pos = 0;
      } else {
        *pos = size_ + *pos;
      }
      position_ = *pos;
      break;
    default:
      return SZ_ERROR_PARAM;
  }
  return SZ_OK;
}