Method showResults

lib/timer.cpp:34–78

TODO: this does not include any file context when SHOWTIME_FILE thus rendering it useless - should we include the logging with the progress logging? that could also get rid of the broader locking

// TODO: this does not include any file context when SHOWTIME_FILE thus rendering it useless - should we include the logging with the progress logging?
// that could also get rid of the broader locking
void TimerResults::showResults(size_t max_results, bool metrics) const
{
    using dataElementType = std::pair<std::string, std::vector<std::chrono::milliseconds>>;

    std::vector<dataElementType> data;
    {
        std::lock_guard<std::mutex> l(mResultsSync);

        data.reserve(mResults.size());
        data.insert(data.begin(), mResults.cbegin(), mResults.cend());
    }

    const auto asSeconds = [](std::chrono::milliseconds ms) -> std::chrono::duration<double> {
        return std::chrono::duration_cast<std::chrono::duration<double>>(ms);
    };

    const auto getSeconds = [&asSeconds](const std::vector<std::chrono::milliseconds>& results) -> std::chrono::duration<double> {
        return std::accumulate(results.cbegin(), results.cend(), std::chrono::duration<double>{}, [&asSeconds](std::chrono::duration<double> secs, std::chrono::milliseconds duration) {
            return secs + asSeconds(duration);
        });
    };

    std::sort(data.begin(), data.end(), [&getSeconds](const dataElementType& lhs, const dataElementType& rhs) -> bool {
        return getSeconds(lhs.second) > getSeconds(rhs.second);
    });

    // lock the whole logging operation to avoid multiple threads printing their results at the same time
    std::lock_guard<std::mutex> l(stdCoutLock);

    size_t ordinal = 1; // maybe it would be nice to have an ordinal in output later!
    for (auto iter=data.cbegin(); iter!=data.cend(); ++iter) {
        if (ordinal <= max_results) {
            const double sec = getSeconds(iter->second).count();
            std::cout << iter->first << ": " << sec << "s";
            if (metrics) {
                const double secAverage = sec / static_cast<double>(iter->second.size());
                const double secMin = asSeconds(*std::min_element(iter->second.cbegin(), iter->second.cend())).count();
                const double secMax = asSeconds(*std::max_element(iter->second.cbegin(), iter->second.cend())).count();
                std::cout << " (avg. " << secAverage << "s / min " << secMin << "s / max " << secMax << "s - " << iter->second.size() << " result(s))";
            }
            std::cout << std::endl;
        }
        ++ordinal;
    }
}

void TimerResults::addResults(const std::string& name, std::chrono::milliseconds duration)
{