v8::FunctionTemplate Class Reference

A FunctionTemplate is used to create functions at runtime. More...

#include <v8.h>

Inheritance diagram for v8::FunctionTemplate:

Collaboration diagram for v8::FunctionTemplate:

Public Member Functions
Local< Function >	GetFunction ()
	Returns the unique function instance in the current execution context. More...
void	SetCallHandler (FunctionCallback callback, Handle< Value > data=Handle< Value >())
	Set the call-handler callback for a FunctionTemplate. More...
void	SetLength (int length)
	Set the predefined length property for the FunctionTemplate. More...
Local< ObjectTemplate >	InstanceTemplate ()
	Get the InstanceTemplate. More...
void	Inherit (Handle< FunctionTemplate > parent)
	Causes the function template to inherit from a parent function template. More...
Local< ObjectTemplate >	PrototypeTemplate ()
	A PrototypeTemplate is the template used to create the prototype object of the function created by this template. More...
void	SetClassName (Handle< String > name)
	Set the class name of the FunctionTemplate. More...
void	SetHiddenPrototype (bool value)
	Determines whether the proto accessor ignores instances of the function template. More...
void	ReadOnlyPrototype ()
	Sets the ReadOnly flag in the attributes of the 'prototype' property of functions created from this FunctionTemplate to true. More...
void	RemovePrototype ()
	Removes the prototype property from functions created from this FunctionTemplate. More...
bool	HasInstance (Handle< Value > object)
	Returns true if the given object is an instance of this function template. More...
Public Member Functions inherited from v8::Template
void	Set (Handle< Name > name, Handle< Data > value, PropertyAttribute attributes=None)
	Adds a property to each instance created by this template. More...
void	Set (Isolate *isolate, const char *name, Handle< Data > value)
void	SetAccessorProperty (Local< Name > name, Local< FunctionTemplate > getter=Local< FunctionTemplate >(), Local< FunctionTemplate > setter=Local< FunctionTemplate >(), PropertyAttribute attribute=None, AccessControl settings=DEFAULT)
void	SetNativeDataProperty (Local< String > name, AccessorGetterCallback getter, AccessorSetterCallback setter=0, Handle< Value > data=Handle< Value >(), PropertyAttribute attribute=None, Local< AccessorSignature > signature=Local< AccessorSignature >(), AccessControl settings=DEFAULT)
	Whenever the property with the given name is accessed on objects created from this Template the getter and setter callbacks are called instead of getting and setting the property directly on the JavaScript object. More...
void	SetNativeDataProperty (Local< Name > name, AccessorNameGetterCallback getter, AccessorNameSetterCallback setter=0, Handle< Value > data=Handle< Value >(), PropertyAttribute attribute=None, Local< AccessorSignature > signature=Local< AccessorSignature >(), AccessControl settings=DEFAULT)
bool	SetDeclaredAccessor (Local< Name > name, Local< DeclaredAccessorDescriptor > descriptor, PropertyAttribute attribute=None, Local< AccessorSignature > signature=Local< AccessorSignature >(), AccessControl settings=DEFAULT)

Static Public Member Functions
static Local< FunctionTemplate >	New (Isolate *isolate, FunctionCallback callback=0, Handle< Value > data=Handle< Value >(), Handle< Signature > signature=Handle< Signature >(), int length=0)
	Creates a function template. More...

Private Member Functions
	FunctionTemplate ()

Friends
class	Context
class	ObjectTemplate

Detailed 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.

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();
t->Set("func_property", v8::Number::New(1));
 
v8::Local<v8::Template> proto_t = t->PrototypeTemplate();
proto_t->Set("proto_method", v8::FunctionTemplate::New(InvokeCallback));
proto_t->Set("proto_const", v8::Number::New(2));
 
