BinaryReader.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 "BinaryReader.h"
#include <algorithm>

using Utils::Encodings::BinaryReader;


BinaryReader::BinaryReader (const QByteArray &rawData, ByteOrder byteOrder)
 :  d()
{
    d.rawData       = rawData;
    d.readOrigin    = ReadFromStart;
    d.dataStart     = d.rawData.data();
    d.dataEnd       = d.dataStart + d.rawData.size();
    // Make sure d.swapBytes and d.byteOrder are initialized:
    setByteOrder (byteOrder);
}


void BinaryReader::doRead (char *destination, size_t count)
{
    // Only read if enough unread data left:
    if (canRead (count)) {
        if (const char* start = getRangePtrs (count))
            copyBytes (start, start+count, destination);
    }
    bumpPtrs (count);
}


const char* BinaryReader::getRangePtrs (size_t count)
{
    Q_ASSERT (canRead (count));
    if (d.readOrigin == ReadFromEnd)
        return d.dataEnd - count;
    else
        return d.dataStart;
}


void BinaryReader::copyBytes (const char *beg, const char *end, char *dest)
{
    if (d.swapBytes)
        while (beg != end) *dest++ = *--end;
    else
        std::copy (beg, end, dest);
}


void BinaryReader::bumpPtrs (size_t count)
{
    if (d.readOrigin == ReadFromStart)
        d.dataStart += count;
    else
        d.dataEnd -= count;
}

uchar BinaryReader::lookAhead (const int count)
{
    Q_ASSERT (count > 0);
    uchar res = 0;
    // Only return if the requested data is within the buffer:
    if (canRead (count)) {
        if (d.readOrigin == ReadFromEnd) {
            res = *(d.dataEnd - count);
        } else {
            res = *(d.dataStart + count - 1);
        }
    }
    return res;
}


bool BinaryReader::canRead (const int count)
{
    return d.dataStart + count <= d.dataEnd;
}


uchar BinaryReader::readByte()
{
    uchar res = 0;
    doRead (reinterpret_cast <char *> (&res), sizeof (res));
    return res;
}


quint16 BinaryReader::readUInt16()
{
    quint16 res = 0;
    doRead (reinterpret_cast <char *> (&res), sizeof (res));
    return res;
}


quint32 BinaryReader::readUInt32()
{
    quint32 res = 0;
    doRead (reinterpret_cast <char *> (&res), sizeof (res));
    return res;
}


quint64 BinaryReader::readUInt64()
{
    quint64 res = 0;
    doRead (reinterpret_cast <char *> (&res), sizeof (res));
    return res;
}

QByteArray BinaryReader::readAll()
{
    if (d.dataEnd <= d.dataStart)
        return QByteArray();
    else
        return readBytes (d.dataEnd - d.dataStart);
}


QByteArray BinaryReader::readBytes (size_t count)
{
    QByteArray res (count, '\0');
    if (canRead(count)) {
        const char* start = getRangePtrs (count);
        std::copy (start, start+count, res.data());
    }
    bumpPtrs (count);
    return res;
}


QByteArray BinaryReader::getSharedBytes (size_t count)
{
    QByteArray res;
    if (canRead (count)) {
        if (d.readOrigin == ReadFromStart)
            res = QByteArray::fromRawData (d.dataStart, count);
        else
            res = QByteArray::fromRawData (d.dataEnd - count, count);
    } else {
        res = QByteArray (count, '\0');
    }
    bumpPtrs (count);
    return res;
}


QByteArray BinaryReader::readString (char terminator)
{
    QByteArray res;
    if (d.readOrigin == ReadFromStart) {
        char *pos = d.dataStart;
        while (pos < d.dataEnd && *pos != terminator)
            res.append (*pos++); // could potentially throw bad_alloc.
        // Eigher a zero, or the end was reached, step past it:
        d.dataStart = ++pos;
    } else {
        char *pos = d.dataEnd;
        --pos; // Move on the last byte, don't stay past it.
        while (pos >= d.dataStart && *pos != terminator)
            res.prepend (*pos--); // could potentially throw bad_alloc.
        d.dataEnd = pos;
    }
    return res;
}


void BinaryReader::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);
}


void BinaryReader::setReadOrigin (ReadOrigin readOrigin)
{
    Q_ASSERT (d.readOrigin == ReadFromStart || d.readOrigin == ReadFromEnd);
    d.readOrigin = readOrigin;
}


bool BinaryReader::hasReadPastEnd() const
{
    return d.dataStart > d.dataEnd;
}


bool BinaryReader::hasReadAll() const
{
    return d.dataStart >= d.dataEnd;
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.