void CVkProto::OnReceiveMyInfo(NETLIBHTTPREQUEST *reply, AsyncHttpRequest *pReq)
{
debugLogA("CVkProto::OnReceiveMyInfo %d", reply->resultCode);
if (reply->resultCode != 200) {
ConnectionFailed(LOGINERR_WRONGPASSWORD);
return;
}
JSONROOT pRoot;
JSONNODE *pResponse = CheckJsonResponse(pReq, reply, pRoot);
if (pResponse == NULL)
return;
for (size_t i = 0; i < json_size(pResponse); i++) {
JSONNODE *it = json_at(pResponse, i);
LPCSTR id = json_name(it);
if (!_stricmp(id, "user_id")) {
m_myUserId = json_as_int(it);
setDword("ID", m_myUserId);
}
}
OnLoggedIn();
RetrieveUserInfo(m_myUserId);
RetrieveFriends();
RetrieveUnreadMessages();
RetrievePollingInfo();
}
void SdkHandler::passwordFinished(char *bufferchar)
{
CCLOG("in function:[%s], buff:[%s]", __FUNCTION__, bufferchar);
int state = 0;
int userId = 0;
int flag = 0;
JSONNODE *n = json_parse(bufferchar);
if (n == NULL){
return;
}
JSONNODE_ITERATOR i = json_begin(n);
while (i != json_end(n)){
CCLOG("Start Parse Json in [%s]", __FUNCTION__);
if (*i == NULL){
break;
}
// recursively call ourselves to dig deeper into the tree
if (json_type(*i) == JSON_ARRAY || json_type(*i) == JSON_NODE){
break;
}
// get the node name and value as a string
json_char *node_name = json_name(*i);
// find out where to store the values
if (strcmp(node_name, "STATE") == 0){
json_int_t node_value = json_as_int(*i);
state = node_value;
}
else if (strcmp(node_name, "USER_ID") == 0){
json_int_t node_value = json_as_int(*i);
userId = node_value;
}
else if (strcmp(node_name, "LOGIN_KEY") == 0){
json_char *node_value = json_as_string(*i);
json_free(node_value);
}
else if (strcmp(node_name, "ERROR_TYPE") == 0){
json_int_t node_value = json_as_int(*i);
flag = node_value;
}
// cleanup and increment the iterator
json_free(node_name);
++i;
}
CCLOG("state:[%d], flag:[%d]", state, flag);
SdkInfoData *sdkLoginData = new SdkInfoData();
sdkLoginData->state = state;
sdkLoginData->errorFlag = flag;
SGNotificationCenter::sharedNotificationCenter()->postNotification(PASSWORDLAG,sdkLoginData,false);
}
bool Json::Parse(const string& str)
{
JSONNODE* node = json_parse(str.c_str());
if (node == NULL)
return false;
JSONNODE_ITERATOR iter = json_begin(node);
while (iter != json_end(node))
{
json_char* nodeName = json_name(*iter);
if(string(nodeName) == "" || json_type(*iter) == JSON_NULL)
{
json_free(nodeName);
break;
}
if (json_type(*iter) == JSON_NODE)
{
if(!Parse(nodeName, *iter))
return false;
}
else if(json_type(*iter) == JSON_ARRAY)
{
JSONNODE_ITERATOR i = json_begin(*iter);
while (i != json_end(*iter))
{
if(json_type(*iter) == JSON_NUMBER)
{
mDataFloatArray[nodeName].push_back(json_as_float(*i));
}
else
{
mDataStrArray[nodeName].push_back(json_as_string(*i));
}
i++;
}
}
else if(json_type(*iter) == JSON_NUMBER)
{
mDataFloat[nodeName] = json_as_float(*iter);
}
else if(json_type(*iter) == JSON_BOOL)
{
mDataBool[nodeName] = json_as_bool(*iter);
}
else if(json_type(*iter) == JSON_STRING)
{
mDataStr[nodeName] = json_as_string(*iter);
}
json_free(nodeName);
iter++;
}
json_delete(node);
return true;
}
void SdkHandler::destroyGuestFinished(char *bufferchar)
{
CCLOG("in function:[%s], buff:[%s]", __FUNCTION__, bufferchar);
int state = 0;
int userId = 0;
int flag = 0;
JSONNODE *n = json_parse(bufferchar);
if (n == NULL){
return;
}
JSONNODE_ITERATOR i = json_begin(n);
while (i != json_end(n)){
CCLOG("Start Parse Json in [%s]", __FUNCTION__);
if (*i == NULL){
break;
}
// recursively call ourselves to dig deeper into the tree
if (json_type(*i) == JSON_ARRAY || json_type(*i) == JSON_NODE){
break;
}
// get the node name and value as a string
json_char *node_name = json_name(*i);
// find out where to store the values
if (strcmp(node_name, "STATE") == 0){
json_int_t node_value = json_as_int(*i);
state = node_value;
}
else if (strcmp(node_name, "USER_ID") == 0){
json_int_t node_value = json_as_int(*i);
userId = node_value;
}
else if (strcmp(node_name, "LOGIN_KEY") == 0){
json_char *node_value = json_as_string(*i);
json_free(node_value);
}
else if (strcmp(node_name, "ERROR_TYPE") == 0){
json_int_t node_value = json_as_int(*i);
flag = node_value;
}
// cleanup and increment the iterator
json_free(node_name);
++i;
}
}
void Callback(JSONNODE * test, void *){
++counter;
switch(counter){
case 1:
assertEquals(json_type(test), JSON_NODE);
assertTrue(json_empty(test));
break;
case 2:
assertEquals(json_type(test), JSON_ARRAY);
assertTrue(json_empty(test));
break;
case 3:{
assertEquals(json_type(test), JSON_NODE);
assertEquals(json_size(test), 1);
json_char * temp = json_name(json_at(test, 0));
assertCStringSame(temp, JSON_TEXT("hello"));
json_free(temp);
assertEquals(json_as_int(json_at(test, 0)), 1);
break;}
case 4:
assertEquals(json_type(test), JSON_ARRAY);
assertEquals(json_size(test), 3);
break;
case 5:{
assertEquals(json_type(test), JSON_NODE);
assertEquals(json_size(test), 1);
json_char * temp = json_name(json_at(test, 0));
assertCStringSame(temp, JSON_TEXT("hi"));
json_free(temp);
assertEquals(json_size(json_at(test, 0)), 1);
assertEquals(json_type(json_at(json_at(test, 0),0)), JSON_NUMBER);
temp = json_name(json_at(json_at(test, 0),0));
assertCStringSame(temp, JSON_TEXT("one"));
json_free(temp);
assertEquals(json_as_int(json_at(json_at(test, 0),0)), 1);
break;}
}
}
void JSON_Get_name(sLONG_PTR *pResult, PackagePtr pParams)
{
C_TEXT json;
C_TEXT returnValue;
json.fromParamAtIndex(pParams, 1);
JSONNODE *n = _fromHex(json);
if(n){
json_char *s = json_name(n);
std::wstring w = std::wstring(s);
_copyString(w, returnValue);
json_free(s);
}
returnValue.setReturn(pResult);
}
bool admJsonToCouple::scan( void *xnode,string name)
{
JSONNODE *node=(JSONNODE *)xnode;
if (!node){
ADM_error("Invalid JSON Node\n");
return false;
}
JSONNODE_ITERATOR i = json_begin(node);
while (i != json_end(node)){
if (*i == NULL){
ADM_error("Invalid JSON Node\n");
return false;
}
json_char *node_name = json_name(*i);
//printf("Node :%s\n",node_name);
// recursively call ourselves to dig deeper into the tree
if (json_type(*i) == JSON_ARRAY || json_type(*i) == JSON_NODE)
{
if(name=="")
scan(*i,string(node_name));
else
scan(*i,name+string(".")+string(node_name));
}
else
{
keyVal k;
json_char *node_value = json_as_string(*i);
if(name=="")
k.key=string(node_name);
else
k.key=string(name)+string(".")+string(node_name);
k.value=string(node_value);
readItems.push_back(k);
json_free(node_value);
}
json_free(node_name);
++i;
}
return true;
}
// master不保存settings，直接传给plugin_init()
int load_task_setting(ls_master_t* master) {
LOG("load_task_setting()\n");
const char* setting_file = "task/setting.json";
char* buf;
long len;
FILE* f = fopen(setting_file, "r");
if (f == NULL) {
LOGE("Failed to open setting_file: %s\n", setting_file);// TODO errno
return -1;
}
fseek(f, 0, SEEK_END);
len = ftell(f);
rewind(f);
buf = (char*) malloc(len + 1);
if (NULL == buf) {
LOGE("Failed to malloc for task_setting: %s\n", strerror(errno));
return -1;
}
len = fread(buf, 1, len, f);
buf[len] = '\0';
JSONNODE* setting = json_parse(buf);
master->num_plugins = json_size(setting);
master->plugins = (ls_plugin_t*)malloc(master->num_plugins * sizeof(ls_plugin_t));
ls_plugin_t* plugin;
size_t plugin_index = 0;
char plugin_path[128];
for (JSONNODE_ITERATOR i = json_begin(setting); i != json_end(setting); ++i, ++plugin_index) {
plugin = master->plugins + plugin_index;
plugin->plugin_index = plugin_index;
json_char* plugin_name = json_name(*i);
if (NULL == plugin_name) {
LOGE("Failed to get plugin_name from task_setting\n");
return -1;
}
snprintf(plugin_path, sizeof(plugin_path), "plugin/%s/%s.so", plugin_name, plugin_name);
if (uv_dlopen(plugin_path, &plugin->plugin_lib) < 0) {
LOGE(" Failed to uv_dlopen: %s\n", uv_dlerror(&plugin->plugin_lib));
return -1;
}
if (uv_dlsym(&(plugin->plugin_lib), "plugin_declare", (void**)&(plugin->plugin_declare)) < 0) {
LOGE(" Failed to uv_dlsym\n");
return -1;
}
if ((plugin->plugin_declare(plugin) < 0)) {
LOGE(" Failed to plugin_declare\n");
return -1;
}
JSONNODE* settings = *i;
// if (plugin->master_init != NULL && (plugin->master_init)(master, settings) < 0)
if (plugin->plugin_init != NULL && (plugin->plugin_init)(settings) < 0) {
LOGE("ERROR failed to plugin_init()\n");
return -1;
}
}
// TODO json_free
return 0;
}
void JSON_GET_CHILD_NODES(sLONG_PTR *pResult, PackagePtr pParams)
{
C_TEXT json;
ARRAY_TEXT nodes;
ARRAY_LONGINT types;
ARRAY_TEXT names;
json.fromParamAtIndex(pParams, 1);
nodes.setSize(1);
types.setSize(1);
names.setSize(1);
JSONNODE *n = _fromHex(json);
if(n){
JSONNODE_ITERATOR i = json_begin(n);
while (i != json_end(n)){
if (*i){
json_char *s = json_name(*i);
std::wstring w = std::wstring(s);
C_TEXT t;
_copyString(w, t);
json_free(s);
CUTF16String nodeName;
t.copyUTF16String(&nodeName);
names.appendUTF16String(&nodeName);
C_TEXT h;
_toHex(*i, h);
CUTF16String nodeRef;
h.copyUTF16String(&nodeRef);
nodes.appendUTF16String(&nodeRef);
switch (json_type(*i)) {
case JSON_NULL:
types.appendIntValue(0);
break;
case JSON_STRING:
types.appendIntValue(1);
break;
case JSON_NUMBER:
types.appendIntValue(2);
break;
case JSON_BOOL:
types.appendIntValue(3);
break;
case JSON_ARRAY:
types.appendIntValue(4);
break;
case JSON_NODE:
types.appendIntValue(5);
break;
}
}
++i;
}
}
nodes.toParamAtIndex(pParams, 2);
types.toParamAtIndex(pParams, 3);
names.toParamAtIndex(pParams, 4);
}
void TestSuite::TestFunctions(void){
UnitTest::SetPrefix("TestFunctions.cpp - Swap");
#ifdef JSON_LIBRARY
JSONNODE * test1 = json_new(JSON_NODE);
JSONNODE * test2 = json_new(JSON_NODE);
json_set_i(test1, 14);
json_set_i(test2, 35);
json_swap(test1, test2);
assertEquals_Primitive(json_as_int(test1), 35);
assertEquals_Primitive(json_as_int(test2), 14);
UnitTest::SetPrefix("TestFunctions.cpp - Duplicate");
json_delete(test1);
test1 = json_duplicate(test2);
#ifdef JSON_UNIT_TEST
assertNotEquals(((JSONNode*)test1) -> internal, ((JSONNode*)test2) -> internal);
#endif
assertTrue(json_equal(test1, test2));
UnitTest::SetPrefix("TestFunctions.cpp - Duplicate with children");
JSONNODE * node = json_new(JSON_NODE);
json_push_back(node, json_new_i(JSON_TEXT(""), 15));
json_push_back(node, json_new_f(JSON_TEXT(""), 27.4f));
json_push_back(node, json_new_b(JSON_TEXT(""), true));
TestSuite::testParsingItself(node);
JSONNODE * dup = json_duplicate(node);
assertEquals(json_size(dup), 3);
#ifdef JSON_UNIT_TEST
assertNotEquals(((JSONNode*)node) -> internal, ((JSONNode*)dup) -> internal);
#endif
assertEquals(json_type(dup), JSON_NODE);
TestSuite::testParsingItself(node);
TestSuite::testParsingItself(dup);
assertEquals_Primitive(json_as_int(json_at(dup, 0)), 15);
assertEquals_Primitive(json_as_float(json_at(dup, 1)), 27.4f);
assertEquals(json_as_bool(json_at(dup, 2)), true);
assertTrue(json_equal(json_at(dup, 0), json_at(node, 0)));
assertTrue(json_equal(json_at(dup, 1), json_at(node, 1)));
assertTrue(json_equal(json_at(dup, 2), json_at(node, 2)));
TestSuite::testParsingItself(dup);
#ifdef JSON_ITERATORS
for(JSONNODE_ITERATOR it = json_begin(node), end = json_end(node), dup_it = json_begin(dup);
it != end;
++it, ++dup_it){
assertTrue(json_equal(*it, *dup_it));
#ifdef JSON_UNIT_TEST
assertNotEquals(((JSONNode*)(*it)) -> internal, ((JSONNode*)(*dup_it)) -> internal);
#endif
}
#endif
UnitTest::SetPrefix("TestFunctions.cpp - Nullify");
json_nullify(test1);
assertEquals(json_type(test1), JSON_NULL);
json_char * res = json_name(test1);
assertCStringSame(res, JSON_TEXT(""));
json_free(res);
#ifdef JSON_CASTABLE
UnitTest::SetPrefix("TestFunctions.cpp - Cast");
json_cast(test1, JSON_NULL);
json_set_i(test2, 1);
json_cast(test2, JSON_BOOL);
assertEquals(json_type(test1), JSON_NULL);
assertEquals(json_type(test2), JSON_BOOL);
assertEquals(json_as_bool(test2), true);
json_set_b(test2, true);
assertEquals(json_as_bool(test2), true);
json_cast(test2, JSON_NUMBER);
assertEquals_Primitive(json_as_float(test2), 1.0f);
json_set_f(test2, 0.0f);
assertEquals_Primitive(json_as_float(test2), 0.0f);
json_cast(test2, JSON_BOOL);
assertEquals(json_as_bool(test2), false);
#endif
UnitTest::SetPrefix("TestFunctions.cpp - Merge");
json_set_a(test1, JSON_TEXT("hello"));
json_set_a(test2, JSON_TEXT("hello"));
#ifdef JSON_UNIT_TEST
assertNotEquals(((JSONNode*)test1) -> internal, ((JSONNode*)test2) -> internal);
#endif
assertTrue(json_equal(test1, test2));
json_merge(test1, test2);
#ifdef JSON_UNIT_TEST
#ifdef JSON_REF_COUNT
assertEquals(((JSONNode*)test1) -> internal, ((JSONNode*)test2) -> internal);
#else
assertNotEquals(((JSONNode*)test1) -> internal, ((JSONNode*)test2) -> internal);
#endif
#endif
#ifdef JSON_CASTABLE
json_cast(test1, JSON_NODE);
json_cast(test2, JSON_NODE);
assertEquals(json_type(test1), JSON_NODE);
assertEquals(json_type(test2), JSON_NODE);
json_push_back(test1, json_new_a(JSON_TEXT("hi"), JSON_TEXT("world")));
json_push_back(test2, json_new_a(JSON_TEXT("hi"), JSON_TEXT("world")));
TestSuite::testParsingItself(test1);
TestSuite::testParsingItself(test2);
json_merge(test1, test2);
#ifdef JSON_UNIT_TEST
#ifdef JSON_REF_COUNT
assertEquals(((JSONNode*)test1) -> internal, ((JSONNode*)test2) -> internal);
#else
assertNotEquals(((JSONNode*)test1) -> internal, ((JSONNode*)test2) -> internal);
#endif
#endif
TestSuite::testParsingItself(test1);
TestSuite::testParsingItself(test2);
#endif
json_delete(test1);
json_delete(test2);
json_delete(node);
json_delete(dup);
#else
JSONNode test1;
JSONNode test2;
test1 = JSON_TEXT("hello");
test2 = JSON_TEXT("world");
test1.swap(test2);
assertEquals(test1, JSON_TEXT("world"));
assertEquals(test2, JSON_TEXT("hello"));
UnitTest::SetPrefix("TestFunctions.cpp - Duplicate");
test1 = test2.duplicate();
#ifdef JSON_UNIT_TEST
assertNotEquals(test1.internal, test2.internal);
#endif
assertEquals(test1, test2);
UnitTest::SetPrefix("TestFunctions.cpp - Duplicate with children");
JSONNode node = JSONNode(JSON_NODE);
node.push_back(JSONNode(JSON_TEXT(""), 15));
node.push_back(JSONNode(JSON_TEXT(""), JSON_TEXT("hello world")));
node.push_back(JSONNode(JSON_TEXT(""), true));
TestSuite::testParsingItself(node);
JSONNode dup = node.duplicate();
assertEquals(dup.size(), 3);
#ifdef JSON_UNIT_TEST
assertNotEquals(node.internal, dup.internal);
#endif
assertEquals(dup.type(), JSON_NODE);
TestSuite::testParsingItself(node);
TestSuite::testParsingItself(dup);
try {
assertEquals(dup.at(0), 15);
assertEquals(dup.at(1), JSON_TEXT("hello world"));
assertEquals(dup.at(2), true);
assertEquals(dup.at(0), node.at(0));
assertEquals(dup.at(1), node.at(1));
assertEquals(dup.at(2), node.at(2));
} catch (std::out_of_range){
FAIL("exception caught");
}
TestSuite::testParsingItself(dup);
#ifdef JSON_ITERATORS
for(JSONNode::iterator it = node.begin(), end = node.end(), dup_it = dup.begin();
it != end;
++it, ++dup_it){
assertEquals(*it, *dup_it);
#ifdef JSON_UNIT_TEST
assertNotEquals((*it).internal, (*dup_it).internal);
#endif
}
#endif
UnitTest::SetPrefix("TestFunctions.cpp - Nullify");
test1.nullify();
assertEquals(test1.type(), JSON_NULL);
assertEquals(test1.name(), JSON_TEXT(""));
#ifdef JSON_CASTABLE
UnitTest::SetPrefix("TestFunctions.cpp - Cast");
test1.cast(JSON_NULL);
test2 = 1;
test2.cast(JSON_BOOL);
assertEquals(test1.type(), JSON_NULL);
assertEquals(test2.type(), JSON_BOOL);
assertEquals(test2, true);
test2 = true;
assertEquals(test2, true);
test2.cast(JSON_NUMBER);
assertEquals(test2, 1.0f);
test2 = 0.0f;
assertEquals(test2, 0.0f);
test2.cast(JSON_BOOL);
assertEquals(test2, false);
#endif
UnitTest::SetPrefix("TestFunctions.cpp - Merge");
test1 = JSON_TEXT("hello");
test2 = JSON_TEXT("hello");
#ifdef JSON_UNIT_TEST
assertNotEquals(test1.internal, test2.internal);
#endif
assertEquals(test1, test2);
test1.merge(test2);
#ifdef JSON_UNIT_TEST
#ifdef JSON_REF_COUNT
assertEquals(test1.internal, test2.internal);
#else
assertNotEquals(test1.internal, test2.internal);
#endif
#endif
#ifdef JSON_CASTABLE
test1.cast(JSON_NODE);
test2.cast(JSON_NODE);
#else
test1 = JSONNode(JSON_NODE);
test2 = JSONNode(JSON_NODE);
#endif
assertEquals(test1.type(), JSON_NODE);
assertEquals(test2.type(), JSON_NODE);
test1.push_back(JSONNode(JSON_TEXT("hi"), JSON_TEXT("world")));
test2.push_back(JSONNode(JSON_TEXT("hi"), JSON_TEXT("world")));
TestSuite::testParsingItself(test1);
TestSuite::testParsingItself(test2);
test1.merge(test2);
#ifdef JSON_UNIT_TEST
#ifdef JSON_REF_COUNT
assertEquals(test1.internal, test2.internal);
#else
assertNotEquals(test1.internal, test2.internal);
#endif
#endif
TestSuite::testParsingItself(test1);
TestSuite::testParsingItself(test2);
#endif
}
SEXP
processJSONNode(JSONNODE *n, int parentType, int simplify, SEXP nullValue, int simplifyWithNames, cetype_t charEncoding,
SEXP r_stringCall, StringFunctionType str_fun_type)
{
if (n == NULL){
PROBLEM "invalid JSON input"
ERROR;
}
JSONNODE *i;
int len = 0, ctr = 0;
int nprotect = 0;
int numNulls = 0;
len = json_size(n);
char startType = parentType; // was 127
int isNullHomogeneous = (TYPEOF(nullValue) == LGLSXP || TYPEOF(nullValue) == REALSXP ||
TYPEOF(nullValue) == STRSXP || TYPEOF(nullValue) == INTSXP);
int numStrings = 0;
int numLogicals = 0;
int numNumbers = 0;
SEXP ans, names = NULL;
PROTECT(ans = NEW_LIST(len)); nprotect++;
int homogeneous = 0;
int elType = NILSXP;
while (ctr < len){ // i != json_end(n)
i = json_at(n, ctr);
if (i == NULL){
PROBLEM "Invalid JSON Node"
ERROR;
}
json_char *node_name = json_name(i);
char type = json_type(i);
if(startType == 127)
startType = type;
SEXP el;
switch(type) {
case JSON_NULL:
el = nullValue; /* R_NilValue; */
numNulls++;
if(isNullHomogeneous) {
homogeneous++;
elType = setType(elType, TYPEOF(nullValue));
} else
elType = TYPEOF(nullValue);
break;
case JSON_ARRAY:
case JSON_NODE:
el = processJSONNode(i, type, simplify, nullValue, simplifyWithNames, charEncoding, r_stringCall, str_fun_type);
if(Rf_length(el) > 1)
elType = VECSXP;
else
elType = setType(elType, TYPEOF(el));
break;
case JSON_NUMBER:
el = ScalarReal(json_as_float(i));
homogeneous++;
elType = setType(elType, REALSXP);
numNumbers++;
break;
case JSON_BOOL:
el = ScalarLogical(json_as_bool(i));
elType = setType(elType, LGLSXP);
numLogicals++;
break;
case JSON_STRING:
{
//XXX Garbage collection
#if 0 //def JSON_UNICODE
wchar_t *wtmp = json_as_string(i);
char *tmp;
int len = wcslen(wtmp);
int size = sizeof(char) * (len * MB_LEN_MAX + 1);
tmp = (char *)malloc(size);
if (tmp == NULL) {
PROBLEM "Cannot allocate memory"
ERROR;
}
wcstombs(tmp, wtmp, size);
#else
char *tmp = json_as_string(i);
// tmp = reEnc(tmp, CE_BYTES, CE_UTF8, 1);
#endif
if(r_stringCall != NULL && TYPEOF(r_stringCall) == EXTPTRSXP) {
if(str_fun_type == SEXP_STR_ROUTINE) {
SEXPStringRoutine fun;
fun = (SEXPStringRoutine) R_ExternalPtrAddr(r_stringCall);
el = fun(tmp, charEncoding);
} else {
char *tmp1;
StringRoutine fun;
fun = (StringRoutine) R_ExternalPtrAddr(r_stringCall);
tmp1 = fun(tmp);
if(tmp1 != tmp)
json_free(tmp);
tmp = tmp1;
el = ScalarString(mkCharCE(tmp, charEncoding));
}
} else {
el = ScalarString(mkCharCE(tmp, charEncoding));
/* Call the R function if there is one. */
if(r_stringCall != NULL) {
SETCAR(CDR(r_stringCall), el);
el = Rf_eval(r_stringCall, R_GlobalEnv);
}
/* XXX compute with elType. */
}
json_free(tmp);
elType = setType(elType,
/* If we have a class, not a primitive type */
Rf_length(getAttrib(el, Rf_install("class"))) ? LISTSXP : TYPEOF(el));
if(r_stringCall != NULL && str_fun_type != NATIVE_STR_ROUTINE) {
switch(TYPEOF(el)) {
case REALSXP:
numNumbers++;
break;
case LGLSXP:
numLogicals++;
break;
case STRSXP:
numStrings++;
break;
}
} else if(TYPEOF(el) == STRSXP)
numStrings++;
}
break;
default:
PROBLEM "shouldn't be here"
WARN;
el = R_NilValue;
break;
}
SET_VECTOR_ELT(ans, ctr, el);
if(parentType == JSON_NODE || (node_name && node_name[0])) {
if(names == NULL) {
PROTECT(names = NEW_CHARACTER(len)); nprotect++;
}
if(node_name && node_name[0])
SET_STRING_ELT(names, ctr, mkChar(node_name));
}
json_free(node_name);
ctr++;
}
/* If we have an empty object, we try to make it into a form equivalent to emptyNamedList
if it is a {}, or as an AsIs object in R if an empty array. */
if(len == 0 && (parentType == -1 || parentType == JSON_ARRAY || parentType == JSON_NODE)) {
if(parentType == -1)
parentType = startType;
if(parentType == JSON_NODE)
SET_NAMES(ans, NEW_CHARACTER(0));
else {
SET_CLASS(ans, ScalarString(mkChar("AsIs")));
}
} else if(simplifyWithNames || names == NULL || Rf_length(names) == 0) {
int allSame = (numNumbers == len || numStrings == len || numLogicals == len) ||
((TYPEOF(nullValue) == LGLSXP && LOGICAL(nullValue)[0] == NA_INTEGER) &&
((numNumbers + numNulls) == len || (numStrings + numNulls) == len || (numLogicals + numNulls) == len));
homogeneous = allSame || ( (numNumbers + numStrings + numLogicals + numNulls) == len);
if(simplify == NONE) {
} else if(allSame &&
(numNumbers == len && (simplify & STRICT_NUMERIC)) ||
((numLogicals == len) && (simplify & STRICT_LOGICAL)) ||
( (numStrings == len) && (simplify & STRICT_CHARACTER))) {
ans = makeVector(ans, len, elType, nullValue);
} else if((simplify == ALL && homogeneous) || (simplify == STRICT && allSame)) {
ans = makeVector(ans, len, elType, nullValue);
}
}
if(names)
SET_NAMES(ans, names);
UNPROTECT(nprotect);
return(ans);
}
void TestSuite::TestInspectors(void){
UnitTest::SetPrefix("TestInspectors.cpp - Inspectors");
#ifdef JSON_LIBRARY
JSONNODE * test = json_new(JSON_NULL);
assertEquals(json_type(test), JSON_NULL);
json_char * res = json_as_string(test);
assertCStringSame(res, JSON_TEXT(""));
json_free(res);
assertEquals_Primitive(json_as_int(test), 0);
assertEquals_Primitive(json_as_float(test), 0.0f);
assertEquals(json_as_bool(test), false);
json_set_f(test, 15.5f);
assertEquals(json_type(test), JSON_NUMBER);
#ifdef JSON_CASTABLE
res = json_as_string(test);
assertCStringSame(res, JSON_TEXT("15.5"));
json_free(res);
#endif
assertEquals_Primitive(json_as_int(test), 15);
assertEquals_Primitive(json_as_float(test), 15.5f);
#ifdef JSON_CASTABLE
assertEquals(json_as_bool(test), true);
#endif
json_set_f(test, 0.0f);
assertEquals(json_type(test), JSON_NUMBER);
#ifdef JSON_CASTABLE
res = json_as_string(test);
assertCStringSame(res, JSON_TEXT("0"));
json_free(res);
#endif
assertEquals_Primitive(json_as_int(test), 0);
assertEquals_Primitive(json_as_float(test), 0.0f);
#ifdef JSON_CASTABLE
assertEquals(json_as_bool(test), false);
#endif
json_set_b(test, true);
assertEquals(json_type(test), JSON_BOOL);
#ifdef JSON_CASTABLE
res = json_as_string(test);
assertCStringSame(res, JSON_TEXT("true"));
json_free(res);
assertEquals_Primitive(json_as_int(test), 1);
assertEquals_Primitive(json_as_float(test), 1.0f);
#endif
assertEquals(json_as_bool(test), true);
json_set_b(test, false);
assertEquals(json_type(test), JSON_BOOL);
#ifdef JSON_CASTABLE
res = json_as_string(test);
assertCStringSame(res, JSON_TEXT("false"));
json_free(res);
assertEquals_Primitive(json_as_int(test), 0);
assertEquals_Primitive(json_as_float(test), 0.0f);
#endif
assertEquals(json_as_bool(test), false);
#ifdef JSON_CASTABLE
json_cast(test, JSON_NODE);
assertEquals(json_type(test), JSON_NODE);
assertEquals(json_size(test), 0);
json_push_back(test, json_new_a(JSON_TEXT("hi"), JSON_TEXT("world")));
json_push_back(test, json_new_a(JSON_TEXT("hello"), JSON_TEXT("mars")));
json_push_back(test, json_new_a(JSON_TEXT("salut"), JSON_TEXT("france")));
assertEquals(json_size(test), 3);
TestSuite::testParsingItself(test);
JSONNODE * casted = json_as_array(test);
#ifdef JSON_UNIT_TEST
assertNotEquals(((JSONNode*)casted) -> internal, ((JSONNode*)test) -> internal);
#endif
assertEquals(json_type(casted), JSON_ARRAY);
assertEquals(json_type(test), JSON_NODE);
assertEquals(json_size(test), 3);
assertEquals(json_size(casted), 3);
TestSuite::testParsingItself(casted);
#endif
UnitTest::SetPrefix("TestInspectors.cpp - Location");
#ifdef JSON_CASTABLE
#define CheckAt(parent, locale, text)\
if(JSONNODE * temp = json_at(parent, locale)){\
json_char * _res = json_as_string(temp);\
assertCStringSame(_res, text);\
json_free(_res);\
} else {\
FAIL(std::string("CheckAt: ") + #parent + "[" + #locale + "]");\
}
#define CheckNameAt(parent, locale, text)\
if(JSONNODE * temp = json_at(parent, locale)){\
json_char * _res = json_name(temp);\
assertCStringSame(_res, text);\
json_free(_res);\
} else {\
FAIL(std::string("CheckNameAt: ") + #parent + "[" + #locale + "]");\
}
CheckAt(casted, 0, JSON_TEXT("world"));
CheckAt(casted, 1, JSON_TEXT("mars"));
CheckAt(casted, 2, JSON_TEXT("france"));
CheckNameAt(casted, 0, JSON_TEXT(""));
CheckNameAt(casted, 1, JSON_TEXT(""));
CheckNameAt(casted, 2, JSON_TEXT(""));
CheckAt(test, 0, JSON_TEXT("world"));
CheckAt(test, 1, JSON_TEXT("mars"));
CheckAt(test, 2, JSON_TEXT("france"));
CheckNameAt(test, 0, JSON_TEXT("hi"));
CheckNameAt(test, 1, JSON_TEXT("hello"));
CheckNameAt(test, 2, JSON_TEXT("salut"));
#define CheckGet(parent, locale, text)\
if(JSONNODE * temp = json_get(parent, locale)){\
json_char * _res = json_as_string(temp);\
assertCStringSame(_res, text);\
json_free(_res);\
} else {\
FAIL(std::string("CheckGet: ") + #parent + "[" + #locale + "]");\
}
#ifdef JSON_CASE_INSENSITIVE_FUNCTIONS
#define CheckGetNoCase(parent, locale, text)\
if(JSONNODE * temp = json_get_nocase(parent, locale)){\
json_char * _res = json_as_string(temp);\
assertCStringSame(_res, text);\
json_free(_res);\
} else {\
FAIL(std::string("CheckGetNoCase: ") + #parent + "[" + #locale + "]");\
}
#else
#define CheckGetNoCase(parent, locale, text)
#endif
CheckGet(test, JSON_TEXT("hi"), JSON_TEXT("world"));
CheckGetNoCase(test, JSON_TEXT("HI"), JSON_TEXT("world"));
CheckGet(test, JSON_TEXT("hello"), JSON_TEXT("mars"));
CheckGetNoCase(test, JSON_TEXT("HELLO"), JSON_TEXT("mars"));
CheckGet(test, JSON_TEXT("salut"), JSON_TEXT("france"));
CheckGetNoCase(test, JSON_TEXT("SALUT"), JSON_TEXT("france"));
assertNull(json_get(test, JSON_TEXT("meh")));
#ifdef JSON_CASE_INSENSITIVE_FUNCTIONS
assertNull(json_get_nocase(test, JSON_TEXT("meh")));
#endif
#endif
#ifdef JSON_ITERATORS
#ifdef JSON_CASTABLE
UnitTest::SetPrefix("TestInspectors.cpp - Iterators");
for(JSONNODE_ITERATOR it = json_begin(casted), end = json_end(casted); it != end; ++it){
json_char * _res = json_name(*it);
assertCStringSame(_res, JSON_TEXT(""));
json_free(_res);
}
#endif
#endif
#ifdef JSON_BINARY
UnitTest::SetPrefix("TestInspectors.cpp - Binary");
json_set_binary(test, (const unsigned char *)"Hello World", 11);
assertEquals(json_type(test), JSON_STRING);
json_char * _res = json_as_string(test);
assertCStringSame(_res, JSON_TEXT("SGVsbG8gV29ybGQ="));
json_free(_res);
unsigned long i;
if(char * bin = (char*)json_as_binary(test, &i)){
assertEquals(i, 11);
char * terminated = (char*)std::memcpy(std::malloc(i + 1), bin, i);
terminated[i] = '\0';
assertCStringEquals(terminated, "Hello World");
json_free(bin);
std::free(terminated);
} else {
FAIL("as_binary failed");
}
json_set_a(test, JSON_TEXT("Hello World"));
assertEquals(json_type(test), JSON_STRING);
_res = json_as_string(test);
assertCStringSame(_res, JSON_TEXT("Hello World"));
json_free(_res);
#ifdef JSON_SAFE
assertEquals(json_as_binary(test, &i), 0);
assertEquals(i, 0);
#endif
#endif
json_delete(test);
#ifdef JSON_CASTABLE
json_delete(casted);
#endif
#else
JSONNode test = JSONNode(JSON_NULL);
#ifdef JSON_CASTABLE
assertEquals(test.as_string(), JSON_TEXT(""));
assertEquals(test.as_int(), 0);
assertEquals(test.as_float(), 0.0f);
assertEquals(test.as_bool(), false);
#endif
test = 15.5f;
assertEquals(test.type(), JSON_NUMBER);
#ifdef JSON_CASTABLE
assertEquals(test.as_string(), JSON_TEXT("15.5"));
#endif
assertEquals(test.as_int(), 15);
assertEquals(test.as_float(), 15.5f);
#ifdef JSON_CASTABLE
assertEquals(test.as_bool(), true);
#endif
test = 0.0f;
assertEquals(test.type(), JSON_NUMBER);
#ifdef JSON_CASTABLE
assertEquals(test.as_string(), JSON_TEXT("0"));
#endif
assertEquals(test.as_int(), 0);
assertEquals(test.as_float(), 0.0f);
#ifdef JSON_CASTABLE
assertEquals(test.as_bool(), false);
#endif
test = true;
assertEquals(test.type(), JSON_BOOL);
#ifdef JSON_CASTABLE
assertEquals(test.as_string(), JSON_TEXT("true"));
assertEquals(test.as_int(), 1);
assertEquals(test.as_float(), 1.0f);
#endif
assertEquals(test.as_bool(), true);
test = false;
assertEquals(test.type(), JSON_BOOL);
#ifdef JSON_CASTABLE
assertEquals(test.as_string(), JSON_TEXT("false"));
assertEquals(test.as_int(), 0);
assertEquals(test.as_float(), 0.0f);
#endif
assertEquals(test.as_bool(), false);
#ifdef JSON_CASTABLE
test.cast(JSON_NODE);
#else
test = JSONNode(JSON_NODE);
#endif
assertEquals(test.type(), JSON_NODE);
assertEquals(test.size(), 0);
test.push_back(JSONNode(JSON_TEXT("hi"), JSON_TEXT("world")));
test.push_back(JSONNode(JSON_TEXT("hello"), JSON_TEXT("mars")));
test.push_back(JSONNode(JSON_TEXT("salut"), JSON_TEXT("france")));
assertEquals(test.size(), 3);
TestSuite::testParsingItself(test);
#ifdef JSON_CASTABLE
JSONNode casted = test.as_array();
#ifdef JSON_UNIT_TEST
assertNotEquals(casted.internal, test.internal);
#endif
assertEquals(casted.type(), JSON_ARRAY);
assertEquals(test.type(), JSON_NODE);
assertEquals(test.size(), 3);
assertEquals(casted.size(), 3);
TestSuite::testParsingItself(casted);
#endif
UnitTest::SetPrefix("TestInspectors.cpp - Location");
try {
#ifdef JSON_CASTABLE
assertEquals(casted.at(0), JSON_TEXT("world"));
assertEquals(casted.at(1), JSON_TEXT("mars"));
assertEquals(casted.at(2), JSON_TEXT("france"));
assertEquals(casted.at(0).name(), JSON_TEXT(""));
assertEquals(casted.at(1).name(), JSON_TEXT(""));
assertEquals(casted.at(2).name(), JSON_TEXT(""));
#endif
assertEquals(test.at(0), JSON_TEXT("world"));
assertEquals(test.at(1), JSON_TEXT("mars"));
assertEquals(test.at(2), JSON_TEXT("france"));
assertEquals(test.at(0).name(), JSON_TEXT("hi"));
assertEquals(test.at(1).name(), JSON_TEXT("hello"));
assertEquals(test.at(2).name(), JSON_TEXT("salut"));
} catch (std::out_of_range){
FAIL("exception caught");
}
try {
assertEquals(test.at(JSON_TEXT("hi")), JSON_TEXT("world"));
assertEquals(test.at(JSON_TEXT("hello")), JSON_TEXT("mars"));
assertEquals(test.at(JSON_TEXT("salut")), JSON_TEXT("france"));
#ifdef JSON_CASE_INSENSITIVE_FUNCTIONS
assertEquals(test.at_nocase(JSON_TEXT("SALUT")), JSON_TEXT("france"));
assertEquals(test.at_nocase(JSON_TEXT("HELLO")), JSON_TEXT("mars"));
assertEquals(test.at_nocase(JSON_TEXT("HI")), JSON_TEXT("world"));
#endif
} catch (std::out_of_range){
FAIL("exception caught");
}
assertException(test.at(JSON_TEXT("meh")), std::out_of_range);
#ifdef JSON_CASE_INSENSITIVE_FUNCTIONS
assertException(test.at_nocase(JSON_TEXT("meh")), std::out_of_range);
#endif
assertEquals(test[JSON_TEXT("hi")], json_string(JSON_TEXT("world")));
assertEquals(test[JSON_TEXT("hello")], json_string(JSON_TEXT("mars")));
assertEquals(test[JSON_TEXT("salut")], json_string(JSON_TEXT("france")));
assertEquals(test[0], JSON_TEXT("world"));
assertEquals(test[1], JSON_TEXT("mars"));
assertEquals(test[2], JSON_TEXT("france"));
#ifdef JSON_ITERATORS
#ifdef JSON_CASTABLE
UnitTest::SetPrefix("TestInspectors.cpp - Iterators");
for(JSONNode::iterator it = casted.begin(), end = casted.end(); it != end; ++it){
assertEquals((*it).name(), JSON_TEXT(""));
}
#endif
#endif
#ifdef JSON_BINARY
UnitTest::SetPrefix("TestInspectors.cpp - Binary");
test.set_binary((const unsigned char *)"Hello World", 11);
assertEquals(test.type(), JSON_STRING);
assertEquals(test.as_string(), JSON_TEXT("SGVsbG8gV29ybGQ="));
assertEquals(test.as_binary(), "Hello World");
assertEquals(test.as_binary().size(), 11);
test = JSON_TEXT("Hello World");
assertEquals(test.type(), JSON_STRING);
assertEquals(test.as_string(), JSON_TEXT("Hello World"));
#ifdef JSON_SAFE
assertEquals(test.as_binary(), "");
#endif
#endif
#ifdef JSON_READ_PRIORITY
//This is a regression test for a bug in at()
json_string buffer(JSON_TEXT("{ \"myValue1\" : \"foo\", \"myValue2\" : \"bar\"}"));
JSONNode current = libjson::parse(buffer);
try {
JSONNode & value1 = current[JSON_TEXT("myValue1")];
assertEquals(value1.as_string(), JSON_TEXT("foo"));
JSONNode & value2 = current[JSON_TEXT("myValue2")];
assertEquals(value2.as_string(), JSON_TEXT("bar"));
} catch (...){
assertTrue(false);
}
#endif
#endif
}
void SdkHandler::registFinished(char *bufferchar)
{
CCLOG("in function:[%s], buff:[%s]", __FUNCTION__, bufferchar);
int state = 0;
int userId = 0;
int flag = 0;
const char* loginKey = NULL;
JSONNODE *n = json_parse(bufferchar);
if (n == NULL){
return;
}
JSONNODE_ITERATOR i = json_begin(n);
while (i != json_end(n)){
CCLOG("Start Parse Json in [%s]", __FUNCTION__);
if (*i == NULL){
break;
}
// recursively call ourselves to dig deeper into the tree
if (json_type(*i) == JSON_ARRAY || json_type(*i) == JSON_NODE){
break;
}
// get the node name and value as a string
json_char *node_name = json_name(*i);
// find out where to store the values
if (strcmp(node_name, "STATE") == 0){
json_int_t node_value = json_as_int(*i);
state = node_value;
}
else if (strcmp(node_name, "USER_ID") == 0){
json_int_t node_value = json_as_int(*i);
userId = node_value;
}
else if (strcmp(node_name, "LOGIN_KEY") == 0){
json_char *node_value = json_as_string(*i);
loginKey = node_value;
}
else if (strcmp(node_name, "ERROR_TYPE") == 0){
json_int_t node_value = json_as_int(*i);
flag = node_value;
}
// cleanup and increment the iterator
json_free(node_name);
++i;
}
//这里做状态判定
if (flag == 10)
{
SGNotificationCenter::sharedNotificationCenter()->postNotification(INVALID_INFO_TIP,new CCInteger(10),false);
return ;
}
else if (flag == 11)
{
SGNotificationCenter::sharedNotificationCenter()->postNotification(INVALID_INFO_TIP,new CCInteger(11),false);
return ;
}
else if (flag == 12)
{
SGNotificationCenter::sharedNotificationCenter()->postNotification(INVALID_INFO_TIP,new CCInteger(12),false);
return ;
}
CCLOG("Json parse completed! in fun : [%s]", __FUNCTION__);
SdkInfoData *sdkLoginData = new SdkInfoData();
sdkLoginData->state = state;
sdkLoginData->accountId = userId;
sdkLoginData->flag = flag;
sdkLoginData->loginKey = std::string(loginKey);
sdkLoginData->userName = userName;
sdkLoginData->password = password;
sdkLoginData->isEx = true;
CCLOG("####state:[%d]m accountId : [%d], flag : [%d], loginKey:[%s]####", state, userId, flag, loginKey);
SGNotificationCenter::sharedNotificationCenter()->postNotification(REREGISTFLAG,sdkLoginData,false);
}
void SdkHandler::thirdLoginFinished(char *bufferchar)
{
CCLOG("in function:[%s], buff:[%s]", __FUNCTION__, bufferchar);
CCLOG("userName:[%s], password:[%s]", userName.c_str(), password.c_str());
int state = 0;
int userId = 0;
int flag = 0;
const char* loginKey = NULL;
JSONNODE *n = json_parse(bufferchar);
if (n == NULL){
return;
}
JSONNODE_ITERATOR i = json_begin(n);
while (i != json_end(n)){
CCLOG("Start Parse Json in [%s]", __FUNCTION__);
if (*i == NULL){
break;
}
// recursively call ourselves to dig deeper into the tree
if (json_type(*i) == JSON_ARRAY || json_type(*i) == JSON_NODE){
break;
}
// get the node name and value as a string
json_char *node_name = json_name(*i);
// find out where to store the values
if (strcmp(node_name, "STATE") == 0){
json_int_t node_value = json_as_int(*i);
state = node_value;
}
else if (strcmp(node_name, "USER_ID") == 0){
json_int_t node_value = json_as_int(*i);
userId = node_value;
}
else if (strcmp(node_name, "LOGIN_KEY") == 0){
json_char *node_value = json_as_string(*i);
loginKey = node_value;
}
else if (strcmp(node_name, "ERROR_TYPE") == 0){
json_int_t node_value = json_as_int(*i);
flag = node_value;
}
// cleanup and increment the iterator
json_free(node_name);
++i;
}
if (flag == 20)
{
SGNotificationCenter::sharedNotificationCenter()->postNotification(INVALID_INFO_TIP,new CCInteger(20),false);
return ;
}
CCLOG("state:[%d], err_type:[%d]", state, flag);
if (state == 1)
{
SdkInfoData *sdkLoginData = new SdkInfoData();
sdkLoginData->accountId = userId;
sdkLoginData->errorFlag = flag;
sdkLoginData->loginKey = std::string(loginKey);
sdkLoginData->userName = this->userName;
sdkLoginData->password = this->password;
sdkLoginData->isEx = this->isExist;
CCLOG("loginKey:[%s]", loginKey);
//需要将登陆数据写入本地,在此非主线程,需要将当前数据发至主线程写入本地文件
SGNotificationCenter::sharedNotificationCenter()->postNotification(THIRDPARTYLOGIN,sdkLoginData,false);
}
else if (flag == 13)
{
SGNotificationCenter::sharedNotificationCenter()->postNotification(BIND_FAILED, false);
}
else
{
CCLOG("Login Failed!");
}
}