v8::Local<v8::ObjectTemplate> instance_t = t->InstanceTemplate();
instance_t->SetAccessor("instance_accessor", InstanceAccessorCallback);
instance_t->SetNamedPropertyHandler(PropertyHandlerCallback, ...);
instance_t->Set("instance_property", Number::New(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;

Definition at line 3640 of file v8.h.

Constructor & Destructor Documentation

FunctionTemplate()

v8::FunctionTemplate::FunctionTemplate ( )

private

Member Function Documentation

GetFunction()

Local< v8::Function > v8::FunctionTemplate::GetFunction

(

)

Returns the unique function instance in the current execution context.

Definition at line 5327 of file api.cc.

                                                {
  i::Isolate* isolate = i::Isolate::Current();
  ON_BAILOUT(isolate, "v8::FunctionTemplate::GetFunction()",
             return Local<v8::Function>());
  LOG_API(isolate, "FunctionTemplate::GetFunction");
  ENTER_V8(isolate);
  EXCEPTION_PREAMBLE(isolate);
  i::Handle<i::Object> obj;
  has_pending_exception = !i::Execution::InstantiateFunction(
      Utils::OpenHandle(this)).ToHandle(&obj);
  EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::Function>());
  return Utils::ToLocal(i::Handle<i::JSFunction>::cast(obj));
}

References ENTER_V8, EXCEPTION_BAILOUT_CHECK, EXCEPTION_PREAMBLE, LOG_API, ON_BAILOUT, v8::Utils::OpenHandle(), and v8::Utils::ToLocal().

Here is the call graph for this function:

HasInstance()

bool v8::FunctionTemplate::HasInstance

(

Handle< Value >

object

)

Returns true if the given object is an instance of this function template.

Definition at line 5342 of file api.cc.

                                                          {
  ON_BAILOUT(i::Isolate::Current(), "v8::FunctionTemplate::HasInstanceOf()",
             return false);
  i::Object* obj = *Utils::OpenHandle(*value);
  return Utils::OpenHandle(this)->IsTemplateFor(obj);
}

References ON_BAILOUT, and v8::Utils::OpenHandle().

Here is the call graph for this function:

Inherit()

void v8::FunctionTemplate::Inherit

(

v8::Handle< FunctionTemplate >

value

)

Causes the function template to inherit from a parent function template.

Definition at line 864 of file api.cc.

                                                               {
  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
  ENTER_V8(isolate);
  Utils::OpenHandle(this)->set_parent_template(*Utils::OpenHandle(*value));
}

References ENTER_V8, and v8::Utils::OpenHandle().

Here is the call graph for this function:

InstanceTemplate()

Local< ObjectTemplate > v8::FunctionTemplate::InstanceTemplate

(

)

Get the InstanceTemplate.

Definition at line 1181 of file api.cc.

                                                         {
  i::Handle<i::FunctionTemplateInfo> handle = Utils::OpenHandle(this, true);
  if (!Utils::ApiCheck(!handle.is_null(),
                       "v8::FunctionTemplate::InstanceTemplate()",
                       "Reading from empty handle")) {
    return Local<ObjectTemplate>();
  }
  i::Isolate* isolate = handle->GetIsolate();
  ENTER_V8(isolate);
  if (handle->instance_template()->IsUndefined()) {
    Local<ObjectTemplate> templ =
        ObjectTemplate::New(isolate, ToApiHandle<FunctionTemplate>(handle));
    handle->set_instance_template(*Utils::OpenHandle(*templ));
  }
  i::Handle<i::ObjectTemplateInfo> result(
      i::ObjectTemplateInfo::cast(handle->instance_template()));
  return Utils::ToLocal(result);
}

References v8::Utils::ApiCheck(), ENTER_V8, v8::internal::handle(), v8::ObjectTemplate::New(), v8::Utils::OpenHandle(), and v8::Utils::ToLocal().

Here is the call graph for this function:

New()

Local< FunctionTemplate > v8::FunctionTemplate::New ( Isolate *  isolate, FunctionCallback  callback = 0, v8::Handle< Value >  data = Handle<Value>(), v8::Handle< Signature >  signature = Handle<Signature>(), int  length = 0  )

static

Creates a function template.

Definition at line 904 of file api.cc.

                {
  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
  LOG_API(i_isolate, "FunctionTemplate::New");
  ENTER_V8(i_isolate);
  return FunctionTemplateNew(
      i_isolate, callback, data, signature, length, false);
}

References ENTER_V8, v8::FunctionTemplateNew(), and LOG_API.

Referenced by v8::Shell::AddOSMethods(), v8::Shell::CreateGlobalTemplate(), v8::EnsureConstructor(), v8::internal::ExternalizeStringExtension::GetNativeFunctionTemplate(), v8::internal::FreeBufferExtension::GetNativeFunctionTemplate(), v8::internal::GCExtension::GetNativeFunctionTemplate(), v8::internal::StatisticsExtension::GetNativeFunctionTemplate(), and v8::internal::TriggerFailureExtension::GetNativeFunctionTemplate().

Here is the call graph for this function:

Here is the caller graph for this function:

PrototypeTemplate()

Local< ObjectTemplate > v8::FunctionTemplate::PrototypeTemplate

(

)

A PrototypeTemplate is the template used to create the prototype object of the function created by this template.

Definition at line 850 of file api.cc.

                                                          {
  i::Isolate* i_isolate = Utils::OpenHandle(this)->GetIsolate();
  ENTER_V8(i_isolate);
  i::Handle<i::Object> result(Utils::OpenHandle(this)->prototype_template(),
                              i_isolate);
  if (result->IsUndefined()) {
    v8::Isolate* isolate = reinterpret_cast<v8::Isolate*>(i_isolate);
    result = Utils::OpenHandle(*ObjectTemplate::New(isolate));
    Utils::OpenHandle(this)->set_prototype_template(*result);
  }
  return ToApiHandle<ObjectTemplate>(result);
}

References ENTER_V8, v8::ObjectTemplate::New(), v8::Utils::OpenHandle(), and v8::internal::prototype_template.

Here is the call graph for this function:

ReadOnlyPrototype()

void v8::FunctionTemplate::ReadOnlyPrototype

(

)

Sets the ReadOnly flag in the attributes of the 'prototype' property of functions created from this FunctionTemplate to true.

Definition at line 1222 of file api.cc.

                                         {
  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
  ENTER_V8(isolate);
  Utils::OpenHandle(this)->set_read_only_prototype(true);
}

References ENTER_V8, and v8::Utils::OpenHandle().

Here is the call graph for this function:

RemovePrototype()

void v8::FunctionTemplate::RemovePrototype

(

)

Removes the prototype property from functions created from this FunctionTemplate.

Definition at line 1229 of file api.cc.

                                       {
  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
  ENTER_V8(isolate);
  Utils::OpenHandle(this)->set_remove_prototype(true);
}

References ENTER_V8, and v8::Utils::OpenHandle().

Here is the call graph for this function:

SetCallHandler()

void v8::FunctionTemplate::SetCallHandler	(	FunctionCallback	callback,
		v8::Handle< Value >	data = Handle<Value>()
	)

Set the call-handler callback for a FunctionTemplate.

This callback is called whenever the function created from this FunctionTemplate is called.

Definition at line 1107 of file api.cc.

                                                            {
  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
  ENTER_V8(isolate);
  i::HandleScope scope(isolate);
  i::Handle<i::Struct> struct_obj =
      isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE);
  i::Handle<i::CallHandlerInfo> obj =
      i::Handle<i::CallHandlerInfo>::cast(struct_obj);
  SET_FIELD_WRAPPED(obj, set_callback, callback);
  if (data.IsEmpty()) {
    data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
  }
  obj->set_data(*Utils::OpenHandle(*data));
  Utils::OpenHandle(this)->set_call_code(*obj);
}

