@encharm/cws 4.4.1 → 4.5.1

package/src/headers/18/base_object-inl.h

@@ -1,374 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-#ifndef SRC_BASE_OBJECT_INL_H_
-#define SRC_BASE_OBJECT_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "base_object.h"
-#include "env-inl.h"
-#include "util.h"
-
-#include "v8.h"
-
-namespace node {
-
-BaseObject::BaseObject(Environment* env, v8::Local<v8::Object> object)
-    : persistent_handle_(env->isolate(), object), env_(env) {
-  CHECK_EQ(false, object.IsEmpty());
-  CHECK_GT(object->InternalFieldCount(), 0);
-  object->SetAlignedPointerInInternalField(
-      BaseObject::kSlot,
-      static_cast<void*>(this));
-  env->AddCleanupHook(DeleteMe, static_cast<void*>(this));
-  env->modify_base_object_count(1);
-}
-
-BaseObject::~BaseObject() {
-  env()->modify_base_object_count(-1);
-  env()->RemoveCleanupHook(DeleteMe, static_cast<void*>(this));
-
-  if (UNLIKELY(has_pointer_data())) {
-    PointerData* metadata = pointer_data();
-    CHECK_EQ(metadata->strong_ptr_count, 0);
-    metadata->self = nullptr;
-    if (metadata->weak_ptr_count == 0)
-      delete metadata;
-  }
-
-  if (persistent_handle_.IsEmpty()) {
-    // This most likely happened because the weak callback below cleared it.
-    return;
-  }
-
-  {
-    v8::HandleScope handle_scope(env()->isolate());
-    object()->SetAlignedPointerInInternalField(BaseObject::kSlot, nullptr);
-  }
-}
-
-void BaseObject::Detach() {
-  CHECK_GT(pointer_data()->strong_ptr_count, 0);
-  pointer_data()->is_detached = true;
-}
-
-v8::Global<v8::Object>& BaseObject::persistent() {
-  return persistent_handle_;
-}
-
-
-v8::Local<v8::Object> BaseObject::object() const {
-  return PersistentToLocal::Default(env()->isolate(), persistent_handle_);
-}
-
-v8::Local<v8::Object> BaseObject::object(v8::Isolate* isolate) const {
-  v8::Local<v8::Object> handle = object();
-
-  DCHECK_EQ(handle->GetCreationContext().ToLocalChecked()->GetIsolate(),
-            isolate);
-  DCHECK_EQ(env()->isolate(), isolate);
-
-  return handle;
-}
-
-Environment* BaseObject::env() const {
-  return env_;
-}
-
-BaseObject* BaseObject::FromJSObject(v8::Local<v8::Value> value) {
-  v8::Local<v8::Object> obj = value.As<v8::Object>();
-  DCHECK_GE(obj->InternalFieldCount(), BaseObject::kSlot);
-  return static_cast<BaseObject*>(
-      obj->GetAlignedPointerFromInternalField(BaseObject::kSlot));
-}
-
-
-template <typename T>
-T* BaseObject::FromJSObject(v8::Local<v8::Value> object) {
-  return static_cast<T*>(FromJSObject(object));
-}
-
-
-void BaseObject::MakeWeak() {
-  if (has_pointer_data()) {
-    pointer_data()->wants_weak_jsobj = true;
-    if (pointer_data()->strong_ptr_count > 0) return;
-  }
-
-  persistent_handle_.SetWeak(
-      this,
-      [](const v8::WeakCallbackInfo<BaseObject>& data) {
-        BaseObject* obj = data.GetParameter();
-        // Clear the persistent handle so that ~BaseObject() doesn't attempt
-        // to mess with internal fields, since the JS object may have
-        // transitioned into an invalid state.
-        // Refs: https://github.com/nodejs/node/issues/18897
-        obj->persistent_handle_.Reset();
-        CHECK_IMPLIES(obj->has_pointer_data(),
-                      obj->pointer_data()->strong_ptr_count == 0);
-        obj->OnGCCollect();
-      }, v8::WeakCallbackType::kParameter);
-}
-
-void BaseObject::OnGCCollect() {
-  delete this;
-}
-
-void BaseObject::ClearWeak() {
-  if (has_pointer_data())
-    pointer_data()->wants_weak_jsobj = false;
-
-  persistent_handle_.ClearWeak();
-}
-
-bool BaseObject::IsWeakOrDetached() const {
-  if (persistent_handle_.IsWeak()) return true;
-
-  if (!has_pointer_data()) return false;
-  const PointerData* pd = const_cast<BaseObject*>(this)->pointer_data();
-  return pd->wants_weak_jsobj || pd->is_detached;
-}
-
-void BaseObject::LazilyInitializedJSTemplateConstructor(
-    const v8::FunctionCallbackInfo<v8::Value>& args) {
-  DCHECK(args.IsConstructCall());
-  DCHECK_GT(args.This()->InternalFieldCount(), 0);
-  args.This()->SetAlignedPointerInInternalField(BaseObject::kSlot, nullptr);
-}
-
-v8::Local<v8::FunctionTemplate>
-BaseObject::MakeLazilyInitializedJSTemplate(Environment* env) {
-  v8::Local<v8::FunctionTemplate> t =
-      env->NewFunctionTemplate(LazilyInitializedJSTemplateConstructor);
-  t->Inherit(BaseObject::GetConstructorTemplate(env));
-  t->InstanceTemplate()->SetInternalFieldCount(
-      BaseObject::kInternalFieldCount);
-  return t;
-}
-
-template <int Field>
-void BaseObject::InternalFieldGet(
-    v8::Local<v8::String> property,
-    const v8::PropertyCallbackInfo<v8::Value>& info) {
-  info.GetReturnValue().Set(info.This()->GetInternalField(Field));
-}
-
-template <int Field, bool (v8::Value::* typecheck)() const>
-void BaseObject::InternalFieldSet(v8::Local<v8::String> property,
-                                  v8::Local<v8::Value> value,
-                                  const v8::PropertyCallbackInfo<void>& info) {
-  // This could be e.g. value->IsFunction().
-  CHECK(((*value)->*typecheck)());
-  info.This()->SetInternalField(Field, value);
-}
-
-bool BaseObject::has_pointer_data() const {
-  return pointer_data_ != nullptr;
-}
-
-BaseObject::PointerData* BaseObject::pointer_data() {
-  if (!has_pointer_data()) {
-    PointerData* metadata = new PointerData();
-    metadata->wants_weak_jsobj = persistent_handle_.IsWeak();
-    metadata->self = this;
-    pointer_data_ = metadata;
-  }
-  CHECK(has_pointer_data());
-  return pointer_data_;
-}
-
-void BaseObject::decrease_refcount() {
-  CHECK(has_pointer_data());
-  PointerData* metadata = pointer_data();
-  CHECK_GT(metadata->strong_ptr_count, 0);
-  unsigned int new_refcount = --metadata->strong_ptr_count;
-  if (new_refcount == 0) {
-    if (metadata->is_detached) {
-      OnGCCollect();
-    } else if (metadata->wants_weak_jsobj && !persistent_handle_.IsEmpty()) {
-      MakeWeak();
-    }
-  }
-}
-
-void BaseObject::increase_refcount() {
-  unsigned int prev_refcount = pointer_data()->strong_ptr_count++;
-  if (prev_refcount == 0 && !persistent_handle_.IsEmpty())
-    persistent_handle_.ClearWeak();
-}
-
-template <typename T, bool kIsWeak>
-BaseObject::PointerData*
-BaseObjectPtrImpl<T, kIsWeak>::pointer_data() const {
-  if (kIsWeak) {
-    return data_.pointer_data;
-  }
-  if (get_base_object() == nullptr) {
-    return nullptr;
-  }
-  return get_base_object()->pointer_data();
-}
-
-template <typename T, bool kIsWeak>
-BaseObject* BaseObjectPtrImpl<T, kIsWeak>::get_base_object() const {
-  if (kIsWeak) {
-    if (pointer_data() == nullptr) {
-      return nullptr;
-    }
-    return pointer_data()->self;
-  }
-  return data_.target;
-}
-
-template <typename T, bool kIsWeak>
-BaseObjectPtrImpl<T, kIsWeak>::~BaseObjectPtrImpl() {
-  if (kIsWeak) {
-    if (pointer_data() != nullptr &&
-        --pointer_data()->weak_ptr_count == 0 &&
-        pointer_data()->self == nullptr) {
-      delete pointer_data();
-    }
-  } else if (get() != nullptr) {
-    get()->decrease_refcount();
-  }
-}
-
-template <typename T, bool kIsWeak>
-BaseObjectPtrImpl<T, kIsWeak>::BaseObjectPtrImpl() {
-  data_.target = nullptr;
-}
-
-template <typename T, bool kIsWeak>
-BaseObjectPtrImpl<T, kIsWeak>::BaseObjectPtrImpl(T* target)
-  : BaseObjectPtrImpl() {
-  if (target == nullptr) return;
-  if (kIsWeak) {
-    data_.pointer_data = target->pointer_data();
-    CHECK_NOT_NULL(pointer_data());
-    pointer_data()->weak_ptr_count++;
-  } else {
-    data_.target = target;
-    CHECK_NOT_NULL(pointer_data());
-    get()->increase_refcount();
-  }
-}
-
-template <typename T, bool kIsWeak>
-template <typename U, bool kW>
-BaseObjectPtrImpl<T, kIsWeak>::BaseObjectPtrImpl(
-    const BaseObjectPtrImpl<U, kW>& other)
-  : BaseObjectPtrImpl(other.get()) {}
-
-template <typename T, bool kIsWeak>
-BaseObjectPtrImpl<T, kIsWeak>::BaseObjectPtrImpl(const BaseObjectPtrImpl& other)
-  : BaseObjectPtrImpl(other.get()) {}
-
-template <typename T, bool kIsWeak>
-template <typename U, bool kW>
-BaseObjectPtrImpl<T, kIsWeak>& BaseObjectPtrImpl<T, kIsWeak>::operator=(
-    const BaseObjectPtrImpl<U, kW>& other) {
-  if (other.get() == get()) return *this;
-  this->~BaseObjectPtrImpl();
-  return *new (this) BaseObjectPtrImpl(other);
-}
-
-template <typename T, bool kIsWeak>
-BaseObjectPtrImpl<T, kIsWeak>& BaseObjectPtrImpl<T, kIsWeak>::operator=(
-    const BaseObjectPtrImpl& other) {
-  if (other.get() == get()) return *this;
-  this->~BaseObjectPtrImpl();
-  return *new (this) BaseObjectPtrImpl(other);
-}
-
-template <typename T, bool kIsWeak>
-BaseObjectPtrImpl<T, kIsWeak>::BaseObjectPtrImpl(BaseObjectPtrImpl&& other)
-  : data_(other.data_) {
-  if (kIsWeak)
-    other.data_.target = nullptr;
-  else
-    other.data_.pointer_data = nullptr;
-}
-
-template <typename T, bool kIsWeak>
-BaseObjectPtrImpl<T, kIsWeak>& BaseObjectPtrImpl<T, kIsWeak>::operator=(
-    BaseObjectPtrImpl&& other) {
-  if (&other == this) return *this;
-  this->~BaseObjectPtrImpl();
-  return *new (this) BaseObjectPtrImpl(std::move(other));
-}
-
-template <typename T, bool kIsWeak>
-void BaseObjectPtrImpl<T, kIsWeak>::reset(T* ptr) {
-  *this = BaseObjectPtrImpl(ptr);
-}
-
-template <typename T, bool kIsWeak>
-T* BaseObjectPtrImpl<T, kIsWeak>::get() const {
-  return static_cast<T*>(get_base_object());
-}
-
-template <typename T, bool kIsWeak>
-T& BaseObjectPtrImpl<T, kIsWeak>::operator*() const {
-  return *get();
-}
-
-template <typename T, bool kIsWeak>
-T* BaseObjectPtrImpl<T, kIsWeak>::operator->() const {
-  return get();
-}
-
-template <typename T, bool kIsWeak>
-BaseObjectPtrImpl<T, kIsWeak>::operator bool() const {
-  return get() != nullptr;
-}
-
-template <typename T, bool kIsWeak>
-template <typename U, bool kW>
-bool BaseObjectPtrImpl<T, kIsWeak>::operator ==(
-    const BaseObjectPtrImpl<U, kW>& other) const {
-  return get() == other.get();
-}
-
-template <typename T, bool kIsWeak>
-template <typename U, bool kW>
-bool BaseObjectPtrImpl<T, kIsWeak>::operator !=(
-    const BaseObjectPtrImpl<U, kW>& other) const {
-  return get() != other.get();
-}
-
-template <typename T, typename... Args>
-BaseObjectPtr<T> MakeBaseObject(Args&&... args) {
-  return BaseObjectPtr<T>(new T(std::forward<Args>(args)...));
-}
-
-template <typename T, typename... Args>
-BaseObjectPtr<T> MakeDetachedBaseObject(Args&&... args) {
-  BaseObjectPtr<T> target = MakeBaseObject<T>(std::forward<Args>(args)...);
-  target->Detach();
-  return target;
-}
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_BASE_OBJECT_INL_H_

package/src/headers/18/callback_queue-inl.h

@@ -1,97 +0,0 @@
-#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_

package/src/headers/18/callback_queue.h

@@ -1,78 +0,0 @@
-#ifndef SRC_CALLBACK_QUEUE_H_
-#define SRC_CALLBACK_QUEUE_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <atomic>
-
-namespace node {
-
-namespace CallbackFlags {
-enum Flags {
-  kUnrefed = 0,
-  kRefed = 1,
-};
-}
-
-// A queue of C++ functions that take Args... as arguments and return R
-// (this is similar to the signature of std::function).
-// New entries are added using `CreateCallback()`/`Push()`, and removed using
-// `Shift()`.
-// The `refed` flag is left for easier use in situations in which some of these
-// should be run even if nothing else is keeping the event loop alive.
-template <typename R, typename... Args>
-class CallbackQueue {
- public:
-  class Callback {
-   public:
-    explicit inline Callback(CallbackFlags::Flags flags);
-
-    virtual ~Callback() = default;
-    virtual R Call(Args... args) = 0;
-
-    inline CallbackFlags::Flags flags() const;
-
-   private:
-    inline std::unique_ptr<Callback> get_next();
-    inline void set_next(std::unique_ptr<Callback> next);
-
-    CallbackFlags::Flags flags_;
-    std::unique_ptr<Callback> next_;
-
-    friend class CallbackQueue;
-  };
-
-  template <typename Fn>
-  inline std::unique_ptr<Callback> CreateCallback(
-      Fn&& fn, CallbackFlags::Flags);
-
-  inline std::unique_ptr<Callback> Shift();
-  inline void Push(std::unique_ptr<Callback> cb);
-  // ConcatMove adds elements from 'other' to the end of this list, and clears
-  // 'other' afterwards.
-  inline void ConcatMove(CallbackQueue&& other);
-
-  // size() is atomic and may be called from any thread.
-  inline size_t size() const;
-
- private:
-  template <typename Fn>
-  class CallbackImpl final : public Callback {
-   public:
-    CallbackImpl(Fn&& callback, CallbackFlags::Flags flags);
-    R Call(Args... args) override;
-
-   private:
-    Fn callback_;
-  };
-
-  std::atomic<size_t> size_ {0};
-  std::unique_ptr<Callback> head_;
-  Callback* tail_ = nullptr;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_CALLBACK_QUEUE_H_