#include <v8.h>
構成 | |
| class | Data |
Public メソッド | |
| HandleScope () | |
| ~HandleScope () | |
| template<class T > | |
| Local< T > | Close (Handle< T > value) |
Static Public メソッド | |
| static int | NumberOfHandles () |
| static void ** | CreateHandle (void *value) |
Private メソッド | |
| HandleScope (const HandleScope &) | |
| void | operator= (const HandleScope &) |
| void * | operator new (size_t size) |
| void | operator delete (void *, size_t) |
| void | RestorePreviousState () |
| void ** | RawClose (void **value) |
Static Private メソッド | |
| static void | DeleteExtensions () |
| static void | ZapRange (void **start, void **end) |
Private 変数 | |
| const Data | previous_ |
| bool | is_closed_ |
Static Private 変数 | |
| static Data | current_ = { -1, NULL, NULL } |
フレンド | |
| class | ImplementationUtilities |
A stack-allocated class that governs a number of local handles. After a handle scope has been created, all local handles will be allocated within that handle scope until either the handle scope is deleted or another handle scope is created. If there is already a handle scope and a new one is created, all allocations will take place in the new handle scope until it is deleted. After that, new handles will again be allocated in the original handle scope.
After the handle scope of a local handle has been deleted the garbage collector will no longer track the object stored in the handle and may deallocate it. The behavior of accessing a handle for which the handle scope has been deleted is undefined.
| v8::HandleScope::HandleScope | ( | const HandleScope & | ) | [private] |
TODO(1245391): Consider introducing a subclass for this. Closes the handle scope and returns the value as a handle in the previous scope, which is the new current scope after the call.
参照先 RawClose(), と T.
参照元 v8::internal::Handle< T >::EscapeFrom(), v8::Message::Get(), v8::Shell::GetCompletions(), v8::Object::GetPropertyNames(), v8::Message::GetScriptResourceName(), v8::Message::GetSourceLine(), と v8::Function::NewInstance().
| void ** v8::HandleScope::CreateHandle | ( | void * | value | ) | [static] |
Creates a new handle with the given value.
参照先 v8::ApiCheck(), ASSERT, v8::internal::HandleScopeImplementer::Blocks(), current_, v8::HandleScope::Data::extensions, v8::internal::HandleScopeImplementer::GetSpareOrNewBlock(), v8::internal::kHandleBlockSize, v8::HandleScope::Data::limit, v8::HandleScope::Data::next, NULL, と v8::thread_local.
参照元 v8::internal::Handle< T >::Handle(), と v8::Local< T >::New().
| void v8::HandleScope::DeleteExtensions | ( | ) | [static, private] |
Deallocates any extensions used by the current scope.
参照先 ASSERT, current_, v8::internal::HandleScopeImplementer::DeleteExtensions(), v8::HandleScope::Data::extensions, と v8::thread_local.
| int v8::HandleScope::NumberOfHandles | ( | ) | [static] |
Counts the number of allocated handles.
参照先 v8::internal::HandleScopeImplementer::Blocks(), current_, v8::internal::kHandleBlockSize, v8::HandleScope::Data::next, と v8::thread_local.
| void v8::HandleScope::operator delete | ( | void * | , | |
| size_t | ||||
| ) | [private] |
| void* v8::HandleScope::operator new | ( | size_t | size | ) | [private] |
| void v8::HandleScope::operator= | ( | const HandleScope & | ) | [private] |
| void ** v8::HandleScope::RawClose | ( | void ** | value | ) | [private] |
| void v8::HandleScope::RestorePreviousState | ( | ) | [inline, private] |
Re-establishes the previous scope state. Should be called only once, and only for the current scope.
参照元 RawClose().
| void v8::HandleScope::ZapRange | ( | void ** | start, | |
| void ** | end | |||
| ) | [static, private] |
参照先 v8::internal::kHandleZapValue, と NULL.
friend class ImplementationUtilities [friend] |
HandleScope::Data v8::HandleScope::current_ = { -1, NULL, NULL } [static, private] |
bool v8::HandleScope::is_closed_ [private] |
参照元 RawClose().
const Data v8::HandleScope::previous_ [private] |
1.7.1
