Differential D13711 Diff 36711 src/backend/datasources/filters/ROOTFilter.cpp

Changeset View

Standalone View

View Options

src/backend/datasources/filters/ROOTFilter.cpp

  • This file was added.
1​/***************************************************************************
2​File : ROOTFilter.cpp
3​Project : LabPlot
4​Description : ROOT(CERN) I/O-filter
5​--------------------------------------------------------------------
6​Copyright : (C) 2018 by Christoph Roick (chrisito@gmx.de)
7​***************************************************************************/
8​
9​/***************************************************************************
10​* *
11​* This program is free software; you can redistribute it and/or modify *
12​* it under the terms of the GNU General Public License as published by *
13​* the Free Software Foundation; either version 2 of the License, or *
14​* (at your option) any later version. *
15​* *
16​* This program is distributed in the hope that it will be useful, *
17​* but WITHOUT ANY WARRANTY; without even the implied warranty of *
18​* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19​* GNU General Public License for more details. *
20​* *
21​* You should have received a copy of the GNU General Public License *
22​* along with this program; if not, write to the Free Software *
23​* Foundation, Inc., 51 Franklin Street, Fifth Floor, *
24​* Boston, MA 02110-1301 USA *
25​* *
26​***************************************************************************/
27​
28​#include "backend/datasources/filters/ROOTFilter.h"
29​#include "backend/datasources/filters/ROOTFilterPrivate.h"
30​#include "backend/datasources/AbstractDataSource.h"
31​#include "backend/core/column/Column.h"
32​
33​#include <KLocalizedString>
34​
35​#ifdef HAVE_ZIP
36​
37​#include <lz4.h>
38​#include <zlib.h>
39​
40​#endif
41​
42​#include <cmath>
43​#include <fstream>
44​#include <limits>
45​#include <map>
46​#include <string>
47​#include <vector>
48​
49​ROOTFilter::ROOTFilter():AbstractFileFilter(), d(new ROOTFilterPrivate) {}
50​
51​ROOTFilter::~ROOTFilter() {}
52​
53​QVector<QStringList> ROOTFilter::readDataFromFile(const QString& fileName, AbstractDataSource* dataSource,
54​ AbstractFileFilter::ImportMode importMode, int) {
55​ d->readDataFromFile(fileName, dataSource, importMode);
56​ return QVector<QStringList>(); //TODO: remove this later once all read*-functions in the filter classes don't return any preview strings anymore
57​}
58​
59​void ROOTFilter::write(const QString& fileName, AbstractDataSource* dataSource) {
60​ d->write(fileName, dataSource);
61​}
62​
63​void ROOTFilter::loadFilterSettings(const QString& filterName) {
64​ Q_UNUSED(filterName);
65​}
66​
67​void ROOTFilter::saveFilterSettings(const QString& filterName) const {
68​ Q_UNUSED(filterName);
69​}
70​
71​void ROOTFilter::setCurrentHistogram(const QString& histogram) {
72​ d->currentHistogram = histogram;
73​}
74​
75​const QString ROOTFilter::currentHistogram() const {
76​ return d->currentHistogram;
77​}
78​
79​QStringList ROOTFilter::listHistograms(const QString& fileName) {
80​ return d->listHistograms(fileName);
81​}
82​
83​QVector<QStringList> ROOTFilter::previewCurrentHistogram(const QString& fileName,
84​ int first, int last) {
85​ return d->previewCurrentHistogram(fileName, first, last);
86​}
87​
88​int ROOTFilter::binsInCurrentHistogram(const QString& fileName) {
89​ return d->binsInCurrentHistogram(fileName);
90​}
91​
92​void ROOTFilter::setStartBin(const int s) {
93​ d->startBin = s;
94​}
95​
96​int ROOTFilter::startBin() const {
97​ return d->startBin;
98​}
99​
100​void ROOTFilter::setEndBin(const int e) {
101​ d->endBin = e;
102​}
103​
104​int ROOTFilter::endBin() const {
105​ return d->endBin;
106​}
107​
108​void ROOTFilter::setColumns(const int columns) {
109​ d->columns = columns;
110​}
111​
112​int ROOTFilter::columns() const {
113​ return d->columns;
114​}
115​
116​void ROOTFilter::save(QXmlStreamWriter* writer) const {
117​ writer->writeStartElement("rootFilter");
118​ writer->writeAttribute("startBin", QString::number(d->startBin) );
119​ writer->writeAttribute("endBin", QString::number(d->endBin) );
120​ writer->writeAttribute("columns", QString::number(d->columns) );
121​ writer->writeEndElement();
122​}
123​
124​bool ROOTFilter::load(XmlStreamReader* reader) {
125​ if (!reader->isStartElement() || reader->name() != "rootFilter") {
126​ reader->raiseError(i18n("no ROOT filter element found"));
127​ return false;
128​ }
129​
130​ QString attributeWarning = i18n("Attribute '%1' missing or empty, default value is used");
131​ QXmlStreamAttributes attribs = reader->attributes();
132​
133​ // read attributes
134​ QString str = attribs.value("startBin").toString();
135​ if (str.isEmpty())
136​ reader->raiseWarning(attributeWarning.arg("'startBin'"));
137​ else
138​ d->startBin = str.toInt();
139​
140​ str = attribs.value("endBin").toString();
141​ if (str.isEmpty())
142​ reader->raiseWarning(attributeWarning.arg("'endBin'"));
143​ else
144​ d->endBin = str.toInt();
145​
146​ str = attribs.value("columns").toString();
147​ if (str.isEmpty())
148​ reader->raiseWarning(attributeWarning.arg("'columns'"));
149​ else
150​ d->columns = str.toInt();
151​
152​ return true;
153​}
154​
155​/**************** ROOTFilterPrivate implementation *******************/
156​
157​ROOTFilterPrivate::ROOTFilterPrivate() {}
158​
159​void ROOTFilterPrivate::readDataFromFile(const QString& fileName, AbstractDataSource* dataSource,
160​ AbstractFileFilter::ImportMode importMode) {
161​ DEBUG("readDataFromFile()");
162​
163​ setFile(fileName);
164​
165​ auto bins = readHistogram();
166​ const int nbins = bins.size();
167​
168​ // skip underflow and overflow bins by default
169​ int first = qMax(startBin, 0);
fkristofUnsubmitted
Done

columnOffSet can be const if you don't intend to change it.

fkristof: columnOffSet can be const if you don't intend to change it.
170​ int last = qMin(endBin, nbins - 1);
171​
172​ QStringList colNames = createHeaders();
173​
174​ QVector<void*> dataContainer;
175​ const int columnOffset = dataSource->prepareImport(dataContainer, importMode, last - first + 1, colNames.size(),
176​ colNames, QVector<AbstractColumn::ColumnMode>(
177​ colNames.size(), AbstractColumn::Numeric));
178​
179​ // read data
180​ DEBUG("reading " << first - last + 1 << " lines");
181​
182​ size_t c = 0;
fkristofUnsubmitted
Done

I suggest you to group these conditions with parenthesis so it's easier to understand them.

fkristof: I suggest you to group these conditions with parenthesis so it's easier to understand them.
183​ if (columns & ROOTFilter::Center) {
184​ QVector<double>& container = *static_cast<QVector<double>*>(dataContainer[c++]);
185​ for (int i = first; i <= last; ++i)
186​ container[i - first] = (i > 0 && i < nbins - 1) ? 0.5 * (bins[i].lowedge + bins[i + 1].lowedge)
187​ : i == 0 ? bins.front().lowedge // -infinity
188​ : -bins.front().lowedge; // +infinity
189​ }
190​ if (columns & ROOTFilter::Low) {
191​ QVector<double>& container = *static_cast<QVector<double>*>(dataContainer[c++]);
192​ for (int i = first; i <= last; ++i)
fkristofUnsubmitted
Done
const QString & fileName

Extra space, remove it

fkristof: ``` const QString & fileName ``` Extra space, remove it
193​ container[i - first] = bins[i].lowedge;
194​ }
195​ if (columns & ROOTFilter::Content) {
196​ QVector<double>& container = *static_cast<QVector<double>*>(dataContainer[c++]);
197​ for (int i = first; i <= last; ++i)
198​ container[i - first] = bins[i].content;
199​ }
200​ if (columns & ROOTFilter::Error) {
201​ QVector<double>& container = *static_cast<QVector<double>*>(dataContainer[c++]);
202​ for (int i = first; i <= last; ++i)
fkristofUnsubmitted
Done

This should be

const auto&
fkristof: This should be ``` const auto& ```
203​ container[i - first] = std::sqrt(bins[i].sumw2);
204​ }
205​
206​ dataSource->finalizeImport(columnOffset, 0, colNames.size() - 1, QString(), importMode);
207​}
208​
209​void ROOTFilterPrivate::write(const QString& fileName, AbstractDataSource* dataSource) {
210​ Q_UNUSED(fileName);
211​ Q_UNUSED(dataSource);
212​ //TODO
213​}
214​
215​QStringList ROOTFilterPrivate::listHistograms(const QString& fileName) {
216​ setFile(fileName);
217​
218​ QStringList histList;
219​ for (const auto& hist : currentROOTHist->listHistograms()) {
220​ histList << QString::fromStdString(hist);
221​ }
222​
223​ return histList;
224​}
225​
226​QVector<QStringList> ROOTFilterPrivate::previewCurrentHistogram(const QString& fileName,
227​ int first, int last) {
228​ DEBUG("previewCurrentHistogram()");
229​
230​ setFile(fileName);
231​
232​ auto bins = readHistogram();
233​ const int nbins = bins.size();
234​
235​ last = qMin(nbins - 1, last);
236​
237​ QVector<QStringList> preview(qMax(last - first + 2, 1));
238​ preview.last() = createHeaders();
239​
240​ // read data
241​ DEBUG("reading " << preview.size() << " lines");
242​
243​ if (columns & ROOTFilter::Center) {
244​ for (int i = first; i <= last; ++i)
245​ preview[i - first] << QString::number(
246​ (i > 0 && i < nbins - 1) ? 0.5 * (bins[i].lowedge + bins[i + 1].lowedge)
247​ : i == 0 ? bins.front().lowedge // -infinity
248​ : -bins.front().lowedge); // +infinity
249​ }
250​ if (columns & ROOTFilter::Low) {
251​ for (int i = first; i <= last; ++i)
252​ preview[i - first] << QString::number(bins[i].lowedge);
253​ }
254​ if (columns & ROOTFilter::Content) {
255​ for (int i = first; i <= last; ++i)
256​ preview[i - first] << QString::number(bins[i].content);
257​ }
258​ if (columns & ROOTFilter::Error) {
259​ for (int i = first; i <= last; ++i)
260​ preview[i - first] << QString::number(std::sqrt(bins[i].sumw2));
261​ }
262​
263​ return preview;
264​}
265​
266​int ROOTFilterPrivate::binsInCurrentHistogram(const QString& fileName) {
267​ setFile(fileName);
268​
269​ QStringList nameindex = currentHistogram.split(';');
270​ bool ok = nameindex.size() > 1;
271​ int cycle = ok ? nameindex.last().toInt(&ok) : 1;
272​ if (ok) {
273​ nameindex.removeLast();
274​ } else {
275​ cycle = 1;
276​ }
277​
278​ return currentROOTHist->histogramBins(nameindex.join(';').toStdString(), cycle);
279​}
280​
281​QStringList ROOTFilterPrivate::createHeaders() {
282​ QStringList colNames;
283​ if (columns & ROOTFilter::Center)
284​ colNames << i18n("Bin Center");
285​ if (columns & ROOTFilter::Low)
286​ colNames << i18n("Low Edge");
287​ if (columns & ROOTFilter::Content)
288​ colNames << i18n("Content");
289​ if (columns & ROOTFilter::Error)
290​ colNames << i18n("Error");
291​ return colNames;
292​}
293​
294​void ROOTFilterPrivate::setFile(const QString& fileName) {
295​ if (!currentROOTHist || fileName != currentFile) {
296​ currentFile = fileName;
297​ currentROOTHist.reset(new ROOTHist(fileName.toStdString()));
298​ }
299​}
300​
301​std::vector<ROOTHist::BinPars> ROOTFilterPrivate::readHistogram() {
302​ QStringList nameindex = currentHistogram.split(';');
303​ bool ok = nameindex.size() > 1;
304​ int cycle = ok ? nameindex.last().toInt(&ok) : 1;
305​ if (ok) {
306​ nameindex.removeLast();
307​ } else {
308​ cycle = 1;
309​ }
310​
311​ return currentROOTHist->readHistogram(nameindex.join(';').toStdString(), cycle);
312​}
313​
314​/******************** ROOTHist implementation ************************/
315​
316​namespace ROOTHistHelpers {
317​
318​/// Read value from stream
319​template<class T>
320​T read(std::ifstream& is) {
321​ union {
322​ T val;
323​ char buf[sizeof(T)];
324​ } r;
325​ for (size_t i = 0; i < sizeof(T); ++i) {
326​ r.buf[sizeof(T) - i - 1] = is.get();
327​ }
328​
329​ return r.val;
330​}
331​
332​/// Read value from buffer
333​template<class T>
334​T read(char*& s) {
335​ union {
336​ T val;
337​ char buf[sizeof(T)];
338​ } r;
339​ for (size_t i = 0; i < sizeof(T); ++i) {
340​ r.buf[sizeof(T) - i - 1] = *(s++);
341​ }
342​
343​ return r.val;
344​}
345​
346​/// Get version of ROOT object, obtain number of bytes in object
347​short Version(char*& buffer, size_t& count) {
348​ count = read<unsigned int>(buffer);
349​ short version = (count & 0x40000000) ? read<short>(buffer) : read<short>(buffer -= 4);
350​ count &= (count & 0x40000000) ? (~0x40000000) : 0;
351​ return version;
352​}
353​
354​/// Get version of ROOT object
355​short Version(char*& buffer) {
356​ size_t c;
357​ return Version(buffer, c);
358​}
359​
360​/// Skip ROOT object
361​void Skip(char*& buffer, const size_t& n) {
362​ for (size_t i = 0; i < n; ++i) {
363​ char* nbuf = buffer + 4;
364​ size_t count;
365​ Version(buffer, count);
366​ buffer = nbuf + count;
367​ }
368​}
369​
370​/// Skip TObject header
371​void SkipObject(char*& buffer) {
372​ Version(buffer);
373​ buffer += 8;
374​}
375​
376​/// Get TString
377​std::string String(char*& buffer) {
378​ size_t s = *(buffer++);
379​ if (s == 0)
380​ return std::string();
381​ else {
382​ if (s == 0xFF)
383​ s = read<int>(buffer);
384​ buffer += s;
385​ return std::string(buffer - s, buffer);
386​ }
387​}
388​
389​}
390​
391​using namespace ROOTHistHelpers;
392​
393​ROOTHist::ROOTHist(const std::string& filename) : filename(filename) {
394​ // The file structure is described in root/io/io/src/TFile.cxx
395​ std::ifstream is(filename, std::ifstream::binary);
396​ std::string root(4, 0);
397​ is.read(const_cast<char*>(root.data()), 4);
398​ if (root != "root")
399​ return;
400​
401​ is.seekg(8); // skip version
402​ int pos = read<int>(is);
403​ is.seekg(16);
404​ int lastpos = read<int>(is);
405​
406​ is.seekg(33);
407​ compression = read<int>(is);
408​ compression = compression > 0 ? compression : 0;
409​
410​ while (is.good() && pos < lastpos) {
411​ is.seekg(pos);
412​ size_t lcdata = read<unsigned int>(is);
413​ is.seekg(2, is.cur); // short version = read<short>(is);
414​ size_t ldata = read<unsigned int>(is);
415​ is.seekg(4, is.cur);
416​ size_t lkey = read<unsigned short int>(is);
417​ short cycle = read<short>(is);
418​ is.seekg(8, is.cur);
419​ std::string cname(read<unsigned char>(is), 0);
420​ is.read(&cname[0], cname.size());
421​ if (cname.size() == 4 && cname.substr(0, 3) == "TH1") {
422​ KeyBuffer::ContentType type;
423​ switch (cname[3]) {
424​ case 'D':
425​ type = KeyBuffer::ContentType::Double;
426​ break;
427​ case 'F':
428​ type = KeyBuffer::ContentType::Float;
429​ break;
430​ case 'I':
431​ type = KeyBuffer::ContentType::Int;
432​ break;
433​ case 'S':
434​ type = KeyBuffer::ContentType::Short;
435​ break;
436​ case 'C':
437​ type = KeyBuffer::ContentType::Byte;
438​ break;
439​ default:
440​ type = KeyBuffer::ContentType::Invalid;
441​ break;
442​ }
443​ if (type) {
444​ std::string name(read<unsigned char>(is), 0);
445​ is.read(&name[0], name.size());
446​ std::string title(read<unsigned char>(is), 0);
447​ is.read(&title[0], title.size());
448​
449​ auto it = histkeys.end();
450​ // see root/io/io/src/TKey.cxx for reference
451​ if (compression && ldata > 256) {
452​# ifdef HAVE_ZIP
453​ if (compression / 100 <= 1) {
454​ // see root/core/zip/src/RZip.cxx -> R__unzip
455​ std::string lib(2, 0);
456​ is.read(&lib[0], 2);
457​ char method = is.get();
458​ size_t chcdata = is.get();
459​ chcdata |= (is.get() << 8);
460​ chcdata |= (is.get() << 16);
461​ size_t chdata = is.get();
462​ chdata |= (is.get() << 8);
463​ chdata |= (is.get() << 16);
464​
465​ if (chcdata == lcdata - lkey - 9 && chdata == ldata) {
466​ if (lib == "ZL" && method == Z_DEFLATED) {
467​ it = histkeys.emplace(name + ";" + std::to_string(cycle),
468​ KeyBuffer{name, title, cycle, type, KeyBuffer::zlib,
469​ pos + lkey + 9, chcdata, chdata, 0}
470​ ).first;
471​ } else if (lib == "L4" && method == LZ4_versionNumber() / (100 * 100)) {
472​ it = histkeys.emplace(name + ";" + std::to_string(cycle),
473​ KeyBuffer{name, title, cycle, type, KeyBuffer::lz4,
474​ pos + lkey + 9 + 8, chcdata - 8, chdata, 0}
475​ ).first;
476​ }
477​ }
478​ }
479​# endif
480​ } else {
481​ it = histkeys.emplace(name + ";" + std::to_string(cycle),
482​ KeyBuffer{name, title, cycle, type, KeyBuffer::none,
483​ pos + lkey, ldata, ldata, 0}
484​ ).first;
485​ }
486​ if (it != histkeys.end())
487​ readNBins(it->second);
488​ }
489​ }
490​ pos += lcdata;
491​ }
492​}
493​
494​std::vector<std::string> ROOTHist::listHistograms() const {
495​ std::vector<std::string> l;
496​ for (auto& n : histkeys) {
497​ l.emplace_back(n.first);
498​ }
499​ return l;
500​}
501​
502​std::vector<ROOTHist::BinPars> ROOTHist::readHistogram(const std::string& name, int cycle) {
503​ auto it = histkeys.find(name + ";" + std::to_string(cycle));
504​ if (it == histkeys.end())
505​ return std::vector<ROOTHist::BinPars>();
506​
507​ std::string buffer = data(it->second);
508​ if (!buffer.empty()) {
509​ // The object structure can be retrieved from TFile::GetStreamerInfoList().
510​ // Every ROOT object contains a version number which may include the byte count
511​ // for the object. The latter is currently assumed to be present to skip unused
512​ // objects. No checks are performed. The corresponding ROOT code is quite nested
513​ // but the actual readout is straight forward.
514​ // Files for reference:
515​ // root/io/io/src/TBufferFile.cxx -> ReadVersion, ReadTString, ReadObjectAny
516​ // root/core/cont/src/TArrayD.cxx -> Streamer
517​ // root/hist/hist/src/TH1.cxx -> Streamer
518​ char *buf = &buffer[0];
519​ size_t count;
520​ Version(buf, count); // TH1(D/F/I/S/C)
521​ char* dbuf = buf + 4;
522​ Version(buf, count); // TH1
523​ dbuf += count;
524​ Skip(buf, 4); // skip TNamed, TAttLine, TAttFill, TAttMarker
525​
526​ std::vector<BinPars> r(read<int>(buf)); // fNcells
527​ if (r.size() < 3)
528​ return std::vector<BinPars>();
529​
530​ r.front().lowedge = -std::numeric_limits<double>::infinity();
531​
532​ // x-Axis
533​ char* nbuf = buf + 4;
534​ Version(buf, count); // TAxis
535​ nbuf += count;
536​ Skip(buf, 2); // skip TNamed, TAttAxis
537​
538​ int nbins = read<int>(buf);
539​ double xmin = read<double>(buf);
540​ double xmax = read<double>(buf);
541​ const size_t nborders = read<int>(buf);
542​
543​ if (nborders == r.size() - 1) {
544​ for (size_t i = 0; i < nborders; ++i) {
545​ r[i + 1].lowedge = read<double>(buf);
546​ }
547​ } else {
548​ buf += sizeof(double) * nbins;
549​ const double scale = (xmax - xmin) / static_cast<double>(nbins);
550​ for (size_t i = 0; i < r.size() - 1; ++i) {
551​ r[i + 1].lowedge = static_cast<double>(i) * scale + xmin;
552​ }
553​ }
554​ buf = nbuf;
555​ Skip(buf, 2); // skip y-Axis and z-Axis;
556​ buf += 68; // skip 2 shorts and 8 doubles
557​ buf += read<int>(buf) * 8; // skip fContour array
558​
559​ if (static_cast<size_t>(read<int>(buf)) == r.size()) {
560​ for (auto& b : r)
561​ b.sumw2 = read<double>(buf); // always double
562​ }
563​
564​ buf = dbuf; // skip to contents of TH1(D/F/I/S/C)
565​
566​ if (static_cast<size_t>(read<int>(buf)) == r.size()) {
567​ switch (it->second.type) {
568​ case KeyBuffer::ContentType::Double:
569​ for (auto& b : r)
570​ b.content = read<double>(buf);
571​ break;
572​ case KeyBuffer::ContentType::Float:
573​ for (auto& b : r)
574​ b.content = read<float>(buf);
575​ break;
576​ case KeyBuffer::ContentType::Int:
577​ for (auto& b : r)
578​ b.content = read<int>(buf);
579​ break;
580​ case KeyBuffer::ContentType::Short:
581​ for (auto& b : r)
582​ b.content = read<short>(buf);
583​ break;
584​ case KeyBuffer::ContentType::Byte:
585​ for (auto& b : r)
586​ b.content = read<char>(buf);
587​ break;
588​ case KeyBuffer::ContentType::Invalid: // never reached
589​ default:
590​ break;
591​ }
592​ }
593​
594​ return r;
595​ } else
596​ return std::vector<BinPars>();
597​}
598​
599​void ROOTHist::readNBins(ROOTHist::KeyBuffer& kbuffer) {
600​ std::string buffer = data(kbuffer);
601​ if (!buffer.empty()) {
602​ // The object structure can be retrieved from TFile::GetStreamerInfoList().
603​ // Every ROOT object contains a version number which may include the byte count
604​ // for the object. The latter is currently assumed to be present to skip unused
605​ // objects. No checks are performed. The corresponding ROOT code is quite nested
606​ // but the actual readout is straight forward.
607​ // Files for reference:
608​ // root/io/io/src/TBufferFile.cxx -> ReadVersion, ReadTString, ReadObjectAny
609​ // root/core/cont/src/TArrayD.cxx -> Streamer
610​ // root/hist/hist/src/TH1.cxx -> Streamer
611​ char *buf = &buffer[0];
612​ size_t count;
613​ Version(buf, count); // TH1(D/F/I/S/C)
614​ char* dbuf = buf + 4;
615​ Version(buf, count); // TH1
616​ dbuf += count;
617​ Skip(buf, 4); // skip TNamed, TAttLine, TAttFill, TAttMarker
618​
619​ kbuffer.nbins = read<int>(buf); // fNcells
620​ }
621​}
622​
623​std::string ROOTHist::data(const ROOTHist::KeyBuffer& buffer) const {
624​ std::ifstream is(filename, std::ifstream::binary);
625​ return data(buffer, is);
626​}
627​
628​std::string ROOTHist::data(const ROOTHist::KeyBuffer& buffer, std::ifstream& is) const {
629​ std::string data(buffer.count, 0);
630​ is.seekg(buffer.start);
631​ if (buffer.compression == KeyBuffer::none) {
632​ is.read(&data[0], buffer.count);
633​ return data;
634​#ifdef HAVE_ZIP
635​ } else if (buffer.compression == KeyBuffer::zlib) {
636​ std::string cdata(buffer.compressed_count, 0);
637​ is.read(&cdata[0], buffer.compressed_count);
638​ size_t luncomp = buffer.count;
639​ if (uncompress((Bytef *)data.data(), &luncomp, (Bytef *)cdata.data(), cdata.size()) == Z_OK && data.size() == luncomp)
640​ return data;
641​ } else {
642​ std::string cdata(buffer.compressed_count, 0);
643​ is.read(&cdata[0], buffer.compressed_count);
644​ if (LZ4_decompress_safe(cdata.data(), const_cast<char*>(data.data()), buffer.compressed_count, buffer.count) == static_cast<int>(buffer.count))
645​ return data;
646​#endif
647​ }
648​
649​ return std::string();
650​}