C++ Isolate::NewString方法代码示例

result_t CustomExtLoader::compile(SandBox::Context* ctx, Buffer_base* src, exlib::string name,
    exlib::string arg_names, v8::Local<v8::Script>& script)
{
    Isolate* isolate = ctx->m_sb->holder();
    v8::Local<v8::Value> require_fn = ctx->m_sb->GetPrivate(SandBox::_get_extloader_pname(m_ext));

    exlib::string strScript;
    // read filecontent and compile to strScript :start
    v8::Local<v8::Value> transpileArgs[2];

    src->valueOf(transpileArgs[0]);
    v8::Local<v8::Object> requireInfo = v8::Object::New(isolate->m_isolate);
    transpileArgs[1] = requireInfo;

    requireInfo->Set(isolate->NewString("filename"), isolate->NewString(name));

    v8::Local<v8::Value> fileContent = v8::Local<v8::Function>::Cast(require_fn)->Call(v8::Undefined(isolate->m_isolate), 2, transpileArgs);
    if (fileContent.IsEmpty())
        return CALL_E_JAVASCRIPT;

    result_t hr = GetArgumentValue(fileContent, strScript, true);
    if (hr < 0)
        return CHECK_ERROR(hr);
    // read filecontent and compile to strScript :end

    obj_ptr<Buffer_base> buf = new Buffer(strScript);

    return JsLoader::compile(ctx, buf, name, arg_names, script);
}

result_t MongoCollection::update(v8::Local<v8::Object> query,
    v8::Local<v8::Object> document, v8::Local<v8::Object> options)
{
    Isolate* isolate = holder();
    return update(query, document,
        options->Get(isolate->NewString("upsert", 6))->BooleanValue(),
        options->Get(isolate->NewString("multi", 5))->BooleanValue());
}

result_t fs_base::get_constants(v8::Local<v8::Object>& retVal)
{
    Isolate* isolate = Isolate::current();
    retVal = v8::Object::New(isolate->m_isolate);

    retVal->Set(isolate->NewString("F_OK"), v8::Integer::New(isolate->m_isolate, F_OK));
    retVal->Set(isolate->NewString("R_OK"), v8::Integer::New(isolate->m_isolate, R_OK));
    retVal->Set(isolate->NewString("W_OK"), v8::Integer::New(isolate->m_isolate, W_OK));
    retVal->Set(isolate->NewString("X_OK"), v8::Integer::New(isolate->m_isolate, X_OK));

    return 0;
}

result_t MongoCollection::ensureIndex(v8::Local<v8::Object> keys,
    v8::Local<v8::Object> options)
{
    obj_ptr<MongoDB> db(m_db);
    if (!db)
        return CHECK_ERROR(CALL_E_INVALID_CALL);

    exlib::string name;

    v8::Local<v8::Array> ks = keys->GetPropertyNames();
    int32_t len = (int32_t)ks->Length();
    int32_t i;

    for (i = 0; i < len; i++) {
        v8::Local<v8::Value> k = ks->Get(i);
        v8::Local<v8::Value> v = keys->Get(k);

        if (!v->IsNumber() && !v->IsNumberObject())
            return CHECK_ERROR(CALL_E_INVALIDARG);

        v8::String::Utf8Value sk(k);
        v8::String::Utf8Value sv(v);

        if (name.length())
            name += '_';

        name.append(*sk, sk.length());
        name += '_';
        name.append(*sv, sv.length());
    }

    Isolate* isolate = holder();
    v8::Local<v8::Object> idx = v8::Object::New(isolate->m_isolate);

    idx->Set(isolate->NewString("name"), isolate->NewString(name));
    idx->Set(isolate->NewString("key"), keys);
    extend(options, idx);

    v8::Local<v8::Array> idxs = v8::Array::New(isolate->m_isolate);
    idxs->Set(0, idx);

    v8::Local<v8::Object> cmd = v8::Object::New(isolate->m_isolate);
    cmd->Set(isolate->NewString("indexes"), idxs);

    v8::Local<v8::Object> retVal;
    return runCommand("createIndexes", cmd, retVal);
}

result_t MongoCollection::getIndexes(obj_ptr<MongoCursor_base>& retVal)
{
    obj_ptr<MongoDB> db(m_db);
    if (!db)
        return CHECK_ERROR(CALL_E_INVALID_CALL);

    result_t hr;
    obj_ptr<MongoCollection_base> coll;

    hr = db->getCollection("system.indexes", coll);
    if (hr < 0)
        return hr;

    Isolate* isolate = holder();
    v8::Local<v8::Object> f = v8::Object::New(isolate->m_isolate);
    v8::Local<v8::Object> q = v8::Object::New(isolate->m_isolate);
    q->Set(isolate->NewString("ns"), isolate->NewString(m_ns));

    return coll->find(q, f, retVal);
}

result_t HttpUploadCollection::_named_enumerator(v8::Local<v8::Array>& retVal)
{
    int32_t i;
    Isolate* isolate = holder();

    retVal = v8::Array::New(isolate->m_isolate);
    for (i = 0; i < m_count; i++)
        retVal->Set(i, isolate->NewString(m_map[i].first));

    return 0;
}

result_t HttpCollection::_named_enumerator(v8::Local<v8::Array>& retVal)
{
    int32_t i, n;
    std::set<exlib::string> name_set;
    Isolate* isolate = holder();

    retVal = v8::Array::New(isolate->m_isolate);
    for (i = 0, n = 0; i < m_count; i++) {
        exlib::string& name = m_map[i].first;
        if (name_set.insert(name).second)
            retVal->Set(n++, isolate->NewString(name));
    }

    return 0;
}

