net/tools/balsa/simple_buffer.cc

// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "net/tools/balsa/simple_buffer.h"
#include "base/logging.h"

// Some of the following member functions are marked inlined, even though they
// are virtual. This may seem counter-intuitive, since virtual functions are
// generally not eligible for inlining. Profiling results indicate that these
// large amount of runtime is spent on virtual function dispatch on these
// simple functions. They are virtual because of the interface this class
// inherits from. However, it is very unlikely that anyone will sub-class
// SimpleBuffer and change their implementation. To get rid of this baggage,
// internal implementation (e.g., Write) explicitly use SimpleBuffer:: to
// qualify the method calls, thus disabling the virtual dispatch and enable
// inlining.

namespace net {

static const int kInitialSimpleBufferSize = 10;

SimpleBuffer::SimpleBuffer()
  : storage_(new char[kInitialSimpleBufferSize]),
    write_idx_(0),
    read_idx_(0),
    storage_size_(kInitialSimpleBufferSize) {
}

SimpleBuffer::SimpleBuffer(int size)
  : write_idx_(0),
    read_idx_(0),
    storage_size_(size) {
  // Callers may try to allocate overly large blocks, but negative sizes are
  // obviously wrong.
  CHECK_GE(size, 0);
  storage_ = new char[size];
}

SimpleBuffer::~SimpleBuffer() {
  delete[] storage_;
}


////////////////////////////////////////////////////////////////////////////////

int SimpleBuffer::ReadableBytes() const {
  return write_idx_ - read_idx_;
}

////////////////////////////////////////////////////////////////////////////////

std::string SimpleBuffer::str() const {
  std::string s;
  char * readable_ptr;
  int readable_size;
  GetReadablePtr(&readable_ptr, &readable_size);
  s.append(readable_ptr, readable_ptr + readable_size);
  return s;
}

////////////////////////////////////////////////////////////////////////////////

int SimpleBuffer::BufferSize() const {
  return storage_size_;
}

////////////////////////////////////////////////////////////////////////////////

inline int SimpleBuffer::BytesFree() const {
  return (storage_size_ - write_idx_);
}

////////////////////////////////////////////////////////////////////////////////

bool SimpleBuffer::Empty() const {
  return (read_idx_ == write_idx_);
}

////////////////////////////////////////////////////////////////////////////////

bool SimpleBuffer::Full() const {
  return ((write_idx_ == storage_size_) && (read_idx_ != write_idx_));
}

////////////////////////////////////////////////////////////////////////////////

// returns the number of characters written.
// appends up-to-'size' bytes to the simplebuffer.
int SimpleBuffer::Write(const char* bytes, int size) {
  bool has_room = ((storage_size_ - write_idx_) >= size);
  if (!has_room) {
    (void)Reserve(size);
  }
  memcpy(storage_ + write_idx_, bytes, size);
  SimpleBuffer::AdvanceWritablePtr(size);
  return size;
}

////////////////////////////////////////////////////////////////////////////////

// stores a pointer into the simple buffer in *ptr,
// and stores the number of characters which are allowed
// to be written in *size.
inline void SimpleBuffer::GetWritablePtr(char **ptr, int* size) const {
  *ptr = storage_ + write_idx_;
  *size = SimpleBuffer::BytesFree();
}

////////////////////////////////////////////////////////////////////////////////

// stores a pointer into the simple buffer in *ptr,
// and stores the number of characters which are allowed
// to be read in *size.
void SimpleBuffer::GetReadablePtr(char **ptr, int* size) const {
  *ptr = storage_ + read_idx_;
  *size = write_idx_ - read_idx_;
}

////////////////////////////////////////////////////////////////////////////////

// returns the number of bytes read into 'bytes'
int SimpleBuffer::Read(char* bytes, int size) {
  char * read_ptr = NULL;
  int read_size = 0;
  GetReadablePtr(&read_ptr, &read_size);
  if (read_size > size) {
    read_size = size;
  }
  memcpy(bytes, read_ptr, read_size);
  AdvanceReadablePtr(read_size);
  return read_size;
}

////////////////////////////////////////////////////////////////////////////////

// removes all data from the simple buffer
void SimpleBuffer::Clear() {
  read_idx_ = write_idx_ = 0;
}

////////////////////////////////////////////////////////////////////////////////

// Attempts to reserve a contiguous block of buffer space by either reclaiming
// old data that is already read, and reallocate large storage as needed.
bool SimpleBuffer::Reserve(int size) {
  if (size > 0 && BytesFree() < size) {
    char * read_ptr = NULL;
    int read_size = 0;
    GetReadablePtr(&read_ptr, &read_size);

    if (read_size + size <= BufferSize()) {
      // Can reclaim space from already read bytes by shifting
      memmove(storage_, read_ptr, read_size);
      read_idx_ = 0;
      write_idx_ = read_size;
      CHECK_GE(BytesFree(), size);
    } else {
      // what we need is to have at least size bytes available for writing.
      // This implies that the buffer needs to be at least size bytes +
      // read_size bytes long. Since we want linear time extensions in the case
      // that we're extending this thing repeatedly, we should extend to twice
      // the current size (if that is big enough), or the size + read_size
      // bytes, whichever is larger.
      int new_storage_size = 2 * storage_size_;
      if (new_storage_size < size + read_size) {
        new_storage_size = size + read_size;
      }

      // have to extend the thing
      char* new_storage = new char[new_storage_size];

      // copy still useful info to the new buffer.
      memcpy(new_storage, read_ptr, read_size);
      // reset pointers.
      read_idx_ = 0;
      write_idx_ = read_size;
      delete[] storage_;
      storage_ = new_storage;
      storage_size_ = new_storage_size;
    }
  }
  return true;
}

////////////////////////////////////////////////////////////////////////////////

// removes the oldest 'amount_to_consume' characters.
void SimpleBuffer::AdvanceReadablePtr(int amount_to_advance) {
  read_idx_ += amount_to_advance;
  if (read_idx_ > storage_size_) {
    read_idx_ = storage_size_;
  }
}

////////////////////////////////////////////////////////////////////////////////

// Moves the internal pointers around such that the
// amount of data specified here is expected to
// already be resident (as if it was Written)
inline void SimpleBuffer::AdvanceWritablePtr(int amount_to_advance) {
  write_idx_ += amount_to_advance;
  if (write_idx_ > storage_size_) {
    write_idx_ = storage_size_;
  }
}

}  // namespace net