atoms/buffer.cc

Go to the documentation of this file.

#include <atoms/buffer.hh>
#include <string.h>
#include <algorithm>
#include <limits>
#include <boost/shared_ptr.hpp>
#include <atoms/stream.hh>
#include <atoms/error.hh>

using namespace std;
using namespace boost;

namespace atoms {

size_t Buffer::MINIMUM_ALLOCATION = 1024;
DebugLogger Buffer::LOGGER("org.atoms.slamb.Buffer");
//size_t Buffer::MINIMUM_ALLOCATION = 1;

size_t Buffer::readAndAppend(Stream *s, size_t min) {
    assert(s != NULL);
    prepareForAppend(min);
    size_t actuallyRead = s->read(buf + limit, capacity - limit);
    assert(0 < actuallyRead && actuallyRead <= capacity - limit);
    limit += actuallyRead;
    return actuallyRead;
}

void Buffer::append(const void *src, size_t n) {
    assert(src != NULL);
    prepareForAppend(n);
    memcpy(buf + limit, src, n);
    limit += n;
}

void Buffer::replace(const void *src, size_t p, size_t n) {
    assert(src != NULL);
    assert(p <= limit - position);
    size_t excess = 0;
    if (p + n > limit - position) {
        excess = (p + n) - (limit - position);
        prepareForAppend(excess);
    }
    memcpy(buf + position + p, src, n);
    limit += excess;
}

size_t Buffer::writeAndShift(Stream *s, size_t max) {
    assert(s != NULL);
    assert(limit - position >= max);
    size_t actuallyWritten = s->write(buf + position, max);
    position += actuallyWritten;
    return actuallyWritten;
}

void Buffer::shift(void *dest, size_t n) {
    assert(limit - position >= n);
    if (dest != NULL)
        memcpy(dest, buf + position, n);
    position += n;
}

size_t Buffer::truncate(size_t n) {
    assert(limit - position >= n);
    size_t numTruncated = limit - position - n;
    limit -= numTruncated;
    return numTruncated;
}

void Buffer::prepareForAppend(size_t n) {
    if (!markSet)
        mark = position;
    size_t currentBytesToKeep = limit - mark;
    size_t bytesNeeded = currentBytesToKeep + n;
    if (bytesNeeded < currentBytesToKeep) {
        // Overflow; don't try to expand into less space.
        throw std::bad_alloc();
    }
    if (bytesNeeded > capacity) {
        // We need to reallocate.
        size_t newCapacity = max(MINIMUM_ALLOCATION, capacity);
        if (bytesNeeded>static_cast<size_t>(numeric_limits<ssize_t>::max())) {
            // The powers of two logic will loop infinitely.
            // This is too big to bother trying, anyway.
            throw std::bad_alloc();
        }
        while (newCapacity < bytesNeeded)
            newCapacity <<= 1;
        LOGGER.log(DebugLogger::lInfo, "Expanding buffer %p to %zu bytes",
                   this, newCapacity);
        char *newBuf = reinterpret_cast<char*>(realloc(buf, newCapacity));
        if (newBuf == NULL)
            throw std::bad_alloc();
        buf = newBuf;
        capacity = newCapacity;
    }
    if (bytesNeeded > capacity - mark) {
        // We need to move the important buffer contents
        memmove(buf, buf + mark, currentBytesToKeep);
        limit -= mark;
        position -= mark;
        mark = 0;
    }
}

} // namespace atoms

---