@@ -54,9 +54,9 @@ using v8::Object;
54
54
using v8::Value;
55
55
56
56
57
- void StreamWrap ::Initialize (Local<Object> target,
58
- Local<Value> unused,
59
- Local<Context> context) {
57
+ void LibuvStreamWrap ::Initialize (Local<Object> target,
58
+ Local<Value> unused,
59
+ Local<Context> context) {
60
60
Environment* env = Environment::GetCurrent (context);
61
61
62
62
auto is_construct_call_callback =
@@ -85,10 +85,10 @@ void StreamWrap::Initialize(Local<Object> target,
85
85
}
86
86
87
87
88
- StreamWrap::StreamWrap (Environment* env,
89
- Local<Object> object,
90
- uv_stream_t * stream,
91
- AsyncWrap::ProviderType provider)
88
+ LibuvStreamWrap::LibuvStreamWrap (Environment* env,
89
+ Local<Object> object,
90
+ uv_stream_t * stream,
91
+ AsyncWrap::ProviderType provider)
92
92
: HandleWrap(env,
93
93
object,
94
94
reinterpret_cast <uv_handle_t *>(stream),
@@ -101,15 +101,15 @@ StreamWrap::StreamWrap(Environment* env,
101
101
}
102
102
103
103
104
- void StreamWrap ::AddMethods (Environment* env,
105
- v8::Local<v8::FunctionTemplate> target,
106
- int flags) {
104
+ void LibuvStreamWrap ::AddMethods (Environment* env,
105
+ v8::Local<v8::FunctionTemplate> target,
106
+ int flags) {
107
107
env->SetProtoMethod (target, " setBlocking" , SetBlocking);
108
- StreamBase::AddMethods<StreamWrap >(env, target, flags);
108
+ StreamBase::AddMethods<LibuvStreamWrap >(env, target, flags);
109
109
}
110
110
111
111
112
- int StreamWrap ::GetFD () {
112
+ int LibuvStreamWrap ::GetFD () {
113
113
int fd = -1 ;
114
114
#if !defined(_WIN32)
115
115
if (stream () != nullptr )
@@ -119,53 +119,53 @@ int StreamWrap::GetFD() {
119
119
}
120
120
121
121
122
- bool StreamWrap ::IsAlive () {
122
+ bool LibuvStreamWrap ::IsAlive () {
123
123
return HandleWrap::IsAlive (this );
124
124
}
125
125
126
126
127
- bool StreamWrap ::IsClosing () {
127
+ bool LibuvStreamWrap ::IsClosing () {
128
128
return uv_is_closing (reinterpret_cast <uv_handle_t *>(stream ()));
129
129
}
130
130
131
131
132
- void * StreamWrap ::Cast () {
132
+ void * LibuvStreamWrap ::Cast () {
133
133
return reinterpret_cast <void *>(this );
134
134
}
135
135
136
136
137
- AsyncWrap* StreamWrap ::GetAsyncWrap () {
137
+ AsyncWrap* LibuvStreamWrap ::GetAsyncWrap () {
138
138
return static_cast <AsyncWrap*>(this );
139
139
}
140
140
141
141
142
- bool StreamWrap ::IsIPCPipe () {
142
+ bool LibuvStreamWrap ::IsIPCPipe () {
143
143
return is_named_pipe_ipc ();
144
144
}
145
145
146
146
147
- void StreamWrap ::UpdateWriteQueueSize () {
147
+ void LibuvStreamWrap ::UpdateWriteQueueSize () {
148
148
HandleScope scope (env ()->isolate ());
149
149
Local<Integer> write_queue_size =
150
150
Integer::NewFromUnsigned (env ()->isolate (), stream ()->write_queue_size );
151
151
object ()->Set (env ()->write_queue_size_string (), write_queue_size);
152
152
}
153
153
154
154
155
- int StreamWrap ::ReadStart () {
155
+ int LibuvStreamWrap ::ReadStart () {
156
156
return uv_read_start (stream (), OnAlloc, OnRead);
157
157
}
158
158
159
159
160
- int StreamWrap ::ReadStop () {
160
+ int LibuvStreamWrap ::ReadStop () {
161
161
return uv_read_stop (stream ());
162
162
}
163
163
164
164
165
- void StreamWrap ::OnAlloc (uv_handle_t * handle,
165
+ void LibuvStreamWrap ::OnAlloc (uv_handle_t * handle,
166
166
size_t suggested_size,
167
167
uv_buf_t * buf) {
168
- StreamWrap * wrap = static_cast <StreamWrap *>(handle->data );
168
+ LibuvStreamWrap * wrap = static_cast <LibuvStreamWrap *>(handle->data );
169
169
HandleScope scope (wrap->env ()->isolate ());
170
170
Context::Scope context_scope (wrap->env ()->context ());
171
171
@@ -175,14 +175,14 @@ void StreamWrap::OnAlloc(uv_handle_t* handle,
175
175
}
176
176
177
177
178
- void StreamWrap ::OnAllocImpl (size_t size, uv_buf_t * buf, void * ctx) {
178
+ void LibuvStreamWrap ::OnAllocImpl (size_t size, uv_buf_t * buf, void * ctx) {
179
179
buf->base = node::Malloc (size);
180
180
buf->len = size;
181
181
}
182
182
183
183
184
184
template <class WrapType , class UVType >
185
- static Local<Object> AcceptHandle (Environment* env, StreamWrap * parent) {
185
+ static Local<Object> AcceptHandle (Environment* env, LibuvStreamWrap * parent) {
186
186
EscapableHandleScope scope (env->isolate ());
187
187
Local<Object> wrap_obj;
188
188
UVType* handle;
@@ -202,11 +202,11 @@ static Local<Object> AcceptHandle(Environment* env, StreamWrap* parent) {
202
202
}
203
203
204
204
205
- void StreamWrap ::OnReadImpl (ssize_t nread,
205
+ void LibuvStreamWrap ::OnReadImpl (ssize_t nread,
206
206
const uv_buf_t * buf,
207
207
uv_handle_type pending,
208
208
void * ctx) {
209
- StreamWrap * wrap = static_cast <StreamWrap *>(ctx);
209
+ LibuvStreamWrap * wrap = static_cast <LibuvStreamWrap *>(ctx);
210
210
Environment* env = wrap->env ();
211
211
HandleScope handle_scope (env->isolate ());
212
212
Context::Scope context_scope (env->context ());
@@ -244,10 +244,10 @@ void StreamWrap::OnReadImpl(ssize_t nread,
244
244
}
245
245
246
246
247
- void StreamWrap ::OnRead (uv_stream_t * handle,
247
+ void LibuvStreamWrap ::OnRead (uv_stream_t * handle,
248
248
ssize_t nread,
249
249
const uv_buf_t * buf) {
250
- StreamWrap * wrap = static_cast <StreamWrap *>(handle->data );
250
+ LibuvStreamWrap * wrap = static_cast <LibuvStreamWrap *>(handle->data );
251
251
HandleScope scope (wrap->env ()->isolate ());
252
252
Context::Scope context_scope (wrap->env ()->context ());
253
253
uv_handle_type type = UV_UNKNOWN_HANDLE;
@@ -273,8 +273,8 @@ void StreamWrap::OnRead(uv_stream_t* handle,
273
273
}
274
274
275
275
276
- void StreamWrap ::SetBlocking (const FunctionCallbackInfo<Value>& args) {
277
- StreamWrap * wrap;
276
+ void LibuvStreamWrap ::SetBlocking (const FunctionCallbackInfo<Value>& args) {
277
+ LibuvStreamWrap * wrap;
278
278
ASSIGN_OR_RETURN_UNWRAP (&wrap, args.Holder ());
279
279
280
280
CHECK_GT (args.Length (), 0 );
@@ -286,15 +286,15 @@ void StreamWrap::SetBlocking(const FunctionCallbackInfo<Value>& args) {
286
286
}
287
287
288
288
289
- int StreamWrap ::DoShutdown (ShutdownWrap* req_wrap) {
289
+ int LibuvStreamWrap ::DoShutdown (ShutdownWrap* req_wrap) {
290
290
int err;
291
291
err = uv_shutdown (req_wrap->req (), stream (), AfterShutdown);
292
292
req_wrap->Dispatched ();
293
293
return err;
294
294
}
295
295
296
296
297
- void StreamWrap ::AfterShutdown (uv_shutdown_t * req, int status) {
297
+ void LibuvStreamWrap ::AfterShutdown (uv_shutdown_t * req, int status) {
298
298
ShutdownWrap* req_wrap = ShutdownWrap::from_req (req);
299
299
CHECK_NE (req_wrap, nullptr );
300
300
HandleScope scope (req_wrap->env ()->isolate ());
@@ -307,7 +307,7 @@ void StreamWrap::AfterShutdown(uv_shutdown_t* req, int status) {
307
307
// values, shifting their base and decrementing their length. This is
308
308
// required in order to skip the data that was successfully written via
309
309
// uv_try_write().
310
- int StreamWrap ::DoTryWrite (uv_buf_t ** bufs, size_t * count) {
310
+ int LibuvStreamWrap ::DoTryWrite (uv_buf_t ** bufs, size_t * count) {
311
311
int err;
312
312
size_t written;
313
313
uv_buf_t * vbufs = *bufs;
@@ -343,7 +343,7 @@ int StreamWrap::DoTryWrite(uv_buf_t** bufs, size_t* count) {
343
343
}
344
344
345
345
346
- int StreamWrap ::DoWrite (WriteWrap* w,
346
+ int LibuvStreamWrap ::DoWrite (WriteWrap* w,
347
347
uv_buf_t * bufs,
348
348
size_t count,
349
349
uv_stream_t * send_handle) {
@@ -372,7 +372,7 @@ int StreamWrap::DoWrite(WriteWrap* w,
372
372
}
373
373
374
374
375
- void StreamWrap ::AfterWrite (uv_write_t * req, int status) {
375
+ void LibuvStreamWrap ::AfterWrite (uv_write_t * req, int status) {
376
376
WriteWrap* req_wrap = WriteWrap::from_req (req);
377
377
CHECK_NE (req_wrap, nullptr );
378
378
HandleScope scope (req_wrap->env ()->isolate ());
@@ -381,11 +381,12 @@ void StreamWrap::AfterWrite(uv_write_t* req, int status) {
381
381
}
382
382
383
383
384
- void StreamWrap ::OnAfterWriteImpl (WriteWrap* w, void * ctx) {
385
- StreamWrap * wrap = static_cast <StreamWrap *>(ctx);
384
+ void LibuvStreamWrap ::OnAfterWriteImpl (WriteWrap* w, void * ctx) {
385
+ LibuvStreamWrap * wrap = static_cast <LibuvStreamWrap *>(ctx);
386
386
wrap->UpdateWriteQueueSize ();
387
387
}
388
388
389
389
} // namespace node
390
390
391
- NODE_MODULE_CONTEXT_AWARE_BUILTIN (stream_wrap, node::StreamWrap::Initialize)
391
+ NODE_MODULE_CONTEXT_AWARE_BUILTIN (stream_wrap,
392
+ node::LibuvStreamWrap::Initialize)
0 commit comments