FinceptTerminal is a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment.
C++ ai-agentsalgorithmic-tradingbloomberg-terminalcppfinancefinancial-marketsfintechgood-first-issueinvestmentinvestment-researchmachine-learningopensourcepythonqtquantitative-financestock-markettrading
#include "trading/instruments/InstrumentDecompress.h"
#include "core/logging/Logger.h"
#include <cstring>
// Qt Core bundles zlib and exports it with a `z_` prefix (see Qt's zconf.h:
// "Qt Core must export these symbols, define Z_PREFIX to avoid clashes with
// system zlib"). We link Qt6::ZlibPrivate on Windows, so the calls must be
// prefixed too. Qt's own zconf.h auto-defines Z_PREFIX, but if another zlib.h
// shadows it on the include path (e.g. a PostgreSQL install whose include dir
// precedes QtZlib), the unprefixed symbols won't link. Define it ourselves so
// inflate() → z_inflate() regardless of which standard zlib.h is picked up.
// On macOS/Linux we link the system zlib (ZLIB::ZLIB in CMakeLists.txt),
// whose symbols are unprefixed — so only define Z_PREFIX on Windows.
#if defined(_WIN32) && !defined(Z_PREFIX)
# define Z_PREFIX
#endif
#include <zlib.h>
namespace fincept::trading::decompress {
namespace {
// Inflate `in` using the given window-bits setting. 15|16 → gzip, -15 → raw deflate.
QByteArray inflate_stream(const QByteArray& in, int window_bits) {
if (in.isEmpty())
return {};
z_stream s;
std::memset(&s, 0, sizeof(s));
if (inflateInit2(&s, window_bits) != Z_OK)
return {};
s.next_in = reinterpret_cast<Bytef*>(const_cast<char*>(in.constData()));
s.avail_in = static_cast<uInt>(in.size());
QByteArray out;
char chunk[32768];
int rc = Z_OK;
do {
s.next_out = reinterpret_cast<Bytef*>(chunk);
s.avail_out = sizeof(chunk);
rc = inflate(&s, Z_NO_FLUSH);
if (rc != Z_OK && rc != Z_STREAM_END && rc != Z_BUF_ERROR) {
inflateEnd(&s);
return {};
}
const int produced = static_cast<int>(sizeof(chunk) - s.avail_out);
if (produced > 0)
out.append(chunk, produced);
// Z_BUF_ERROR with no progress and no input left → done.
if (rc == Z_BUF_ERROR && s.avail_in == 0 && produced == 0)
break;
} while (rc != Z_STREAM_END);
inflateEnd(&s);
return out;
}
quint16 le16(const QByteArray& b, int off) {
return static_cast<quint16>(static_cast<unsigned char>(b[off])) |
(static_cast<quint16>(static_cast<unsigned char>(b[off + 1])) << 8);
}
quint32 le32(const QByteArray& b, int off) {
return static_cast<quint32>(static_cast<unsigned char>(b[off])) |
(static_cast<quint32>(static_cast<unsigned char>(b[off + 1])) << 8) |
(static_cast<quint32>(static_cast<unsigned char>(b[off + 2])) << 16) |
(static_cast<quint32>(static_cast<unsigned char>(b[off + 3])) << 24);
}
} // namespace
QByteArray gunzip(const QByteArray& gz) {
QByteArray out = inflate_stream(gz, 15 + 16);
if (out.isEmpty())
LOG_WARN("InstrumentDecompress", "gunzip produced no output");
return out;
}
QByteArray unzip_first_entry(const QByteArray& zip) {
// Local file header: "PK\x03\x04", then at fixed offsets:
// 8 compression method (u16) 18 compressed size (u32)
// 26 file name length (u16) 28 extra field length (u16)
// 30 + nameLen + extraLen → start of compressed data.
if (zip.size() < 30 || !zip.startsWith("PK\x03\x04")) {
LOG_WARN("InstrumentDecompress", "not a zip (bad local header signature)");
return {};
}
const quint16 method = le16(zip, 8);
const quint16 flags = le16(zip, 6);
quint32 comp_size = le32(zip, 18);
const quint16 name_len = le16(zip, 26);
const quint16 extra_len = le16(zip, 28);
const int data_off = 30 + name_len + extra_len;
if (data_off > zip.size()) {
LOG_WARN("InstrumentDecompress", "zip data offset past end");
return {};
}
// When a data descriptor is used (bit 3), the local header size may be 0;
// hand the rest of the buffer to the inflater and let Z_STREAM_END stop it.
if (comp_size == 0 || (flags & 0x08))
comp_size = static_cast<quint32>(zip.size() - data_off);
if (data_off + static_cast<int>(comp_size) > zip.size())
comp_size = static_cast<quint32>(zip.size() - data_off);
const QByteArray payload = zip.mid(data_off, static_cast<int>(comp_size));
if (method == 0) // stored
return payload;
if (method == 8) // deflate
return inflate_stream(payload, -15);
LOG_WARN("InstrumentDecompress", QString("unsupported zip method %1").arg(method));
return {};
}
} // namespace fincept::trading::decompress