cube-game-plus-plus/common/stream/Stream.cpp

#include <cstring>
#include <netinet/in.h>

#include "common/stream/Stream.h"

Stream::Stream() : error(false), writeIndex(0), readIndex(0) {
}

Stream::Stream(size_t capacity) : data(capacity), error(false), writeIndex(0), readIndex(0) {
}

bool Stream::hasData() const {
    return readIndex < writeIndex;
}

bool Stream::hasError() const {
    return error;
}

void Stream::clearError() {
    error = false;
}

void Stream::write(const void* writeData, size_t length) {
    if(data.write(writeIndex, writeData, length)) {
        writeIndex += length;
    } else {
        error = true;
    }
}

void Stream::write(const char* writeData) {
    write(writeData, strlen(writeData));
}

void Stream::writeUnsignedChar(u8 uc) {
    write(&uc, sizeof (u8));
}

void Stream::writeUnsignedShort(u16 us) {
    us = htons(us);
    write(&us, sizeof (u16));
}

void Stream::writeUnsignedInt(u32 ui) {
    ui = htonl(ui);
    write(&ui, sizeof (u32));
}

void Stream::read(void* buffer, size_t length) {
    if(readIndex + length <= writeIndex && data.read(readIndex, buffer, length)) {
        readIndex += length;
    } else {
        error = true;
    }
}

u8 Stream::readUnsignedChar() {
    u8 uc;
    read(&uc, sizeof (u8));
    return uc;
}

u16 Stream::readUnsignedShort() {
    u16 us;
    read(&us, sizeof (u16));
    us = ntohs(us);
    return us;
}

u32 Stream::readUnsignedInt() {
    u32 ui;
    read(&ui, sizeof (u32));
    ui = ntohl(ui);
    return ui;
}

bool Stream::readSocket(int socket) {
    readIndex = 0;
    return data.readSocket(socket, writeIndex);
}

void Stream::sendToSocket(int socket) const {
    data.sendToSocket(socket, writeIndex);
}