lukechilds/node - node - Gitea: Git with a cup of tea

Commit Graph

Author	SHA1	Message	Date
Fedor Indutny	291b310e21	stream_base: various improvements Expose and use in TLSWrap an `v8::External` wrap of the `StreamBase*` pointer instead of guessing the ancestor C++ class in `node_wrap.h`. Make use of `StreamBase::Callback` structure for storing/passing both callback and context in a single object. Introduce `GetObject()` for future user-land usage, when a child class is not going to be inherited from AsyncWrap. PR-URL: https://github.com/nodejs/node/pull/2351 Reviewed-By: Trevor Norris <trev.norris@gmail.com>	10 years ago
Fedor Indutny	1738c77835	streams: introduce StreamWrap and JSStream Introduce a way to wrap plain-js `stream.Duplex` streams into C++ StreamBase's child class. With such method at hand it is now possible to pass `stream.Duplex` instance as a `socket` parameter to `tls.connect()`. PR-URL: https://github.com/iojs/io.js/pull/926 Reviewed-By: Chris Dickinson <christopher.s.dickinson@gmail.com>	10 years ago
Fedor Indutny	b9686233fc	stream_base: introduce StreamBase StreamBase is an improved way to write C++ streams. The class itself is for separting `StreamWrap` (with the methods like `.writeAsciiString`, `.writeBuffer`, `.writev`, etc) from the `HandleWrap` class, making possible to write abstract C++ streams that are not bound to any uv socket. The following methods are important part of the abstraction (which mimics libuv's stream API): * Events: * `OnAlloc(size_t size, uv_buf_t)` `OnRead(ssize_t nread, const uv_buf_t, uv_handle_type pending)` `OnAfterWrite(WriteWrap)` Wrappers: * `DoShutdown(ShutdownWrap)` `DoTryWrite(uv_buf_t** bufs, size_t* count)` * `DoWrite(WriteWrap, uv_buf_t, size_t count, uv_stream_t* handle)` * `Error()` * `ClearError()` The implementation should provide all of these methods, thus providing the access to the underlying resource (be it uv handle, TLS socket, or anything else). A C++ stream may consume the input of another stream by replacing the event callbacks and proxying the writes. This kind of API is actually used now for the TLSWrap implementation, making it possible to wrap TLS stream into another TLS stream. Thus legacy API calls are no longer required in `_tls_wrap.js`. PR-URL: https://github.com/iojs/io.js/pull/840 Reviewed-By: Trevor Norris <trev.norris@gmail.com> Reviewed-By: Chris Dickinson <christopher.s.dickinson@gmail.com>	10 years ago
isaacs	3e1b1dd4a9	Remove excessive copyright/license boilerplate The copyright and license notice is already in the LICENSE file. There is no justifiable reason to also require that it be included in every file, since the individual files are not individually distributed except as part of the entire package.	10 years ago
Ben Noordhuis	2d82cdf670	src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.	10 years ago
Fedor Indutny	75adde07f9	src: remove `node_isolate` from source fix #6899	11 years ago
Trevor Norris	613d76ef6a	src: shorten Object{Wrap,Unwrap} Going back to the original names of Wrap/Unwrap now that most all the class members that duplicate the name and functionality have been removed.	11 years ago
Trevor Norris	f2e3be53bc	src: don't use class specific Unwrap methods Instead use the template functions in util.h.	11 years ago
Ben Noordhuis	756b622295	src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now "remember" the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.	12 years ago
Ben Noordhuis	4692b725de	src: constify WITH_GENERIC_STREAM macro Make the pointer-to-wrap const (i.e. mutable but not assignable) to prevent accidental reassignment in the macro body.	12 years ago
Ben Noordhuis	c079f6e210	src: add IsEmpty() check to HasInstance() The check has virtually zero overhead and it simplifies the call sites because they were calling IsEmpty() anwyay.	12 years ago
Ben Noordhuis	45d056ee69	src: fix WITH_GENERIC_STREAM() type check bug The handle object was checked against the wrong constructor template. Put another way, it was unwrapped as the wrong StreamWrap type.	12 years ago
Fedor Indutny	8e29ce9f13	src: lint c++ code	12 years ago
Ben Noordhuis	110a9cd8db	lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo<T>& argument rather than a const v8::Arguments& argument. * Binding functions return void rather than v8::Handle<v8::Value>. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent<T> no longer derives from v8::Handle<T> and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local<T> from the persistent handle with the Local<T>::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached<T>, which wraps a v8::Persistent<T> with some template sugar. It can hold arbitrary types but so far it's exclusively used for v8::Strings (which was by far the most commonly cached handle type.)	12 years ago
Timothy J Fontaine	c0281f1b30	build: fix include order for building on windows fallout from the tls_wrap feature landing	12 years ago
Fedor Indutny	6978e998ee	process: abstract out HandleToStream Originally contributed by @tjfontaine, but modified to be faster and more generic.	12 years ago

16 Commits (c529bf55212dc13359ab18d86d0f19cfa05b2166)