atoms/buffer.hh

Go to the documentation of this file.

#ifndef ATOMS_BUFFER_HH
#define ATOMS_BUFFER_HH

#include <atoms/gen.hh>
#include <stdlib.h>
#include <locale>
#include <atoms/stream.hh>

namespace atoms {

class Buffer {
public:
    Buffer() : markSet(false), position(0), limit(0), capacity(0), buf(NULL) {}

    ~Buffer() {
        assert(!markSet);
        free(buf);
    }

    size_t readAndAppend(Stream *s, size_t min);
    size_t readAndAppend(const boost::shared_ptr<Stream> &s, size_t min) {
        return readAndAppend(s.get(), min);
    }

    void append(const void *src, size_t n);

    template <typename internT, typename externT, typename stateT>
    void append(const internT *from, const internT *fromEnd, stateT&,
                const std::codecvt<internT,externT,stateT>&);

    void replace(const void *src, size_t p, size_t n);

    size_t writeAndShift(Stream *s, size_t max);
    size_t writeAndShift(const boost::shared_ptr<Stream> &s, size_t max) {
        return writeAndShift(s.get(), max);
    }

    void shift(void *dest, size_t n);

    size_t truncate(size_t n);

    size_t getSize() const { return limit - position; }

    size_t getCapacity() const { return capacity; }

    size_t getRollbackSize() const { return position; }

    void setMark() {
        assert(!markSet);
        mark = position;
        markSet = true;
    }

    void rollback() {
        assert(markSet);
        position = mark;
        markSet = false;
    }

    void rollback(size_t n) {
        assert(n <= position);
        position -= n;
        if (position <= mark) {
            markSet = false;
        }
    }

    void clear() {
        assert(markSet);
        markSet = false;
    }
private:
    void prepareForAppend(size_t n);

    size_t mark;
    bool markSet;

    size_t position;

    size_t limit;

    size_t capacity;

    char *buf;

    static size_t MINIMUM_ALLOCATION;

    static DebugLogger LOGGER;
};

template <typename internT, typename externT, typename stateT>
void Buffer::append(const internT *from, const internT *fromEnd, stateT &state,
                    const std::codecvt<internT,externT,stateT> &cvt) {
    using namespace std;
    size_t oldSize = getSize();
    std::codecvt_base::result r;
    try {
        const internT *fromNext = from;
        externT *to, *toEnd, *toNext;
        do {
            // Make sure we have at least a little space.
            prepareForAppend(sizeof(externT));

            // And try the conversion.
            to = toNext = reinterpret_cast<externT*>(&buf[limit]);
            toEnd = reinterpret_cast<externT*>(&buf[capacity]);
            r = cvt.out(state, from, fromEnd, from, to, toEnd, to);
            limit += (toNext - to) * sizeof(externT);
            from = fromNext;
        } while (r == codecvt_base::partial && to == toEnd) ;
    } catch (std::bad_alloc&) {
        // On allocation failure, leave the buffer as it was.
        limit = position + oldSize;
        throw;
    }
    if (r == codecvt_base::error) {
        // If there's an error converting to the locale, throw an exception
        // and leave the buffer as before.
        limit = position + oldSize;
        throw Error("Invalid character conversion.");
    }
    if (r == codecvt_base::noconv) {
        append(from, sizeof(internT) * (fromEnd - from));
        return;
    }
    assert(r == codecvt_base::ok);
}

} // namespace atoms
#endif // !ATOMS_BUFFER_HH

---