#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_