#include "base_object.h"

#include "env-inl.h"

#include "node_messaging.h"

#include "node_realm-inl.h"

namespace node {

using v8::Context;

using v8::FunctionCallbackInfo;

using v8::FunctionTemplate;

using v8::HandleScope;

using v8::Just;

using v8::Local;

using v8::Maybe;

using v8::Object;

using v8::Value;

using v8::ValueDeserializer;

using v8::WeakCallbackInfo;

using v8::WeakCallbackType;

BaseObject::BaseObject(Realm* realm, Local<Object> object)

}

BaseObject::~BaseObject() {

realm()->modify_base_object_count(-1);

realm()->RemoveCleanupHook(DeleteMe, static_cast<void*>(this));

if (UNLIKELY(has_pointer_data())) {

PointerData* metadata = pointer_data();

CHECK_EQ(metadata->strong_ptr_count, 0);

metadata->self = nullptr;

if (metadata->weak_ptr_count == 0) delete metadata;

}

if (persistent_handle_.IsEmpty()) {

// This most likely happened because the weak callback below cleared it.

return;

}

{

HandleScope handle_scope(realm()->isolate());

object()->SetAlignedPointerInInternalField(BaseObject::kSlot, nullptr);

}

}

void BaseObject::MakeWeak() {

}

void BaseObject::LazilyInitializedJSTemplateConstructor(

}

Local<FunctionTemplate> BaseObject::MakeLazilyInitializedJSTemplate(

Environment* env) {

return MakeLazilyInitializedJSTemplate(env->isolate_data());

}

Local<FunctionTemplate> BaseObject::MakeLazilyInitializedJSTemplate(

}

BaseObject::TransferMode BaseObject::GetTransferMode() const {

return TransferMode::kDisallowCloneAndTransfer;

}

std::unique_ptr<worker::TransferData> BaseObject::TransferForMessaging() {

return {};

}

std::unique_ptr<worker::TransferData> BaseObject::CloneForMessaging() const {

return {};

}

Maybe<std::vector<BaseObjectPtr<BaseObject>>> BaseObject::NestedTransferables()

const {

return Just(std::vector<BaseObjectPtr<BaseObject>>{});

}

Maybe<bool> BaseObject::FinalizeTransferRead(Local<Context> context,

ValueDeserializer* deserializer) {

return Just(true);

}

BaseObject::PointerData* BaseObject::pointer_data() {

if (!has_pointer_data()) {

PointerData* metadata = new PointerData();

metadata->wants_weak_jsobj = persistent_handle_.IsWeak();

metadata->self = this;

pointer_data_ = metadata;

}

CHECK(has_pointer_data());

return pointer_data_;

}

void BaseObject::decrease_refcount() {

}

void BaseObject::increase_refcount() {

}

void BaseObject::DeleteMe(void* data) {

}

bool BaseObject::IsDoneInitializing() const {

return true;

}

Local<Object> BaseObject::WrappedObject() const {

return object();

}

bool BaseObject::IsRootNode() const {

return !persistent_handle_.IsWeak();

}

bool BaseObject::IsNotIndicativeOfMemoryLeakAtExit() const {

return IsWeakOrDetached();

}

} // namespace node