C++ Persistent::NewInstance方法代码示例

static Handle<Value> Nil(const Arguments& args)
{
    HandleScope handle_scope;

    if (object_template_.IsEmpty()) {
        Handle<ObjectTemplate> raw_template = PrepareTemplate();
        object_template_ = Persistent<ObjectTemplate>::New(raw_template);
    }

    if (nil_instance_.IsEmpty()) {
        nil_instance_ = Persistent<Value>::New(object_template_->NewInstance());
    }
    
    return handle_scope.Close(nil_instance_);
}

    static Handle<Value> WrapResults(cached_object cache)
    {
        HandleScope handle_scope;


        if (object_template_.IsEmpty()) {
            Handle<ObjectTemplate> raw_template = PrepareTemplate();
            object_template_ = Persistent<ObjectTemplate>::New(raw_template);
        }

        Handle<Object> new_object = object_template_->NewInstance();
        //new_object->SetInternalField(1, External::New(results));

        //printf("Here: %x\n", buffer);

        object* obj = new object(cache);
        obj->Wrap(new_object);
        // TODO: Lookup the args id and wrap it

        //printf("Wrapped and returning\n");

        return handle_scope.Close(new_object);
    }

    static Handle<Value> ObjectGet(Local<String> name, const AccessorInfo& info)
    {
        object* obj = ObjectWrap::Unwrap<object>(info.Holder());

        // Fetch the map wrapped by this object.
        /*
        Handle<External> field = Handle<External>::Cast(info.Holder()->GetInternalField(1));
        void* ptr = field->Value();
        js0n::result_vector* members = reinterpret_cast<js0n::result_vector*>(ptr);
        */
        //printf("Going to call find_key\n");
        js0n::js_value* value = js0n::find_key(*(String::Utf8Value(name)), &obj->cache_);
        //printf("Found type(%u) length(%u) start(%u) depth(%u)\n", value->type, value->length, value->start, value->depth);

        switch (value->type) {
        case JST_string:
            return String::New(obj->cache_.buffer + value->start, value->length);
        case JST_number:
            char tmpBuf[value->length];
            strncpy(tmpBuf, obj->cache_.buffer + value->start, value->length);
            // TODO: determine the if this is a float or an integer and return correctly
            return Integer::New(atoi(tmpBuf));
        case JST_null:
            return Null();
        case JST_boolean:
            // This was validated by the parser already so just check the first letter
            return Boolean::New((obj->cache_.buffer[value->start] == 't') ? true : false);
        case JST_array:
            // TODO: make it return a warpped array
            return Undefined();
        case JST_object:
            {
                // TODO: return a new wrapped object
                Local<Object> new_object = object_template_->NewInstance();
                //new_object->SetInternalField(1, External::New(results));

                //printf("Here: %x\n", buffer);
                cached_object subCache;
                // -1 +sizeof(js_value) to shift into the object actually
                subCache.count = obj->cache_.count - ((value - obj->cache_.values) / sizeof(js_value)) - 1;
                subCache.values = &value[1];
                subCache.buffer_length = obj->cache_.buffer_length;
                subCache.buffer = obj->cache_.buffer;

                object* obj = new object(subCache);
                obj->Wrap(new_object);
                return new_object;
            }
        default:
            return Undefined();
        }
        //js0n::js_value member = js0n::find_key(*members, *String::Utf8Value(name)); 
        //printf("Out of find_key\n");
        //printf("member type(%u) length(%u) start(%u) depth(%u)\n", member.type, member.length, member.start, member.depth);

      /* // Convert the JavaScript string to a std::string. */
      /* string key = ObjectToString(name); */

      /* // Look up the value if it exists using the standard STL ideom. */
      /* map<string, string>::iterator iter = obj->find(key); */

      /* // If the key is not present return an empty handle as signal */
      /* if (iter == obj->end()) return Handle<Value>(); */

      /* // Otherwise fetch the value and wrap it in a JavaScript string */
      /* const string& value = (*iter).second; */
    }

// Creates and launches a new isolate in a new background thread.
//创建并启动一个新的 isolate v8 运行时
static Handle<Value> Create (const Arguments &args) {
    HandleScope scope;
    
    typeThread* thread; 
    typeQueueItem* qitem= NULL;


    qitem= queue_pull(freeThreadsQueue); //从闲置队列中获取一个item
    if (qitem) {//如果获取到了这个item，则把这个item指向的线程赋值给thread指针
      thread= (typeThread*) qitem->asPtr;
      destroyItem(qitem); //摧毁这个item
    }
    else { //如果没有找到
      thread= (typeThread*) calloc(1, sizeof(typeThread)); //则创建一个空的 thread 指针指向 typeThread
      thread->threadMagicCookie= kThreadMagicCookie; //设置这个 thread 的标示
    }
    
    static long int threadsCtr= 0; //静态变量 threadsCtr ，用来做线程id的标示，每次创建都 +1
    thread->id= threadsCtr++;
    
    //为thread的jsobject实例设置属性，返回一个 threadTemplate 的实例 Local< Object >
    //然后调用  
    //Persistent<T> v8::Persistent<T>::New(Handle<T> that)   [inline, static]
    //将Handle<T> 改变为 Persistent<Object>
    thread->JSObject= Persistent<Object>::New(threadTemplate->NewInstance());
    //设置一个属性id在js对象中，让js对象可以访问
    //id_symbol 为 Persistent<String>::New(String::NewSymbol("id"));
    thread->JSObject->Set(id_symbol, Integer::New(thread->id));
    //SetPointerInInternalField (int index, void *value)
    //设置一个内部c++指针在js的对象中
    thread->JSObject->SetPointerInInternalField(0, thread);

/*
    这里比较复杂，需要一点点分析了
    1.static Local<Script> v8::Script::Compile  ( Handle< String >  source,
    ScriptOrigin *  origin = NULL,
    ScriptData *  pre_data = NULL,
    Handle< String >  script_data = Handle< String >()   
    )
    第一步compile将返回 Local<Script> 
    第二步run()将返回 kEvents_js 返回的内容，
    第三步将返回的内容，转为ToObject(), Local< Object >
    第四部调用CallAsFunction，环境对象使用 threadTemplate 实例，这样就继承了 events 对象
*/
    Local<Value> dispatchEvents= Script::Compile(String::New(kEvents_js))->Run()->ToObject()->CallAsFunction(thread->JSObject, 0, NULL);

    //将thread的 dispatchEvents 指针指向   Persistent<Object> 类型的 dispatchEvents
    thread->dispatchEvents= Persistent<Object>::New(dispatchEvents->ToObject());
    



    //注册libuv和callback
    //当执行 uv_async_send 时，就会调用注册进入的callback

    uv_async_init(uv_default_loop(), &thread->async_watcher, Callback);

    
    pthread_cond_init(&thread->IDLE_cv, NULL);
    pthread_mutex_init(&thread->IDLE_mutex, NULL);
    pthread_mutex_init(&thread->inQueue.queueLock, NULL);
    pthread_mutex_init(&thread->outQueue.queueLock, NULL);


    if (pthread_create(&thread->thread, NULL, aThread, thread)) { //如果创建线程不成功
      //Ha habido un error no se ha arrancado este hilo
      destroyaThread(thread);
      return ThrowException(Exception::TypeError(String::New("create(): error in pthread_create()")));
    }
    
    /*
    V8::AdjustAmountOfExternalAllocatedMemory(sizeof(typeThread));  //OJO V8 con V mayúscula.
    */
    
    return scope.Close(thread->JSObject);
}