自学教程：C++ CREATE_VECTOR1函数代码示例

bool TestExtString::test_sscanf() {  VS(f_sscanf(0, "SN/2350001", "SN/%d"), CREATE_VECTOR1(2350001));  Variant out;  VS(f_sscanf(0, "SN/2350001", "SN/%d", CREATE_VECTOR1(ref(out))), 1);  VS(out, 2350001);  return Count(true);}

bool TestExtJson::test_json_decode() {  Array arr = CREATE_MAP1("fbid", 101501853510151001LL);  VS(f_json_decode(f_json_encode(arr), true), arr);  VS(f_json_decode("{/"0/":{/"00/":0}}", true),     CREATE_MAP1("0", CREATE_MAP1("00", 0)));  VS(f_json_decode("{/"a/":1,/"b/":2.3,/"3/":/"test/"}", true),     CREATE_MAP3("a", 1, "b", 2.3, 3, "test"));  VS(f_json_decode("[/"a/",1,true,false,null]", true),     CREATE_VECTOR5("a", 1, true, false, null));  Object obj = f_json_decode("{/"a/":1,/"b/":2.3,/"3/":/"test/"}");  Object obj2(SystemLib::AllocStdClassObject());  obj2->o_set("a", 1);  obj2->o_set("b", 2.3);  obj2->o_set("3", "test");  VS(obj.toArray(), obj2.toArray());  obj = f_json_decode("[/"a/",1,true,false,null]");  VS(obj.toArray(), CREATE_VECTOR5("a", 1, true, false, null));  VS(f_json_decode("{z:1}",     true),       null);  VS(f_json_decode("{z:1}",     true, k_JSON_FB_LOOSE), CREATE_MAP1("z", 1));  VS(f_json_decode("{z:/"z/"}", true),       null);  VS(f_json_decode("{z:/"z/"}", true, k_JSON_FB_LOOSE), CREATE_MAP1("z", "z"));  VS(f_json_decode("{'x':1}",   true),       null);  VS(f_json_decode("{'x':1}",   true, k_JSON_FB_LOOSE), CREATE_MAP1("x", 1));  VS(f_json_decode("{y:1,}",    true),       null);  VS(f_json_decode("{y:1,}",    true, k_JSON_FB_LOOSE), CREATE_MAP1("y", 1));  VS(f_json_decode("{,}",       true),       null);  VS(f_json_decode("{,}",       true, k_JSON_FB_LOOSE), null);  VS(f_json_decode("[1,2,3,]",  true),       null);  VS(f_json_decode("[1,2,3,]",  true, k_JSON_FB_LOOSE), CREATE_VECTOR3(1,2,3));  VS(f_json_decode("[,]",       true),       null);  VS(f_json_decode("[,]",       true, k_JSON_FB_LOOSE), null);  VS(f_json_decode("[]",        true),       Array::Create());  VS(f_json_decode("[]",        true, k_JSON_FB_LOOSE), Array::Create());  VS(f_json_decode("{}",        true),       Array::Create());  VS(f_json_decode("{}",        true, k_JSON_FB_LOOSE), Array::Create());  VS(f_json_decode("test",      true),       null);  VS(f_json_decode("test",      true, k_JSON_FB_LOOSE), "test");  VS(f_json_decode("'test'",    true),       null);  VS(f_json_decode("'test'",    true, k_JSON_FB_LOOSE), "test");  VS(f_json_decode("/"test/"",  true),       "test");  VS(f_json_decode("/"test/"",  true, k_JSON_FB_LOOSE), "test");  VS(f_json_decode("[{/"a/":/"apple/"},{/"b/":/"banana/"}]", true),     CREATE_VECTOR2(CREATE_MAP1("a", "apple"), CREATE_MAP1("b", "banana")));  Variant a = "[{/"a/":[{/"n/":/"1st/"}]},{/"b/":[{/"n/":/"2nd/"}]}]";  VS(f_json_decode(a, true),     CREATE_VECTOR2     (CREATE_MAP1("a", CREATE_VECTOR1(CREATE_MAP1("n", "1st"))),      CREATE_MAP1("b", CREATE_VECTOR1(CREATE_MAP1("n", "2nd")))));  return Count(true);}

