void Callback(JSONNode & test, void * ide){ assertEquals(ide, (void*)0xDEADBEEF); ++counter; switch(counter){ case 1: assertEquals(test.type(), JSON_NODE); assertTrue(test.empty()); break; case 2: assertEquals(test.type(), JSON_ARRAY); assertTrue(test.empty()); break; case 3: assertEquals(test.type(), JSON_NODE); assertEquals(test.size(), 1); assertEquals(test[0].name(), JSON_TEXT("hello")); assertEquals(test[0].as_int(), 1); break; case 4: assertEquals(test.type(), JSON_ARRAY); assertEquals(test.size(), 3); break; case 5: assertEquals(test.type(), JSON_NODE); assertEquals(test.size(), 1); assertEquals(test[0].name(), JSON_TEXT("hi")); assertEquals(test[0].size(), 1) assertEquals(test[0][0].type(), JSON_NUMBER); assertEquals(test[0][0].name(), JSON_TEXT("one")); assertEquals(test[0][0].as_int(), 1); break; } }
void write_formatted(JSONNode n, const char *filename){ if(n.type()!=JSON_NULL){ std::string jc = n.write_formatted(); std::ofstream out(filename); out << jc; out.close(); } }
bool USB_device::processMessage(ClientConn& client, string& cmd, JSONNode& n){ if (cmd == "controlTransfer"){ unsigned id = jsonIntProp(n, "id", 0); uint8_t bmRequestType = jsonIntProp(n, "bmRequestType", 0xC0); uint8_t bRequest = jsonIntProp(n, "bRequest"); uint16_t wValue = jsonIntProp(n, "wValue", 0); uint16_t wIndex = jsonIntProp(n, "wIndex", 0); bool isIn = bmRequestType & 0x80; JSONNode reply(JSON_NODE); reply.push_back(JSONNode("_action", "return")); reply.push_back(JSONNode("id", id)); int ret = -1000; if (isIn){ uint16_t wLength = jsonIntProp(n, "wLength", 64); if (wLength > 64) wLength = 64; if (wLength < 0) wLength = 0; uint8_t data[wLength]; ret = controlTransfer(bmRequestType, bRequest, wValue, wIndex, data, wLength); if (ret >= 0){ JSONNode data_arr(JSON_ARRAY); for (int i=0; i<ret && i<wLength; i++){ data_arr.push_back(JSONNode("", data[i])); } data_arr.set_name("data"); reply.push_back(data_arr); } }else{ string datastr; JSONNode data = n.at("data"); if (data.type() == JSON_ARRAY){ for(JSONNode::iterator i=data.begin(); i!=data.end(); i++){ datastr.push_back(i->as_int()); } }else{ datastr = data.as_string(); } ret = controlTransfer(bmRequestType, bRequest, wValue, wIndex, (uint8_t *)datastr.data(), datastr.size()); } reply.push_back(JSONNode("status", ret)); client.sendJSON(reply); }else if(cmd == "enterBootloader"){ std::cout << "enterBootloader: "; int r = controlTransfer(0x40|0x80, 0xBB, 0, 0, NULL, 100); std::cout << "return " << r << std::endl; }else{ return false; } return true; }
HQLOperand::HQLOperand(const JSONNode &n, OPERAND_TYPE ot) { // ot == ID -> auto switch(n.type()){ case JSON_NULL: type = NIL; break; case JSON_STRING: { if(ot == ID){ type = ID; data.str = new string(n.as_string()); }else{ type = STRING; data.str = new string(string("\"") + n.as_string() + "\""); } break; } case JSON_NUMBER: { type = NUM; data.num = n.as_float(); break; } case JSON_BOOL: { type = BOOL; data.boolean = n.as_bool(); break; } case JSON_ARRAY: case JSON_NODE: { //TODO break; } default: type = NIL; } }
void xmm::Label::from_json(JSONNode root) { try { if (root.type() != JSON_NODE) throw JSONException("Wrong type: was expecting 'JSON_NODE'", root.name()); JSONNode::const_iterator root_it = root.begin(); if (root_it == root.end()) throw JSONException("JSON Node is incomplete", root_it->name()); if (root_it->name() != "type") throw JSONException("Wrong name: was expecting 'type'", root_it->name()); if (root_it->type() != JSON_STRING) throw JSONException("Wrong type: was expecting 'JSON_STRING'", root_it->name()); if (root_it->as_string() == "INT") type = INT; else type = SYM; ++root_it; if (root_it == root.end()) throw JSONException("JSON Node is incomplete", root_it->name()); if (root_it->name() != "value") throw JSONException("Wrong name: was expecting 'value'", root_it->name()); if (type == INT) { if (root_it->type() != JSON_NUMBER) throw JSONException("Wrong type: was expecting 'JSON_NUMBER'", root_it->name()); intLabel_ = static_cast<int>(root_it->as_int()); } else { if (root_it->type() != JSON_STRING) throw JSONException("Wrong type: was expecting 'JSON_STRING'", root_it->name()); symLabel_ = root_it->as_string(); } } catch (JSONException &e) { throw JSONException(e, root.name()); } catch (std::exception &e) { throw JSONException(e, root.name()); } }
void TestSuite::TestInspectors(void){ UnitTest::SetPrefix("TestInspectors.cpp - Inspectors"); 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 }
TEST_F(OffsetTableUnittest, TableToJSON) { Savepoint sp0, sp1; sp0.Init("FastWavesUnittest.Divergence-in"); sp0.AddMetainfo("LargeTimeStep", 1); sp0.AddMetainfo("RKStageNumber", 2); sp0.AddMetainfo("ldyn_bbc", false); sp1.Init("DycoreUnittest.DoStep-out"); sp1.AddMetainfo("LargeTimeStep", 2); sp1.AddMetainfo("hd", (Real).5); // Just for the sake of getting some valid checksums double somedata[] = { 1.1, 2.2, 3.3, 4.4 }; // Fill table OffsetTable table; ASSERT_NO_THROW(table.AddNewSavepoint(sp0, 0)); ASSERT_NO_THROW(table.AddNewSavepoint(sp1, 1)); ASSERT_NO_THROW(table.AddFieldRecord(sp0, "Field1", 0, computeChecksum(somedata, 4))); ASSERT_NO_THROW(table.AddFieldRecord( 0, "Field2", 0, computeChecksum(somedata, 8))); ASSERT_NO_THROW(table.AddFieldRecord( 1, "Field1", 100, computeChecksum(somedata, 12))); ASSERT_NO_THROW(table.AddFieldRecord(sp1, "Field2", 100, computeChecksum(somedata, 16))); //Generate table JSON JSONNode tableNode = table.TableToJSON(); ASSERT_EQ(JSON_ARRAY, tableNode.type()); ASSERT_EQ(2, tableNode.size()); // Check first savepoint ASSERT_EQ(std::string("FastWavesUnittest.Divergence-in"), tableNode[0]["__name"].as_string()); ASSERT_EQ(0, tableNode[0]["__id"].as_int()); ASSERT_EQ(1, tableNode[0]["LargeTimeStep"].as_int()); ASSERT_EQ(2, tableNode[0]["RKStageNumber"].as_int()); ASSERT_FALSE(tableNode[0]["ldyn_bbc"].as_bool()); ASSERT_EQ((int)JSON_ARRAY, (int)tableNode[0]["__offsets"][0].type()); ASSERT_EQ(std::string("Field1"), tableNode[0]["__offsets"][0].name()); ASSERT_EQ(0, tableNode[0]["__offsets"][0][0].as_int()); ASSERT_EQ(computeChecksum(somedata, 4), tableNode[0]["__offsets"][0][1].as_string()); ASSERT_EQ(0, tableNode[0]["__offsets"][1][0].as_int()); ASSERT_EQ(computeChecksum(somedata, 8), tableNode[0]["__offsets"][1][1].as_string()); // Check second savepoint ASSERT_EQ(std::string("DycoreUnittest.DoStep-out"), tableNode[1]["__name"].as_string()); ASSERT_EQ(1, tableNode[1]["__id"].as_int()); ASSERT_EQ(2, tableNode[1]["LargeTimeStep"].as_int()); ASSERT_EQ(0.5, tableNode[1]["hd"].as_float()); ASSERT_EQ((int)JSON_ARRAY, (int)tableNode[1]["__offsets"][0].type()); ASSERT_EQ(std::string("Field1"), tableNode[1]["__offsets"][0].name()); ASSERT_EQ(100, tableNode[1]["__offsets"][0][0].as_int()); ASSERT_EQ(computeChecksum(somedata, 12), tableNode[1]["__offsets"][0][1].as_string()); ASSERT_EQ(100, tableNode[1]["__offsets"][1][0].as_int()); ASSERT_EQ(computeChecksum(somedata, 16), tableNode[1]["__offsets"][1][1].as_string()); // Interpret JSON for table OffsetTable table2; table2.TableFromJSON(tableNode); // Check savepoints std::vector<Savepoint> const & sp = GetSavepoints(table2); ASSERT_EQ(2, sp.size()); ASSERT_EQ(sp0, sp[0]); ASSERT_EQ(sp1, sp[1]); ASSERT_EQ(0, table2.GetSavepointID(sp[0])); ASSERT_EQ(1, table2.GetSavepointID(sp[1])); // Check methods ASSERT_EQ( 0, table2.GetOffset(sp0, "Field1")); ASSERT_EQ( 0, table2.GetOffset(sp0, "Field2")); ASSERT_EQ(100, table2.GetOffset(sp1, "Field1")); ASSERT_EQ(100, table2.GetOffset(sp1, "Field2")); ASSERT_EQ( 0, table2.AlreadySerialized("Field1", computeChecksum(somedata, 4))); ASSERT_EQ(100, table2.AlreadySerialized("Field1", computeChecksum(somedata, 12))); ASSERT_EQ( 0, table2.AlreadySerialized("Field2", computeChecksum(somedata, 8))); ASSERT_EQ(100, table2.AlreadySerialized("Field2", computeChecksum(somedata, 16))); ASSERT_EQ( -1, table2.AlreadySerialized("Field1", computeChecksum(somedata, 8))); ASSERT_EQ( -1, table2.AlreadySerialized("Field2", computeChecksum(somedata, 4))); }
TEST_F(FieldsTableUnittest, Serilalize) { // Filling some info DataFieldInfo info1, info2; info1.Init( "Field1", "double", 8, 3, 38, 24, 60, 1, 3, 3, 3, 3, 0, 0, 0, 0); info1.AddMetainfo("ADV", true); info2.Init( "Field2", "double", 8, 3, 38, 24, 61, 1, 3, 3, 3, 3, 0, 1, 0, 0); info2.AddMetainfo("Init", 7.4); // Registering fields into table table.RegisterField(info1); table.RegisterField(info2); // Checking table ASSERT_EQ(2, getTableSize()); ASSERT_TRUE(table.HasField("Field1")); ASSERT_TRUE(table.HasField("Field2")); ASSERT_FALSE(table.HasField("Field3")); ASSERT_TRUE(info1 == table.Find("Field1")); ASSERT_TRUE(info2 == table.Find("Field2")); JSONNode node = table.TableToJSON(); ASSERT_EQ(node.name(), "FieldsTable"); ASSERT_EQ(node.type(), JSON_ARRAY); ASSERT_EQ(node.size(), 2); // Check first field info ASSERT_EQ(node[0].name(), "DataFieldInfo"); ASSERT_EQ(node[0]["__name"].as_string(), "Field1"); ASSERT_EQ(node[0]["__id"].as_int(), 0); ASSERT_EQ(node[0]["__isize"].as_int(), 38); ASSERT_EQ(node[0]["__jsize"].as_int(), 24); ASSERT_EQ(node[0]["__ksize"].as_int(), 60); ASSERT_EQ(node[0]["__iminushalosize"].as_int(), 3); ASSERT_EQ(node[0]["__iplushalosize"].as_int(), 3); ASSERT_EQ(node[0]["__jminushalosize"].as_int(), 3); ASSERT_EQ(node[0]["__jplushalosize"].as_int(), 3); ASSERT_EQ(node[0]["__kminushalosize"].as_int(), 0); ASSERT_EQ(node[0]["__kplushalosize"].as_int(), 0); ASSERT_EQ(node[0]["ADV"].as_bool(), true); // Check second field info ASSERT_EQ(node[1].name(), "DataFieldInfo"); ASSERT_EQ(node[1]["__name"].as_string(), "Field2"); ASSERT_EQ(node[1]["__id"].as_int(), 1); ASSERT_EQ(node[1]["__isize"].as_int(), 38); ASSERT_EQ(node[1]["__jsize"].as_int(), 24); ASSERT_EQ(node[1]["__ksize"].as_int(), 61); ASSERT_EQ(node[1]["__iminushalosize"].as_int(), 3); ASSERT_EQ(node[1]["__iplushalosize"].as_int(), 3); ASSERT_EQ(node[1]["__jminushalosize"].as_int(), 3); ASSERT_EQ(node[1]["__jplushalosize"].as_int(), 3); ASSERT_EQ(node[1]["__kminushalosize"].as_int(), 0); ASSERT_EQ(node[1]["__kplushalosize"].as_int(), 1); ASSERT_EQ(node[1]["Init"].as_float(), 7.4); }
void xmm::TrainingSet::from_json(JSONNode root) { if (!owns_data) throw std::runtime_error("Cannot read Training Set with Shared memory"); try { if (root.type() != JSON_NODE) throw JSONException("Wrong type: was expecting 'JSON_NODE'", root.name()); JSONNode::const_iterator root_it = root.begin(); // Get Number of modalities root_it = root.find("bimodal"); if (root_it == root.end()) throw JSONException("JSON Node is incomplete", root_it->name()); if (root_it->type() != JSON_BOOL) throw JSONException("Wrong type for node 'bimodal': was expecting 'JSON_BOOL'", root_it->name()); if(bimodal_ != root_it->as_bool()) { if (bimodal_) throw JSONException("Trying to read an unimodal model in a bimodal model.", root.name()); else throw JSONException("Trying to read a bimodal model in an unimodal model.", root.name()); } // Get Dimension root_it = root.find("dimension"); if (root_it == root.end()) throw JSONException("JSON Node is incomplete", root_it->name()); if (root_it->type() != JSON_NUMBER) throw JSONException("Wrong type for node 'dimension': was expecting 'JSON_NUMBER'", root_it->name()); dimension_ = static_cast<unsigned int>(root_it->as_int()); // Get Input Dimension if bimodal_ if (bimodal_){ root_it = root.find("dimension_input"); if (root_it == root.end()) throw JSONException("JSON Node is incomplete", root_it->name()); if (root_it->type() != JSON_NUMBER) throw JSONException("Wrong type for node 'dimension_input': was expecting 'JSON_NUMBER'", root_it->name()); dimension_input_ = static_cast<unsigned int>(root_it->as_int()); } // Get Column Names column_names_.assign(dimension_, ""); root_it = root.find("column_names"); if (root_it != root.end()) { if (root_it->type() != JSON_ARRAY) throw JSONException("Wrong type for node 'column_names': was expecting 'JSON_ARRAY'", root_it->name()); json2vector(*root_it, column_names_, dimension_); } // Get Size: Number of Phrases root_it = root.find("size"); if (root_it == root.end()) throw JSONException("JSON Node is incomplete", root_it->name()); if (root_it->type() != JSON_NUMBER) throw JSONException("Wrong type for node 'size': was expecting 'JSON_NUMBER'", root_it->name()); unsigned int ts_size = static_cast<unsigned int>(root_it->as_int()); // Get Default label root_it = root.find("defaultlabel"); if (root_it == root.end()) throw JSONException("JSON Node is incomplete", root_it->name()); if (root_it->type() != JSON_NODE) throw JSONException("Wrong type for node 'defaultlabel': was expecting 'JSON_NODE'", root_it->name()); defaultLabel_.from_json(*root_it); // Get Phrases phrases.clear(); phraseLabels.clear(); root_it = root.find("phrases"); if (root_it == root.end()) throw JSONException("JSON Node is incomplete", root_it->name()); if (root_it->type() != JSON_ARRAY) throw JSONException("Wrong type for node 'phrases': was expecting 'JSON_ARRAY'", root_it->name()); for (unsigned int i=0 ; i<ts_size ; i++) { JSONNode::const_iterator array_it = (*root_it)[i].end(); // Get Index array_it = (*root_it)[i].find("index"); if (array_it == (*root_it)[i].end()) throw JSONException("JSON Node is incomplete", array_it->name()); if (array_it->type() != JSON_NUMBER) throw JSONException("Wrong type for node 'index': was expecting 'JSON_NUMBER'", array_it->name()); unsigned int phraseIndex = static_cast<unsigned int>(array_it->as_int()); // Get Label array_it = (*root_it)[i].find("label"); if (array_it == (*root_it)[i].end()) throw JSONException("JSON Node is incomplete", array_it->name()); if (array_it->type() != JSON_NODE) throw JSONException("Wrong type for node 'label': was expecting 'JSON_NODE'", array_it->name()); phraseLabels[phraseIndex].from_json(*array_it); updateLabelList(); // Get Phrase Content array_it = (*root_it)[i].find("Phrase"); if (array_it == (*root_it)[i].end()) throw JSONException("JSON Node is incomplete", array_it->name()); if (array_it->type() != JSON_NODE) throw JSONException("Wrong type for node 'Phrase': was expecting 'JSON_NODE'", array_it->name()); phrases[phraseIndex] = new Phrase(flags_, dimension_, dimension_input_); phrases[phraseIndex]->from_json(*array_it); } if (ts_size != phrases.size()) throw JSONException("Number of phrases does not match", root_it->name()); has_changed_ = true; } catch (JSONException &e) { throw JSONException(e, root.name()); } catch (std::exception &e) { throw JSONException(e, root.name()); } }
bool HQLOperand::predicate(const HQLOperand &o, const JSONNode &n) { if(type != COOP){ return false; } switch(data.coop){ case COND_OPER::EQ: return CompareHQLOperandAndJSONNode<COND_OPER::EQ>(o, n); break; case COND_OPER::GT: return CompareHQLOperandAndJSONNode<COND_OPER::GT>(o, n); break; case COND_OPER::LT: return CompareHQLOperandAndJSONNode<COND_OPER::LT>(o, n); break; case COND_OPER::GE: return CompareHQLOperandAndJSONNode<COND_OPER::GE>(o, n); break; case COND_OPER::LE: return CompareHQLOperandAndJSONNode<COND_OPER::LE>(o, n); break; case COND_OPER::IN: { if(o.get_type()==NUM_ARRAY){ if(n.type()==JSON_NUMBER){ string ns=num2str(n.as_int()); vector<string>::const_iterator it=o.as_str_array()->begin(); for(;it!=o.as_str_array()->end();it++){ if(ns==*it)return true; } return false; } return false; }else if(o.get_type()==STR_ARRAY){ if(n.type()==JSON_STRING){ string ns=n.as_string(); vector<string>::const_iterator it=o.as_str_array()->begin(); for(;it!=o.as_str_array()->end();it++){ if(ns==*it)return true; } return false; } return false; } return false; break; } case COND_OPER::CONTAINS: { string val = o.as_str_array()->at(0); string sep = o.as_str_array()->at(1); string ns=n.as_string(); string unit; string::size_type start = 0, end = 0; while(end!=string::npos){ end = ns.find_first_of(sep, start); if(end==string::npos){ unit = ns.substr(start); }else{ unit = ns.substr(start, end-start); } start = end + 1; if(val == "\"" + unit + "\""){ return true; } } return false; break; } case COND_OPER::TIME_IN: { if(n.type()!=JSON_NUMBER) return false; if(o.get_type()!=NUM) return false; time_t now = time(NULL); return now-o.as_num() <= n.as_float(); break; } default: return false; } return false; }
const map<uint64_t, set<string> > SLFKCondNode::match(const Model &m, ModelGetter *getter) { map<uint64_t, set<string> > ret; if(m.attr<bool>("deleted")) return ret; //uint64_t fn = m.fullname(); uint64_t gn = m.attr<uint64_t>(*operands[1].as_str()); string type = m.type(); string attr = *operands[3].as_str(); JSONNode v = m.attr<JSONNode>(attr); if(v.type()==JSON_NODE && v.size()<=0){ return ret; } if(!TypeConfig::is_subtype(type, *operands[0].as_str())){ // this will not happens return ret; } if(TypeConfig::type_id(*operands[0].as_str())==0){ gn = FULLNAME_SET_CAT(gn); } if(this->has_semantic_each()){ switch(operands[4].as_coop_type()){ case COND_OPER::EQ: { HQLOperand o = HQLOperand(v); SLFKCondNode n = SLFKCondNode(type, *operands[1].as_str(), etype, attr, operands[4], o); ret[gn].insert(n.cache_key()); break; } case COND_OPER::CONTAINS: { string sep = operands[5].as_str_array()->at(1); string val = v.as_string(); string unit; string::size_type start = 0, end = 0; while(end!=string::npos){ end = val.find_first_of(sep, start); if(end==string::npos){ unit = val.substr(start); }else{ unit = val.substr(start, end-start); } start = end + 1; if(unit.size()<1) continue; vector<string> *arg = new vector<string>;//({unit, sep}); arg->push_back("\"" + unit + "\""); arg->push_back(sep); HQLOperand o = HQLOperand(arg, HQLOperand::CONTAINS_ARG); SLFKCondNode n = SLFKCondNode(type, *operands[1].as_str(), etype, attr, operands[4], o); ret[gn].insert(n.cache_key()); } break; } default: { //this will not happens return ret; } } }else{ if(operands[4].predicate(operands[5], v)){ ret[gn].insert(this->cache_key()); } } return ret; }