36242499959

Committed 26 Sep 2026 12:37PM UTC coverage: 93.049% (-0.07%) from 93.121%

Build # 36242499959

Build Type

push

github

Committed by

web-flow

Commit Message

Merge f3486039f into f7e61bab2

Coverage Stats

31 of 33 new or added lines in 2 files covered. (93.94%)

1874 of 2014 relevant lines covered (93.05%)

3072600.08 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.08

/src/cli/ConsoleProgress.cpp

#include "ConsoleProgress.hpp"

#include <bkcrack/log.hpp>

#include <array>
#include <cstdio>

#ifdef _WIN32

#define WIN32_LEAN_AND_MEAN
#include <windows.h>

#endif // _WIN32

ConsoleProgress::ConsoleProgress(std::ostream& os, const std::chrono::milliseconds& interval)
: Progress{os}
, m_interval{interval}
, m_in_destructor{false}
, m_printer{&ConsoleProgress::printerFunction, this}
{
#ifdef _WIN32
    const auto hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
    if (auto curInfo = CONSOLE_CURSOR_INFO{}; GetConsoleCursorInfo(hStdOut, &curInfo))
    {
        curInfo.bVisible = FALSE;
        SetConsoleCursorInfo(hStdOut, &curInfo);
    }
#endif // _WIN32
}

ConsoleProgress::~ConsoleProgress()
{
    {
        const auto lock = std::scoped_lock{m_in_destructor_mutex};
        m_in_destructor = true;
    }

    m_in_destructor_cv.notify_all();
    m_printer.join();

#ifdef _WIN32
    const auto hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
    if (auto curInfo = CONSOLE_CURSOR_INFO{}; GetConsoleCursorInfo(hStdOut, &curInfo))
    {
        curInfo.bVisible = TRUE;
        SetConsoleCursorInfo(hStdOut, &curInfo);
    }
#endif // _WIN32
}

void ConsoleProgress::printerFunction()
{
    auto repeat = true;

    // Give a small delay before the first time progress is printed so that
    // the running operation is likely to have initialized the total number of steps.
    {
        auto lock = std::unique_lock{m_in_destructor_mutex};
        repeat = !m_in_destructor_cv.wait_for(lock, std::chrono::milliseconds{1}, [this] { return m_in_destructor; });
    }

    while (repeat)
    {
        if (const auto line = getProgressLine(); !line.empty())
        {
            const auto lock = std::scoped_lock{m_os_mutex};
            m_os << '\r' << line;
            if (line.size() < m_lengthToClear)
                m_os << std::string(m_lengthToClear - line.size(), ' ');
            m_os << std::flush;
            m_lengthToClear = line.size();
        }

        auto lock = std::unique_lock{m_in_destructor_mutex};
        repeat    = !m_in_destructor_cv.wait_for(lock, m_interval, [this] { return m_in_destructor; });
    }

    if (const auto line = getProgressLine(); !line.empty())
    {
        const auto lock = std::scoped_lock{m_os_mutex};
        m_os << '\r' << line;
        if (line.size() < m_lengthToClear)
            m_os << std::string(m_lengthToClear - line.size(), ' ');
        m_os << std::endl;
        m_lengthToClear = 0;
    }
}

void ConsoleProgress::beforeLog(std::ostream& os)
{
    if (!m_lengthToClear)
        return;

    os << '\r' << std::string(m_lengthToClear, ' ') << '\r';
    m_lengthToClear = 0;
}

auto ConsoleProgress::getProgressLine() -> std::string
{
    if (const auto total = this->total.load())
    {
        const auto done   = this->done.load();
        auto       buffer = std::array<char, 80 + 1>{};
        const auto length =
            std::snprintf(buffer.data(), buffer.size(), "%.1f %% (%d / %d)", 100.0 * done / total, done, total);
        if (0 <= length && length < int{sizeof(buffer)})
            return std::string{buffer.data(), static_cast<std::size_t>(length)};
    }
    return "";
}