result_t MongoCollection::save(v8::Local<v8::Object> document)
{
    Isolate* isolate = holder();

    v8::Local<v8::String> strId = isolate->NewString("_id", 3);
    v8::Local<v8::Value> id = document->Get(strId);

    if (IsEmpty(id))
        return insert(document);
    else {
        v8::Local<v8::Object> query = v8::Object::New(isolate->m_isolate);

        query->Set(strId, id);
        return update(query, document, true, false);
    }
}

result_t JsonLoader::run(SandBox::Context* ctx, Buffer_base* src, exlib::string name,
    exlib::string arg_names, std::vector<v8::Local<v8::Value>>& args)
{
    Isolate* isolate = ctx->m_sb->holder();
    v8::Local<v8::Function> func = isolate->NewFunction("json_loader", _json_loader, src->wrap());
    if (func.IsEmpty())
        return CHECK_ERROR(Runtime::setError("function alloc error."));

    v8::Local<v8::Object> module = v8::Local<v8::Object>::Cast(args[5]);
    module->SetPrivate(module->CreationContext(),
        v8::Private::ForApi(isolate->m_isolate, isolate->NewString("entry")),
        func);

    v8::Local<v8::Object> glob = isolate->context()->Global();
    v8::Local<v8::Value> v = func->Call(glob, (int32_t)args.size(), args.data());
    if (v.IsEmpty())
        return CALL_E_JAVASCRIPT;

    return 0;
}

result_t util_base::buildInfo(v8::Local<v8::Object>& retVal)
{
    Isolate* isolate = Isolate::current();
    retVal = v8::Object::New(isolate->m_isolate);

    retVal->Set(isolate->NewString("fibjs"), isolate->NewString(fibjs_version));

#ifdef GIT_INFO
    retVal->Set(isolate->NewString("git"), isolate->NewString(GIT_INFO));
#endif

#if defined(__clang__)
    retVal->Set(isolate->NewString("clang"),
        isolate->NewString(STR(__clang_major__) "." STR(__clang_minor__)));
#elif defined(__GNUC__)
    retVal->Set(isolate->NewString("gcc"),
        isolate->NewString(STR(__GNUC__) "." STR(__GNUC_MINOR__) "." STR(__GNUC_PATCHLEVEL__)));
#elif defined(_MSC_VER)
    retVal->Set(isolate->NewString("msvc"),
        isolate->NewString(STR(_MSC_VER)));
#endif

    retVal->Set(isolate->NewString("date"),
        isolate->NewString(__DATE__ " " __TIME__));

#ifndef NDEBUG
    retVal->Set(isolate->NewString("debug"), v8::True(isolate->m_isolate));
#endif

    {
        v8::Local<v8::Object> vender = v8::Object::New(isolate->m_isolate);
        char str[64];

        retVal->Set(isolate->NewString("vender"), vender);

        vender->Set(isolate->NewString("ev"),
            isolate->NewString(STR(EV_VERSION_MAJOR) "." STR(EV_VERSION_MINOR)));

        vender->Set(isolate->NewString("expat"),
            isolate->NewString(STR(XML_MAJOR_VERSION) "." STR(XML_MINOR_VERSION) "." STR(XML_MICRO_VERSION)));

        vender->Set(isolate->NewString("gd"), isolate->NewString(GD_VERSION_STRING));
        vender->Set(isolate->NewString("jpeg"), isolate->NewString(STR(JPEG_LIB_VERSION_MAJOR) "." STR(JPEG_LIB_VERSION_MINOR)));
        sprintf(str, "%d.%d", leveldb::kMajorVersion, leveldb::kMinorVersion);
        vender->Set(isolate->NewString("leveldb"), isolate->NewString(str));
        vender->Set(isolate->NewString("mongo"), isolate->NewString(STR(MONGO_MAJOR) "." STR(MONGO_MINOR)));
        vender->Set(isolate->NewString("pcre"), isolate->NewString(STR(PCRE_MAJOR) "." STR(PCRE_MINOR)));
        vender->Set(isolate->NewString("png"), isolate->NewString(PNG_LIBPNG_VER_STRING));
        vender->Set(isolate->NewString("mbedtls"), isolate->NewString(MBEDTLS_VERSION_STRING));
        vender->Set(isolate->NewString("snappy"),
            isolate->NewString(STR(SNAPPY_MAJOR) "." STR(SNAPPY_MINOR) "." STR(SNAPPY_PATCHLEVEL)));
        vender->Set(isolate->NewString("sqlite"), isolate->NewString(SQLITE_VERSION));
        vender->Set(isolate->NewString("tiff"), isolate->NewString(TIFFLIB_VERSION_STR));
        vender->Set(isolate->NewString("uuid"), isolate->NewString("1.6.2"));
        vender->Set(isolate->NewString("v8"), isolate->NewString(v8::V8::GetVersion()));

        vender->Set(isolate->NewString("v8-snapshot"),
            v8::internal::Snapshot::DefaultSnapshotBlob() ? v8::True(isolate->m_isolate) : v8::False(isolate->m_isolate));

        vender->Set(isolate->NewString("zlib"), isolate->NewString(ZLIB_VERSION));
        vender->Set(isolate->NewString("zmq"), isolate->NewString(STR(ZMQ_VERSION_MAJOR) "." STR(ZMQ_VERSION_MINOR)));
    }

    {
        v8::Local<v8::Array> modules = v8::Array::New(isolate->m_isolate);
        retVal->Set(isolate->NewString("modules"), modules);

        RootModule* pModule = RootModule::g_root;
        intptr_t icnt = 0;

        while (pModule) {
            modules->Set((int32_t)(icnt++), isolate->NewString(pModule->name()));
            pModule = pModule->m_next;
        }
    }

    return 0;
}