7e9eb9e3f1
* perf: cache the dictionary handle * refactor: prefer result.IsJust() over !result.IsNothing() for consistency * refactor: prefer maybe.FromMaybe() over maybe.IsJust() && maybe.FromJust() the inlined code is simpler * refactor: simplify Get() impl * refactor: add private helper Dictionary::MakeKey() refactor: add private helper Dictionary::MakeHiddenKey()
229 lines
7.7 KiB
C++
229 lines
7.7 KiB
C++
// Copyright (c) 2019 GitHub, Inc.
|
|
// Use of this source code is governed by the MIT license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#ifndef ELECTRON_SHELL_COMMON_GIN_HELPER_DICTIONARY_H_
|
|
#define ELECTRON_SHELL_COMMON_GIN_HELPER_DICTIONARY_H_
|
|
|
|
#include <optional>
|
|
#include <string_view>
|
|
#include <type_traits>
|
|
#include <utility>
|
|
|
|
#include "gin/dictionary.h"
|
|
#include "shell/common/gin_converters/std_converter.h"
|
|
#include "shell/common/gin_helper/accessor.h"
|
|
#include "shell/common/gin_helper/function_template.h"
|
|
|
|
namespace gin_helper {
|
|
|
|
// Adds a few more extends methods to gin::Dictionary.
|
|
//
|
|
// Note that as the destructor of gin::Dictionary is not virtual, and we want to
|
|
// convert between 2 types, we must not add any member.
|
|
class Dictionary : public gin::Dictionary {
|
|
public:
|
|
Dictionary() : gin::Dictionary(nullptr) {}
|
|
Dictionary(v8::Isolate* isolate, v8::Local<v8::Object> object)
|
|
: gin::Dictionary(isolate, object) {}
|
|
|
|
// Allow implicitly converting from gin::Dictionary, as it is absolutely
|
|
// safe in this case.
|
|
Dictionary(const gin::Dictionary& dict) // NOLINT(runtime/explicit)
|
|
: gin::Dictionary(dict) {}
|
|
|
|
static Dictionary CreateEmpty(v8::Isolate* isolate) {
|
|
return gin::Dictionary::CreateEmpty(isolate);
|
|
}
|
|
|
|
// Differences from the Get method in gin::Dictionary:
|
|
// 1. This is a const method;
|
|
// 2. It checks whether the key exists before reading;
|
|
// 3. It accepts arbitrary type of key.
|
|
template <typename K, typename V>
|
|
bool Get(const K& key, V* out) const {
|
|
v8::Isolate* const iso = isolate();
|
|
v8::Local<v8::Object> handle = GetHandle();
|
|
v8::Local<v8::Context> context = iso->GetCurrentContext();
|
|
v8::Local<v8::Value> v8_key = gin::ConvertToV8(iso, key);
|
|
v8::Local<v8::Value> value;
|
|
// Check for existence before getting, otherwise this method will always
|
|
// returns true when T == v8::Local<v8::Value>.
|
|
return handle->Has(context, v8_key).FromMaybe(false) &&
|
|
handle->Get(context, v8_key).ToLocal(&value) &&
|
|
gin::ConvertFromV8(iso, value, out);
|
|
}
|
|
|
|
// Differences from the Set method in gin::Dictionary:
|
|
// 1. It accepts arbitrary type of key.
|
|
template <typename K, typename V>
|
|
bool Set(const K& key, const V& val) {
|
|
v8::Local<v8::Value> v8_value;
|
|
if (!gin::TryConvertToV8(isolate(), val, &v8_value))
|
|
return false;
|
|
v8::Maybe<bool> result =
|
|
GetHandle()->Set(isolate()->GetCurrentContext(),
|
|
gin::ConvertToV8(isolate(), key), v8_value);
|
|
return result.FromMaybe(false);
|
|
}
|
|
|
|
// Like normal Get but put result in an std::optional.
|
|
template <typename T>
|
|
bool GetOptional(const std::string_view key, std::optional<T>* out) const {
|
|
T ret;
|
|
if (Get(key, &ret)) {
|
|
out->emplace(std::move(ret));
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
bool GetHidden(std::string_view key, T* out) const {
|
|
v8::Isolate* const iso = isolate();
|
|
v8::Local<v8::Object> handle = GetHandle();
|
|
v8::Local<v8::Context> context = iso->GetCurrentContext();
|
|
v8::Local<v8::Private> privateKey = MakeHiddenKey(key);
|
|
v8::Local<v8::Value> value;
|
|
return handle->HasPrivate(context, privateKey).FromMaybe(false) &&
|
|
handle->GetPrivate(context, privateKey).ToLocal(&value) &&
|
|
gin::ConvertFromV8(iso, value, out);
|
|
}
|
|
|
|
template <typename T>
|
|
bool SetHidden(std::string_view key, T val) {
|
|
v8::Isolate* const iso = isolate();
|
|
v8::Local<v8::Value> v8_value;
|
|
if (!gin::TryConvertToV8(iso, val, &v8_value))
|
|
return false;
|
|
v8::Local<v8::Context> context = iso->GetCurrentContext();
|
|
v8::Local<v8::Private> privateKey = MakeHiddenKey(key);
|
|
v8::Maybe<bool> result =
|
|
GetHandle()->SetPrivate(context, privateKey, v8_value);
|
|
return result.FromMaybe(false);
|
|
}
|
|
|
|
template <typename T>
|
|
bool SetMethod(std::string_view key, const T& callback) {
|
|
auto context = isolate()->GetCurrentContext();
|
|
auto templ = CallbackTraits<T>::CreateTemplate(isolate(), callback);
|
|
return GetHandle()
|
|
->Set(context, MakeKey(key),
|
|
templ->GetFunction(context).ToLocalChecked())
|
|
.ToChecked();
|
|
}
|
|
|
|
template <typename K, typename V>
|
|
bool SetGetter(const K& key,
|
|
const V& val,
|
|
v8::PropertyAttribute attribute = v8::None) {
|
|
AccessorValue<V> acc_value;
|
|
acc_value.Value = val;
|
|
|
|
v8::Local<v8::Value> v8_value_accessor;
|
|
if (!gin::TryConvertToV8(isolate(), acc_value, &v8_value_accessor))
|
|
return false;
|
|
|
|
auto context = isolate()->GetCurrentContext();
|
|
|
|
return GetHandle()
|
|
->SetNativeDataProperty(
|
|
context, MakeKey(key),
|
|
[](v8::Local<v8::Name> property_name,
|
|
const v8::PropertyCallbackInfo<v8::Value>& info) {
|
|
AccessorValue<V> acc_value;
|
|
if (!gin::ConvertFromV8(info.GetIsolate(), info.Data(),
|
|
&acc_value))
|
|
return;
|
|
|
|
V val = acc_value.Value;
|
|
v8::Local<v8::Value> v8_value;
|
|
if (gin::TryConvertToV8(info.GetIsolate(), val, &v8_value))
|
|
info.GetReturnValue().Set(v8_value);
|
|
},
|
|
nullptr, v8_value_accessor, attribute)
|
|
.ToChecked();
|
|
}
|
|
|
|
template <typename T>
|
|
bool SetReadOnly(std::string_view key, const T& val) {
|
|
v8::Local<v8::Value> v8_value;
|
|
if (!gin::TryConvertToV8(isolate(), val, &v8_value))
|
|
return false;
|
|
v8::Maybe<bool> result = GetHandle()->DefineOwnProperty(
|
|
isolate()->GetCurrentContext(), MakeKey(key), v8_value, v8::ReadOnly);
|
|
return result.FromMaybe(false);
|
|
}
|
|
|
|
// Note: If we plan to add more Set methods, consider adding an option instead
|
|
// of copying code.
|
|
template <typename T>
|
|
bool SetReadOnlyNonConfigurable(std::string_view key, T val) {
|
|
v8::Local<v8::Value> v8_value;
|
|
if (!gin::TryConvertToV8(isolate(), val, &v8_value))
|
|
return false;
|
|
v8::Maybe<bool> result = GetHandle()->DefineOwnProperty(
|
|
isolate()->GetCurrentContext(), MakeKey(key), v8_value,
|
|
static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete));
|
|
return result.FromMaybe(false);
|
|
}
|
|
|
|
bool Has(std::string_view key) const {
|
|
v8::Maybe<bool> result =
|
|
GetHandle()->Has(isolate()->GetCurrentContext(), MakeKey(key));
|
|
return result.FromMaybe(false);
|
|
}
|
|
|
|
bool Delete(std::string_view key) {
|
|
v8::Maybe<bool> result =
|
|
GetHandle()->Delete(isolate()->GetCurrentContext(), MakeKey(key));
|
|
return result.FromMaybe(false);
|
|
}
|
|
|
|
bool IsEmpty() const { return isolate() == nullptr || GetHandle().IsEmpty(); }
|
|
|
|
v8::Local<v8::Object> GetHandle() const {
|
|
return gin::ConvertToV8(isolate(),
|
|
*static_cast<const gin::Dictionary*>(this))
|
|
.As<v8::Object>();
|
|
}
|
|
|
|
private:
|
|
// DO NOT ADD ANY DATA MEMBER.
|
|
|
|
[[nodiscard]] v8::Local<v8::String> MakeKey(
|
|
const std::string_view key) const {
|
|
return gin::StringToV8(isolate(), key);
|
|
}
|
|
|
|
[[nodiscard]] v8::Local<v8::Private> MakeHiddenKey(
|
|
const std::string_view key) const {
|
|
return v8::Private::ForApi(isolate(), MakeKey(key));
|
|
}
|
|
};
|
|
|
|
} // namespace gin_helper
|
|
|
|
namespace gin {
|
|
|
|
template <>
|
|
struct Converter<gin_helper::Dictionary> {
|
|
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
|
|
gin_helper::Dictionary val) {
|
|
return val.GetHandle();
|
|
}
|
|
static bool FromV8(v8::Isolate* isolate,
|
|
v8::Local<v8::Value> val,
|
|
gin_helper::Dictionary* out) {
|
|
gin::Dictionary gdict(isolate);
|
|
if (!ConvertFromV8(isolate, val, &gdict))
|
|
return false;
|
|
*out = gin_helper::Dictionary(gdict);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
} // namespace gin
|
|
|
|
#endif // ELECTRON_SHELL_COMMON_GIN_HELPER_DICTIONARY_H_
|