1	#include "ConsoleProgress.hpp"
2
3	#include <bkcrack/log.hpp>
4
5	#include <array>
6	#include <cstdio>
7
8	#ifdef _WIN32
9
10	#define WIN32_LEAN_AND_MEAN
11	#include <windows.h>
12
13	#endif // _WIN32
14
15	ConsoleProgress::ConsoleProgress(std::ostream& os, const std::chrono::milliseconds& interval)	26✔
16	: Progress{os}
17	, m_interval{interval}	26✔
18	, m_in_destructor{false}	26✔
19	, m_printer{&ConsoleProgress::printerFunction, this}	26✔
20	{
21	#ifdef _WIN32
22	const auto hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
23	if (auto curInfo = CONSOLE_CURSOR_INFO{}; GetConsoleCursorInfo(hStdOut, &curInfo))
24	{
25	curInfo.bVisible = FALSE;
26	SetConsoleCursorInfo(hStdOut, &curInfo);
27	}
28	#endif // _WIN32
29	}	26✔
30
31	ConsoleProgress::~ConsoleProgress()	52✔
32	{
33	{
34	const auto lock = std::scoped_lock{m_in_destructor_mutex};	52✔
35	m_in_destructor = true;	52✔
36	}	52✔
37
38	m_in_destructor_cv.notify_all();	52✔
39	m_printer.join();	52✔
40
41	#ifdef _WIN32
42	const auto hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
43	if (auto curInfo = CONSOLE_CURSOR_INFO{}; GetConsoleCursorInfo(hStdOut, &curInfo))
44	{
45	curInfo.bVisible = TRUE;
46	SetConsoleCursorInfo(hStdOut, &curInfo);
47	}
48	#endif // _WIN32
49	}	52✔
50
51	void ConsoleProgress::printerFunction()	26✔
52	{
53	auto repeat = true;	26✔
54
55	// Give a small delay before the first time progress is printed so that
56	// the running operation is likely to have initialized the total number of steps.
57	{
58	auto lock = std::unique_lock{m_in_destructor_mutex};	26✔
59	repeat = !m_in_destructor_cv.wait_for(lock, std::chrono::milliseconds{1}, [this] { return m_in_destructor; });	78✔
60	}	26✔
61
62	while (repeat)	264✔
63	{
64	if (const auto line = getProgressLine(); !line.empty())	238✔
65	{
66	const auto lock = std::scoped_lock{m_os_mutex};	234✔
67	m_os << '\r' << line;	234✔
68	if (line.size() < m_lengthToClear)	234✔
NEW 69	m_os << std::string(m_lengthToClear - line.size(), ' ');	×
70	m_os << std::flush;	234✔
71	m_lengthToClear = line.size();	234✔
72	}	472✔
73
74	auto lock = std::unique_lock{m_in_destructor_mutex};	238✔
75	repeat = !m_in_destructor_cv.wait_for(lock, m_interval, [this] { return m_in_destructor; });	714✔
76	}	238✔
77
78	if (const auto line = getProgressLine(); !line.empty())	26✔
79	{
80	const auto lock = std::scoped_lock{m_os_mutex};	9✔
81	m_os << '\r' << line;	9✔
82	if (line.size() < m_lengthToClear)	9✔
NEW 83	m_os << std::string(m_lengthToClear - line.size(), ' ');	×
84	m_os << std::endl;	9✔
85	m_lengthToClear = 0;	9✔
86	}	35✔
87	}	26✔
88
89	void ConsoleProgress::beforeLog(std::ostream& os)	43✔
90	{
91	if (!m_lengthToClear)	43✔
92	return;	38✔
93
94	os << '\r' << std::string(m_lengthToClear, ' ') << '\r';	10✔
95	m_lengthToClear = 0;	5✔
96	}
97
98	auto ConsoleProgress::getProgressLine() -> std::string	264✔
99	{
100	if (const auto total = this->total.load())	528✔
101	{
102	const auto done = this->done.load();	243✔
103	auto buffer = std::array<char, 80 + 1>{};	243✔
104	const auto length =
105	std::snprintf(buffer.data(), buffer.size(), "%.1f %% (%d / %d)", 100.0 * done / total, done, total);	486✔
106	if (0 <= length && length < int{sizeof(buffer)})	243✔
107	return std::string{buffer.data(), static_cast<std::size_t>(length)};	729✔
108	}
109	return "";	42✔
110	}

kimci86 / bkcrack / 36242499959

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous