// 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