mirror of
https://github.com/quizhizhe/LiteLoaderBDS-1.16.40.git
synced 2025-06-07 12:18:11 +00:00
111 lines
3.2 KiB
C++
111 lines
3.2 KiB
C++
#ifndef SRC_ALLOCATED_BUFFER_INL_H_
|
|
#define SRC_ALLOCATED_BUFFER_INL_H_
|
|
|
|
#include "allocated_buffer.h"
|
|
#include "base_object-inl.h"
|
|
#include "node_buffer.h"
|
|
#include "env-inl.h"
|
|
#include "uv.h"
|
|
#include "v8.h"
|
|
#include "util-inl.h"
|
|
#include "node_internals.h"
|
|
|
|
namespace node {
|
|
|
|
// It's a bit awkward to define this Buffer::New() overload here, but it
|
|
// avoids a circular dependency with node_internals.h.
|
|
namespace Buffer {
|
|
v8::MaybeLocal<v8::Uint8Array> New(Environment* env,
|
|
v8::Local<v8::ArrayBuffer> ab,
|
|
size_t byte_offset,
|
|
size_t length);
|
|
}
|
|
|
|
NoArrayBufferZeroFillScope::NoArrayBufferZeroFillScope(
|
|
IsolateData* isolate_data)
|
|
: node_allocator_(isolate_data->node_allocator()) {
|
|
if (node_allocator_ != nullptr) node_allocator_->zero_fill_field()[0] = 0;
|
|
}
|
|
|
|
NoArrayBufferZeroFillScope::~NoArrayBufferZeroFillScope() {
|
|
if (node_allocator_ != nullptr) node_allocator_->zero_fill_field()[0] = 1;
|
|
}
|
|
|
|
AllocatedBuffer AllocatedBuffer::AllocateManaged(
|
|
Environment* env,
|
|
size_t size) {
|
|
NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data());
|
|
std::unique_ptr<v8::BackingStore> bs =
|
|
v8::ArrayBuffer::NewBackingStore(env->isolate(), size);
|
|
return AllocatedBuffer(env, std::move(bs));
|
|
}
|
|
|
|
AllocatedBuffer::AllocatedBuffer(
|
|
Environment* env, std::unique_ptr<v8::BackingStore> bs)
|
|
: env_(env), backing_store_(std::move(bs)) {}
|
|
|
|
AllocatedBuffer::AllocatedBuffer(
|
|
Environment* env, uv_buf_t buffer)
|
|
: env_(env) {
|
|
if (buffer.base == nullptr) return;
|
|
auto map = env->released_allocated_buffers();
|
|
auto it = map->find(buffer.base);
|
|
CHECK_NE(it, map->end());
|
|
backing_store_ = std::move(it->second);
|
|
map->erase(it);
|
|
}
|
|
|
|
void AllocatedBuffer::Resize(size_t len) {
|
|
if (len == 0) {
|
|
backing_store_ = v8::ArrayBuffer::NewBackingStore(env_->isolate(), 0);
|
|
return;
|
|
}
|
|
NoArrayBufferZeroFillScope no_zero_fill_scope(env_->isolate_data());
|
|
backing_store_ = v8::BackingStore::Reallocate(
|
|
env_->isolate(), std::move(backing_store_), len);
|
|
}
|
|
|
|
uv_buf_t AllocatedBuffer::release() {
|
|
if (data() == nullptr) return uv_buf_init(nullptr, 0);
|
|
|
|
CHECK_NOT_NULL(env_);
|
|
uv_buf_t ret = uv_buf_init(data(), size());
|
|
env_->released_allocated_buffers()->emplace(
|
|
ret.base, std::move(backing_store_));
|
|
return ret;
|
|
}
|
|
|
|
char* AllocatedBuffer::data() {
|
|
if (!backing_store_) return nullptr;
|
|
return static_cast<char*>(backing_store_->Data());
|
|
}
|
|
|
|
const char* AllocatedBuffer::data() const {
|
|
if (!backing_store_) return nullptr;
|
|
return static_cast<char*>(backing_store_->Data());
|
|
}
|
|
|
|
|
|
size_t AllocatedBuffer::size() const {
|
|
if (!backing_store_) return 0;
|
|
return backing_store_->ByteLength();
|
|
}
|
|
|
|
void AllocatedBuffer::clear() {
|
|
backing_store_.reset();
|
|
}
|
|
|
|
v8::MaybeLocal<v8::Object> AllocatedBuffer::ToBuffer() {
|
|
v8::Local<v8::ArrayBuffer> ab = ToArrayBuffer();
|
|
return Buffer::New(env_, ab, 0, ab->ByteLength())
|
|
.FromMaybe(v8::Local<v8::Uint8Array>());
|
|
}
|
|
|
|
v8::Local<v8::ArrayBuffer> AllocatedBuffer::ToArrayBuffer() {
|
|
return v8::ArrayBuffer::New(env_->isolate(), std::move(backing_store_));
|
|
}
|
|
|
|
} // namespace node
|
|
|
|
#endif // SRC_ALLOCATED_BUFFER_INL_H_
|