16262579083

Committed 14 Jul 2025 09:00AM UTC coverage: 45.192% (-0.02%) from 45.212%

Build # 16262579083

Build Type

Pull #2613

github

Committed by

web-flow

Commit Message

Merge 256efa2d7 into 6c112e71f

Pull Request Pull Request #2613: core: fix regression in locked_queue

Run Details

7 of 8 new or added lines in 1 file covered. (87.5%)

9 existing lines in 2 files now uncovered.

15416 of 34112 relevant lines covered (45.19%)

115532.92 hits per line

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

97.5

/src/mavsdk/core/locked_queue.h

#pragma once

#include <queue>
#include <mutex>
#include <memory>
#include <condition_variable>

namespace mavsdk {

template<class T> class LockedQueue {
public:
    LockedQueue() = default;
    ~LockedQueue() = default;

    void push_back(std::shared_ptr<T> item_ptr)
    {
        std::lock_guard<std::mutex> lock(_mutex);
        _queue.push_back(item_ptr);
        _condition_var.notify_one();
    }

    size_t size()
    {
        std::lock_guard<std::mutex> lock(_mutex);
        return _queue.size();
    }

    void stop()
    {
        std::lock_guard<std::mutex> lock(_mutex);
        _should_exit = true;
        _condition_var.notify_all();
    }

    using iterator = typename std::deque<std::shared_ptr<T>>::iterator;
    iterator begin() { return _queue.begin(); }

    iterator end() { return _queue.end(); }

    iterator erase(iterator it) { return _queue.erase(it); }

    // This guard serves the purpose to combine a get_front with a pop_front.
    // Thus, no one can interfere between the two steps.
    class Guard {
    public:
        explicit Guard(LockedQueue& locked_queue) :
            _locked_queue(locked_queue),
            _lock(locked_queue._mutex)
        {}

        ~Guard() = default;

        Guard(Guard& other) = delete;
        Guard(const Guard& other) = delete;
        Guard(Guard&& other) = delete;
        Guard(const Guard&& other) = delete;
        Guard& operator=(const Guard& other) = delete;
        Guard& operator=(Guard&& other) = delete;

        std::shared_ptr<T> get_front()
        {
            if (_locked_queue._queue.size() == 0) {
                return nullptr;
            }
            return _locked_queue._queue.front();
        }

        std::shared_ptr<T> wait_and_pop_front()
        {
            while (_locked_queue._queue.empty()) {
                if (_locked_queue._should_exit) {
                    return std::shared_ptr<T>{};
                }
                _locked_queue._condition_var.wait(_lock);
            }
            if (_locked_queue._should_exit) {
                return std::shared_ptr<T>{};
            }

            auto result = _locked_queue._queue.front();
            _locked_queue._queue.pop_front();
            return result;
        }

        void pop_front() { _locked_queue._queue.pop_front(); }

    private:
        LockedQueue<T>& _locked_queue;
        std::unique_lock<std::mutex> _lock;
    };

private:
    std::deque<std::shared_ptr<T>> _queue{};
    std::mutex _mutex{};
    std::condition_variable _condition_var{};
    bool _should_exit{false};
};

} // namespace mavsdk

1	#pragma once
2
3	#include <queue>
4	#include <mutex>
5	#include <memory>
6	#include <condition_variable>
7
8	namespace mavsdk {
9
10	template<class T> class LockedQueue {
11	public:
12	LockedQueue() = default;	758✔
13	~LockedQueue() = default;	758✔
14
15	void push_back(std::shared_ptr<T> item_ptr)	1,616✔
16	{
17	std::lock_guard<std::mutex> lock(_mutex);	1,616✔
18	_queue.push_back(item_ptr);	1,616✔
19	_condition_var.notify_one();	1,616✔
20	}	1,616✔
21
22	size_t size()	1,055✔
23	{
24	std::lock_guard<std::mutex> lock(_mutex);	1,055✔
25	return _queue.size();	1,055✔
26	}	1,055✔
27
28	void stop()	88✔
29	{
30	std::lock_guard<std::mutex> lock(_mutex);	88✔
31	_should_exit = true;	88✔
32	_condition_var.notify_all();	88✔
33	}	88✔
34
35	using iterator = typename std::deque<std::shared_ptr<T>>::iterator;
36	iterator begin() { return _queue.begin(); }	9,662✔
37
38	iterator end() { return _queue.end(); }	9,742✔
39
40	iterator erase(iterator it) { return _queue.erase(it); }	205✔
41
42	// This guard serves the purpose to combine a get_front with a pop_front.
43	// Thus, no one can interfere between the two steps.
44	class Guard {
45	public:
46	explicit Guard(LockedQueue& locked_queue) :	259,526,465✔
47	_locked_queue(locked_queue),	259,526,465✔
48	_lock(locked_queue._mutex)	259,526,465✔
49	{}	272,551,772✔
50
51	~Guard() = default;	257,064,252✔
52
53	Guard(Guard& other) = delete;
54	Guard(const Guard& other) = delete;
55	Guard(Guard&& other) = delete;
56	Guard(const Guard&& other) = delete;
57	Guard& operator=(const Guard& other) = delete;
58	Guard& operator=(Guard&& other) = delete;
59
60	std::shared_ptr<T> get_front()	261,635,176✔
61	{
62	if (_locked_queue._queue.size() == 0) {	261,635,176✔
63	return nullptr;	260,773,466✔
64	}
65	return _locked_queue._queue.front();	2,485✔
66	}
67
68	std::shared_ptr<T> wait_and_pop_front()	1,136✔
69	{
70	while (_locked_queue._queue.empty()) {	2,038✔
71	if (_locked_queue._should_exit) {	990✔
72	return std::shared_ptr<T>{};	88✔
73	}
74	_locked_queue._condition_var.wait(_lock);	902✔
75	}
76	if (_locked_queue._should_exit) {	1,048✔
NEW 77	return std::shared_ptr<T>{};	×
78	}
79
80	auto result = _locked_queue._queue.front();	1,048✔
81	_locked_queue._queue.pop_front();	1,048✔
82	return result;	1,048✔
83	}	1,048✔
84
85	void pop_front() { _locked_queue._queue.pop_front(); }	339✔
86
87	private:
88	LockedQueue<T>& _locked_queue;
89	std::unique_lock<std::mutex> _lock;
90	};
91
92	private:
93	std::deque<std::shared_ptr<T>> _queue{};
94	std::mutex _mutex{};
95	std::condition_variable _condition_var{};
96	bool _should_exit{false};
97	};
98
99	} // namespace mavsdk

mavlink / MAVSDK / 16262579083

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