binarywriter.cpp

Go to the documentation of this file.

#include "binarywriter.h"

#include "../conversion/conversionexception.h"

#include <cstring>
#include <memory>

using namespace std;
using namespace IoUtilities;
using namespace ConversionUtilities;

BinaryWriter::BinaryWriter(ostream *stream, ByteOrder byteOrder) :
    m_stream(stream),
    m_ownership(false),
    m_byteOrder(byteOrder)
{}

BinaryWriter::BinaryWriter(const BinaryWriter &other) :
    m_stream(other.m_stream),
    m_ownership(false),
    m_byteOrder(other.m_byteOrder)
{}

BinaryWriter::~BinaryWriter()
{
    if(m_stream && m_ownership) {
        delete m_stream;
    }
}

ostream *BinaryWriter::stream()
{
    return m_stream;
}

const ostream *BinaryWriter::stream() const
{
    return m_stream;
}

void BinaryWriter::setStream(ostream *stream, bool giveOwnership)
{
    if(m_stream && m_ownership)
        delete m_stream;
    if(stream) {
        m_stream = stream;
        m_ownership = giveOwnership;
    } else {
        m_stream = nullptr;
        m_ownership = false;
    }
}

bool BinaryWriter::hasOwnership() const
{
    return m_ownership;
}

void BinaryWriter::giveOwnership()
{
    if(m_stream) {
        m_ownership = true;
    }
}

void BinaryWriter::detatchOwnership()
{
    m_ownership = false;
}

ByteOrder BinaryWriter::byteOrder() const
{
    return m_byteOrder;
}

void BinaryWriter::setByteOrder(ByteOrder value)
{
    m_byteOrder = value;
}

void BinaryWriter::flush()
{
    if(m_stream) {
        m_stream->flush();
    }
}

bool BinaryWriter::fail() const
{
    if(m_stream) {
        return m_stream->fail();
    } else {
        return false;
    }
}

void BinaryWriter::write(const char *buffer, streamsize length)
{
    m_stream->write(buffer, length);
}

void BinaryWriter::write(const std::vector<char> &buffer, streamsize length)
{
    m_stream->write(buffer.data(), length);
}

void BinaryWriter::writeChar(char value)
{
    char buff[1] = {value};
    m_stream->write(buff, 1);
}

void BinaryWriter::writeByte(byte value)
{
    char buff[1] = {*reinterpret_cast<char *>(&value)};
    m_stream->write(buff, 1);
}

void BinaryWriter::writeInt16(int16 value)
{
    char buff[sizeof(int16)];
    getBytes(value, buff, 0, m_byteOrder);
    m_stream->write(buff, sizeof(int16));
}

void BinaryWriter::writeUInt16(uint16 value)
{
    char buff[sizeof(uint16)];
    getBytes(value, buff, 0, m_byteOrder);
    m_stream->write(buff, sizeof(uint16));
}

void BinaryWriter::writeInt24(int32 value)
{
    // discard most significant byte
    char buff[4] = {0};
    getBytes(value, buff, 0, m_byteOrder);
    switch(m_byteOrder) {
    case ByteOrder::BigEndian:
        m_stream->write(buff + 1, 3);
        break;
    case ByteOrder::LittleEndian:
        m_stream->write(buff, 3);
        break;
    }
}

void BinaryWriter::writeUInt24(uint32 value)
{
    // discard most significant byte
    char buff[4] = {0};
    getBytes(value, buff, 0, m_byteOrder);
    switch(m_byteOrder) {
    case ByteOrder::BigEndian:
        m_stream->write(buff + 1, 3);
        break;
    case ByteOrder::LittleEndian:
        m_stream->write(buff, 3);
        break;
    }
}

void BinaryWriter::writeInt32(int32 value)
{
    char buff[sizeof(int32)];
    getBytes(value, buff, 0, m_byteOrder);
    m_stream->write(buff, sizeof(int32));
}

void BinaryWriter::writeUInt32(uint32 value)
{
    char buff[sizeof(uint32)];
    getBytes(value, buff, 0, m_byteOrder);
    m_stream->write(buff, sizeof(uint32));
}

void BinaryWriter::writeInt64(int64 value)
{
    char buff[sizeof(int64)];
    getBytes(value, buff, 0, m_byteOrder);
    m_stream->write(buff, sizeof(int64));
}

void BinaryWriter::writeUInt64(uint64 value)
{
    char buff[sizeof(uint64)];
    getBytes(value, buff, 0, m_byteOrder);
    m_stream->write(buff, sizeof(uint64));
}

void BinaryWriter::writeFloat32(float32 value)
{
    char buff[sizeof(float32)];
    getBytes(value, buff, 0, m_byteOrder);
    m_stream->write(buff, sizeof(float32));
}

void BinaryWriter::writeFloat64(float64 value)
{
    char buff[sizeof(float64)];
    getBytes(value, buff, 0, m_byteOrder);
    m_stream->write(buff, sizeof(float64));
}

void BinaryWriter::writeString(const string &value)
{
    m_stream->write(value.c_str(), value.length());
}

void BinaryWriter::writeLengthPrefixedString(const string &value)
{
    size_t length = value.length();
    char buff[4] = {0};
    if(length < 0x80) {
        buff[0] = 0x80 | length;
        m_stream->write(buff, 1);
    } else if(length < 0x4000) {
        getBytes(static_cast<uint16>(0x4000 | length), buff, 0, ByteOrder::BigEndian);
        m_stream->write(buff, 2);
    } else if(length < 0x200000) {
        getBytes(static_cast<uint32>(0x200000 | length), buff, 0, ByteOrder::BigEndian);
        m_stream->write(buff + 1, 3);
    } else if(length < 0x10000000) {
        getBytes(static_cast<uint32>(0x10000000 | length), buff, 0, ByteOrder::BigEndian);
        m_stream->write(buff, 4);
    } else {
        throw ConversionException("The size of the string exceeds the maximum.");
    }
    m_stream->write(value.c_str(), length);
}

void BinaryWriter::writeBool(bool value)
{
    writeByte(value ? 1 : 0);
}

void BinaryWriter::writeSynchsafeUInt32(uint32 valueToConvertAndWrite)
{
    writeUInt32(ConversionUtilities::toSynchsafeInt(valueToConvertAndWrite));
}