bool TestExtMb::test_mb_ereg_search_regs() {  String str = "Pr/xC3/x9C/xC3/x9D""fung abc p/xC3/x9C";  String reg = "//w+";  f_mb_regex_encoding("UTF-8");  f_mb_ereg_search_init(str, reg);  Variant r = f_mb_ereg_search();  r = f_mb_ereg_search_getregs(); // get first result  VS(r, CREATE_VECTOR1("Pr/xC3/x9C/xC3/x9D""fung"));  r = f_mb_ereg_search_regs();    // get next result  VS(r, CREATE_VECTOR1("abc"));  return Count(true);}

bool TestExtFb::test_fb_thrift_serialize() {  Variant ret;  VS(f_fb_thrift_unserialize(f_fb_thrift_serialize("test"), ref(ret)), "test");  VERIFY(same(ret, true));  ret = null;  VS(f_fb_thrift_unserialize(f_fb_thrift_serialize(CREATE_VECTOR1("test")),                             ref(ret)),     CREATE_VECTOR1("test"));  VERIFY(same(ret, true));  return Count(true);}

bool TestExtFb::test_fb_call_user_func_safe_return() {  {    Variant ret = f_fb_call_user_func_safe_return      (1, "TEst", "ok", CREATE_VECTOR1("param"));    VS(ret, "param");  }  {    Variant ret = f_fb_call_user_func_safe_return      (1, "NonTEst", "ok", CREATE_VECTOR1("param"));    VS(ret, "ok");  }  return Count(true);}

bool TestExtFb::test_fb_call_user_func_safe() {  {    Variant ret = f_fb_call_user_func_safe      (1, "TEst", CREATE_VECTOR1("param"));    VS(ret, CREATE_VECTOR2(true, "param"));  }  {    Variant ret = f_fb_call_user_func_safe      (1, "NonTEst", CREATE_VECTOR1("param"));    VS(ret, CREATE_VECTOR2(false, uninit_null()));  }  return Count(true);}

bool TestExtJson::test_json_encode() {  VS(f_json_encode(CREATE_MAP3("a", 1, "b", 2.3, 3, "test")),     "{/"a/":1,/"b/":2.3,/"3/":/"test/"}");  VS(f_json_encode(CREATE_VECTOR5("a", 1, true, false, uninit_null())),     "[/"a/",1,true,false,null]");  VS(f_json_encode("a/xE0"), "null");  VS(f_json_encode("a/xE0", k_JSON_FB_LOOSE), "/"a?/"");  VS(f_json_encode(CREATE_MAP2("0", "apple", "1", "banana")),     "[/"apple/",/"banana/"]");  VS(f_json_encode(CREATE_VECTOR1(CREATE_MAP1("a", "apple"))),     "[{/"a/":/"apple/"}]");  VS(f_json_encode(CREATE_VECTOR1(CREATE_MAP1("a", "apple")),                   k_JSON_PRETTY_PRINT),    "[/n    {/n        /"a/": /"apple/"/n    }/n]");  VS(f_json_encode(CREATE_VECTOR4(1, 2, 3, CREATE_VECTOR3(1, 2, 3)),                   k_JSON_PRETTY_PRINT),    "[/n"    "    1,/n"    "    2,/n"    "    3,/n"    "    [/n"    "        1,/n"    "        2,/n"    "        3/n"    "    ]/n"    "]");  Array arr = CREATE_MAP3(    "a", 1,    "b", CREATE_VECTOR2(1, 2),    "c", CREATE_MAP1("d", 42)  );  VS(f_json_encode(arr, k_JSON_PRETTY_PRINT),    "{/n"    "    /"a/": 1,/n"    "    /"b/": [/n"    "        1,/n"    "        2/n"    "    ],/n"    "    /"c/": {/n"    "        /"d/": 42/n"    "    }/n"    "}");  return Count(true);}

bool TestExtMath::test_max() {  VS(f_max(4, 2, CREATE_VECTOR4(3, 1, 6, 7)), 7);  VS(f_max(0, CREATE_VECTOR3(2, 4, 5)), 5);  VS(f_max(1, 0, CREATE_VECTOR1("hello")), 0);  VS(f_max(1, "hello", CREATE_VECTOR1(0)), "hello");  VS(f_max(1, "hello", CREATE_VECTOR1(-1)), "hello");  VS(f_max(1, CREATE_VECTOR3(2, 4, 8),           CREATE_VECTOR1(CREATE_VECTOR3(2, 5, 1))),     CREATE_VECTOR3(2, 5, 1));  VS(f_max(1, "string", CREATE_VECTOR2(CREATE_VECTOR3(2, 5, 7), 42)),     CREATE_VECTOR3(2, 5, 7));  VS(f_max(1, CREATE_MAP1(1, "1236150163")), "1236150163");  return Count(true);}

bool BaseExecutionContext::onUnhandledException(Object e) {  String err = e.toString();  if (RuntimeOption::AlwaysLogUnhandledExceptions) {    Logger::Error("HipHop Fatal error: Uncaught %s", err.data());  }  if (e.instanceof("Exception")) {    // user thrown exception    if (!m_userExceptionHandlers.empty()) {      if (!same(f_call_user_func_array                (m_userExceptionHandlers.back(),                 CREATE_VECTOR1(e)),                false)) {        return true;      }    }  } else {    ASSERT(false);  }  m_lastError = err;  if (!RuntimeOption::AlwaysLogUnhandledExceptions) {    Logger::Error("HipHop Fatal error: Uncaught %s", err.data());  }  return false;}

Variant f_check_user_func_async(CVarRef handles, int timeout /* = -1 */) {  if (handles.isArray()) {    return FiberAsyncFunc::Status(handles, timeout);  }  Array ret = FiberAsyncFunc::Status(CREATE_VECTOR1(handles), timeout);  return !ret.empty();}

bool TestExtApc::test_apc_exists() {  f_apc_store(s_ts, s_TestString);  VS(f_apc_exists(s_ts), true);  VS(f_apc_exists(s_TestString), false);  VS(f_apc_exists(CREATE_VECTOR2(s_ts, s_TestString)), CREATE_VECTOR1(s_ts));  return Count(true);}

bool ExecutionContext::obFlush() {  ASSERT(m_protectedLevel >= 0);  if ((int)m_buffers.size() > m_protectedLevel) {    list<OutputBuffer*>::const_iterator iter = m_buffers.end();    OutputBuffer *last = *(--iter);    if (iter != m_buffers.begin()) {      OutputBuffer *prev = *(--iter);      if (last->handler.isNull()) {        prev->oss << last->oss.str();      } else {        try {          string output = last->oss.str();          String sout(output.data(), output.length(), AttachLiteral);          Variant tout =            f_call_user_func_array(last->handler, CREATE_VECTOR1(sout));          sout = tout.toString();          prev->oss << string(sout.data(), sout.size());        } catch (...) {          prev->oss << last->oss.str();        }      }      last->oss.str("");      return true;    }    cout << last->oss.str();    last->oss.str("");  }  return false;}

ObjectData* SystemLib::AllocBadMethodCallExceptionObject(CVarRef message) {  if (hhvm) {    CREATE_AND_CONSTRUCT(BadMethodCallException, CREATE_VECTOR1(message));  } else {    return (NEWOBJ(c_BadMethodCallException)())->create(message);  }}

bool UserFile::lock(int operation, bool &wouldBlock) {    int64_t op = 0;    if (operation & LOCK_NB) {        op |= k_LOCK_NB;    }    switch (operation & ~LOCK_NB) {    case LOCK_SH:        op |= k_LOCK_SH;        break;    case LOCK_EX:        op |= k_LOCK_EX;        break;    case LOCK_UN:        op |= k_LOCK_UN;        break;    }    // bool stream_lock(int $operation)    bool success = false;    Variant ret = invoke(m_StreamLock, s_stream_lock,                         CREATE_VECTOR1(op), success);    if (!success) {        if (operation) {            raise_warning("%s::stream_lock is not implemented!",                          m_cls->name()->data());        }        return false;    }    return ret.isBoolean() ? ret.toBoolean() : false;}

bool TestExtApc::test_apc_exists() {  f_apc_store("ts", "TestString");  VS(f_apc_exists("ts"), true);  VS(f_apc_exists("TestString"), false);  VS(f_apc_exists(CREATE_VECTOR2("ts", "TestString")), CREATE_VECTOR1("ts"));  return Count(true);}

bool TestExtVariable::test_is_scalar() {  VERIFY(f_is_scalar(123));  VERIFY(f_is_scalar("test"));  VERIFY(!f_is_scalar(uninit_null()));  VERIFY(!f_is_scalar(CREATE_VECTOR1(123)));  return Count(true);}

Variant EvalObjectData::t___unset(Variant v_name) {    const MethodStatement *ms = getMethodStatement("__unset");    if (ms) {        return ms->invokeInstance(Object(root), CREATE_VECTOR1(v_name), false);    } else {        return DynamicObjectData::t___unset(v_name);    }}

void CmdUser::invokeList(DebuggerClient *client, const std::string &cls) {  p_DebuggerClient pclient(NEW(c_DebuggerClient)());  pclient->m_client = client;  try {    Object cmd = create_object(cls.c_str(), null_array);    cmd->o_invoke("onAutoComplete", CREATE_VECTOR1(pclient), -1);  } catch (...) {}}

static bool filter_func(CVarRef value, const void *data) {  HPHP::VM::CallCtx* ctx = (HPHP::VM::CallCtx*)data;  Variant ret;  g_vmContext->invokeFunc((TypedValue*)&ret, ctx->func, CREATE_VECTOR1(value),                          ctx->this_, ctx->cls,                          NULL, ctx->invName);  return ret.toBoolean();}

bool TestExtCurl::test_evhttp_post() {  Variant ret = f_evhttp_post(String(get_request_uri()), "echo",                              CREATE_VECTOR1("ECHO: foo"));  VS(ret[s_code], 200);  VS(ret[s_response], "POST: echo");  VS(ret[s_headers][0], "ECHOED: foo");  VS(ret[s_headers][4], "Content-Length: 10");  return Count(true);}

void objOffsetUnset(TypedValue* base, CVarRef offset) {  objArrayAccess(base);  static StringData* sd__offsetUnset    = StringData::GetStaticString("offsetUnset");  ObjectData* obj = base->m_data.pobj;  if (LIKELY(obj->isInstance())) {    Instance* instance = static_cast<Instance*>(obj);    const Func* method = instance->methodNamed(sd__offsetUnset);    ASSERT(method != NULL);    TypedValue tv;    tvWriteUninit(&tv);    instance->invokeUserMethod(&tv, method, CREATE_VECTOR1(offset));    tvRefcountedDecRef(&tv);  } else {    tvAsVariant(base).getArrayAccess()      ->o_invoke(sd__offsetUnset, CREATE_VECTOR1(offset));  }}

bool TestExtCurl::test_evhttp_get() {  Variant ret = f_evhttp_get(String(get_request_uri()),                             CREATE_VECTOR1("ECHO: foo"));  VS(ret["code"], 200);  VS(ret["response"], "OK");  VS(ret["headers"][0], "ECHOED: foo");  VS(ret["headers"][4], "Content-Length: 2");  return Count(true);}

Variant EvalObjectData::t___set_state(Variant v_properties) {  const MethodStatement *ms = getMethodStatement("__set_state");  if (ms) {    return ms->invokeInstance(Object(root), CREATE_VECTOR1(v_properties),        false);  } else {    return DynamicObjectData::t___set_state(v_properties);  }}

bool CmdUser::onServer(DebuggerProxy *proxy) {  if (m_cmd.isNull()) return false;  p_DebuggerProxy pproxy(NEW(c_DebuggerProxy)());  pproxy->m_proxy = proxy;  try {    Variant ret = m_cmd->o_invoke("onServer", CREATE_VECTOR1(pproxy), -1);    return !same(ret, false);  } catch (...) {}  return false;}

bool objOffsetExists(TypedValue* base, CVarRef offset) {  objArrayAccess(base);  TypedValue tvResult;  tvWriteUninit(&tvResult);  static StringData* sd__offsetExists    = StringData::GetStaticString("offsetExists");  ObjectData* obj = base->m_data.pobj;  if (LIKELY(obj->isInstance())) {    Instance* instance = static_cast<Instance*>(obj);    const Func* method = instance->methodNamed(sd__offsetExists);    ASSERT(method != NULL);    instance->invokeUserMethod(&tvResult, method, CREATE_VECTOR1(offset));  } else {    tvAsVariant(&tvResult) = tvAsVariant(base).getArrayAccess()      ->o_invoke(sd__offsetExists, CREATE_VECTOR1(offset));  }  tvCastToBooleanInPlace(&tvResult);  return bool(tvResult.m_data.num);}