BinaryWriter.cpp

Go to the documentation of this file.

/*

Copyright (C) 2006-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Calitko is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#include "Qt.h"
#include "BinaryWriter.h"
#include <iterator>

using Utils::Encodings::BinaryWriter;
using std::reverse_iterator;


BinaryWriter::BinaryWriter (QByteArray *buffer, ByteOrder byteOrder,
                            bool autoGrow)
 :  d()
{
    d.ownsBuffer    = false;
    d.buffer        = buffer;
    d.dataStart     = d.buffer->data();
    d.dataEnd       = d.dataStart + d.buffer->size();
    d.autoGrow      = autoGrow;
    // Make sure d.swapBytes and d.byteOrder are initialized:
    setByteOrder (byteOrder);
}


BinaryWriter::BinaryWriter (ByteOrder byteOrder, bool autoGrow)
 :  d()
{
    d.ownsBuffer    = true;
    d.buffer        = new QByteArray();
    d.dataStart     = d.buffer->data();
    d.dataEnd       = d.dataStart + d.buffer->size();
    d.autoGrow      = autoGrow;
    // Make sure d.swapBytes and d.byteOrder are initialized:
    setByteOrder (byteOrder);
}


BinaryWriter::~BinaryWriter()
{
    if (d.ownsBuffer)
        delete d.buffer;
}


void BinaryWriter::reserve (size_t count)
{
    growBuffer (count, true);
    d.autoGrow = false;
}


inline
void BinaryWriter::growBuffer (size_t count, bool force)
{
    // Currently only owned buffers are growable.
    if ((d.autoGrow || force) && d.dataStart + count > d.dataEnd) {
        size_t written = bytesWritten();
        d.buffer->resize (written + count);
        d.dataStart = d.buffer->data() + written;
        d.dataEnd = d.dataStart + count;
    }
}


inline
void BinaryWriter::doWrite (char *source, size_t count)
{
    growBuffer (count); // Grow buffer if growable and necessary.
    // Only write if enough free bytes left:
    if (d.dataStart + count <= d.dataEnd) {
        if (d.swapBytes)
            qCopy (source, source + count,
                   reverse_iterator <char *> (d.dataStart + count));
        else
            qCopy (source, source + count, d.dataStart);
    }
    d.dataStart += count;
}


void BinaryWriter::writeByte (uchar value)
{
    doWrite (reinterpret_cast <char *> (&value), sizeof (value));
}


void BinaryWriter::writeUInt16 (quint16 value)
{
    doWrite (reinterpret_cast <char *> (&value), sizeof (value));
}


void BinaryWriter::writeUInt32 (quint32 value)
{
    doWrite (reinterpret_cast <char *> (&value), sizeof (value));
}


void BinaryWriter::writeUInt64 (quint64 value)
{
    doWrite (reinterpret_cast <char *> (&value), sizeof (value));
}


void BinaryWriter::writeBytes (const QByteArray &bytes)
{
    size_t count = bytes.length();
    growBuffer (count); // Grow buffer if growable and necessary.
    char *end = d.dataStart + count;
    if (end <= d.dataEnd)
        qCopy (bytes.data(), bytes.data() + count, d.dataStart);
    d.dataStart = end;
}


void BinaryWriter::writeString (const QByteArray &string, char terminator)
{
    size_t count = string.length();
    growBuffer (count + 1);
    // Write the string:
    writeBytes (string);
    // Write the ending zero:
    if (d.dataStart < d.dataEnd)
        *d.dataStart = terminator;
    // Advance past the zero or past the end:
    d.dataStart++;
}


void BinaryWriter::setByteOrder (ByteOrder byteOrder)
{
    d.byteOrder = byteOrder;
    if (byteOrder == LittleEndian)
        d.swapBytes = QSysInfo::ByteOrder != QSysInfo::LittleEndian;
    else if (byteOrder == BigEndian)
        d.swapBytes = QSysInfo::ByteOrder != QSysInfo::BigEndian;
    else
        Q_ASSERT (false);
}


bool BinaryWriter::hasWrittenAll() const
{
    return d.dataStart >= d.dataEnd;
}


bool BinaryWriter::hasWrittenPastEnd() const
{
    return d.dataStart > d.dataEnd;
}


size_t BinaryWriter::bytesWritten() const
{
    return d.dataStart - d.buffer->data();
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.