Isolate *isolate,

v8::Local<ObjectTemplate> instance_or_template,

v8::Local<ObjectTemplate> prototype_or_template,

v8::Local<FunctionTemplate> interface_or_template,

v8::Local<v8::Signature> signature,

const AccessorConfiguration *props,

size_t length) {

for (int i = 0; i < length; i++) {

InstallAccessor(isolate, instance_or_template, prototype_or_template, interface_or_template, signature, props[i]);

}

Isolate *isolate,

v8::Local<ObjectOrTemplate> instance_or_template,

v8::Local<ObjectOrTemplate> prototype_or_template,

v8::Local<FunctionOrTemplate> interface_or_template,

v8::Local<v8::Signature> signature,

const AccessorConfiguration &prop) {

Local<FunctionTemplate> getter = v8::FunctionTemplate::New(

isolate, prop.getter, Local<Value>(), signature, 0 );

if (!getter.IsEmpty()) {

getter->RemovePrototype();

getter->SetAcceptAnyReceiver(true);

}

Local<FunctionTemplate> setter = v8::FunctionTemplate::New(

isolate, prop.setter, Local<Value>(), signature, 1 );

if (!setter.IsEmpty()) {

setter->RemovePrototype();

setter->SetAcceptAnyReceiver(true);

}

unsigned location = prop.property_location_configuration;

Local<String> name = String::NewFromUtf8( isolate, prop.name, v8::NewStringType::kInternalized, strlen(prop.name) ).ToLocalChecked();

if ( location & (kOnInstance | kOnPrototype) ) {

if (location & kOnInstance && !instance_or_template.IsEmpty()) {

instance_or_template->SetAccessorProperty(

name, getter, setter,

static_cast<v8::PropertyAttribute>(prop.attribute));

}

if (location & kOnPrototype && !instance_or_template.IsEmpty()) {

prototype_or_template->SetAccessorProperty(

name, getter, setter,

static_cast<v8::PropertyAttribute>(prop.attribute));

}

}

if (location & kOnInterface) {

interface_or_template->SetAccessorProperty(

name, getter, setter,

static_cast<v8::PropertyAttribute>(prop.attribute));

}

Isolate *isolate,

v8::Local<v8::ObjectTemplate> instance_or_template,

v8::Local<v8::ObjectTemplate> prototype_or_template,

v8::Local<v8::FunctionTemplate> interface_or_template,

v8::Local<v8::Signature> signature,

const MethodConfiguration *methods,

size_t length) {

for (int i = 0; i < length; i++) {

InstallMethod(isolate, instance_or_template, prototype_or_template, interface_or_template, signature, methods[i]);

}

Isolate* isolate,

v8::Local<v8::ObjectTemplate> instance_or_template,

v8::Local<v8::ObjectTemplate> prototype_or_template,

v8::Local<v8::FunctionTemplate> interface_or_template,

v8::Local<v8::Signature> signature,

const MethodConfiguration& method ) {

v8::FunctionCallback callback = method.callback;

if (method.property_location_configuration & (kOnInstance | kOnPrototype)) {

v8::Local<v8::FunctionTemplate> function_template =

v8::FunctionTemplate::New(isolate, callback, v8::Local<v8::Value>(),

signature, method.length);

function_template->RemovePrototype();

if (method.property_location_configuration & kOnInstance) {

instance_or_template->Set(method.MethodName(isolate), function_template,

static_cast<v8::PropertyAttribute>(method.attribute));

}

if (method.property_location_configuration & kOnPrototype) {

prototype_or_template->Set(method.MethodName(isolate), function_template,

static_cast<v8::PropertyAttribute>(method.attribute));

}

}

if (method.property_location_configuration & kOnInterface) {

v8::Local<v8::FunctionTemplate> function_template =

v8::FunctionTemplate::New(isolate, callback, v8::Local<v8::Value>(),

v8::Local<v8::Signature>(), method.length);

function_template->RemovePrototype();

interface_or_template->Set(method.MethodName(isolate), function_template,

static_cast<v8::PropertyAttribute>(method.attribute));

}

const WrapperTypeInfo& typeInfo,

Config::InstallTemplateFunction itf) {

std::string name = typeInfo.interface_name;

auto iter= iterfaceTemplates_.find(name);

if ( iter != iterfaceTemplates_.end() ) {

return (*iter).second.Get(isolate);

}

auto ft = v8::FunctionTemplate::New( isolate );

itf(isolate, ft );

iterfaceTemplates_.insert(

std::pair<std::string, v8::Eternal<v8::FunctionTemplate>>(

name,

v8::Eternal<v8::FunctionTemplate>(isolate, ft)));

return ft;

v8::Isolate* isolate,

v8::Local<v8::ObjectTemplate> object_template,

const char* class_string) {

object_template->Set(

v8::Symbol::GetToStringTag(isolate),

v8::String::NewFromOneByte(isolate, (const uint8_t *)class_string),

static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));

v8::Local<v8::FunctionTemplate> interface_template,

const WrapperTypeInfo& typeInfo) {

interface_template->SetClassName(v8::String::NewFromOneByte(isolate, (const uint8_t *)typeInfo.interface_name));

interface_template->ReadOnlyPrototype();

v8::Local<v8::ObjectTemplate> instance_template = interface_template->InstanceTemplate();

v8::Local<v8::ObjectTemplate> prototype_template = interface_template->PrototypeTemplate();

instance_template->SetInternalFieldCount(typeInfo.internal_field_count);

SetClassString(isolate, prototype_template, typeInfo.interface_name);

if ( typeInfo.parent_class!=nullptr ) {

Local<FunctionTemplate> parent_interface_template = typeInfo.parent_class(isolate);

if (!parent_interface_template.IsEmpty()) {

interface_template->Inherit(parent_interface_template);

prototype_template->SetInternalFieldCount(1);

}

}

if (!isolate_->IsExecutionTerminating()) {

isolate_->ThrowException(

v8::Exception::Error(

v8::String::NewFromUtf8(

isolate_,

message)));

}

}