Struct rusty_v8::FunctionTemplate [−][src]
#[repr(C)]pub struct FunctionTemplate(_);Expand description
A FunctionTemplate is used to create functions at runtime. There can only be one function created from a FunctionTemplate in a context. The lifetime of the created function is equal to the lifetime of the context. So in case the embedder needs to create temporary functions that can be collected using Scripts is preferred.
Any modification of a FunctionTemplate after first instantiation will trigger a crash.
A FunctionTemplate can have properties, these properties are added to the function object when it is created.
A FunctionTemplate has a corresponding instance template which is used to create object instances when the function is used as a constructor. Properties added to the instance template are added to each object instance.
A FunctionTemplate can have a prototype template. The prototype template is used to create the prototype object of the function.
The following example shows how to use a FunctionTemplate:
v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate);
t->Set(isolate, "func_property", v8::Number::New(isolate, 1));
v8::Local<v8::Template> proto_t = t->PrototypeTemplate();
proto_t->Set(isolate,
"proto_method",
v8::FunctionTemplate::New(isolate, InvokeCallback));
proto_t->Set(isolate, "proto_const", v8::Number::New(isolate, 2));
v8::Local<v8::ObjectTemplate> instance_t = t->InstanceTemplate();
instance_t->SetAccessor(
String::NewFromUtf8Literal(isolate, "instance_accessor"),
InstanceAccessorCallback);
instance_t->SetHandler(
NamedPropertyHandlerConfiguration(PropertyHandlerCallback));
instance_t->Set(String::NewFromUtf8Literal(isolate, "instance_property"),
Number::New(isolate, 3));
v8::Local<v8::Function> function = t->GetFunction();
v8::Local<v8::Object> instance = function->NewInstance();Let’s use “function” as the JS variable name of the function object and “instance” for the instance object created above. The function and the instance will have the following properties:
func_property in function == true;
function.func_property == 1;
function.prototype.proto_method() invokes 'InvokeCallback'
function.prototype.proto_const == 2;
instance instanceof function == true;
instance.instance_accessor calls 'InstanceAccessorCallback'
instance.instance_property == 3;A FunctionTemplate can inherit from another one by calling the FunctionTemplate::Inherit method. The following graph illustrates the semantics of inheritance:
FunctionTemplate Parent -> Parent() . prototype -> { }
^ ^
| Inherit(Parent) | .__proto__
| |
FunctionTemplate Child -> Child() . prototype -> { }A FunctionTemplate ‘Child’ inherits from ‘Parent’, the prototype object of the Child() function has proto pointing to the Parent() function’s prototype object. An instance of the Child function has all properties on Parent’s instance templates.
Let Parent be the FunctionTemplate initialized in the previous section and create a Child FunctionTemplate by:
Local<FunctionTemplate> parent = t;
Local<FunctionTemplate> child = FunctionTemplate::New();
child->Inherit(parent);
Local<Function> child_function = child->GetFunction();
Local<Object> child_instance = child_function->NewInstance();The Child function and Child instance will have the following properties:
child_func.prototype.__proto__ == function.prototype;
child_instance.instance_accessor calls 'InstanceAccessorCallback'
child_instance.instance_property == 3;The additional ‘c_function’ parameter refers to a fast API call, which must not trigger GC or JavaScript execution, or call into V8 in other ways. For more information how to define them, see include/v8-fast-api-calls.h. Please note that this feature is still experimental.
Implementations
Create a FunctionBuilder to configure a FunctionTemplate.
This is the same as FunctionBuilder::
pub fn new<'s>(
scope: &mut HandleScope<'s, ()>,
callback: impl MapFnTo<FunctionCallback>
) -> Local<'s, FunctionTemplate>
pub fn new<'s>(
scope: &mut HandleScope<'s, ()>,
callback: impl MapFnTo<FunctionCallback>
) -> Local<'s, FunctionTemplate>
Creates a function template.
Returns the unique function instance in the current execution context.
Set the class name of the FunctionTemplate. This is used for printing objects created with the function created from the FunctionTemplate as its constructor.
pub fn prototype_template<'s>(
&self,
scope: &mut HandleScope<'s, ()>
) -> Local<'s, ObjectTemplate>
pub fn prototype_template<'s>(
&self,
scope: &mut HandleScope<'s, ()>
) -> Local<'s, ObjectTemplate>
Returns the ObjectTemplate that is used by this FunctionTemplate as a PrototypeTemplate
Causes the function template to inherit from a parent function template. This means the function’s prototype.proto is set to the parent function’s prototype.
Sets the ReadOnly flag in the attributes of the ‘prototype’ property of functions created from this FunctionTemplate to true.
Removes the prototype property from functions created from this FunctionTemplate.
Methods from Deref<Target = Template>
Adds a property to each instance created by this template.
pub fn set_with_attr(
&self,
key: Local<'_, Name>,
value: Local<'_, Data>,
attr: PropertyAttribute
)
pub fn set_with_attr(
&self,
key: Local<'_, Name>,
value: Local<'_, Data>,
attr: PropertyAttribute
)
Adds a property to each instance created by this template with the specified property attributes.
Methods from Deref<Target = Data>
Returns the V8 hash value for this value. The current implementation uses a hidden property to store the identity hash on some object types.
The return value will never be 0. Also, it is not guaranteed to be unique.
Returns true if this data is a Private.
Returns true if this data is an ObjectTemplate
Returns true if this data is a FunctionTemplate.