Where Online Learning is simpler!

The C and C++ Include Header Files

/usr/include/nodejs/src/callback_queue-inl.h


$ cat -n /usr/include/nodejs/src/callback_queue-inl.h

     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	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>
    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>
    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>
    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>
    55	size_t CallbackQueue<R, Args...>::size() const {
    56	  return size_.load();
    57	}
    58	
    59	template <typename R, typename... Args>
    60	CallbackQueue<R, Args...>::Callback::Callback(CallbackFlags::Flags flags)
    61	  : flags_(flags) {}
    62	
    63	template <typename R, typename... Args>
    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>
    70	CallbackQueue<R, Args...>::Callback::get_next() {
    71	  return std::move(next_);
    72	}
    73	
    74	template <typename R, typename... Args>
    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>
    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>
    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_