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>
CreateCallback(Fn && fn,CallbackFlags::Flags flags)13 CallbackQueue<R, Args...>::CreateCallback(Fn&& fn, CallbackFlags::Flags flags) {
14 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>
Shift()19 CallbackQueue<R, Args...>::Shift() {
20 std::unique_ptr<Callback> ret = std::move(head_);
21 if (ret) {
22 head_ = ret->get_next();
23 if (!head_)
24 tail_ = nullptr; // The queue is now empty.
25 size_--;
26 }
27 return ret;
28 }
29
30 template <typename R, typename... Args>
Push(std::unique_ptr<Callback> cb)31 void CallbackQueue<R, Args...>::Push(std::unique_ptr<Callback> cb) {
32 Callback* prev_tail = tail_;
33
34 size_++;
35 tail_ = cb.get();
36 if (prev_tail != nullptr)
37 prev_tail->set_next(std::move(cb));
38 else
39 head_ = std::move(cb);
40 }
41
42 template <typename R, typename... Args>
ConcatMove(CallbackQueue<R,Args...> && other)43 void CallbackQueue<R, Args...>::ConcatMove(CallbackQueue<R, Args...>&& other) {
44 size_ += other.size_;
45 if (tail_ != nullptr)
46 tail_->set_next(std::move(other.head_));
47 else
48 head_ = std::move(other.head_);
49 tail_ = other.tail_;
50 other.tail_ = nullptr;
51 other.size_ = 0;
52 }
53
54 template <typename R, typename... Args>
size()55 size_t CallbackQueue<R, Args...>::size() const {
56 return size_.load();
57 }
58
59 template <typename R, typename... Args>
Callback(CallbackFlags::Flags flags)60 CallbackQueue<R, Args...>::Callback::Callback(CallbackFlags::Flags flags)
61 : flags_(flags) {}
62
63 template <typename R, typename... Args>
flags()64 CallbackFlags::Flags CallbackQueue<R, Args...>::Callback::flags() const {
65 return flags_;
66 }
67
68 template <typename R, typename... Args>
69 std::unique_ptr<typename CallbackQueue<R, Args...>::Callback>
get_next()70 CallbackQueue<R, Args...>::Callback::get_next() {
71 return std::move(next_);
72 }
73
74 template <typename R, typename... Args>
set_next(std::unique_ptr<Callback> next)75 void CallbackQueue<R, Args...>::Callback::set_next(
76 std::unique_ptr<Callback> next) {
77 next_ = std::move(next);
78 }
79
80 template <typename R, typename... Args>
81 template <typename Fn>
CallbackImpl(Fn && callback,CallbackFlags::Flags flags)82 CallbackQueue<R, Args...>::CallbackImpl<Fn>::CallbackImpl(
83 Fn&& callback, CallbackFlags::Flags flags)
84 : Callback(flags),
85 callback_(std::move(callback)) {}
86
87 template <typename R, typename... Args>
88 template <typename Fn>
Call(Args...args)89 R CallbackQueue<R, Args...>::CallbackImpl<Fn>::Call(Args... args) {
90 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_
98