JSONNODE* json_wlparam_format(wlp_descr_t* wlp) { JSONNODE* wlp_node = json_new(JSON_NODE); json_set_name(wlp_node, wlp->name); switch(wlp->type) { case WLP_BOOL: json_push_back(wlp_node, json_new_a("type", "bool")); if(wlp->defval.enabled) json_push_back(wlp_node, json_new_b("default", wlp->defval.b)); break; case WLP_INTEGER: json_push_back(wlp_node, json_new_a("type", "integer")); if(wlp->range.range) { json_push_back(wlp_node, json_new_i("min", wlp->range.i_min)); json_push_back(wlp_node, json_new_i("max", wlp->range.i_max)); } if(wlp->defval.enabled) json_push_back(wlp_node, json_new_i("default", wlp->defval.i)); break; case WLP_FLOAT: json_push_back(wlp_node, json_new_a("type", "float")); if(wlp->range.range) { json_push_back(wlp_node, json_new_f("min", wlp->range.d_min)); json_push_back(wlp_node, json_new_f("max", wlp->range.d_max)); } if(wlp->defval.enabled) json_push_back(wlp_node, json_new_f("default", wlp->defval.f)); break; case WLP_SIZE: json_push_back(wlp_node, json_new_a("type", "size")); if(wlp->range.range) { json_push_back(wlp_node, json_new_i("min", wlp->range.sz_min)); json_push_back(wlp_node, json_new_i("max", wlp->range.sz_max)); } if(wlp->defval.enabled) json_push_back(wlp_node, json_new_i("default", wlp->defval.sz)); break; case WLP_RAW_STRING: json_push_back(wlp_node, json_new_a("type", "string")); json_push_back(wlp_node, json_new_i("len", wlp->range.str_length)); if(wlp->defval.enabled) json_push_back(wlp_node, json_new_a("default", wlp->defval.s)); break; case WLP_STRING_SET: json_push_back(wlp_node, json_new_a("type", "strset")); json_push_back(wlp_node, json_wlparam_strset_format(wlp)); if(wlp->defval.enabled) json_push_back(wlp_node, json_new_i("default", wlp->defval.ssi)); break; } json_push_back(wlp_node, json_new_i("flags", wlp->flags)); json_push_back(wlp_node, json_new_a("description", wlp->description)); return wlp_node; }
void JSON_Append_real_array(sLONG_PTR *pResult, PackagePtr pParams) { C_TEXT json; C_TEXT node; ARRAY_REAL values; C_TEXT returnValue; json.fromParamAtIndex(pParams, 1); node.fromParamAtIndex(pParams, 2); values.fromParamAtIndex(pParams, 3); JSONNODE *n = _fromHex(json); if(n){ std::wstring nodeName; _copyString(node, nodeName); JSONNODE *_node = json_new(JSON_ARRAY); json_set_name(_node, nodeName.c_str()); for (unsigned int i = 1; i < values.getSize(); ++i) { json_push_back(_node, json_new_f(L"", values.getDoubleValueAtIndex(i))); } json_push_back(n, _node); _toHex(_node, returnValue); } returnValue.setReturn(pResult); }
/** * Gets the current CPM reading as * { "cpm": { * "value": val, // Actual value * "valid": boolean, // Valid flag * "raw": val, // Uncompensated value * "cpm30": val // 30 second window * } * } * * See Geiger.cpp for a more in-depth explanation of * raw and compensated CPM values. */ void cmd_cpm(char *line) { JSONNODE *n = json_new(JSON_NODE); JSONNODE *reading = json_new(JSON_NODE); json_set_name(reading, "cpm"); json_push_back(reading, json_new_f("value", system_geiger->get_cpm_deadtime_compensated())); json_push_back(reading, json_new_b("valid", system_geiger->is_cpm_valid())); json_push_back(reading, json_new_f("raw", system_geiger->get_cpm())); json_push_back(reading, json_new_f("cpm30", system_geiger->get_cpm30())); json_push_back(n, reading); json_char *jc = json_write_formatted(n); serial_write_string(jc); json_free(jc); json_delete(n); }
void Json::SetValue(JSONNODE* node, const string& key, const vector<float>& array) { if(node == NULL) node = mpRootNode; JSONNODE* c = json_new(JSON_ARRAY); json_set_name(c, key.c_str()); for(size_t i = 0; i < array.size(); i++) { json_push_back(c, json_new_f(NULL, array[i])); } json_push_back(node, c); }
void JSON_Append_real(sLONG_PTR *pResult, PackagePtr pParams) { C_TEXT json; C_TEXT node; C_REAL value; C_TEXT returnValue; json.fromParamAtIndex(pParams, 1); node.fromParamAtIndex(pParams, 2); value.fromParamAtIndex(pParams, 3); JSONNODE *n = _fromHex(json); if(n){ std::wstring nodeName; _copyString(node, nodeName); JSONNODE *_node = json_new_f(nodeName.c_str(), value.getDoubleValue()); json_push_back(n, _node); _toHex(_node, returnValue); } returnValue.setReturn(pResult); }
void Json::SetValue(JSONNODE* node, const string& key, float value) { if(node == NULL) node = mpRootNode; json_push_back(node, json_new_f(key.c_str(), value)); }
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 }
bool admJson::addFloat(const char *key,const float value) { json_push_back(COOKIE, json_new_f(key,value)); return true; }
bool admJson::addDouble(const char *key,const double value) { json_push_back(COOKIE, json_new_f(key,value)); return true; }