Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	callback_queue-inl.h	Lines:	41	42	97.6 %
Date:	2022-09-21 04:23:13	Branches:	7	8	87.5 %


#ifndef SRC_CALLBACK_QUEUE_INL_H_
#define SRC_CALLBACK_QUEUE_INL_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#include "callback_queue.h"

namespace node {

template <typename R, typename... Args>
template <typename Fn>
std::unique_ptr<typename CallbackQueue<R, Args...>::Callback>
CallbackQueue<R, Args...>::CreateCallback(Fn&& fn, CallbackFlags::Flags flags) {
  return std::make_unique<CallbackImpl<Fn>>(std::move(fn), flags);
}

template <typename R, typename... Args>
std::unique_ptr<typename CallbackQueue<R, Args...>::Callback>
CallbackQueue<R, Args...>::Shift() {
  std::unique_ptr<Callback> ret = std::move(head_);
  if (ret) {
    head_ = ret->get_next();
    if (!head_)
      tail_ = nullptr;  // The queue is now empty.
    size_--;
  }
  return ret;
}

template <typename R, typename... Args>
void CallbackQueue<R, Args...>::Push(std::unique_ptr<Callback> cb) {
  Callback* prev_tail = tail_;

  size_++;
  tail_ = cb.get();
  if (prev_tail != nullptr)
    prev_tail->set_next(std::move(cb));
  else
    head_ = std::move(cb);
}

template <typename R, typename... Args>
void CallbackQueue<R, Args...>::ConcatMove(CallbackQueue<R, Args...>&& other) {
  size_ += other.size_;
  if (tail_ != nullptr)
    tail_->set_next(std::move(other.head_));
  else
    head_ = std::move(other.head_);
  tail_ = other.tail_;
  other.tail_ = nullptr;
  other.size_ = 0;
}

template <typename R, typename... Args>
size_t CallbackQueue<R, Args...>::size() const {
  return size_.load();
}

template <typename R, typename... Args>
CallbackQueue<R, Args...>::Callback::Callback(CallbackFlags::Flags flags)
  : flags_(flags) {}

template <typename R, typename... Args>
CallbackFlags::Flags CallbackQueue<R, Args...>::Callback::flags() const {
  return flags_;
}

template <typename R, typename... Args>
std::unique_ptr<typename CallbackQueue<R, Args...>::Callback>
CallbackQueue<R, Args...>::Callback::get_next() {
  return std::move(next_);
}

template <typename R, typename... Args>
void CallbackQueue<R, Args...>::Callback::set_next(
    std::unique_ptr<Callback> next) {
  next_ = std::move(next);
}

template <typename R, typename... Args>
template <typename Fn>
CallbackQueue<R, Args...>::CallbackImpl<Fn>::CallbackImpl(
    Fn&& callback, CallbackFlags::Flags flags)
  : Callback(flags),
    callback_(std::move(callback)) {}

template <typename R, typename... Args>
template <typename Fn>
R CallbackQueue<R, Args...>::CallbackImpl<Fn>::Call(Args... args) {
  return callback_(std::forward<Args>(args)...);
}

}  // namespace node

#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#endif  // SRC_CALLBACK_QUEUE_INL_H_


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			#ifndef SRC_CALLBACK_QUEUE_INL_H_
2			#define SRC_CALLBACK_QUEUE_INL_H_
3
4			#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
5
6			#include "callback_queue.h"
7
8			namespace node {
9
10			template <typename R, typename... Args>
11			template <typename Fn>
12			std::unique_ptr<typename CallbackQueue<R, Args...>::Callback>
13		130358	CallbackQueue<R, Args...>::CreateCallback(Fn&& fn, CallbackFlags::Flags flags) {
14		130358	return std::make_unique<CallbackImpl<Fn>>(std::move(fn), flags);
15			}
16
17			template <typename R, typename... Args>
18			std::unique_ptr<typename CallbackQueue<R, Args...>::Callback>
19		549540	CallbackQueue<R, Args...>::Shift() {
20		549540	std::unique_ptr<Callback> ret = std::move(head_);
21	✓✓	549540	if (ret) {
22		70685	head_ = ret->get_next();
23	✓✓	70685	if (!head_)
24		64125	tail_ = nullptr; // The queue is now empty.
25		70685	size_--;
26			}
27		549540	return ret;
28			}
29
30			template <typename R, typename... Args>
31		70776	void CallbackQueue<R, Args...>::Push(std::unique_ptr<Callback> cb) {
32		70776	Callback* prev_tail = tail_;
33
34		70776	size_++;
35		70776	tail_ = cb.get();
36	✓✓	70776	if (prev_tail != nullptr)
37		6578	prev_tail->set_next(std::move(cb));
38			else
39		64198	head_ = std::move(cb);
40		70776	}
41
42			template <typename R, typename... Args>
43		11857	void CallbackQueue<R, Args...>::ConcatMove(CallbackQueue<R, Args...>&& other) {
44		11857	size_ += other.size_;
45	✗✓	11857	if (tail_ != nullptr)
46			tail_->set_next(std::move(other.head_));
47			else
48		11857	head_ = std::move(other.head_);
49		11857	tail_ = other.tail_;
50		11857	other.tail_ = nullptr;
51		11857	other.size_ = 0;
52		11857	}
53
54			template <typename R, typename... Args>
55		518830	size_t CallbackQueue<R, Args...>::size() const {
56		1037660	return size_.load();
57			}
58
59			template <typename R, typename... Args>
60		70776	CallbackQueue<R, Args...>::Callback::Callback(CallbackFlags::Flags flags)
61		70776	: flags_(flags) {}
62
63			template <typename R, typename... Args>
64		59919	CallbackFlags::Flags CallbackQueue<R, Args...>::Callback::flags() const {
65		59919	return flags_;
66			}
67
68			template <typename R, typename... Args>
69			std::unique_ptr<typename CallbackQueue<R, Args...>::Callback>
70		70685	CallbackQueue<R, Args...>::Callback::get_next() {
71		70685	return std::move(next_);
72			}
73
74			template <typename R, typename... Args>
75		6578	void CallbackQueue<R, Args...>::Callback::set_next(
76			std::unique_ptr<Callback> next) {
77		6578	next_ = std::move(next);
78		6578	}
79
80			template <typename R, typename... Args>
81			template <typename Fn>
82		130358	CallbackQueue<R, Args...>::CallbackImpl<Fn>::CallbackImpl(
83			Fn&& callback, CallbackFlags::Flags flags)
84			: Callback(flags),
85		130358	callback_(std::move(callback)) {}
86
87			template <typename R, typename... Args>
88			template <typename Fn>
89		70414	R CallbackQueue<R, Args...>::CallbackImpl<Fn>::Call(Args... args) {
90		70414	return callback_(std::forward<Args>(args)...);
91			}
92
93			} // namespace node
94
95			#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
96
97			#endif // SRC_CALLBACK_QUEUE_INL_H_