References v8::internal::CALL_HANDLER_INFO_TYPE, v8::internal::Handle< T >::cast(), ENTER_V8, v8::internal::Isolate::factory(), v8::Handle< T >::IsEmpty(), v8::Utils::OpenHandle(), SET_FIELD_WRAPPED, and v8::Undefined().

Here is the call graph for this function:

SetClassName()

void v8::FunctionTemplate::SetClassName

(

Handle< String >

name

)

Set the class name of the FunctionTemplate.

This is used for printing objects created with the function created from the FunctionTemplate as its constructor.

Definition at line 1208 of file api.cc.

                                                       {
  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
  ENTER_V8(isolate);
  Utils::OpenHandle(this)->set_class_name(*Utils::OpenHandle(*name));
}

References ENTER_V8, name, and v8::Utils::OpenHandle().

Here is the call graph for this function:

SetHiddenPrototype()

void v8::FunctionTemplate::SetHiddenPrototype

(

bool

value

)

Determines whether the proto accessor ignores instances of the function template.

If instances of the function template are ignored, proto skips all instances and instead returns the next object in the prototype chain.

Call with a value of true to make the proto accessor ignore instances of the function template. Call with a value of false to make the proto accessor not ignore instances of the function template. By default, instances of a function template are not ignored.

Definition at line 1215 of file api.cc.

                                                    {
  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
  ENTER_V8(isolate);
  Utils::OpenHandle(this)->set_hidden_prototype(value);
}

References ENTER_V8, and v8::Utils::OpenHandle().

Here is the call graph for this function:

SetLength()

void v8::FunctionTemplate::SetLength

(

int

length

)

Set the predefined length property for the FunctionTemplate.

Definition at line 1201 of file api.cc.

                                           {
  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
  ENTER_V8(isolate);
  Utils::OpenHandle(this)->set_length(length);
}

References ENTER_V8, and v8::Utils::OpenHandle().

Here is the call graph for this function:

Friends And Related Function Documentation

Context

friend class Context

friend

Definition at line 3717 of file v8.h.

ObjectTemplate

friend class ObjectTemplate

friend

Definition at line 3718 of file v8.h.

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/include/v8.h
• /mnt/V8SourceCode/src/api.cc