mirror of
https://github.com/Cockatrice/Cockatrice.git
synced 2026-04-27 07:48:01 -07:00
Move stuff to src/utility/external
Took 10 minutes Took 4 seconds
This commit is contained in:
Lukas Brübach
parent
c55af67325
commit
e08f28b110
13 changed files with 0 additions and 4984 deletions
|
|
@ -1,250 +0,0 @@
|
|||
/*
|
||||
* Simple routing to extract a single file from a xz archive
|
||||
* Heavily based from doc/examples/02_decompress.c obtained from
|
||||
* the official xz git repository: git.tukaani.org/xz.git
|
||||
* The license from the original file header follows
|
||||
*
|
||||
* Author: Lasse Collin
|
||||
* This file has been put into the public domain.
|
||||
* You can do whatever you want with this file.
|
||||
*/
|
||||
|
||||
|
||||
#include <lzma.h>
|
||||
#include <QDebug>
|
||||
|
||||
#include "decompress.h"
|
||||
|
||||
XzDecompressor::XzDecompressor(QObject *parent)
|
||||
: QObject(parent)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
bool XzDecompressor::decompress(QBuffer *in, QBuffer *out)
|
||||
{
|
||||
lzma_stream strm = LZMA_STREAM_INIT;
|
||||
bool success;
|
||||
|
||||
if (!init_decoder(&strm)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
success = internal_decompress(&strm, in, out);
|
||||
|
||||
// Free the memory allocated for the decoder. This only needs to be
|
||||
// done after the last file.
|
||||
lzma_end(&strm);
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
bool XzDecompressor::init_decoder(lzma_stream *strm)
|
||||
{
|
||||
// Initialize a .xz decoder. The decoder supports a memory usage limit
|
||||
// and a set of flags.
|
||||
//
|
||||
// The memory usage of the decompressor depends on the settings used
|
||||
// to compress a .xz file. It can vary from less than a megabyte to
|
||||
// a few gigabytes, but in practice (at least for now) it rarely
|
||||
// exceeds 65 MiB because that's how much memory is required to
|
||||
// decompress files created with "xz -9". Settings requiring more
|
||||
// memory take extra effort to use and don't (at least for now)
|
||||
// provide significantly better compression in most cases.
|
||||
//
|
||||
// Memory usage limit is useful if it is important that the
|
||||
// decompressor won't consume gigabytes of memory. The need
|
||||
// for limiting depends on the application. In this example,
|
||||
// no memory usage limiting is used. This is done by setting
|
||||
// the limit to UINT64_MAX.
|
||||
//
|
||||
// The .xz format allows concatenating compressed files as is:
|
||||
//
|
||||
// echo foo | xz > foobar.xz
|
||||
// echo bar | xz >> foobar.xz
|
||||
//
|
||||
// When decompressing normal standalone .xz files, LZMA_CONCATENATED
|
||||
// should always be used to support decompression of concatenated
|
||||
// .xz files. If LZMA_CONCATENATED isn't used, the decoder will stop
|
||||
// after the first .xz stream. This can be useful when .xz data has
|
||||
// been embedded inside another file format.
|
||||
//
|
||||
// Flags other than LZMA_CONCATENATED are supported too, and can
|
||||
// be combined with bitwise-or. See lzma/container.h
|
||||
// (src/liblzma/api/lzma/container.h in the source package or e.g.
|
||||
// /usr/include/lzma/container.h depending on the install prefix)
|
||||
// for details.
|
||||
lzma_ret ret = lzma_stream_decoder(
|
||||
strm, UINT64_MAX, LZMA_CONCATENATED);
|
||||
|
||||
// Return successfully if the initialization went fine.
|
||||
if (ret == LZMA_OK)
|
||||
return true;
|
||||
|
||||
// Something went wrong. The possible errors are documented in
|
||||
// lzma/container.h (src/liblzma/api/lzma/container.h in the source
|
||||
// package or e.g. /usr/include/lzma/container.h depending on the
|
||||
// install prefix).
|
||||
//
|
||||
// Note that LZMA_MEMLIMIT_ERROR is never possible here. If you
|
||||
// specify a very tiny limit, the error will be delayed until
|
||||
// the first headers have been parsed by a call to lzma_code().
|
||||
const char *msg;
|
||||
switch (ret) {
|
||||
case LZMA_MEM_ERROR:
|
||||
msg = "Memory allocation failed";
|
||||
break;
|
||||
|
||||
case LZMA_OPTIONS_ERROR:
|
||||
msg = "Unsupported decompressor flags";
|
||||
break;
|
||||
|
||||
default:
|
||||
// This is most likely LZMA_PROG_ERROR indicating a bug in
|
||||
// this program or in liblzma. It is inconvenient to have a
|
||||
// separate error message for errors that should be impossible
|
||||
// to occur, but knowing the error code is important for
|
||||
// debugging. That's why it is good to print the error code
|
||||
// at least when there is no good error message to show.
|
||||
msg = "Unknown error, possibly a bug";
|
||||
break;
|
||||
}
|
||||
|
||||
qDebug() << "Error initializing the decoder:" << msg << "(error code " << ret << ")";
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool XzDecompressor::internal_decompress(lzma_stream *strm, QBuffer *in, QBuffer *out)
|
||||
{
|
||||
// When LZMA_CONCATENATED flag was used when initializing the decoder,
|
||||
// we need to tell lzma_code() when there will be no more input.
|
||||
// This is done by setting action to LZMA_FINISH instead of LZMA_RUN
|
||||
// in the same way as it is done when encoding.
|
||||
//
|
||||
// When LZMA_CONCATENATED isn't used, there is no need to use
|
||||
// LZMA_FINISH to tell when all the input has been read, but it
|
||||
// is still OK to use it if you want. When LZMA_CONCATENATED isn't
|
||||
// used, the decoder will stop after the first .xz stream. In that
|
||||
// case some unused data may be left in strm->next_in.
|
||||
lzma_action action = LZMA_RUN;
|
||||
|
||||
uint8_t inbuf[BUFSIZ];
|
||||
uint8_t outbuf[BUFSIZ];
|
||||
qint64 bytesAvailable;
|
||||
|
||||
strm->next_in = NULL;
|
||||
strm->avail_in = 0;
|
||||
strm->next_out = outbuf;
|
||||
strm->avail_out = sizeof(outbuf);
|
||||
while (true) {
|
||||
if (strm->avail_in == 0) {
|
||||
strm->next_in = inbuf;
|
||||
bytesAvailable = in->bytesAvailable();
|
||||
if(bytesAvailable == 0) {
|
||||
// Once the end of the input file has been reached,
|
||||
// we need to tell lzma_code() that no more input
|
||||
// will be coming. As said before, this isn't required
|
||||
// if the LZMA_CONCATENATED flag isn't used when
|
||||
// initializing the decoder.
|
||||
action = LZMA_FINISH;
|
||||
} else if(bytesAvailable >= BUFSIZ) {
|
||||
in->read((char*) inbuf, BUFSIZ);
|
||||
strm->avail_in = BUFSIZ;
|
||||
} else {
|
||||
in->read((char*) inbuf, bytesAvailable);
|
||||
strm->avail_in = bytesAvailable;
|
||||
}
|
||||
}
|
||||
|
||||
lzma_ret ret = lzma_code(strm, action);
|
||||
|
||||
if (strm->avail_out == 0 || ret == LZMA_STREAM_END) {
|
||||
qint64 write_size = sizeof(outbuf) - strm->avail_out;
|
||||
|
||||
if (out->write((char *) outbuf, write_size) != write_size) {
|
||||
qDebug() << "Write error";
|
||||
return false;
|
||||
}
|
||||
|
||||
strm->next_out = outbuf;
|
||||
strm->avail_out = sizeof(outbuf);
|
||||
}
|
||||
|
||||
if (ret != LZMA_OK) {
|
||||
// Once everything has been decoded successfully, the
|
||||
// return value of lzma_code() will be LZMA_STREAM_END.
|
||||
//
|
||||
// It is important to check for LZMA_STREAM_END. Do not
|
||||
// assume that getting ret != LZMA_OK would mean that
|
||||
// everything has gone well or that when you aren't
|
||||
// getting more output it must have successfully
|
||||
// decoded everything.
|
||||
if (ret == LZMA_STREAM_END)
|
||||
return true;
|
||||
|
||||
// It's not LZMA_OK nor LZMA_STREAM_END,
|
||||
// so it must be an error code. See lzma/base.h
|
||||
// (src/liblzma/api/lzma/base.h in the source package
|
||||
// or e.g. /usr/include/lzma/base.h depending on the
|
||||
// install prefix) for the list and documentation of
|
||||
// possible values. Many values listen in lzma_ret
|
||||
// enumeration aren't possible in this example, but
|
||||
// can be made possible by enabling memory usage limit
|
||||
// or adding flags to the decoder initialization.
|
||||
const char *msg;
|
||||
switch (ret) {
|
||||
case LZMA_MEM_ERROR:
|
||||
msg = "Memory allocation failed";
|
||||
break;
|
||||
|
||||
case LZMA_FORMAT_ERROR:
|
||||
// .xz magic bytes weren't found.
|
||||
msg = "The input is not in the .xz format";
|
||||
break;
|
||||
|
||||
case LZMA_OPTIONS_ERROR:
|
||||
// For example, the headers specify a filter
|
||||
// that isn't supported by this liblzma
|
||||
// version (or it hasn't been enabled when
|
||||
// building liblzma, but no-one sane does
|
||||
// that unless building liblzma for an
|
||||
// embedded system). Upgrading to a newer
|
||||
// liblzma might help.
|
||||
//
|
||||
// Note that it is unlikely that the file has
|
||||
// accidentally became corrupt if you get this
|
||||
// error. The integrity of the .xz headers is
|
||||
// always verified with a CRC32, so
|
||||
// unintentionally corrupt files can be
|
||||
// distinguished from unsupported files.
|
||||
msg = "Unsupported compression options";
|
||||
break;
|
||||
|
||||
case LZMA_DATA_ERROR:
|
||||
msg = "Compressed file is corrupt";
|
||||
break;
|
||||
|
||||
case LZMA_BUF_ERROR:
|
||||
// Typically this error means that a valid
|
||||
// file has got truncated, but it might also
|
||||
// be a damaged part in the file that makes
|
||||
// the decoder think the file is truncated.
|
||||
// If you prefer, you can use the same error
|
||||
// message for this as for LZMA_DATA_ERROR.
|
||||
msg = "Compressed file is truncated or "
|
||||
"otherwise corrupt";
|
||||
break;
|
||||
|
||||
default:
|
||||
// This is most likely LZMA_PROG_ERROR.
|
||||
msg = "Unknown error, possibly a bug";
|
||||
break;
|
||||
}
|
||||
|
||||
qDebug() << "Decoder error:" << msg << "(error code " << ret << ")";
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
#ifndef XZ_DECOMPRESS_H
|
||||
#define XZ_DECOMPRESS_H
|
||||
|
||||
#include <lzma.h>
|
||||
#include <QBuffer>
|
||||
|
||||
class XzDecompressor : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
public:
|
||||
XzDecompressor(QObject *parent = 0);
|
||||
~XzDecompressor() { };
|
||||
bool decompress(QBuffer *in, QBuffer *out);
|
||||
private:
|
||||
bool init_decoder(lzma_stream *strm);
|
||||
bool internal_decompress(lzma_stream *strm, QBuffer *in, QBuffer *out);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -1,573 +0,0 @@
|
|||
/* Copyright 2011 Eeli Reilin. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright notice,
|
||||
* this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
* this list of conditions and the following disclaimer in the documentation
|
||||
* and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ''AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
|
||||
* EVENT SHALL EELI REILIN OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
||||
* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
||||
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
* The views and conclusions contained in the software and documentation
|
||||
* are those of the authors and should not be interpreted as representing
|
||||
* official policies, either expressed or implied, of Eeli Reilin.
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file json.cpp
|
||||
*/
|
||||
|
||||
#include "json.h"
|
||||
|
||||
#include <QMetaType>
|
||||
#include <iostream>
|
||||
|
||||
namespace QtJson
|
||||
{
|
||||
|
||||
static QString sanitizeString(QString str)
|
||||
{
|
||||
str.replace(QLatin1String("\\"), QLatin1String("\\\\"));
|
||||
str.replace(QLatin1String("\""), QLatin1String("\\\""));
|
||||
str.replace(QLatin1String("\b"), QLatin1String("\\b"));
|
||||
str.replace(QLatin1String("\f"), QLatin1String("\\f"));
|
||||
str.replace(QLatin1String("\n"), QLatin1String("\\n"));
|
||||
str.replace(QLatin1String("\r"), QLatin1String("\\r"));
|
||||
str.replace(QLatin1String("\t"), QLatin1String("\\t"));
|
||||
return QString(QLatin1String("\"%1\"")).arg(str);
|
||||
}
|
||||
|
||||
static QByteArray join(const QList<QByteArray> &list, const QByteArray &sep)
|
||||
{
|
||||
QByteArray res;
|
||||
for (const QByteArray &i : list) {
|
||||
if (!res.isEmpty()) {
|
||||
res += sep;
|
||||
}
|
||||
res += i;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/**
|
||||
* parse
|
||||
*/
|
||||
QVariant Json::parse(const QString &json)
|
||||
{
|
||||
bool success = true;
|
||||
return Json::parse(json, success);
|
||||
}
|
||||
|
||||
/**
|
||||
* parse
|
||||
*/
|
||||
QVariant Json::parse(const QString &json, bool &success)
|
||||
{
|
||||
success = true;
|
||||
|
||||
// Return an empty QVariant if the JSON data is either null or empty
|
||||
if (!json.isNull() || !json.isEmpty()) {
|
||||
// We'll start from index 0
|
||||
int index = 0;
|
||||
|
||||
// Parse the first value
|
||||
QVariant value = Json::parseValue(json, index, success);
|
||||
|
||||
// Return the parsed value
|
||||
return value;
|
||||
} else {
|
||||
// Return the empty QVariant
|
||||
return QVariant();
|
||||
}
|
||||
}
|
||||
|
||||
QByteArray Json::serialize(const QVariant &data)
|
||||
{
|
||||
bool success = true;
|
||||
return Json::serialize(data, success);
|
||||
}
|
||||
|
||||
QByteArray Json::serialize(const QVariant &data, bool &success)
|
||||
{
|
||||
QByteArray str;
|
||||
success = true;
|
||||
|
||||
if (!data.isValid()) // invalid or null?
|
||||
{
|
||||
str = "null";
|
||||
}
|
||||
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
|
||||
else if ((data.typeId() == QMetaType::Type::QVariantList) ||
|
||||
(data.typeId() == QMetaType::Type::QStringList)) // variant is a list?
|
||||
#else
|
||||
else if ((data.type() == QVariant::List) || (data.type() == QVariant::StringList)) // variant is a list?
|
||||
#endif
|
||||
{
|
||||
QList<QByteArray> values;
|
||||
const QVariantList list = data.toList();
|
||||
for (const QVariant &v : list) {
|
||||
QByteArray serializedValue = serialize(v);
|
||||
if (serializedValue.isNull()) {
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
values << serializedValue;
|
||||
}
|
||||
|
||||
str = "[ " + join(values, ", ") + " ]";
|
||||
}
|
||||
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
|
||||
else if ((data.typeId() == QMetaType::Type::QVariantHash)) // variant is a list?
|
||||
#else
|
||||
else if (data.type() == QVariant::Hash) // variant is a hash?
|
||||
#endif
|
||||
{
|
||||
const QVariantHash vhash = data.toHash();
|
||||
QHashIterator<QString, QVariant> it(vhash);
|
||||
str = "{ ";
|
||||
QList<QByteArray> pairs;
|
||||
|
||||
while (it.hasNext()) {
|
||||
it.next();
|
||||
QByteArray serializedValue = serialize(it.value());
|
||||
|
||||
if (serializedValue.isNull()) {
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
|
||||
pairs << sanitizeString(it.key()).toUtf8() + " : " + serializedValue;
|
||||
}
|
||||
|
||||
str += join(pairs, ", ");
|
||||
str += " }";
|
||||
}
|
||||
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
|
||||
else if ((data.typeId() == QMetaType::Type::QVariantMap)) // variant is a list?
|
||||
#else
|
||||
else if (data.type() == QVariant::Map) // variant is a map?
|
||||
#endif
|
||||
{
|
||||
const QVariantMap vmap = data.toMap();
|
||||
QMapIterator<QString, QVariant> it(vmap);
|
||||
str = "{ ";
|
||||
QList<QByteArray> pairs;
|
||||
while (it.hasNext()) {
|
||||
it.next();
|
||||
QByteArray serializedValue = serialize(it.value());
|
||||
if (serializedValue.isNull()) {
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
pairs << sanitizeString(it.key()).toUtf8() + " : " + serializedValue;
|
||||
}
|
||||
str += join(pairs, ", ");
|
||||
str += " }";
|
||||
}
|
||||
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
|
||||
else if ((data.typeId() == QMetaType::Type::QString) ||
|
||||
(data.typeId() == QMetaType::Type::QByteArray)) // variant is a list?
|
||||
#else
|
||||
else if ((data.type() == QVariant::String) || (data.type() == QVariant::ByteArray)) // a string or a byte array?
|
||||
#endif
|
||||
{
|
||||
str = sanitizeString(data.toString()).toUtf8();
|
||||
}
|
||||
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
|
||||
else if (data.typeId() == QMetaType::Type::Double)
|
||||
#else
|
||||
else if (data.type() == QVariant::Double) // double?
|
||||
#endif
|
||||
{
|
||||
str = QByteArray::number(data.toDouble(), 'g', 20);
|
||||
if (!str.contains(".") && !str.contains("e")) {
|
||||
str += ".0";
|
||||
}
|
||||
}
|
||||
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
|
||||
else if (data.typeId() == QMetaType::Type::Bool)
|
||||
#else
|
||||
else if (data.type() == QVariant::Bool) // boolean value?
|
||||
#endif
|
||||
{
|
||||
str = data.toBool() ? "true" : "false";
|
||||
}
|
||||
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
|
||||
else if (data.typeId() == QMetaType::Type::ULongLong)
|
||||
#else
|
||||
else if (data.type() == QVariant::ULongLong) // large unsigned number?
|
||||
#endif
|
||||
{
|
||||
str = QByteArray::number(data.value<qulonglong>());
|
||||
} else if (data.canConvert<qlonglong>()) // any signed number?
|
||||
{
|
||||
str = QByteArray::number(data.value<qlonglong>());
|
||||
} else if (data.canConvert<long>()) {
|
||||
str = QString::number(data.value<long>()).toUtf8();
|
||||
} else if (data.canConvert<QString>()) // can value be converted to string?
|
||||
{
|
||||
// this will catch QDate, QDateTime, QUrl, ...
|
||||
str = sanitizeString(data.toString()).toUtf8();
|
||||
} else {
|
||||
success = false;
|
||||
}
|
||||
if (success) {
|
||||
return str;
|
||||
} else {
|
||||
return QByteArray();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* parseValue
|
||||
*/
|
||||
QVariant Json::parseValue(const QString &json, int &index, bool &success)
|
||||
{
|
||||
// Determine what kind of data we should parse by
|
||||
// checking out the upcoming token
|
||||
switch (Json::lookAhead(json, index)) {
|
||||
case JsonTokenString:
|
||||
return Json::parseString(json, index, success);
|
||||
case JsonTokenNumber:
|
||||
return Json::parseNumber(json, index);
|
||||
case JsonTokenCurlyOpen:
|
||||
return Json::parseObject(json, index, success);
|
||||
case JsonTokenSquaredOpen:
|
||||
return Json::parseArray(json, index, success);
|
||||
case JsonTokenTrue:
|
||||
Json::nextToken(json, index);
|
||||
return QVariant(true);
|
||||
case JsonTokenFalse:
|
||||
Json::nextToken(json, index);
|
||||
return QVariant(false);
|
||||
case JsonTokenNull:
|
||||
Json::nextToken(json, index);
|
||||
return QVariant();
|
||||
case JsonTokenNone:
|
||||
break;
|
||||
}
|
||||
|
||||
// If there were no tokens, flag the failure and return an empty QVariant
|
||||
success = false;
|
||||
return QVariant();
|
||||
}
|
||||
|
||||
/**
|
||||
* parseObject
|
||||
*/
|
||||
QVariant Json::parseObject(const QString &json, int &index, bool &success)
|
||||
{
|
||||
QVariantMap map;
|
||||
int token;
|
||||
|
||||
// Get rid of the whitespace and increment index
|
||||
Json::nextToken(json, index);
|
||||
|
||||
// Loop through all of the key/value pairs of the object
|
||||
bool done = false;
|
||||
while (!done) {
|
||||
// Get the upcoming token
|
||||
token = Json::lookAhead(json, index);
|
||||
|
||||
if (token == JsonTokenNone) {
|
||||
success = false;
|
||||
return QVariantMap();
|
||||
} else if (token == JsonTokenComma) {
|
||||
Json::nextToken(json, index);
|
||||
} else if (token == JsonTokenCurlyClose) {
|
||||
Json::nextToken(json, index);
|
||||
return map;
|
||||
} else {
|
||||
// Parse the key/value pair's name
|
||||
QString name = Json::parseString(json, index, success).toString();
|
||||
|
||||
if (!success) {
|
||||
return QVariantMap();
|
||||
}
|
||||
|
||||
// Get the next token
|
||||
token = Json::nextToken(json, index);
|
||||
|
||||
// If the next token is not a colon, flag the failure
|
||||
// return an empty QVariant
|
||||
if (token != JsonTokenColon) {
|
||||
success = false;
|
||||
return QVariant(QVariantMap());
|
||||
}
|
||||
|
||||
// Parse the key/value pair's value
|
||||
QVariant value = Json::parseValue(json, index, success);
|
||||
|
||||
if (!success) {
|
||||
return QVariantMap();
|
||||
}
|
||||
|
||||
// Assign the value to the key in the map
|
||||
map[name] = value;
|
||||
}
|
||||
}
|
||||
|
||||
// Return the map successfully
|
||||
return QVariant(map);
|
||||
}
|
||||
|
||||
/**
|
||||
* parseArray
|
||||
*/
|
||||
QVariant Json::parseArray(const QString &json, int &index, bool &success)
|
||||
{
|
||||
QVariantList list;
|
||||
|
||||
Json::nextToken(json, index);
|
||||
|
||||
bool done = false;
|
||||
while (!done) {
|
||||
int token = Json::lookAhead(json, index);
|
||||
|
||||
if (token == JsonTokenNone) {
|
||||
success = false;
|
||||
return QVariantList();
|
||||
} else if (token == JsonTokenComma) {
|
||||
Json::nextToken(json, index);
|
||||
} else if (token == JsonTokenSquaredClose) {
|
||||
Json::nextToken(json, index);
|
||||
break;
|
||||
} else {
|
||||
QVariant value = Json::parseValue(json, index, success);
|
||||
|
||||
if (!success) {
|
||||
return QVariantList();
|
||||
}
|
||||
|
||||
list.push_back(value);
|
||||
}
|
||||
}
|
||||
|
||||
return QVariant(list);
|
||||
}
|
||||
|
||||
/**
|
||||
* parseString
|
||||
*/
|
||||
QVariant Json::parseString(const QString &json, int &index, bool &success)
|
||||
{
|
||||
QString s;
|
||||
QChar c;
|
||||
|
||||
Json::eatWhitespace(json, index);
|
||||
|
||||
c = json[index++];
|
||||
|
||||
bool complete = false;
|
||||
while (!complete) {
|
||||
if (index == json.size()) {
|
||||
break;
|
||||
}
|
||||
|
||||
c = json[index++];
|
||||
|
||||
if (c == '\"') {
|
||||
complete = true;
|
||||
break;
|
||||
} else if (c == '\\') {
|
||||
if (index == json.size()) {
|
||||
break;
|
||||
}
|
||||
|
||||
c = json[index++];
|
||||
|
||||
if (c == '\"') {
|
||||
s.append('\"');
|
||||
} else if (c == '\\') {
|
||||
s.append('\\');
|
||||
} else if (c == '/') {
|
||||
s.append('/');
|
||||
} else if (c == 'b') {
|
||||
s.append('\b');
|
||||
} else if (c == 'f') {
|
||||
s.append('\f');
|
||||
} else if (c == 'n') {
|
||||
s.append('\n');
|
||||
} else if (c == 'r') {
|
||||
s.append('\r');
|
||||
} else if (c == 't') {
|
||||
s.append('\t');
|
||||
} else if (c == 'u') {
|
||||
int remainingLength = json.size() - index;
|
||||
|
||||
if (remainingLength >= 4) {
|
||||
QString unicodeStr = json.mid(index, 4);
|
||||
|
||||
int symbol = unicodeStr.toInt(0, 16);
|
||||
|
||||
s.append(QChar(symbol));
|
||||
|
||||
index += 4;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
s.append(c);
|
||||
}
|
||||
}
|
||||
|
||||
if (!complete) {
|
||||
success = false;
|
||||
return QVariant();
|
||||
}
|
||||
|
||||
return QVariant(s);
|
||||
}
|
||||
|
||||
/**
|
||||
* parseNumber
|
||||
*/
|
||||
QVariant Json::parseNumber(const QString &json, int &index)
|
||||
{
|
||||
Json::eatWhitespace(json, index);
|
||||
|
||||
int lastIndex = Json::lastIndexOfNumber(json, index);
|
||||
int charLength = (lastIndex - index) + 1;
|
||||
QString numberStr;
|
||||
|
||||
numberStr = json.mid(index, charLength);
|
||||
|
||||
index = lastIndex + 1;
|
||||
|
||||
if (numberStr.contains('.')) {
|
||||
return QVariant(numberStr.toDouble(NULL));
|
||||
} else if (numberStr.startsWith('-')) {
|
||||
return QVariant(numberStr.toLongLong(NULL));
|
||||
} else {
|
||||
return QVariant(numberStr.toULongLong(NULL));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* lastIndexOfNumber
|
||||
*/
|
||||
int Json::lastIndexOfNumber(const QString &json, int index)
|
||||
{
|
||||
static const QString numericCharacters("0123456789+-.eE");
|
||||
int lastIndex;
|
||||
|
||||
for (lastIndex = index; lastIndex < json.size(); lastIndex++) {
|
||||
if (numericCharacters.indexOf(json[lastIndex]) == -1) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return lastIndex - 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* eatWhitespace
|
||||
*/
|
||||
void Json::eatWhitespace(const QString &json, int &index)
|
||||
{
|
||||
static const QString whitespaceChars(" \t\n\r");
|
||||
for (; index < json.size(); index++) {
|
||||
if (whitespaceChars.indexOf(json[index]) == -1) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* lookAhead
|
||||
*/
|
||||
int Json::lookAhead(const QString &json, int index)
|
||||
{
|
||||
int saveIndex = index;
|
||||
return Json::nextToken(json, saveIndex);
|
||||
}
|
||||
|
||||
/**
|
||||
* nextToken
|
||||
*/
|
||||
int Json::nextToken(const QString &json, int &index)
|
||||
{
|
||||
Json::eatWhitespace(json, index);
|
||||
|
||||
if (index == json.size()) {
|
||||
return JsonTokenNone;
|
||||
}
|
||||
|
||||
QChar c = json[index];
|
||||
index++;
|
||||
switch (c.toLatin1()) {
|
||||
case '{':
|
||||
return JsonTokenCurlyOpen;
|
||||
case '}':
|
||||
return JsonTokenCurlyClose;
|
||||
case '[':
|
||||
return JsonTokenSquaredOpen;
|
||||
case ']':
|
||||
return JsonTokenSquaredClose;
|
||||
case ',':
|
||||
return JsonTokenComma;
|
||||
case '"':
|
||||
return JsonTokenString;
|
||||
case '0':
|
||||
case '1':
|
||||
case '2':
|
||||
case '3':
|
||||
case '4':
|
||||
case '5':
|
||||
case '6':
|
||||
case '7':
|
||||
case '8':
|
||||
case '9':
|
||||
case '-':
|
||||
return JsonTokenNumber;
|
||||
case ':':
|
||||
return JsonTokenColon;
|
||||
}
|
||||
|
||||
index--;
|
||||
|
||||
int remainingLength = json.size() - index;
|
||||
|
||||
// True
|
||||
if (remainingLength >= 4) {
|
||||
if (json[index] == 't' && json[index + 1] == 'r' && json[index + 2] == 'u' && json[index + 3] == 'e') {
|
||||
index += 4;
|
||||
return JsonTokenTrue;
|
||||
}
|
||||
}
|
||||
|
||||
// False
|
||||
if (remainingLength >= 5) {
|
||||
if (json[index] == 'f' && json[index + 1] == 'a' && json[index + 2] == 'l' && json[index + 3] == 's' &&
|
||||
json[index + 4] == 'e') {
|
||||
index += 5;
|
||||
return JsonTokenFalse;
|
||||
}
|
||||
}
|
||||
|
||||
// Null
|
||||
if (remainingLength >= 4) {
|
||||
if (json[index] == 'n' && json[index + 1] == 'u' && json[index + 2] == 'l' && json[index + 3] == 'l') {
|
||||
index += 4;
|
||||
return JsonTokenNull;
|
||||
}
|
||||
}
|
||||
|
||||
return JsonTokenNone;
|
||||
}
|
||||
|
||||
} // namespace QtJson
|
||||
|
|
@ -1,204 +0,0 @@
|
|||
/* Copyright 2011 Eeli Reilin. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright notice,
|
||||
* this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
* this list of conditions and the following disclaimer in the documentation
|
||||
* and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ''AS IS'' AND ANY EXPRESS OR
|
||||
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
|
||||
* EVENT SHALL EELI REILIN OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
|
||||
* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
||||
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
* The views and conclusions contained in the software and documentation
|
||||
* are those of the authors and should not be interpreted as representing
|
||||
* official policies, either expressed or implied, of Eeli Reilin.
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file json.h
|
||||
*/
|
||||
|
||||
#ifndef JSON_H
|
||||
#define JSON_H
|
||||
|
||||
#include <QVariant>
|
||||
#include <QString>
|
||||
|
||||
namespace QtJson
|
||||
{
|
||||
|
||||
/**
|
||||
* \enum JsonToken
|
||||
*/
|
||||
enum JsonToken
|
||||
{
|
||||
JsonTokenNone = 0,
|
||||
JsonTokenCurlyOpen = 1,
|
||||
JsonTokenCurlyClose = 2,
|
||||
JsonTokenSquaredOpen = 3,
|
||||
JsonTokenSquaredClose = 4,
|
||||
JsonTokenColon = 5,
|
||||
JsonTokenComma = 6,
|
||||
JsonTokenString = 7,
|
||||
JsonTokenNumber = 8,
|
||||
JsonTokenTrue = 9,
|
||||
JsonTokenFalse = 10,
|
||||
JsonTokenNull = 11
|
||||
};
|
||||
|
||||
/**
|
||||
* \class Json
|
||||
* \brief A JSON data parser
|
||||
*
|
||||
* Json parses a JSON data into a QVariant hierarchy.
|
||||
*/
|
||||
class Json
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Parse a JSON string
|
||||
*
|
||||
* \param json The JSON data
|
||||
*/
|
||||
static QVariant parse(const QString &json);
|
||||
|
||||
/**
|
||||
* Parse a JSON string
|
||||
*
|
||||
* \param json The JSON data
|
||||
* \param success The success of the parsing
|
||||
*/
|
||||
static QVariant parse(const QString &json, bool &success);
|
||||
|
||||
/**
|
||||
* This method generates a textual JSON representation
|
||||
*
|
||||
* \param data The JSON data generated by the parser.
|
||||
* \param success The success of the serialization
|
||||
*/
|
||||
static QByteArray serialize(const QVariant &data);
|
||||
|
||||
/**
|
||||
* This method generates a textual JSON representation
|
||||
*
|
||||
* \param data The JSON data generated by the parser.
|
||||
* \param success The success of the serialization
|
||||
*
|
||||
* \return QByteArray Textual JSON representation
|
||||
*/
|
||||
static QByteArray serialize(const QVariant &data, bool &success);
|
||||
|
||||
private:
|
||||
/**
|
||||
* Parses a value starting from index
|
||||
*
|
||||
* \param json The JSON data
|
||||
* \param index The start index
|
||||
* \param success The success of the parse process
|
||||
*
|
||||
* \return QVariant The parsed value
|
||||
*/
|
||||
static QVariant parseValue(const QString &json, int &index,
|
||||
bool &success);
|
||||
|
||||
/**
|
||||
* Parses an object starting from index
|
||||
*
|
||||
* \param json The JSON data
|
||||
* \param index The start index
|
||||
* \param success The success of the object parse
|
||||
*
|
||||
* \return QVariant The parsed object map
|
||||
*/
|
||||
static QVariant parseObject(const QString &json, int &index,
|
||||
bool &success);
|
||||
|
||||
/**
|
||||
* Parses an array starting from index
|
||||
*
|
||||
* \param json The JSON data
|
||||
* \param index The starting index
|
||||
* \param success The success of the array parse
|
||||
*
|
||||
* \return QVariant The parsed variant array
|
||||
*/
|
||||
static QVariant parseArray(const QString &json, int &index,
|
||||
bool &success);
|
||||
|
||||
/**
|
||||
* Parses a string starting from index
|
||||
*
|
||||
* \param json The JSON data
|
||||
* \param index The starting index
|
||||
* \param success The success of the string parse
|
||||
*
|
||||
* \return QVariant The parsed string
|
||||
*/
|
||||
static QVariant parseString(const QString &json, int &index,
|
||||
bool &success);
|
||||
|
||||
/**
|
||||
* Parses a number starting from index
|
||||
*
|
||||
* \param json The JSON data
|
||||
* \param index The starting index
|
||||
*
|
||||
* \return QVariant The parsed number
|
||||
*/
|
||||
static QVariant parseNumber(const QString &json, int &index);
|
||||
|
||||
/**
|
||||
* Get the last index of a number starting from index
|
||||
*
|
||||
* \param json The JSON data
|
||||
* \param index The starting index
|
||||
*
|
||||
* \return The last index of the number
|
||||
*/
|
||||
static int lastIndexOfNumber(const QString &json, int index);
|
||||
|
||||
/**
|
||||
* Skip unwanted whitespace symbols starting from index
|
||||
*
|
||||
* \param json The JSON data
|
||||
* \param index The start index
|
||||
*/
|
||||
static void eatWhitespace(const QString &json, int &index);
|
||||
|
||||
/**
|
||||
* Check what token lies ahead
|
||||
*
|
||||
* \param json The JSON data
|
||||
* \param index The starting index
|
||||
*
|
||||
* \return int The upcoming token
|
||||
*/
|
||||
static int lookAhead(const QString &json, int index);
|
||||
|
||||
/**
|
||||
* Get the next JSON token
|
||||
*
|
||||
* \param json The JSON data
|
||||
* \param index The starting index
|
||||
*
|
||||
* \return int The next JSON token
|
||||
*/
|
||||
static int nextToken(const QString &json, int &index);
|
||||
};
|
||||
|
||||
|
||||
} //end namespace
|
||||
|
||||
#endif //JSON_H
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,155 +0,0 @@
|
|||
/****************************************************************************
|
||||
** Filename: unzip.h
|
||||
** Last updated [dd/mm/yyyy]: 27/03/2011
|
||||
**
|
||||
** pkzip 2.0 decompression.
|
||||
**
|
||||
** Some of the code has been inspired by other open source projects,
|
||||
** (mainly Info-Zip and Gilles Vollant's minizip).
|
||||
** Compression and decompression actually uses the zlib library.
|
||||
**
|
||||
** Copyright (C) 2007-2012 Angius Fabrizio. All rights reserved.
|
||||
**
|
||||
** This file is part of the OSDaB project (http://osdab.42cows.org/).
|
||||
**
|
||||
** This file may be distributed and/or modified under the terms of the
|
||||
** GNU General Public License version 2 as published by the Free Software
|
||||
** Foundation and appearing in the file LICENSE.GPL included in the
|
||||
** packaging of this file.
|
||||
**
|
||||
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
|
||||
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||||
**
|
||||
** See the file LICENSE.GPL that came with this software distribution or
|
||||
** visit http://www.gnu.org/copyleft/gpl.html for GPL licensing information.
|
||||
**
|
||||
**********************************************************************/
|
||||
|
||||
#ifndef OSDAB_UNZIP__H
|
||||
#define OSDAB_UNZIP__H
|
||||
|
||||
#include "zipglobal.h"
|
||||
|
||||
#include <QtCore/QDateTime>
|
||||
#include <QtCore/QMap>
|
||||
#include <QtCore/QtGlobal>
|
||||
#include <zlib.h>
|
||||
|
||||
class QDir;
|
||||
class QFile;
|
||||
class QIODevice;
|
||||
class QString;
|
||||
|
||||
OSDAB_BEGIN_NAMESPACE(Zip)
|
||||
|
||||
class UnzipPrivate;
|
||||
|
||||
class OSDAB_ZIP_EXPORT UnZip
|
||||
{
|
||||
public:
|
||||
enum ErrorCode
|
||||
{
|
||||
Ok,
|
||||
ZlibInit,
|
||||
ZlibError,
|
||||
OpenFailed,
|
||||
PartiallyCorrupted,
|
||||
Corrupted,
|
||||
WrongPassword,
|
||||
NoOpenArchive,
|
||||
FileNotFound,
|
||||
ReadFailed,
|
||||
WriteFailed,
|
||||
SeekFailed,
|
||||
CreateDirFailed,
|
||||
InvalidDevice,
|
||||
InvalidArchive,
|
||||
HeaderConsistencyError,
|
||||
|
||||
Skip,
|
||||
SkipAll // internal use only
|
||||
};
|
||||
|
||||
enum ExtractionOption
|
||||
{
|
||||
ExtractPaths = 0x0001,
|
||||
SkipPaths = 0x0002,
|
||||
VerifyOnly = 0x0004,
|
||||
NoSilentDirectoryCreation = 0x0008
|
||||
};
|
||||
Q_DECLARE_FLAGS(ExtractionOptions, ExtractionOption)
|
||||
|
||||
enum CompressionMethod
|
||||
{
|
||||
NoCompression,
|
||||
Deflated,
|
||||
UnknownCompression
|
||||
};
|
||||
|
||||
enum FileType
|
||||
{
|
||||
File,
|
||||
Directory
|
||||
};
|
||||
|
||||
struct ZipEntry
|
||||
{
|
||||
ZipEntry();
|
||||
|
||||
QString filename;
|
||||
QString comment;
|
||||
|
||||
quint32 compressedSize;
|
||||
quint32 uncompressedSize;
|
||||
quint32 crc32;
|
||||
|
||||
QDateTime lastModified;
|
||||
|
||||
CompressionMethod compression;
|
||||
FileType type;
|
||||
|
||||
bool encrypted;
|
||||
};
|
||||
|
||||
UnZip();
|
||||
virtual ~UnZip();
|
||||
|
||||
bool isOpen() const;
|
||||
|
||||
ErrorCode openArchive(const QString &filename);
|
||||
ErrorCode openArchive(QIODevice *device);
|
||||
void closeArchive();
|
||||
|
||||
QString archiveComment() const;
|
||||
|
||||
QString formatError(UnZip::ErrorCode c) const;
|
||||
|
||||
bool contains(const QString &file) const;
|
||||
|
||||
QStringList fileList() const;
|
||||
QList<ZipEntry> entryList() const;
|
||||
|
||||
ErrorCode verifyArchive();
|
||||
|
||||
ErrorCode extractAll(const QString &dirname, ExtractionOptions options = ExtractPaths);
|
||||
ErrorCode extractAll(const QDir &dir, ExtractionOptions options = ExtractPaths);
|
||||
|
||||
ErrorCode extractFile(const QString &filename, const QString &dirname, ExtractionOptions options = ExtractPaths);
|
||||
ErrorCode extractFile(const QString &filename, const QDir &dir, ExtractionOptions options = ExtractPaths);
|
||||
ErrorCode extractFile(const QString &filename, QIODevice *device, ExtractionOptions options = ExtractPaths);
|
||||
|
||||
ErrorCode
|
||||
extractFiles(const QStringList &filenames, const QString &dirname, ExtractionOptions options = ExtractPaths);
|
||||
ErrorCode extractFiles(const QStringList &filenames, const QDir &dir, ExtractionOptions options = ExtractPaths);
|
||||
|
||||
void setPassword(const QString &pwd);
|
||||
|
||||
private:
|
||||
UnzipPrivate *d;
|
||||
};
|
||||
|
||||
Q_DECLARE_OPERATORS_FOR_FLAGS(UnZip::ExtractionOptions)
|
||||
|
||||
OSDAB_END_NAMESPACE
|
||||
|
||||
#endif // OSDAB_UNZIP__H
|
||||
|
|
@ -1,130 +0,0 @@
|
|||
/****************************************************************************
|
||||
** Filename: unzip_p.h
|
||||
** Last updated [dd/mm/yyyy]: 27/03/2011
|
||||
**
|
||||
** pkzip 2.0 decompression.
|
||||
**
|
||||
** Some of the code has been inspired by other open source projects,
|
||||
** (mainly Info-Zip and Gilles Vollant's minizip).
|
||||
** Compression and decompression actually uses the zlib library.
|
||||
**
|
||||
** Copyright (C) 2007-2012 Angius Fabrizio. All rights reserved.
|
||||
**
|
||||
** This file is part of the OSDaB project (http://osdab.42cows.org/).
|
||||
**
|
||||
** This file may be distributed and/or modified under the terms of the
|
||||
** GNU General Public License version 2 as published by the Free Software
|
||||
** Foundation and appearing in the file LICENSE.GPL included in the
|
||||
** packaging of this file.
|
||||
**
|
||||
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
|
||||
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||||
**
|
||||
** See the file LICENSE.GPL that came with this software distribution or
|
||||
** visit http://www.gnu.org/copyleft/gpl.html for GPL licensing information.
|
||||
**
|
||||
**********************************************************************/
|
||||
|
||||
//
|
||||
// W A R N I N G
|
||||
// -------------
|
||||
//
|
||||
// This file is not part of the Zip/UnZip API. It exists purely as an
|
||||
// implementation detail. This header file may change from version to
|
||||
// version without notice, or even be removed.
|
||||
//
|
||||
// We mean it.
|
||||
//
|
||||
|
||||
#ifndef OSDAB_UNZIP_P__H
|
||||
#define OSDAB_UNZIP_P__H
|
||||
|
||||
#include "unzip.h"
|
||||
#include "zipentry_p.h"
|
||||
|
||||
#include <QtCore/QObject>
|
||||
#include <QtCore/QtGlobal>
|
||||
|
||||
// zLib authors suggest using larger buffers (128K or 256K) for (de)compression (especially for inflate())
|
||||
// we use a 256K buffer here - if you want to use this code on a pre-iceage mainframe please change it ;)
|
||||
#define UNZIP_READ_BUFFER (256*1024)
|
||||
|
||||
OSDAB_BEGIN_NAMESPACE(Zip)
|
||||
|
||||
class UnzipPrivate : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
UnzipPrivate();
|
||||
|
||||
// Replace this with whatever else you use to store/retrieve the password.
|
||||
QString password;
|
||||
|
||||
bool skipAllEncrypted;
|
||||
|
||||
QMap<QString,ZipEntryP*>* headers;
|
||||
|
||||
QIODevice* device;
|
||||
QFile* file;
|
||||
|
||||
char buffer1[UNZIP_READ_BUFFER];
|
||||
char buffer2[UNZIP_READ_BUFFER];
|
||||
|
||||
unsigned char* uBuffer;
|
||||
const quint32* crcTable;
|
||||
|
||||
// Central Directory (CD) offset
|
||||
quint32 cdOffset;
|
||||
// End of Central Directory (EOCD) offset
|
||||
quint32 eocdOffset;
|
||||
|
||||
// Number of entries in the Central Directory (as to the EOCD record)
|
||||
quint16 cdEntryCount;
|
||||
|
||||
// The number of detected entries that have been skipped because of a non compatible format
|
||||
quint16 unsupportedEntryCount;
|
||||
|
||||
QString comment;
|
||||
|
||||
UnZip::ErrorCode openArchive(QIODevice* device);
|
||||
|
||||
UnZip::ErrorCode seekToCentralDirectory();
|
||||
UnZip::ErrorCode parseCentralDirectoryRecord();
|
||||
UnZip::ErrorCode parseLocalHeaderRecord(const QString& path, const ZipEntryP& entry);
|
||||
|
||||
void closeArchive();
|
||||
|
||||
UnZip::ErrorCode extractFile(const QString& path, const ZipEntryP& entry, const QDir& dir, UnZip::ExtractionOptions options);
|
||||
UnZip::ErrorCode extractFile(const QString& path, const ZipEntryP& entry, QIODevice* device, UnZip::ExtractionOptions options);
|
||||
|
||||
UnZip::ErrorCode testPassword(quint32* keys, const QString&_file, const ZipEntryP& header);
|
||||
bool testKeys(const ZipEntryP& header, quint32* keys);
|
||||
|
||||
bool createDirectory(const QString& path);
|
||||
|
||||
inline void decryptBytes(quint32* keys, char* buffer, qint64 read);
|
||||
|
||||
inline quint32 getULong(const unsigned char* data, quint32 offset) const;
|
||||
inline quint64 getULLong(const unsigned char* data, quint32 offset) const;
|
||||
inline quint16 getUShort(const unsigned char* data, quint32 offset) const;
|
||||
inline int decryptByte(quint32 key2) const;
|
||||
inline void updateKeys(quint32* keys, int c) const;
|
||||
inline void initKeys(const QString& pwd, quint32* keys) const;
|
||||
|
||||
inline QDateTime convertDateTime(const unsigned char date[2], const unsigned char time[2]) const;
|
||||
|
||||
private slots:
|
||||
void deviceDestroyed(QObject*);
|
||||
|
||||
private:
|
||||
UnZip::ErrorCode extractStoredFile(const quint32 szComp, quint32** keys,
|
||||
quint32& myCRC, QIODevice* outDev, UnZip::ExtractionOptions options);
|
||||
UnZip::ErrorCode inflateFile(const quint32 szComp, quint32** keys,
|
||||
quint32& myCRC, QIODevice* outDev, UnZip::ExtractionOptions options);
|
||||
void do_closeArchive();
|
||||
};
|
||||
|
||||
OSDAB_END_NAMESPACE
|
||||
|
||||
#endif // OSDAB_UNZIP_P__H
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,158 +0,0 @@
|
|||
/****************************************************************************
|
||||
** Filename: zip.h
|
||||
** Last updated [dd/mm/yyyy]: 27/03/2011
|
||||
**
|
||||
** pkzip 2.0 file compression.
|
||||
**
|
||||
** Some of the code has been inspired by other open source projects,
|
||||
** (mainly Info-Zip and Gilles Vollant's minizip).
|
||||
** Compression and decompression actually uses the zlib library.
|
||||
**
|
||||
** Copyright (C) 2007-2012 Angius Fabrizio. All rights reserved.
|
||||
**
|
||||
** This file is part of the OSDaB project (http://osdab.42cows.org/).
|
||||
**
|
||||
** This file may be distributed and/or modified under the terms of the
|
||||
** GNU General Public License version 2 as published by the Free Software
|
||||
** Foundation and appearing in the file LICENSE.GPL included in the
|
||||
** packaging of this file.
|
||||
**
|
||||
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
|
||||
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||||
**
|
||||
** See the file LICENSE.GPL that came with this software distribution or
|
||||
** visit http://www.gnu.org/copyleft/gpl.html for GPL licensing information.
|
||||
**
|
||||
**********************************************************************/
|
||||
|
||||
#ifndef OSDAB_ZIP__H
|
||||
#define OSDAB_ZIP__H
|
||||
|
||||
#include "zipglobal.h"
|
||||
|
||||
#include <QtCore/QMap>
|
||||
#include <QtCore/QtGlobal>
|
||||
|
||||
#include <zlib/zlib.h>
|
||||
|
||||
class QIODevice;
|
||||
class QFile;
|
||||
class QDir;
|
||||
class QStringList;
|
||||
class QString;
|
||||
|
||||
OSDAB_BEGIN_NAMESPACE(Zip)
|
||||
|
||||
class ZipPrivate;
|
||||
|
||||
class OSDAB_ZIP_EXPORT Zip
|
||||
{
|
||||
public:
|
||||
enum ErrorCode
|
||||
{
|
||||
Ok,
|
||||
ZlibInit,
|
||||
ZlibError,
|
||||
FileExists,
|
||||
OpenFailed,
|
||||
NoOpenArchive,
|
||||
FileNotFound,
|
||||
ReadFailed,
|
||||
WriteFailed,
|
||||
SeekFailed,
|
||||
InternalError
|
||||
};
|
||||
|
||||
enum CompressionLevel
|
||||
{
|
||||
Store,
|
||||
Deflate1 = 1, Deflate2, Deflate3, Deflate4,
|
||||
Deflate5, Deflate6, Deflate7, Deflate8, Deflate9,
|
||||
AutoCPU, AutoMIME, AutoFull
|
||||
};
|
||||
|
||||
enum CompressionOption
|
||||
{
|
||||
/*! Does not preserve absolute paths in the zip file when adding a
|
||||
file or directory (default) */
|
||||
RelativePaths = 0x0001,
|
||||
/*! Preserve absolute paths */
|
||||
AbsolutePaths = 0x0002,
|
||||
/*! Do not store paths. All the files are put in the (evtl. user defined)
|
||||
root of the zip file */
|
||||
IgnorePaths = 0x0004,
|
||||
/*! Works only with addDirectory(). Adds the directory's contents,
|
||||
including subdirectories, but does not add an entry for the root
|
||||
directory itself. */
|
||||
IgnoreRoot = 0x0008,
|
||||
/*! Used only when compressing a directory or multiple files.
|
||||
If set invalid or unreadable files are simply skipped.
|
||||
*/
|
||||
SkipBadFiles = 0x0020,
|
||||
/*! Makes sure a file is never added twice to the same zip archive.
|
||||
This check is only necessary in certain usage scenarios and given
|
||||
that it slows down processing you need to enable it explicitly with
|
||||
this flag.
|
||||
*/
|
||||
CheckForDuplicates = 0x0040
|
||||
};
|
||||
Q_DECLARE_FLAGS(CompressionOptions, CompressionOption)
|
||||
|
||||
Zip();
|
||||
virtual ~Zip();
|
||||
|
||||
bool isOpen() const;
|
||||
|
||||
void setPassword(const QString& pwd);
|
||||
void clearPassword();
|
||||
QString password() const;
|
||||
|
||||
ErrorCode createArchive(const QString& file, bool overwrite = true);
|
||||
ErrorCode createArchive(QIODevice* device);
|
||||
|
||||
QString archiveComment() const;
|
||||
void setArchiveComment(const QString& comment);
|
||||
|
||||
ErrorCode addDirectoryContents(const QString& path,
|
||||
CompressionLevel level = AutoFull);
|
||||
ErrorCode addDirectoryContents(const QString& path, const QString& root,
|
||||
CompressionLevel level = AutoFull);
|
||||
|
||||
ErrorCode addDirectory(const QString& path,
|
||||
CompressionLevel level = AutoFull);
|
||||
ErrorCode addDirectory(const QString& path, const QString& root,
|
||||
CompressionLevel level = AutoFull);
|
||||
ErrorCode addDirectory(const QString& path, const QString& root,
|
||||
CompressionOptions options, CompressionLevel level = AutoFull,
|
||||
int* addedFiles = 0);
|
||||
|
||||
ErrorCode addFile(const QString& path,
|
||||
CompressionLevel level = AutoFull);
|
||||
ErrorCode addFile(const QString& path, const QString& root,
|
||||
CompressionLevel level = AutoFull);
|
||||
ErrorCode addFile(const QString& path, const QString& root,
|
||||
CompressionOptions options,
|
||||
CompressionLevel level = AutoFull);
|
||||
|
||||
ErrorCode addFiles(const QStringList& paths,
|
||||
CompressionLevel level = AutoFull);
|
||||
ErrorCode addFiles(const QStringList& paths, const QString& root,
|
||||
CompressionLevel level = AutoFull);
|
||||
ErrorCode addFiles(const QStringList& paths, const QString& root,
|
||||
CompressionOptions options,
|
||||
CompressionLevel level = AutoFull,
|
||||
int* addedFiles = 0);
|
||||
|
||||
ErrorCode closeArchive();
|
||||
|
||||
QString formatError(ErrorCode c) const;
|
||||
|
||||
private:
|
||||
ZipPrivate* d;
|
||||
};
|
||||
|
||||
Q_DECLARE_OPERATORS_FOR_FLAGS(Zip::CompressionOptions)
|
||||
|
||||
OSDAB_END_NAMESPACE
|
||||
|
||||
#endif // OSDAB_ZIP__H
|
||||
|
|
@ -1,133 +0,0 @@
|
|||
/****************************************************************************
|
||||
** Filename: zip_p.h
|
||||
** Last updated [dd/mm/yyyy]: 27/03/2011
|
||||
**
|
||||
** pkzip 2.0 file compression.
|
||||
**
|
||||
** Some of the code has been inspired by other open source projects,
|
||||
** (mainly Info-Zip and Gilles Vollant's minizip).
|
||||
** Compression and decompression actually uses the zlib library.
|
||||
**
|
||||
** Copyright (C) 2007-2012 Angius Fabrizio. All rights reserved.
|
||||
**
|
||||
** This file is part of the OSDaB project (http://osdab.42cows.org/).
|
||||
**
|
||||
** This file may be distributed and/or modified under the terms of the
|
||||
** GNU General Public License version 2 as published by the Free Software
|
||||
** Foundation and appearing in the file LICENSE.GPL included in the
|
||||
** packaging of this file.
|
||||
**
|
||||
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
|
||||
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||||
**
|
||||
** See the file LICENSE.GPL that came with this software distribution or
|
||||
** visit http://www.gnu.org/copyleft/gpl.html for GPL licensing information.
|
||||
**
|
||||
**********************************************************************/
|
||||
|
||||
//
|
||||
// W A R N I N G
|
||||
// -------------
|
||||
//
|
||||
// This file is not part of the Zip/UnZip API. It exists purely as an
|
||||
// implementation detail. This header file may change from version to
|
||||
// version without notice, or even be removed.
|
||||
//
|
||||
// We mean it.
|
||||
//
|
||||
|
||||
#ifndef OSDAB_ZIP_P__H
|
||||
#define OSDAB_ZIP_P__H
|
||||
|
||||
#include "zip.h"
|
||||
#include "zipentry_p.h"
|
||||
|
||||
#include <QtCore/QFileInfo>
|
||||
#include <QtCore/QObject>
|
||||
#include <QtCore/QtGlobal>
|
||||
|
||||
#include <zlib/zconf.h>
|
||||
|
||||
/*!
|
||||
zLib authors suggest using larger buffers (128K or 256K) for (de)compression (especially for inflate())
|
||||
we use a 256K buffer here - if you want to use this code on a pre-iceage mainframe please change it ;)
|
||||
*/
|
||||
#define ZIP_READ_BUFFER (256*1024)
|
||||
|
||||
OSDAB_BEGIN_NAMESPACE(Zip)
|
||||
|
||||
class ZipPrivate : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
// uLongf from zconf.h
|
||||
typedef uLongf crc_t;
|
||||
|
||||
ZipPrivate();
|
||||
virtual ~ZipPrivate();
|
||||
|
||||
QMap<QString,ZipEntryP*>* headers;
|
||||
|
||||
QIODevice* device;
|
||||
QFile* file;
|
||||
|
||||
char buffer1[ZIP_READ_BUFFER];
|
||||
char buffer2[ZIP_READ_BUFFER];
|
||||
|
||||
unsigned char* uBuffer;
|
||||
|
||||
const crc_t* crcTable;
|
||||
|
||||
QString comment;
|
||||
QString password;
|
||||
|
||||
Zip::ErrorCode createArchive(QIODevice* device);
|
||||
Zip::ErrorCode closeArchive();
|
||||
void reset();
|
||||
|
||||
bool zLibInit();
|
||||
|
||||
bool containsEntry(const QFileInfo& info) const;
|
||||
|
||||
Zip::ErrorCode addDirectory(const QString& path, const QString& root,
|
||||
Zip::CompressionOptions options, Zip::CompressionLevel level,
|
||||
int hierarchyLevel, int* addedFiles = 0);
|
||||
Zip::ErrorCode addFiles(const QStringList& paths, const QString& root,
|
||||
Zip::CompressionOptions options, Zip::CompressionLevel level,
|
||||
int* addedFiles);
|
||||
|
||||
Zip::ErrorCode createEntry(const QFileInfo& file, const QString& root,
|
||||
Zip::CompressionLevel level);
|
||||
Zip::CompressionLevel detectCompressionByMime(const QString& ext);
|
||||
|
||||
inline quint32 updateChecksum(const quint32& crc, const quint32& val) const;
|
||||
|
||||
inline void encryptBytes(quint32* keys, char* buffer, qint64 read);
|
||||
|
||||
inline void setULong(quint32 v, char* buffer, unsigned int offset);
|
||||
inline void updateKeys(quint32* keys, int c) const;
|
||||
inline void initKeys(quint32* keys) const;
|
||||
inline int decryptByte(quint32 key2) const;
|
||||
|
||||
inline QString extractRoot(const QString& p, Zip::CompressionOptions o);
|
||||
|
||||
private slots:
|
||||
void deviceDestroyed(QObject*);
|
||||
|
||||
private:
|
||||
int compressionStrategy(const QString& path, QIODevice& file) const;
|
||||
Zip::ErrorCode deflateFile(const QFileInfo& fileInfo,
|
||||
quint32& crc, qint64& written, const Zip::CompressionLevel& level, quint32** keys);
|
||||
Zip::ErrorCode storeFile(const QString& path, QIODevice& file,
|
||||
quint32& crc, qint64& written, quint32** keys);
|
||||
Zip::ErrorCode compressFile(const QString& path, QIODevice& file,
|
||||
quint32& crc, qint64& written, const Zip::CompressionLevel& level, quint32** keys);
|
||||
Zip::ErrorCode do_closeArchive();
|
||||
Zip::ErrorCode writeEntry(const QString& fileName, const ZipEntryP* h, quint32& szCentralDir);
|
||||
Zip::ErrorCode writeCentralDir(quint32 offCentralDir, quint32 szCentralDir);
|
||||
};
|
||||
|
||||
OSDAB_END_NAMESPACE
|
||||
|
||||
#endif // OSDAB_ZIP_P__H
|
||||
|
|
@ -1,91 +0,0 @@
|
|||
/****************************************************************************
|
||||
** Filename: ZipEntryP.h
|
||||
** Last updated [dd/mm/yyyy]: 27/03/2011
|
||||
**
|
||||
** Wrapper for a ZIP local header.
|
||||
**
|
||||
** Some of the code has been inspired by other open source projects,
|
||||
** (mainly Info-Zip and Gilles Vollant's minizip).
|
||||
** Compression and decompression actually uses the zlib library.
|
||||
**
|
||||
** Copyright (C) 2007-2012 Angius Fabrizio. All rights reserved.
|
||||
**
|
||||
** This file is part of the OSDaB project (http://osdab.42cows.org/).
|
||||
**
|
||||
** This file may be distributed and/or modified under the terms of the
|
||||
** GNU General Public License version 2 as published by the Free Software
|
||||
** Foundation and appearing in the file LICENSE.GPL included in the
|
||||
** packaging of this file.
|
||||
**
|
||||
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
|
||||
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||||
**
|
||||
** See the file LICENSE.GPL that came with this software distribution or
|
||||
** visit http://www.gnu.org/copyleft/gpl.html for GPL licensing information.
|
||||
**
|
||||
**********************************************************************/
|
||||
|
||||
//
|
||||
// W A R N I N G
|
||||
// -------------
|
||||
//
|
||||
// This file is not part of the Zip/UnZip API. It exists purely as an
|
||||
// implementation detail. This header file may change from version to
|
||||
// version without notice, or even be removed.
|
||||
//
|
||||
// We mean it.
|
||||
//
|
||||
|
||||
#ifndef OSDAB_ZIPENTRY_P__H
|
||||
#define OSDAB_ZIPENTRY_P__H
|
||||
|
||||
#include <QtCore/QString>
|
||||
#include <QtCore/QtGlobal>
|
||||
|
||||
OSDAB_BEGIN_NAMESPACE(Zip)
|
||||
|
||||
class ZipEntryP
|
||||
{
|
||||
public:
|
||||
ZipEntryP() :
|
||||
lhOffset(0),
|
||||
dataOffset(0),
|
||||
gpFlag(),
|
||||
compMethod(0),
|
||||
modTime(),
|
||||
modDate(),
|
||||
crc(0),
|
||||
szComp(0),
|
||||
szUncomp(0),
|
||||
absolutePath(),
|
||||
fileSize(0),
|
||||
lhEntryChecked(false)
|
||||
{
|
||||
gpFlag[0] = gpFlag[1] = 0;
|
||||
modTime[0] = modTime[1] = 0;
|
||||
modDate[0] = modDate[1] = 0;
|
||||
}
|
||||
|
||||
quint32 lhOffset; // Offset of the local header record for this entry
|
||||
mutable quint32 dataOffset; // Offset of the file data for this entry
|
||||
unsigned char gpFlag[2]; // General purpose flag
|
||||
quint16 compMethod; // Compression method
|
||||
unsigned char modTime[2]; // Last modified time
|
||||
unsigned char modDate[2]; // Last modified date
|
||||
quint32 crc; // CRC32
|
||||
quint32 szComp; // Compressed file size
|
||||
quint32 szUncomp; // Uncompressed file size
|
||||
QString comment; // File comment
|
||||
|
||||
QString absolutePath; // Internal use
|
||||
qint64 fileSize; // Internal use
|
||||
|
||||
mutable bool lhEntryChecked; // Is true if the local header record for this entry has been parsed
|
||||
|
||||
inline bool isEncrypted() const { return gpFlag[0] & 0x01; }
|
||||
inline bool hasDataDescriptor() const { return gpFlag[0] & 0x08; }
|
||||
};
|
||||
|
||||
OSDAB_END_NAMESPACE
|
||||
|
||||
#endif // OSDAB_ZIPENTRY_P__H
|
||||
|
|
@ -1,150 +0,0 @@
|
|||
/****************************************************************************
|
||||
** Filename: zipglobal.cpp
|
||||
** Last updated [dd/mm/yyyy]: 06/02/2011
|
||||
**
|
||||
** pkzip 2.0 file compression.
|
||||
**
|
||||
** Some of the code has been inspired by other open source projects,
|
||||
** (mainly Info-Zip and Gilles Vollant's minizip).
|
||||
** Compression and decompression actually uses the zlib library.
|
||||
**
|
||||
** Copyright (C) 2007-2012 Angius Fabrizio. All rights reserved.
|
||||
**
|
||||
** This file is part of the OSDaB project (http://osdab.42cows.org/).
|
||||
**
|
||||
** This file may be distributed and/or modified under the terms of the
|
||||
** GNU General Public License version 2 as published by the Free Software
|
||||
** Foundation and appearing in the file LICENSE.GPL included in the
|
||||
** packaging of this file.
|
||||
**
|
||||
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
|
||||
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||||
**
|
||||
** See the file LICENSE.GPL that came with this software distribution or
|
||||
** visit http://www.gnu.org/copyleft/gpl.html for GPL licensing information.
|
||||
**
|
||||
**********************************************************************/
|
||||
|
||||
#include "zipglobal.h"
|
||||
|
||||
#if defined(Q_OS_WIN) || defined(Q_OS_WINCE) || defined(Q_OS_LINUX) || defined(Q_OS_MACOS)
|
||||
#define OSDAB_ZIP_HAS_UTC
|
||||
#include <ctime>
|
||||
#else
|
||||
#undef OSDAB_ZIP_HAS_UTC
|
||||
#endif
|
||||
|
||||
#if defined(Q_OS_WIN)
|
||||
#include <QtCore/qt_windows.h>
|
||||
#elif defined(Q_OS_LINUX) || defined(Q_OS_MACOS)
|
||||
#include <utime.h>
|
||||
#endif
|
||||
|
||||
OSDAB_BEGIN_NAMESPACE(Zip)
|
||||
|
||||
/*! Returns the current UTC offset in seconds unless OSDAB_ZIP_NO_UTC is defined
|
||||
and method is implemented for the current platform and 0 otherwise.
|
||||
*/
|
||||
int OSDAB_ZIP_MANGLE(currentUtcOffset)()
|
||||
{
|
||||
#if !(!defined OSDAB_ZIP_NO_UTC && defined OSDAB_ZIP_HAS_UTC)
|
||||
return 0;
|
||||
#else
|
||||
time_t curr_time_t;
|
||||
time(&curr_time_t);
|
||||
|
||||
#if defined Q_OS_WIN
|
||||
struct tm _tm_struct;
|
||||
struct tm *tm_struct = &_tm_struct;
|
||||
#else
|
||||
struct tm *tm_struct = 0;
|
||||
#endif
|
||||
|
||||
#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
|
||||
// use the reentrant version of localtime() where available
|
||||
tzset();
|
||||
tm res;
|
||||
tm_struct = gmtime_r(&curr_time_t, &res);
|
||||
#elif defined Q_OS_WIN && !defined Q_CC_MINGW
|
||||
if (gmtime_s(tm_struct, &curr_time_t))
|
||||
return 0;
|
||||
#else
|
||||
tm_struct = gmtime(&curr_time_t);
|
||||
#endif
|
||||
|
||||
if (!tm_struct)
|
||||
return 0;
|
||||
|
||||
const time_t global_time_t = mktime(tm_struct);
|
||||
|
||||
#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
|
||||
// use the reentrant version of localtime() where available
|
||||
tm_struct = localtime_r(&curr_time_t, &res);
|
||||
#elif defined Q_OS_WIN && !defined Q_CC_MINGW
|
||||
if (localtime_s(tm_struct, &curr_time_t))
|
||||
return 0;
|
||||
#else
|
||||
tm_struct = localtime(&curr_time_t);
|
||||
#endif
|
||||
|
||||
if (!tm_struct)
|
||||
return 0;
|
||||
|
||||
const time_t local_time_t = mktime(tm_struct);
|
||||
|
||||
const int utcOffset = -qRound(difftime(global_time_t, local_time_t));
|
||||
return tm_struct->tm_isdst > 0 ? utcOffset + 3600 : utcOffset;
|
||||
#endif // No UTC
|
||||
}
|
||||
|
||||
QDateTime OSDAB_ZIP_MANGLE(fromFileTimestamp)(const QDateTime &dateTime)
|
||||
{
|
||||
#if !defined OSDAB_ZIP_NO_UTC && defined OSDAB_ZIP_HAS_UTC
|
||||
const int utc = OSDAB_ZIP_MANGLE(currentUtcOffset)();
|
||||
return dateTime.toUTC().addSecs(utc);
|
||||
#else
|
||||
return dateTime;
|
||||
#endif // OSDAB_ZIP_NO_UTC
|
||||
}
|
||||
|
||||
bool OSDAB_ZIP_MANGLE(setFileTimestamp)(const QString &fileName, const QDateTime &dateTime)
|
||||
{
|
||||
if (fileName.isEmpty())
|
||||
return true;
|
||||
|
||||
#ifdef Q_OS_WIN
|
||||
HANDLE hFile =
|
||||
CreateFileW(fileName.toStdWString().c_str(), GENERIC_WRITE, FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
|
||||
if (hFile == INVALID_HANDLE_VALUE) {
|
||||
return false;
|
||||
}
|
||||
|
||||
SYSTEMTIME st;
|
||||
FILETIME ft, ftLastMod;
|
||||
const QDate date = dateTime.date();
|
||||
const QTime time = dateTime.time();
|
||||
st.wYear = date.year();
|
||||
st.wMonth = date.month();
|
||||
st.wDay = date.day();
|
||||
st.wHour = time.hour();
|
||||
st.wMinute = time.minute();
|
||||
st.wSecond = time.second();
|
||||
st.wMilliseconds = time.msec();
|
||||
|
||||
SystemTimeToFileTime(&st, &ft);
|
||||
LocalFileTimeToFileTime(&ft, &ftLastMod);
|
||||
|
||||
const bool success = SetFileTime(hFile, NULL, NULL, &ftLastMod);
|
||||
CloseHandle(hFile);
|
||||
return success;
|
||||
|
||||
#elif defined(Q_OS_LINUX) || defined(Q_OS_MACOS)
|
||||
|
||||
struct utimbuf t_buffer;
|
||||
t_buffer.actime = t_buffer.modtime = dateTime.toSecsSinceEpoch();
|
||||
return utime(fileName.toLocal8Bit().constData(), &t_buffer) == 0;
|
||||
#endif
|
||||
|
||||
return true;
|
||||
}
|
||||
OSDAB_END_NAMESPACE
|
||||
|
|
@ -1,77 +0,0 @@
|
|||
/****************************************************************************
|
||||
** Filename: zipglobal.h
|
||||
** Last updated [dd/mm/yyyy]: 27/03/2011
|
||||
**
|
||||
** pkzip 2.0 file compression.
|
||||
**
|
||||
** Some of the code has been inspired by other open source projects,
|
||||
** (mainly Info-Zip and Gilles Vollant's minizip).
|
||||
** Compression and decompression actually uses the zlib library.
|
||||
**
|
||||
** Copyright (C) 2007-2012 Angius Fabrizio. All rights reserved.
|
||||
**
|
||||
** This file is part of the OSDaB project (http://osdab.42cows.org/).
|
||||
**
|
||||
** This file may be distributed and/or modified under the terms of the
|
||||
** GNU General Public License version 2 as published by the Free Software
|
||||
** Foundation and appearing in the file LICENSE.GPL included in the
|
||||
** packaging of this file.
|
||||
**
|
||||
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
|
||||
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||||
**
|
||||
** See the file LICENSE.GPL that came with this software distribution or
|
||||
** visit http://www.gnu.org/copyleft/gpl.html for GPL licensing information.
|
||||
**
|
||||
**********************************************************************/
|
||||
|
||||
#ifndef OSDAB_ZIPGLOBAL__H
|
||||
#define OSDAB_ZIPGLOBAL__H
|
||||
|
||||
#include <QtCore/QDateTime>
|
||||
#include <QtCore/QtGlobal>
|
||||
|
||||
/* If you want to build the OSDaB Zip code as
|
||||
a library, define OSDAB_ZIP_LIB in the library's .pro file and
|
||||
in the libraries using it OR remove the #ifndef OSDAB_ZIP_LIB
|
||||
define below and leave the #else body. Also remember to define
|
||||
OSDAB_ZIP_BUILD_LIB in the library's project).
|
||||
*/
|
||||
|
||||
#ifndef OSDAB_ZIP_LIB
|
||||
# define OSDAB_ZIP_EXPORT
|
||||
#else
|
||||
# if defined(OSDAB_ZIP_BUILD_LIB)
|
||||
# define OSDAB_ZIP_EXPORT Q_DECL_EXPORT
|
||||
# else
|
||||
# define OSDAB_ZIP_EXPORT Q_DECL_IMPORT
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef OSDAB_NAMESPACE
|
||||
#define OSDAB_BEGIN_NAMESPACE(ModuleName) namespace Osdab { namespace ModuleName {
|
||||
#else
|
||||
#define OSDAB_BEGIN_NAMESPACE(ModuleName)
|
||||
#endif
|
||||
|
||||
#ifdef OSDAB_NAMESPACE
|
||||
#define OSDAB_END_NAMESPACE } }
|
||||
#else
|
||||
#define OSDAB_END_NAMESPACE
|
||||
#endif
|
||||
|
||||
#ifndef OSDAB_NAMESPACE
|
||||
#define OSDAB_ZIP_MANGLE(x) zip_##x
|
||||
#else
|
||||
#define OSDAB_ZIP_MANGLE(x) x
|
||||
#endif
|
||||
|
||||
OSDAB_BEGIN_NAMESPACE(Zip)
|
||||
|
||||
OSDAB_ZIP_EXPORT int OSDAB_ZIP_MANGLE(currentUtcOffset)();
|
||||
OSDAB_ZIP_EXPORT QDateTime OSDAB_ZIP_MANGLE(fromFileTimestamp)(const QDateTime& dateTime);
|
||||
OSDAB_ZIP_EXPORT bool OSDAB_ZIP_MANGLE(setFileTimestamp)(const QString& fileName, const QDateTime& dateTime);
|
||||
|
||||
OSDAB_END_NAMESPACE
|
||||
|
||||
#endif // OSDAB_ZIPGLOBAL__H
|
||||
Loading…
Add table
Add a link
Reference in a new issue