: Executor(files, fileSettings, settings, suppressions, errorLogger, timerResults)

, mExecuteCommand(std::move(executeCommand))

{

assert(mSettings.jobs > 1);

{

explicit SyncLogForwarder(ThreadExecutor &threadExecutor, ErrorLogger &errorLogger)

: mThreadExecutor(threadExecutor), mErrorLogger(errorLogger) {}

void reportOut(const std::string &outmsg, Color c) override

{

std::lock_guard<std::mutex> lg(mReportSync);

mErrorLogger.reportOut(outmsg, c);

}

void reportErr(const ErrorMessage &msg) override {

if (!mThreadExecutor.hasToLog(msg))

return;

std::lock_guard<std::mutex> lg(mReportSync);

mErrorLogger.reportErr(msg);

}

void reportMetric(const std::string &metric) override {

std::lock_guard<std::mutex> lg(mReportSync);

mErrorLogger.reportMetric(metric);

}

void reportStatus(std::size_t fileindex, std::size_t filecount, std::size_t sizedone, std::size_t sizetotal) {

std::lock_guard<std::mutex> lg(mReportSync);

mThreadExecutor.reportStatus(fileindex, filecount, sizedone, sizetotal);

}

std::mutex mReportSync;

ThreadExecutor &mThreadExecutor;

ErrorLogger &mErrorLogger;

{

ThreadData(ThreadExecutor &threadExecutor, ErrorLogger &errorLogger, TimerResults *timerResults, const Settings &settings, Suppressions& supprs, const std::list<FileWithDetails> &files, const std::list<FileSettings> &fileSettings, CppCheck::ExecuteCmdFn executeCommand)

: mFiles(files), mFileSettings(fileSettings), mTimerResults(timerResults), mSettings(settings), mSuppressions(supprs), mExecuteCommand(std::move(executeCommand)), mLogForwarder(threadExecutor, errorLogger)

{

mItNextFile = mFiles.begin();

mItNextFileSettings = mFileSettings.begin();

mTotalFiles = mFiles.size() + mFileSettings.size();

mTotalFileSize = std::accumulate(mFiles.cbegin(), mFiles.cend(), std::size_t(0), [](std::size_t v, const FileWithDetails& p) {

return v + p.size();

});

}

bool next(const FileWithDetails *&file, const FileSettings *&fs, std::size_t &fileSize) {

std::lock_guard<std::mutex> l(mFileSync);

if (mItNextFile != mFiles.end()) {

file = &(*mItNextFile);

fs = nullptr;

fileSize = mItNextFile->size();

++mItNextFile;

return true;

}

if (mItNextFileSettings != mFileSettings.end()) {

file = nullptr;

fs = &(*mItNextFileSettings);

fileSize = 0;

++mItNextFileSettings;

return true;

}

return false;

}

unsigned int check(const FileWithDetails *file, const FileSettings *fs) {

CppCheck fileChecker(mSettings, mSuppressions, mLogForwarder, mTimerResults, false, mExecuteCommand);

unsigned int result;

if (fs) {

// file settings..

result = fileChecker.check(*fs);

} else {

// Read file from a file

result = fileChecker.check(*file);

}

for (const auto& suppr : mSuppressions.nomsg.getSuppressions()) {

// need to transfer all inline suppressions because these are used later on

if (suppr.isInline) {

const std::string err = mSuppressions.nomsg.addSuppression(suppr);

if (!err.empty()) {

// TODO: only update state if it doesn't exist - otherwise propagate error

mSuppressions.nomsg.updateSuppressionState(suppr); // TODO: check result

}

continue;

}

// propagate state of global suppressions

if (!suppr.isLocal()) {

mSuppressions.nomsg.updateSuppressionState(suppr); // TODO: check result

continue;

}

}

return result;

}

void status(std::size_t fileSize) {

std::lock_guard<std::mutex> l(mFileSync);

mProcessedSize += fileSize;

mProcessedFiles++;

if (!mSettings.quiet)

mLogForwarder.reportStatus(mProcessedFiles, mTotalFiles, mProcessedSize, mTotalFileSize);

}

const std::list<FileWithDetails> &mFiles;

std::list<FileWithDetails>::const_iterator mItNextFile;

const std::list<FileSettings> &mFileSettings;

std::list<FileSettings>::const_iterator mItNextFileSettings;

std::size_t mProcessedFiles{};

std::size_t mTotalFiles{};

std::size_t mProcessedSize{};

std::size_t mTotalFileSize{};

std::mutex mFileSync;

TimerResults *mTimerResults;

const Settings &mSettings;

Suppressions &mSuppressions;

CppCheck::ExecuteCmdFn mExecuteCommand;

SyncLogForwarder mLogForwarder;

{

unsigned int result = 0;

const FileWithDetails *file;

const FileSettings *fs;

std::size_t fileSize;

while (data->next(file, fs, fileSize)) {

result += data->check(file, fs);

data->status(fileSize);

}

return result;

{

std::vector<std::future<unsigned int>> threadFutures;

threadFutures.reserve(mSettings.jobs);

ThreadData data(*this, mErrorLogger, mTimerResults, mSettings, mSuppressions, mFiles, mFileSettings, mExecuteCommand);

for (unsigned int i = 0; i < mSettings.jobs; ++i) {

try {

threadFutures.emplace_back(std::async(std::launch::async, &threadProc, &data));

}

catch (const std::system_error &e) {

std::cerr << "#### ThreadExecutor::check exception :" << e.what() << std::endl;

exit(EXIT_FAILURE);

}

}

unsigned int result = std::accumulate(threadFutures.begin(), threadFutures.end(), 0U, [](unsigned int v, std::future<unsigned int>& f) {

return v + f.get();

});

return result;