lib/node/node_modules/nan/nan_persistent_pre_12_inl.h (c972b0c)

nan_persistent_pre_12_inl.h

/*********************************************************************
 * NAN - Native Abstractions for Node.js
 *
 * Copyright (c) 2018 NAN contributors
 *
 * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
 ********************************************************************/

#ifndef NAN_PERSISTENT_PRE_12_INL_H_
#define NAN_PERSISTENT_PRE_12_INL_H_

template<typename T>
class PersistentBase {
 v8::Persistent<T> persistent;
 template<typename U>
 friend v8::Local New(const PersistentBase &p);
 template<typename U, typename M>
 friend v8::Local New(const Persistent<U, M> &p);
 template<typename U>
 friend v8::Local New(const Global &p);
 template<typename S> friend class ReturnValue;

public:
  inline PersistentBase() :
      persistent() {}

inline void Reset() {
    persistent.Dispose();
    persistent.Clear();
  }

template<typename S>
 inline void Reset(const v8::Local<S> &other) {
 TYPE_CHECK(T, S);

if (!persistent.IsEmpty()) {
      persistent.Dispose();
    }

if (other.IsEmpty()) {
 persistent.Clear();
 } else {
 persistent = v8::Persistent<T>::New(other);
 }
 }

template<typename S>
 inline void Reset(const PersistentBase<S> &other) {
 TYPE_CHECK(T, S);

if (!persistent.IsEmpty()) {
      persistent.Dispose();
    }

if (other.IsEmpty()) {
 persistent.Clear();
 } else {
 persistent = v8::Persistent<T>::New(other.persistent);
 }
 }

inline bool IsEmpty() const { return persistent.IsEmpty(); }

inline void Empty() { persistent.Clear(); }

template<typename S>
 inline bool operator==(const PersistentBase<S> &that) const {
 return this->persistent == that.persistent;
 }

template<typename S>
 inline bool operator==(const v8::Local<S> &that) const {
 return this->persistent == that;
 }

template<typename S>
 inline bool operator!=(const PersistentBase<S> &that) const {
 return !operator==(that);
 }

template<typename S>
 inline bool operator!=(const v8::Local<S> &that) const {
 return !operator==(that);
 }

template<typename P>
 inline void SetWeak(
 P *parameter
 , typename WeakCallbackInfo::Callback callback
 , WeakCallbackType type);

inline void ClearWeak() { persistent.ClearWeak(); }

inline void MarkIndependent() { persistent.MarkIndependent(); }

inline bool IsIndependent() const { return persistent.IsIndependent(); }

inline bool IsNearDeath() const { return persistent.IsNearDeath(); }

inline bool IsWeak() const { return persistent.IsWeak(); }

private:
 inline explicit PersistentBase(v8::Persistent<T> that) :
 persistent(that) { }
 inline explicit PersistentBase(T *val) : persistent(val) {}
 template<typename S, typename M> friend class Persistent;
 template<typename S> friend class Global;
 friend class ObjectWrap;
};

template<typename T>
class NonCopyablePersistentTraits {
 public:
 typedef Persistent<T, NonCopyablePersistentTraits<T> >
 NonCopyablePersistent;
 static const bool kResetInDestructor = false;
 template<typename S, typename M>
 inline static void Copy(const Persistent<S, M> &source,
 NonCopyablePersistent *dest) {
 Uncompilable<v8::Object>();
 }

template<typename O> inline static void Uncompilable() {
 TYPE_CHECK(O, v8::Primitive);
 }
};

template<typename T>
struct CopyablePersistentTraits {
 typedef Persistent<T, CopyablePersistentTraits<T> > CopyablePersistent;
 static const bool kResetInDestructor = true;
 template<typename S, typename M>
 static inline void Copy(const Persistent<S, M> &source,
 CopyablePersistent *dest) {}
};

template<typename T, typename M> class Persistent :
 public PersistentBase<T> {
 public:
 inline Persistent() {}

template<typename S> inline Persistent(v8::Handle<S> that)
 : PersistentBase<T>(v8::Persistent<T>::New(that)) {
 TYPE_CHECK(T, S);
 }

inline Persistent(const Persistent &that) : PersistentBase<T>() {
 Copy(that);
 }

template<typename S, typename M2>
 inline Persistent(const Persistent<S, M2> &that) :
 PersistentBase<T>() {
 Copy(that);
 }

inline Persistent &operator=(const Persistent &that) {
    Copy(that);
    return *this;
  }

template <class S, class M2>
 inline Persistent &operator=(const Persistent<S, M2> &that) {
 Copy(that);
 return *this;
 }

inline ~Persistent() {
    if (M::kResetInDestructor) this->Reset();
  }

private:
 inline T *operator*() const { return *PersistentBase<T>::persistent; }

template<typename S, typename M2>
 inline void Copy(const Persistent<S, M2> &that) {
 TYPE_CHECK(T, S);

this->Reset();

if (!that.IsEmpty()) {
 this->persistent = v8::Persistent<T>::New(that.persistent);
 M::Copy(that, this);
 }
 }
};

template<typename T>
class Global : public PersistentBase<T> {
 struct RValue {
 inline explicit RValue(Global* obj) : object(obj) {}
 Global* object;
 };

public:
 inline Global() : PersistentBase<T>(0) { }

template <typename S>
 inline Global(v8::Local<S> that) // NOLINT(runtime/explicit)
 : PersistentBase<T>(v8::Persistent<T>::New(that)) {
 TYPE_CHECK(T, S);
 }

template <typename S>
 inline Global(const PersistentBase<S> &that) // NOLINT(runtime/explicit)
 : PersistentBase<T>(that) {
 TYPE_CHECK(T, S);
 }
 /**
 * Move constructor.
 */
 inline Global(RValue rvalue) // NOLINT(runtime/explicit)
 : PersistentBase<T>(rvalue.object->persistent) {
 rvalue.object->Reset();
 }
 inline ~Global() { this->Reset(); }
 /**
 * Move via assignment.
 */
 template<typename S>
 inline Global &operator=(Global<S> rhs) {
 TYPE_CHECK(T, S);
 this->Reset(rhs.persistent);
 rhs.Reset();
 return *this;
 }
 /**
 * Cast operator for moves.
 */
 inline operator RValue() { return RValue(this); }
 /**
 * Pass allows returning uniques from functions, etc.
 */
 Global Pass() { return Global(RValue(this)); }

private:
 Global(Global &);
 void operator=(Global &);
 template<typename S> friend class ReturnValue;
};

#endif  // NAN_PERSISTENT_PRE_12_INL_H_

wirc-backend.git

[ini]