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 "Imports.cpp"

BinaryWriter::BinaryWriter (QByteArray *buffer, bool autoGrow)
    : BinaryWriterBase (buffer, LittleEndian, autoGrow)
{
}

BinaryWriter::BinaryWriter (bool autoGrow)
       : BinaryWriterBase (LittleEndian, autoGrow)
{
}


void BinaryWriter::writeUuid (const QUuid &uuid)
{
    setByteOrder (BigEndian);
    writeUInt32 (uuid.data1);
    writeUInt16 (uuid.data2);
    writeUInt16 (uuid.data3);
    writeByte (uuid.data4[0]);
    writeByte (uuid.data4[1]);
    writeByte (uuid.data4[2]);
    writeByte (uuid.data4[3]);
    writeByte (uuid.data4[4]);
    writeByte (uuid.data4[5]);
    writeByte (uuid.data4[6]);
    writeByte (uuid.data4[7]);
    setByteOrder (LittleEndian);
}


void BinaryWriter::writeIPv4Address (const QHostAddress &address)
{
    Q_ASSERT (address.protocol() == QAbstractSocket::IPv4Protocol
             || address.isNull());
    setByteOrder (BigEndian);
    writeUInt32 (address.toIPv4Address());
    setByteOrder (LittleEndian);
}


void BinaryWriter::writeGgepBlock (const GgepBlock &block)
{
    using Extensions::Ggep;
    if (block.extensions().count() == 0)
        return;

    writeByte (GgepBlock::MagicByte);
    const Ggep *lastExtension = block.extensions().last();
    foreach (const Ggep* extension, block.extensions()) {
        writeGgepBlockExtensionHeader (extension, lastExtension);

        QByteArray rawData (extension->rawData());
        writeGgepBlockDataLength (rawData.length());

        writeBytes (rawData);
    }
}


void BinaryWriter::writeGgepBlockExtensionHeader (const Ggep *extension,
                                                  const Ggep *lastExtension)
{
    uchar flags = 0x00;
    if (extension->isFlagSet (Ggep::Compression))
        flags |= Ggep::Compression;
    if (extension->isFlagSet (Ggep::Encoding))
        flags |= Ggep::Encoding;
    if (extension == lastExtension)
        flags |= Ggep::LastExtension;
    flags |= extension->id().size();

    writeByte (static_cast <uchar> (flags));        // flags
    writeBytes (extension->id());                   // ID
}


void BinaryWriter::writeGgepBlockDataLength (int length)
{
    do {
        uchar byte = length & 0x3F;
        length >>= 6;
        byte |= (length > 0) ? 0x80 : 0x40;
        writeByte (byte);                           // length byte
    } while (length > 0);
}


void BinaryWriter::writeQueryData (const QueryData &data)
{
    writeHugeGemBlock (data);
}


void BinaryWriter::writeMinSpeed (const MinSpeed &speed)
{
    uchar flags = 0x80;

    if(speed.isFirewalled)
        flags |= 0x40;
    if(speed.wantXmlMetadata)
        flags |= 0x20;
    if(speed.isLeafGuidedDynamicQuery)
        flags |= 0x10;
    if(speed.isAllowedGgepH)
        flags |= 0x08;
    if(speed.isOutOfBoundQuery)
        flags |= 0x04;

    writeByte (flags);
    writeByte (speed.maxQueryHits);
}


void BinaryWriter::writeVendorCode (const VendorCode &code)
{
    writeBytes (code.toBytes());
}


void BinaryWriter::writeHugeGemBlock (const HugeGemBlock &block)
{
    QList <QByteArray> extensions;

    extensions += block.urnList;
    extensions += block.unknownList;
    extensions += block.xmlList;

    if(block.ggepBlock.extensions().size() > 0) {
        BinaryWriter writer;
        writer.writeGgepBlock (block.ggepBlock);
        extensions += writer.buffer();
    }

    // Write the first extension and remove it from the list:
    if (!extensions.isEmpty())
        writeBytes (extensions.takeFirst());
    // Write further extensions, if any:
    foreach (const QByteArray extension, extensions) {
        writeByte ('\x1c');
        writeBytes (extension);
    }
}


void BinaryWriter::writeQueryHitsData (const QueryHitsData &hitsData)
{
    writeVendorCode (hitsData.vendorCode);

    if(hitsData.xmlData.size() > 0)
        writeByte ('\x04');
    else
        writeByte ('\x02');

    // Prepare the OpenAreaFlags:
    uchar flags1 = 0x3C; // Enable all known flags (except push): 00111100
    uchar flags2 = 0x01; // Enable the push flag here: 00000001
    // Set the corresponfing the bits if the field is set:
    if(hitsData.ggepBlock.extensions().count() > 0)     flags2 |= 0x20;
    if(hitsData.flagUploadSpeed)                        flags2 |= 0x10;
    if(hitsData.flagHaveUploaded)                       flags2 |= 0x08;
    if(hitsData.flagBusy)                               flags2 |= 0x04;
    if(hitsData.flagPush)                               flags1 |= 0x01;
    // Write the flags:
    writeByte (flags1);
    writeByte (flags2);

    // Write the xmlData length + 1 (for the ending zero byte):
    if(hitsData.xmlData.size() > 0)
        writeUInt16 (static_cast <quint16> (hitsData.xmlData.size() + 1));

    // Write any aditional private data:
    writeBytes (hitsData.privateVendor);

    // Write the GGEP block:
    writeGgepBlock (hitsData.ggepBlock);

    // Write the xmlData itself followed by a zero byte:
    if(hitsData.xmlData.size() > 0) {
        writeBytes (hitsData.xmlData);
        writeByte('\0');
    }

    // Finally write the serventId:
    writeUuid (hitsData.serventId);
}


void BinaryWriter::writeQueryHitsResultSet (const ResultSet &resultSet)
{
    foreach(const Result result, resultSet) {
        writeUInt32 (result.fileIndex);
        writeUInt32 (result.fileSize);
        writeString (result.fullFileName.toUtf8());
        writeHugeGemBlock (result.resultData);
        writeByte ('\0');
    }
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.