nan/nan_persistent_12_inl.h at 4bed9681b8bd73b88de2a2653146cfb5a78f4f76 · nodejs/nan · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
/*********************************************************************
 * NAN - Native Abstractions for Node.js
 *
 * Copyright (c) 2016 NAN contributors
 *
 * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
 ********************************************************************/

#ifndef NAN_PERSISTENT_12_INL_H_
#define NAN_PERSISTENT_12_INL_H_

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

  template<typename S> inline explicit Persistent(v8::Local<S> that) :
      v8::Persistent<T, M>(v8::Isolate::GetCurrent(), that) {}

  template<typename S, typename M2>
  inline explicit Persistent(const v8::Persistent<S, M2> &that) :
      v8::Persistent<T, M2>(v8::Isolate::GetCurrent(), that) {}

  inline void Reset() { v8::PersistentBase<T>::Reset(); }

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

  template<typename S>
  inline void Reset(const v8::PersistentBase<S> &other) {
    v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
  }

#if NODE_MODULE_VERSION == NODE_0_12_MODULE_VERSION
  inline void Empty() {
    v8::Persistent<T, M>::ClearAndLeak();
  }
#endif

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

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

    this->Reset();

    if (!that.IsEmpty()) {
      this->Reset(that);
      M::Copy(that, this);
    }
  }
};

#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
template<typename T>
class Global : public v8::Global<T> {
 public:
  inline Global() : v8::Global<T>() {}

  template<typename S> inline explicit Global(v8::Local<S> that) :
    v8::Global<T>(v8::Isolate::GetCurrent(), that) {}

  template<typename S>
  inline explicit Global(const v8::PersistentBase<S> &that) :
      v8::Global<S>(v8::Isolate::GetCurrent(), that) {}

  inline void Reset() { v8::PersistentBase<T>::Reset(); }

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

  template <typename S>
  inline void Reset(const v8::PersistentBase<S> &other) {
    v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
  }

  Global Pass() { return static_cast<Global&&>(*this); }  // NOLINT(build/c++11)

  template<typename P>
  inline void SetWeak(
    P *parameter
    , typename WeakCallbackInfo<P>::Callback callback
    , WeakCallbackType type) {
    static_cast<Persistent<T>*>(static_cast<v8::PersistentBase<T>*>(this))->
        SetWeak(parameter, callback, type);
  }
};
#else
template<typename T>
class Global : public v8::UniquePersistent<T> {
  struct RValue {
    inline explicit RValue(v8::UniquePersistent<T> *obj) : object_(obj) {}
    v8::UniquePersistent<T> *object_;
  };

 public:
  inline Global() : v8::UniquePersistent<T>() {}

  template<typename S> inline explicit Global(v8::Local<S> that) :
    v8::UniquePersistent<T>(v8::Isolate::GetCurrent(), that) {}

  template<typename S>
  inline explicit Global(const v8::PersistentBase<S> &that) :
      v8::UniquePersistent<S>(v8::Isolate::GetCurrent(), that) {}

  inline void Reset() { v8::PersistentBase<T>::Reset(); }

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

  template<typename S>
  inline void Reset(const v8::PersistentBase<S> &other) {
    v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
  }

#if NODE_MODULE_VERSION == NODE_0_12_MODULE_VERSION
  inline void Empty() {
    static_cast<v8::Persistent<T>*>(static_cast<v8::PersistentBase<T>*>(this))->
        ClearAndLeak();
  }
#endif

  inline Global(RValue rvalue) {  // NOLINT(runtime/explicit)
    std::memcpy(this, rvalue.object_, sizeof (*rvalue.object_));
# if NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION
    rvalue.object_->Empty();
# else
    static_cast<v8::Persistent<T>*>(static_cast<v8::PersistentBase<T>*>(
        rvalue.object_))->ClearAndLeak();
# endif
  }

  template<typename S>
  inline Global &operator=(v8::UniquePersistent<S> other) {
    return static_cast<Global&>(v8::UniquePersistent<S>::operator=(other));
  }

  inline operator RValue() { return RValue(this); }

  Global Pass() { return Global(RValue(this)); }

  template<typename P>
  inline void SetWeak(
    P *parameter
    , typename WeakCallbackInfo<P>::Callback callback
    , WeakCallbackType type) {
    static_cast<Persistent<T>*>(static_cast<v8::PersistentBase<T>*>(this))
        ->SetWeak(parameter, callback, type);
  }
};
#endif

#endif  // NAN_PERSISTENT_12_INL_H_