User *User::authenticate(const string &username, const string &password) { Client client; JSON body; body.set_string("username", username); body.set_string("password", password); client.setPayload(body.to_string()); client.get("login"); JSON response; try { response = client.getJSONResponse(); } catch (const exception &e) { return NULL; } if (currentUser_ != NULL) delete currentUser_; currentUser_ = new User(); currentUser_->setUsername(username); currentUser_->setPassword(password); currentUser_->merge(response); return currentUser_; }
Status deserializeQueryLogItem(const JSON& doc, QueryLogItem& item) { if (!doc.doc().IsObject()) { return Status(1); } if (doc.doc().HasMember("diffResults")) { auto status = deserializeDiffResults(doc.doc()["diffResults"], item.results); if (!status.ok()) { return status; } } else if (doc.doc().HasMember("snapshot")) { auto status = deserializeQueryData(doc.doc()["snapshot"], item.snapshot_results); if (!status.ok()) { return status; } } getLegacyFieldsAndDecorations(doc, item); return Status(); }
void Settings::SaveOnly(const Array<const char*> &varNames) { if(settingsJSON == NULL) return; for(int i = 0; i < variables.GetSizeI(); i++) { IVariable* var = variables[i]; bool found = false; for(int namesIndex = 0; namesIndex < varNames.GetSizeI(); namesIndex++) { if(strcmp(var->name, varNames[namesIndex]) == 0) { found = true; break; } } if(!found) { continue; } var->SaveValue(); JSON* varJSON = var->json; if(varJSON == NULL) { varJSON = settingsJSON->GetItemByName(var->name); var->json = varJSON; } if(varJSON == NULL) { settingsJSON->AddItem(var->name,var->Serialize()); } else { varJSON->ReplaceNodeWith(var->Serialize()); } } rootSettingsJSON->Save(settingsFileName); }
uint AuthUserAccount(const char *email, const wchar_t *password) { JSON json; if (!BackendQuery(&json, GAME_AUTH_ACCOUNT, email, password)) return WIC_INVALID_ACCOUNT; int j_status; if (!json.ReadInt("status", &j_status) || j_status == 0) { DatabaseLog("CreateUserAccount: JSON status failed."); return WIC_INVALID_ACCOUNT; } uint j_profileId; if (!json.ReadUInt("profileId", &j_profileId)) { DatabaseLog("Error: Server returned invalid profile ID."); return WIC_INVALID_ACCOUNT; } return j_profileId; }
//----------------------------------------------------------------------------- Profile* ProfileManager::GetTaggedProfile(const char** tag_names, const char** tags, int num_tags) { Lock::Locker lockScope(&ProfileLock); if (ProfileCache == NULL) { // Load the cache LoadCache(false); if (ProfileCache == NULL) return NULL; } JSON* tagged_data = ProfileCache->GetItemByName("TaggedData"); OVR_ASSERT(tagged_data); if (tagged_data == NULL) return NULL; Profile* profile = new Profile(BasePath); JSON* vals = FindTaggedData(tagged_data, tag_names, tags, num_tags); if (vals) { JSON* item = vals->GetFirstItem(); while (item) { //printf("Add %s, %s\n", item->Name.ToCStr(), item->Value.ToCStr()); //profile->Settings.Set(item->Name, item->Value); profile->SetValue(item); item = vals->GetNextItem(item); } return profile; } else { profile->Release(); return NULL; } }
Status serializeDiffResults(const DiffResults& d, const ColumnNames& cols, JSON& doc, rj::Document& obj) { // Serialize and add "removed" first. // A property tree is somewhat ordered, this provides a loose contract to // the logger plugins and their aggregations, allowing them to parse chunked // lines. Note that the chunking is opaque to the database functions. auto removed_arr = doc.getArray(); auto status = serializeQueryData(d.removed, cols, doc, removed_arr); if (!status.ok()) { return status; } doc.add("removed", removed_arr, obj); auto added_arr = doc.getArray(); status = serializeQueryData(d.added, cols, doc, added_arr); if (!status.ok()) { return status; } doc.add("added", added_arr, obj); return Status(); }
JSON* JSON::GetItemByIndex(unsigned index) { unsigned i = 0; JSON* child = 0; if (!Children.IsEmpty()) { child = Children.GetFirst(); while (i < index) { if (Children.IsLast(child)) { child = 0; break; } child = child->GetNext(); i++; } } return child; }
void Settings::DeleteVar(const char* varName) { if(settingsJSON == NULL) return; // Undefine the variable for(int i = 0; i < variables.GetSizeI(); i++) { if(strcmp(variables[i]->name, varName) == 0) { IVariable* toDel = variables[i]; variables.RemoveAtUnordered(i); delete(toDel); break; } } JSON* valJSON = settingsJSON->GetItemByName(varName); if(valJSON) { valJSON->RemoveNode(); valJSON->Release(); rootSettingsJSON->Save(settingsFileName); } }
bool JSON::optJSONObject(int index, JSON& value, bool copy) const { JTRACE; cJSON *elem = getItem(index, true); if(0 != elem) { switch(elem->type) { case cJSON_Object: value.removeSelf(); value.m_node = elem; if(copy) value.m_root = elem; else value.addSelf(this); return true; default: if(copy) cJSON_Delete(elem); } } return false; }
JSON * JSON::parse_array(Lexer *lexer) { JSON *array = new_array(); unsigned int index = 0; if (lexer->end_of_array()) return array; // empty array for (;;) { JSON *item = parse_private(lexer); if (item) array->insert_array_item(index++, item); else { #ifdef DEBUG PRINTLN(F("missing array item")); #endif break; } Json_Token token = lexer->get_token(); if (token == Array_stop_token) return array; if (token != Comma_token) break; } #ifdef DEBUG PRINTLN(F("JSON syntax error in array")); #endif return null; }
inline void getLegacyFieldsAndDecorations(const JSON& doc, QueryLogItem& item) { if (doc.doc().HasMember("decorations")) { if (doc.doc()["decorations"].IsObject()) { for (const auto& i : doc.doc()["decorations"].GetObject()) { item.decorations[i.name.GetString()] = i.value.GetString(); } } } item.name = doc.doc()["name"].GetString(); item.identifier = doc.doc()["hostIdentifier"].GetString(); item.calendar_time = doc.doc()["calendarTime"].GetString(); item.time = doc.doc()["unixTime"].GetUint64(); }
std::pair<JSON, QueryData> getSerializedQueryDataWithColumnOrder() { auto r = getSerializedRow(true); QueryData q = {r.second, r.second}; JSON doc = JSON::newArray(); auto arr1 = doc.getArray(); doc.copyFrom(r.first.doc(), arr1); doc.push(arr1); auto arr2 = doc.getArray(); doc.copyFrom(r.first.doc(), arr2); doc.push(arr2); return std::make_pair(std::move(doc), q); }
void LogInfoReporter::CreateReportMsg(int iLogType, const char* szTypeName, const char* szLogContent, int64_t date, bool pd) { JSON* joMsg = JSON::CreateObject(); joMsg->AddNumberItem("date", date); joMsg->AddNumberItem("eid", iLogType); joMsg->AddStringItem("tname", szTypeName); joMsg->AddStringItem("content", szLogContent); joMsg->AddBoolItem("pd", pd); char *pJsonValue = joMsg->PrintValue(0, false); SetReportMsg(pJsonValue); MJ_FREE(pJsonValue); SetReportType(5); }
bool base_function::setJSON(const JSON& aJSON) { base_function backup(*this); bool result = true, found = false; if (aJSON.exists("title")) { found = true; this->setTitle(aJSON.get("title")); } if (aJSON.exists("description")) { found = true; this->setDescription(aJSON.get("description")); } //This executes the function if (aJSON.exists("parameters")) { found = true; //Make sens of params. It should be a JSON hash, from //string -> string, where key is the param name, and value is the //string representation of the value std::string params = aJSON.get("parameters"); JSON jparams(params); typedef std::vector<std::string>::const_iterator iter; std::vector<std::string> parameters; for (iter itr = mParameters.begin(); itr != mParameters.end(); ++itr) { if (jparams.exists(*itr)) { parameters.push_back(jparams.get(*itr)); } else { result = false; break; } } if (result) { //Call function mpManager->execute_function(this->getTitle(), parameters); } } if(!result) { *this = backup; } return result && found; }
void JSON::addItem(const string& key, const JSON& value) { JTRACE; if(0 == m_node) THROW_MSG(Exception, "JSON node NULL"); if(m_node->type != cJSON_Object) THROW_MSG(Exception, "expected JSON object"); if(0 == value.m_node) THROW_MSG(Exception, "child JSON node NULL"); if(!value.m_root) THROW_MSG(Exception, "child does not own JSON node"); cJSON_AddItemToObject(m_node, key.c_str(), value.m_node); value.m_self->m_root = 0; value.addSelf(this); }
void JSON::replaceItem(int index, const JSON& value) { JTRACE; if(0 == m_node) THROW_MSG(Exception, "JSON node NULL"); if(m_node->type != cJSON_Array) THROW_MSG(Exception, "expected JSON array"); if(0 == value.m_node) THROW_MSG(Exception, "child JSON node NULL"); if(!value.m_root) THROW_MSG(Exception, "child does not own JSON node"); cJSON_ReplaceItemInArray(m_node, index, value.m_node); value.m_self->m_root = 0; value.addSelf(this); }
/// "anims": { "#import" : { "file": "generics.json", "key": "animations", "replace": { "arg4" : "codefragment" } /// "anims": { "#import" : { "file": "generics.json", "key": "animations", "replace": { "arg4" : { "#import": } } /// "$moreanims": { "#import" : "generics.json" }, /// "anims": [ "anim1", "anim2", "anim3", "$moreanims"] bool JSON_ResolveImport(JSON *g) { JSON *j = g->getchild(IMPORTPHRASE); JSON *f = NULL; // the exporting file: "generics.json" JSON *newg = NULL; // the JSON which will replace the old section if(!j) return false; JSON *src = j->getchild("file"); JSON *key = j->getchild("key"); JSON *replace = j->getchild("replace"); if(!src) { return false; } const char *srcname = src->valuestring; f = loadjson(srcname); if(!f) { return false; } if(key) { newg = f->getchild(key->valuestring); } else newg = f; if(!newg){ return false; } JSON_ResolveReplacements(newg, replace); // Replace g with newg: if(g->name) copystring(newg->name, g->name, strlen(g->name)); // "anims" newg->parent = g->parent; newg->next = g->next; newg->prev = g->prev; // tell the others if(g->next) g->next->prev = newg; if(g->parent->firstchild == g) g->parent->firstchild = newg; else g->prev->next = newg; newg->original = g; return true; }
static JSON* FindTaggedData(JSON* data, const char** tag_names, const char** qtags, int num_qtags) { if (data == NULL || !(data->Name == "TaggedData") || data->Type != JSON_Array) return NULL; JSON* tagged_item = data->GetFirstItem(); while (tagged_item) { JSON* tags = tagged_item->GetItemByName("tags"); if (tags->Type == JSON_Array && num_qtags == tags->GetArraySize()) { // Check for a full tag match on each item int num_matches = 0; for (int k=0; k<num_qtags; k++) { JSON* tag = tags->GetFirstItem(); while (tag) { JSON* tagval = tag->GetFirstItem(); if (tagval && tagval->Name == tag_names[k]) { if (tagval->Value == qtags[k]) num_matches++; break; } tag = tags->GetNextItem(tag); } } // if all tags were matched then copy the values into this Profile if (num_matches == num_qtags) { JSON* vals = tagged_item->GetItemByName("vals"); return vals; } } tagged_item = data->GetNextItem(tagged_item); } return NULL; }
//----------------------------------------------------------------------------- void Profile::SetDoubleValues(const char* key, const double* vals, int num_vals) { JSON* value = NULL; int val_count = 0; if (ValMap.Get(key, &value)) { if (value->Type == JSON_Array) { // truncate the existing array if fewer entries provided int num_existing_vals = value->GetArraySize(); for (int i=num_vals; i<num_existing_vals; i++) value->RemoveLast(); JSON* item = value->GetFirstItem(); while (item && val_count < num_vals) { if (item->Type == JSON_Number) item->dValue = vals[val_count]; item = value->GetNextItem(item); val_count++; } } else { return; // Maybe we should change the data type? } } else { value = JSON::CreateArray(); value->Name = key; Values.PushBack(value); ValMap.Set(key, value); } for (; val_count < num_vals; val_count++) value->AddArrayNumber(vals[val_count]); }
Status serializeQueryLogItem(const QueryLogItem& item, JSON& doc) { if (item.results.added.size() > 0 || item.results.removed.size() > 0) { auto obj = doc.getObject(); auto status = serializeDiffResults(item.results, item.columns, doc, obj); if (!status.ok()) { return status; } doc.add("diffResults", obj); } else { auto arr = doc.getArray(); auto status = serializeQueryData(item.snapshot_results, item.columns, doc, arr); if (!status.ok()) { return status; } doc.add("snapshot", arr); doc.addRef("action", "snapshot"); } addLegacyFieldsAndDecorations(item, doc, doc.doc()); return Status(); }
/// Basic and really simplistic routine to fix malformatted .json files /// It will replace the old version of your file on success and create a backup of the old one (called <filename>_backup.json) /// Currently it fixes: double commata, missing " for non-numeric strings int JSON_Fix(const char *filename) { string s; copystring(s, filename); const char *found = findfile(path(s), ""); char *buf = loadfile(found, NULL); if(!buf) return -1; JSON_Minify(buf); size_t len = strlen(buf); char *newbuf = new char[len + 1]; size_t pos = 0; //current position in the newbuf for(size_t i = 0; i < len; i++) { if(buf[i] == ',') { if(!i) i++; //buf starts with a commata else if(buf[i + 1] == ',') i++; //two subsequent commata else { newbuf[pos] = buf[i]; pos++; } } else if(isalpha(buf[i])) { if(!i) //todo worst case: is it an array or object? return 0; else if(buf[i - 1] != '\"') { newbuf[pos] = '\"'; pos++; } //string was missing a leading " newbuf[pos] = buf[i]; pos++; } else { if(i && isalpha(i - 1)) { newbuf[pos] = '\"'; pos++; } //string was missing a trailing " newbuf[pos] = buf[i]; pos++; } } JSON *j = JSON_Parse(newbuf); if(j) { conoutf("%s was malformatted but has been fixed automatically. \nThe original file has been overwritten, but backuped", found); //cutextension .. getextension defformatstring(backupname, "%s_backup", found); if(!rename(found, backupname)) j->save(found); delete j; delete[] buf; delete[] newbuf; return 1; } delete[] buf; delete[] newbuf; return 0; }
SInt64 JSON::cmp_string(const JSON& a, const JSON& b) { return UTF16::comparef(a.as_string(), b.as_string()); }
SInt64 JSON::cmp_bool(const JSON& a, const JSON& b) { return (a.as_bool() ? 1 : 0) - (b.as_bool() ? 1 : 0); }
static void AddParameter(JSON &json, CGparameter param) { const char * const parameterName = cgGetParameterName(param); if (sVerbose) { puts(parameterName); } json.AddObject(parameterName); const CGtype type = cgGetParameterType(param); const CGtype baseType = cgGetParameterBaseType(param); int numRows = cgGetParameterRows(param); const int numColumns = cgGetParameterColumns(param); if (CG_ARRAY == type) { const int totalArraySize = cgGetArrayTotalSize(param); numRows *= totalArraySize; } json.AddString("type", cgGetTypeString(baseType)); if (1 < numRows) { json.AddValue("rows", numRows); } if (1 < numColumns) { json.AddValue("columns", numColumns); } const int maxNumElements = (numColumns * numRows); int n; if (CG_FLOAT == baseType) { float * const values = (float *)malloc(maxNumElements * sizeof(float)); const int numValues = cgGetParameterValuefr(param, maxNumElements, values); if (numValues) { for (n = 0; n < numValues; n++) { if (values[n] != 0.0f) { break; } } if (n < numValues) { json.AddArray("values", true); json.BeginData(true); for (n = 0; n < numValues; n++) { json.AddData(values[n]); } json.EndData(); json.CloseArray(true); } } free(values); } else if (CG_INT == baseType) { int * const values = (int *)malloc(maxNumElements * sizeof(int)); const int numValues = cgGetParameterValueir(param, maxNumElements, values); if (numValues) { for (n = 0; n < numValues; n++) { if (values[n]) { break; } } if (n < numValues) { json.AddArray("values", true); json.BeginData(true); for (n = 0; n < numValues; n++) { json.AddData(values[n]); } json.EndData(); json.CloseArray(true); } } free(values); } else if (CG_BOOL == baseType) { int * const values = (int *)malloc(maxNumElements * sizeof(int)); const int numValues = cgGetParameterValueir(param, maxNumElements, values); if (numValues) { for (n = 0; n < numValues; n++) { if (values[n]) { break; } } if (n < numValues) { json.AddArray("values", true); json.BeginData(true); for (n = 0; n < numValues; n++) { json.AddData(values[n]); } json.EndData(); json.CloseArray(true); } } free(values); } json.CloseObject(); // parameter }
static bool AddPass(CGtechnique technique, JSON &json, CGpass pass, UniformsMap &uniformRemapping) { bool success = true; json.AddObject(NULL); const char * const passName = cgGetPassName(pass); if (NULL != passName) { json.AddString("name", passName); } bool firstParameter = true; #if CG_VERSION_NUM >= 3000 const int CG_NUMBER_OF_DOMAINS = (CG_TESSELLATION_EVALUATION_DOMAIN + 1); #endif for (int domain = CG_FIRST_DOMAIN; domain < CG_NUMBER_OF_DOMAINS; domain++) { const CGprogram program = cgGetPassProgram(pass, (CGdomain)domain); if (NULL != program) { const char * const programString = cgGetProgramString(program, CG_COMPILED_PROGRAM); CGparameter param = cgGetFirstParameter(program, CG_GLOBAL); while (NULL != param) { if (cgIsParameterUsed(param, program) && CG_UNIFORM == cgGetParameterVariability(param)) { if (firstParameter) { firstParameter = false; json.AddArray("parameters", true); json.BeginData(true); } const char * const paramName = cgGetParameterName(param); AddMappedParameter(json, paramName, programString, uniformRemapping); } param = cgGetNextParameter(param); } param = cgGetFirstParameter(program, CG_PROGRAM); while (NULL != param) { if (cgIsParameterUsed(param, program) && CG_UNIFORM == cgGetParameterVariability(param)) { if (firstParameter) { firstParameter = false; json.AddArray("parameters", true); json.BeginData(true); } const char * const paramName = cgGetParameterName(param); AddMappedParameter(json, paramName, programString, uniformRemapping); } param = cgGetNextParameter(param); } } } if (!firstParameter) { json.EndData(); json.CloseArray(true); // parameters } json.AddArray("semantics", true); json.BeginData(true); CGprogram vertexProgram = cgGetPassProgram(pass, CG_VERTEX_DOMAIN); CGparameter vertexInputParameter = cgGetFirstLeafParameter(vertexProgram, CG_PROGRAM); while (NULL != vertexInputParameter) { const CGenum variability = cgGetParameterVariability(vertexInputParameter); if (CG_VARYING == variability) { const CGenum direction = cgGetParameterDirection(vertexInputParameter); if (CG_IN == direction || CG_INOUT == direction) { const char * const semantic = cgGetParameterSemantic(vertexInputParameter); json.AddData(semantic, strlen(semantic)); } } vertexInputParameter = cgGetNextLeafParameter(vertexInputParameter); } json.EndData(); json.CloseArray(true); // semantics json.AddObject("states"); CGstateassignment state = cgGetFirstStateAssignment(pass); if (NULL != state) { do { success &= AddState(json, state); state = cgGetNextStateAssignment(state); } while (NULL != state); } json.CloseObject(); // states json.AddArray("programs", true); json.BeginData(true); for (int domain = CG_FIRST_DOMAIN; domain < CG_NUMBER_OF_DOMAINS; domain++) { const CGprogram program = cgGetPassProgram(pass, (CGdomain)domain); if (NULL != program) { const char * const entryPoint = cgGetProgramString(program, CG_PROGRAM_ENTRY); json.AddData(entryPoint, strlen(entryPoint)); } else if (domain == CG_VERTEX_DOMAIN) { ErrorMessage("%s : No vertex program.", cgGetTechniqueName(technique)); success = false; } else if(domain == CG_FRAGMENT_DOMAIN) { ErrorMessage("%s : No fragment program.", cgGetTechniqueName(technique)); success = false; } } json.EndData(); json.CloseArray(true); // programs json.CloseObject(); // pass return success; }
static void AddMappedParameter(JSON &json, const char *paramName, const char *programString, UniformsMap &uniformRemapping) { const bool isAssembly = (0 == memcmp(programString, "!!ARB", 5)); const char * const vars = strstr(programString, (isAssembly ? "#var" : "//var")); if (NULL != vars) { const size_t paramNameLength = strlen(paramName); const char *var = vars; do { // to skip previous search var += 1; var = strstr(var, paramName); } while (NULL != var && ' ' != var[paramNameLength] && ':' != var[paramNameLength] && '[' != var[paramNameLength]); if (NULL != var) { const char * const semantic = strchr(var, ':'); if (NULL != semantic) { const char *mappedVariable = strchr((semantic + 1), ':'); if (NULL != mappedVariable) { do { mappedVariable++; } while (*mappedVariable <= ' '); const char *mappedVariableEnd = mappedVariable; while (' ' != *mappedVariableEnd && ':' != *mappedVariableEnd && '[' != *mappedVariableEnd && ',' != *mappedVariableEnd && 0 != *mappedVariableEnd) { mappedVariableEnd++; } const size_t mappedVariableLength = (size_t)(mappedVariableEnd - mappedVariable); if (isAssembly) { if (0 < mappedVariableLength) { // Append location to end of string std::string paramString(paramName, paramNameLength); paramString += ':'; // mappedVariable should have the format 'c[{location}]' or 'texunit {location}' const char *location = mappedVariableEnd; while (0 != *location && ('0' > *location || '9' < *location)) { location++; } if (0 != *location) { const char *locationEnd = location; do { locationEnd++; } while (0 != *locationEnd && '0' <= *locationEnd && '9' >= *locationEnd); if (0 != *locationEnd) { paramString.append(location, (size_t)(locationEnd - location)); json.AddData(paramString.c_str(), paramString.size()); } } } return; } const std::string mappedVariableString(mappedVariable, mappedVariableLength); const char * const mappedVariableName = mappedVariableString.c_str(); // Check that it is actually used const char * const main = strstr(mappedVariableEnd, "main()"); if (NULL != main) { const boost::xpressive::cregex re(boost::xpressive::_b >> mappedVariableString >> boost::xpressive::_b); if (!regex_search((main + 6), re)) { return; } } json.AddData(paramName, paramNameLength); const UniformsMap::const_iterator it = uniformRemapping.find(mappedVariableString); if (it == uniformRemapping.end()) { uniformRemapping[mappedVariableString] = paramName; } else if (it->second != paramName) { printf("\nUniform variable conflict '%s':\n\t%s\n\t%s\n", mappedVariableName, it->second.c_str(), paramName); exit(1); } } } } } }
static bool AddState(JSON &json, CGstateassignment sa) { const CGstate state = cgGetStateAssignmentState(sa); const char * const stateName = cgGetStateName(state); if (false == IsValidState(stateName)) { ErrorMessage("Invalid state for OpenGL ES 2.0 %s", stateName); return false; } const CGtype type = cgGetStateType(state); int nValues; switch (type) { case CG_PROGRAM_TYPE: return true; case CG_FLOAT: case CG_FLOAT1: { const float * const fvalues = cgGetFloatStateAssignmentValues(sa, &nValues); json.AddValue(stateName, fvalues[0]); } break; case CG_FLOAT2: case CG_FLOAT3: case CG_FLOAT4: { const float * const fvalues = cgGetFloatStateAssignmentValues(sa, &nValues); json.AddArray(stateName, true); json.BeginData(true); for (int n = 0; n < nValues; ++n) { json.AddData(fvalues[n]); } json.EndData(); json.CloseArray(true); } break; case CG_INT: case CG_INT1: { const int * const ivalues = cgGetIntStateAssignmentValues(sa, &nValues); json.AddValue(stateName, ivalues[0]); } break; case CG_INT2: case CG_INT3: case CG_INT4: { const int * const ivalues = cgGetIntStateAssignmentValues(sa, &nValues); json.AddArray(stateName, true); json.BeginData(true); for (int n = 0; n < nValues; ++n) { json.AddData(ivalues[n]); } json.EndData(); json.CloseArray(true); } break; case CG_BOOL: case CG_BOOL1: { const CGbool * const bvalues = cgGetBoolStateAssignmentValues(sa, &nValues); json.AddBoolean(stateName, (bvalues[0] ? true : false)); } break; case CG_BOOL2: case CG_BOOL3: case CG_BOOL4: { const CGbool * const bvalues = cgGetBoolStateAssignmentValues(sa, &nValues); json.AddArray(stateName, true); json.BeginData(true); for (int n = 0; n < nValues; ++n) { json.AddData(bvalues[n]); } json.EndData(); json.CloseArray(true); } break; case CG_STRING: json.AddString(stateName, cgGetStringStateAssignmentValue(sa)); break; default: ErrorMessage("UNEXPECTED State Assignment Type: %s 0x%x (%d)\n", cgGetTypeString(type), type, type); return false; } return true; }
void Proxy::register_observer(Symbol event, EventFunc handler) { JSON *node = JSON::new_function((GenericFn)handler); JSON *events = WebThings::get_json(this->events); events->insert_property(event, node); }
// set the response handler for the named action void Proxy::register_response_handler(Symbol action, ResponseFunc handler) { JSON *func = JSON::new_function((GenericFn)handler); JSON *actions = WebThings::get_json(this->actions); actions->insert_property(action, func); }
TEST(SEQUENCE_HEURISTIC, IS_VALID) { Heuristic * heuristic = Factory<Heuristic>::getInstance()->create("Sequence"); StringMap settings; settings["heuristics.Sequence.minimumChanges"] = "1"; settings["heuristics.Sequence.minimumDuration"] = "2"; settings["heuristics.Sequence.motionDelayTime"] = "1000"; settings["heuristics.Sequence.noMotionDelayTime"] = "1000"; heuristic->setup(settings); // ---------------------------- // Mocking image Image image; ImageVector images; JSON json; JSON::AllocatorType& allocator = json.GetAllocator(); json.SetObject(); json.AddMember("numberOfChanges", 0, allocator); // -------------------- // Nothing changed thus false. bool isValid = heuristic->isValid(image, images, json); EXPECT_EQ(false, isValid); // --------------------- // Changed, but this is only the first occurence thus again false. json.RemoveMember ("numberOfChanges"); json.AddMember("numberOfChanges", 1, allocator); isValid = heuristic->isValid(image, images, json); EXPECT_EQ(false, isValid); // --------------------- // Changed and the second occurence thus true. isValid = heuristic->isValid(image, images, json); EXPECT_EQ(true, isValid); }