int main() { int numbers[10] = {1,2,3,4,5,6,7,8,9,0}; Set<int> a; Set<int> b(a); Set<int> c(numbers, 10); b = a; assert(b==a); a = b & c; assert(a.empty()); a = b & 3; assert(a.empty()); a = 3 & b; assert(a.empty()); b &= a; assert(b.empty()); b &= 3; assert(b.empty()); b = a | c; assert(b == c); b = a | 3; assert(b.size() == 1); b = 3 | a; assert(b.size() == 1); a |= b; assert(a.size() == 1); a |= 3; assert(a.size() == 1 && a.contains(3)); assert(!(a != b)); assert(a< c); assert(3 < c); c > a; c > 3; a <= c; c >= a; a.contains(3); a.empty(); a.size(); a.insert(99); cout << a << endl << c; a.remove(99); }
bool Store::retrieveValue(const BinaryString &key, Set<BinaryString> &values) { // Note: values is not cleared ! const Identifier localNode = Network::Instance->overlay()->localNode(); Database::Statement statement = mDatabase->prepare("SELECT value FROM map WHERE key = ?1"); statement.bind(1, key); while(statement.step()) { BinaryString v; statement.value(0, v); values.insert(v); } statement.finalize(); if(!values.contains(localNode)) { // Also look for digest in blocks in case map is not up-to-date statement = mDatabase->prepare("SELECT 1 FROM blocks WHERE digest = ?1 LIMIT 1"); statement.bind(1, key); if(statement.step()) values.insert(localNode); statement.finalize(); } return !values.empty(); }
void testBookSet () { Currency const c1 (1); Account const i1 (1); Currency const c2 (2); Account const i2 (2); IssueRef const a1 (c1, i1); IssueRef const a2 (c2, i2); BookRef const b1 (a1, a2); BookRef const b2 (a2, a1); { Set c; c.insert (b1); if (! expect (c.size () == 1)) return; c.insert (b2); if (! expect (c.size () == 2)) return; if (! expect (c.erase (Book (a1, a1)) == 0)) return; if (! expect (c.erase (Book (a1, a2)) == 1)) return; if (! expect (c.erase (Book (a2, a1)) == 1)) return; if (! expect (c.empty ())) return; } { Set c; c.insert (b1); if (! expect (c.size () == 1)) return; c.insert (b2); if (! expect (c.size () == 2)) return; if (! expect (c.erase (BookRef (a1, a1)) == 0)) return; if (! expect (c.erase (BookRef (a1, a2)) == 1)) return; if (! expect (c.erase (BookRef (a2, a1)) == 1)) return; if (! expect (c.empty ())) return; #if STL_SET_HAS_EMPLACE c.emplace (a1, a2); if (! expect (c.size() == 1)) return; c.emplace (a2, a1); if (! expect (c.size() == 2)) return; #endif } }
/** * Make a range de-allocated. */ void unsetAllocated(size_t off) { SetIterator it = set_.lower_bound({off, 0}); assert(it != set_.end()); assert(it->first == off); size_t size = it->second; set_.erase(it); allocated_ -= size; if (set_.empty()) { maxItemSize_ = 0; } }
bool Store::getBlockHints(const BinaryString &digest, Set<BinaryString> &result) { retrieveValue(Store::Hash(digest), result); if(result.empty()) return false; // Add hints of order 2 Set<BinaryString> tmp; for(const BinaryString &value : result) retrieveValue(Store::Hash(value), tmp); result.insertAll(tmp); return true; }
//Beware - FindSolution works only for 4x4 game!!! void Fifteen::FindSolution() { CopyTGameArray(GameArray, GameStartArray); points = 0; Set* nothing; Set* closedSet = new Set(); Set* openSet = new Set(); Set* best = NULL; openSet->add(openSet, 0, GameArray, openSet, nothing); while (!openSet->empty()) { openSet->best(openSet, best); closedSet->add(closedSet, best->G, best->move, best->prev, best); openSet->remove(openSet, best->move); CopyTGameArray(GameArray, best->move); if(best->H < 1) { SetSolution(best); ShowSolution(); closedSet->DeleteAll(closedSet); openSet->DeleteAll(openSet); return; } int zeroX; int zeroY; FindZero(zeroX, zeroY, best->move); for (int i = 0; i < 4; i++) { int dx = (-1) * ((zeroX > 0) && (i == 0)) + ((zeroX < SIZE - 1) && (i == 1)); int dy = (-1) * ((zeroY > 0) && (i == 2)) + ((zeroY < SIZE - 1) && (i == 3)); TGameArray newArray; CopyTGameArray(newArray, best->move); newArray[zeroX][zeroY] = best->move[zeroX+dx][zeroY+dy]; newArray[zeroX+dx][zeroY+dy] = 0; if(!closedSet->isAlready(closedSet, newArray)) { openSet->add(openSet, best->G + 1, newArray, best, nothing); } } } }
void index_set::look_for_cse_mismatch() { collect_type2_common_subexpressions(); Set tmp; set_difference( type2_cse.begin(), type2_cse.end(), marked_cse.begin(), marked_cse.end(), inserter(tmp, tmp.begin()) ); if (!tmp.empty()) { ostringstream os; os << "Indices not marked as CSE: "; copy(tmp.begin(), tmp.end(), ostream_iterator<int>(os, "\t")); ASSERT2(false, os.str()); } }
Provenance::Set* Provenance::descendants(const Set& roots) { Set open = roots; Set* closed = new Set(); while (!open.empty()) { const Provenance* n = *(open.begin()); const Set& c = n->children(); for (const Provenance* s : c) { // If s isn't in closed set, put it in open if (closed->find(s) == closed->end()) open.insert(s); } open.erase(n); closed->insert(n); } return closed; }
int main(void) { Set<int> a = { 1, 2, 3 }; Set<int> b = { 2, 4, 6 }; print("a: %v", &a); print("b: %v", &b); print("a ismember 3: %s", a.ismember(3) ? "OK" : "FAIL"); Set<int> c; c = a | b; print("union: %v", &c); c = a & b; print("intersection: %v", &c); c = a - b; print("difference: %v", &c); c = a ^ b; print("symmetric difference: %v", &c); c = { 1, 2, 3 }; print("eq: %s", (a == c) ? "OK" : "FAIL"); c |= b; print("lt: %s", (a < c) ? "OK" : "FAIL"); print("le: %s", (a <= c) ? "OK" : "FAIL"); c = { 4, 5, 6 }; print("disjoint: %s", a.isdisjoint(c) ? "OK" : "FAIL"); a.remove(2); print("a.remove(2): %v", &a); while(len(b) > 0) { print("b.pop(): %d", b.pop()); } del(a); print("del(a): %v len: %zu", &a, len(a)); print("a.empty(): %s", a.empty() ? "OK" : "FAIL"); print("operator!(): %s", (!a) ? "OK" : "FAIL"); return 0; }
void index_set::push_back_current() { Set* tmp = new Set; for (Map::const_iterator i=current.begin(); i!=current.end(); ++i) { const int index = i->first; const int count = i->second; tmp->insert(index); push_back_type3_cse(index, count); } ASSERT(!tmp->empty()); constraint_index_sets.push_back(tmp); current.clear(); }
Provenance::Set* Provenance::ancestors(const Set& roots) { Set open = roots; Set* closed = new Set(); while (!open.empty()) { const Provenance* n = *(open.begin()); std::pair<CommandChronicle::ParentVector::const_iterator, CommandChronicle::ParentVector::const_iterator> pr = n->parents(); for (CommandChronicle::ParentVector::const_iterator it = pr.first; it != pr.second; ++it) { const Provenance* prov = *it; if (closed->count(prov) == 0) open.insert(prov); } open.erase(n); closed->insert(n); } return closed; }
void test() { Set<int> si; Set<string> ss; assert(si.empty()); assert(ss.size() == 0); assert(si.insert(10)); assert(ss.insert("hello")); assert(si.contains(10)); assert(si.erase(10)); string s; assert(ss.get(0, s) && s == "hello"); Set<string> ss2(ss); ss.swap(ss2); ss = ss2; unite(si,si,si); unite(ss,ss2,ss); subtract(si,si,si); subtract(ss,ss2,ss); cout << "Passed all tests" << endl; }
void Action::ValueDescSkeletonLink::prepare() { if (value_desc_list.empty()) throw Error(Error::TYPE_NOTREADY); clear(); // get bone ValueNode_Bone::Handle bone_value_node; if (value_desc.parent_is_value_node()) bone_value_node = ValueNode_Bone::Handle::cast_dynamic(value_desc.get_parent_value_node()); if (!bone_value_node) throw Error(Error::TYPE_NOTREADY); // get static list of bones (skeleton layer) const ValueDesc &parent = value_desc.get_parent_desc(); ValueNode_StaticList::Handle bone_list_value_node; if (parent.parent_is_value_node()) bone_list_value_node = ValueNode_StaticList::Handle::cast_dynamic(parent.get_parent_value_node()); if (!bone_list_value_node) throw Error(Error::TYPE_NOTREADY); // bones list typedef std::set<ValueNode_Bone::Handle> Set; ValueBase::List value_bone_list = (*bone_list_value_node)(time).get_list(); Set list; for(int i = 0; i < bone_list_value_node->link_count(); ++i) { ValueNode_Bone::Handle bone_value_node = ValueNode_Bone::Handle::cast_dynamic(bone_list_value_node->get_link(i)); if (bone_value_node) list.insert(bone_value_node); } if (list.empty()) throw Error(Error::TYPE_NOTREADY); // process all selected ducks Set current_list; for(std::list<ValueDesc>::iterator iter = value_desc_list.begin(); iter != value_desc_list.end(); ++iter) { ValueDesc& value_desc(*iter); // skip region/outline origin if (value_desc.parent_is_layer() && value_desc.get_param_name() == "origin" && (value_desc.get_layer()->get_name() == "advanced_outline" || value_desc.get_layer()->get_name() == "outline" || value_desc.get_layer()->get_name() == "region")) continue; // check type Type &type(value_desc.get_value_type()); if (!ValueNode_BoneLink::check_type(type) || !ValueNode_WeightedAverage::check_type(type) || !ValueVector::check_type(type) ) continue; // don't link bones to bones if (value_desc.parent_is_value_node() && ValueNode_Bone::Handle::cast_dynamic(value_desc.get_parent_value_node()) ) continue; // List of bones influencing current item current_list.clear(); for(Set::iterator i = list.begin(); i != list.end(); ++i) if ((*i)->have_influence_on(time, ValueVector::get_vector(value_desc.get_value(time)))) current_list.insert(*i); if (current_list.empty()) continue; ValueNode::Handle node; if (current_list.size() > 1) { // make average node ValueNode_WeightedAverage::Handle average_node = new ValueNode_WeightedAverage(type, get_canvas()); // get type of weighted value types_namespace::TypeWeightedValueBase *wt = ValueAverage::get_weighted_type_for(type); assert(wt != NULL); // add each bone from influence_list to Average convert for(Set::iterator i = current_list.begin(); i != current_list.end(); ++i) { // make bone link ValueNode_BoneLink::Handle bone_link_node = ValueNode_BoneLink::create(value_desc.get_value(time)); bone_link_node->set_link("bone", ValueNode_Const::create(ValueBase(*i), get_canvas())); bone_link_node->set_link("base_value", ValueNode_Composite::create( ValueTransformation::back_transform( bone_link_node->get_bone_transformation(time), value_desc.get_value(time) ))); // make weighted value ValueNode_Composite::Handle weighted_node = ValueNode_Composite::create(wt->create_weighted_value(1, value_desc.get_value(time)), get_canvas()); weighted_node->set_link("value", bone_link_node); // add average_node->add(ValueNode::Handle(weighted_node)); } node = average_node; } else { // make bone link ValueNode_BoneLink::Handle bone_link_node = ValueNode_BoneLink::create(value_desc.get_value(time)); bone_link_node->set_link("bone", ValueNode_Const::create(ValueBase(*current_list.begin()), get_canvas())); bone_link_node->set_link("base_value", ValueNode_Composite::create( ValueTransformation::back_transform( bone_link_node->get_bone_transformation(time), value_desc.get_value(time) ))); node = bone_link_node; } if (!node) continue; // enqueue suitable action to assign node if (value_desc.parent_is_canvas()) { Action::Handle action = ValueNodeReplace::create(); action->set_param("canvas", get_canvas()); action->set_param("canvas_interface", get_canvas_interface()); action->set_param("src", node); action->set_param("dest", value_desc.get_value_node()); assert(action->is_ready()); if (!action->is_ready()) throw Error(Error::TYPE_NOTREADY); add_action_front(action); } else if (value_desc.parent_is_layer()) { Action::Handle action = LayerParamConnect::create(); action->set_param("layer", value_desc.get_layer()); action->set_param("param", value_desc.get_param_name()); action->set_param("canvas", get_canvas()); action->set_param("canvas_interface", get_canvas_interface()); action->set_param("value_node", node); assert(action->is_ready()); if (!action->is_ready()) throw Error(Error::TYPE_NOTREADY); add_action_front(action); } else if (value_desc.parent_is_value_node()) { Action::Handle action = ValueNodeLinkConnect::create(); action->set_param("canvas", get_canvas()); action->set_param("canvas_interface", get_canvas_interface()); action->set_param("parent_value_node", value_desc.get_parent_value_node()); action->set_param("index", value_desc.get_index()); action->set_param("value_node", node); assert(action->is_ready()); if (!action->is_ready()) throw Error(Error::TYPE_NOTREADY); add_action_front(action); } } }
void WatcherData::run() { for (;;) { if (hasChanged()) { slices.clear(); updatePaths(); auto where = changes.begin(); const auto end = changes.end(); while (where != end) { auto to = where + MAXIMUM_WAIT_OBJECTS - 1; // - 1 since we want a wakeup event as well if (to > end) to = end; slices.push_back(std::unique_ptr<WatcherSlice>(new WatcherSlice(where, to, std::bind(&WatcherData::updated, this, std::placeholders::_1), handleToPath))); where = to; } } const DWORD res = WaitForSingleObject(wakeupHandle, INFINITE); if (res == WAIT_FAILED) { fprintf(stderr, "Wait failed in WatcherData::run() %lu\n", static_cast<unsigned long>(GetLastError())); break; } assert(res - WAIT_OBJECT_0 == 0); // woken up //printf("!!!Woken up\n"); std::lock_guard<std::mutex> changeLocker(changeMutex); if (stopped) { //printf("!!!! Stopped?\n"); break; } std::lock_guard<std::mutex> updateLocker(updateMutex); if (!changedPaths.empty()) { for (const Path& p : changedPaths) { //printf("path was modified... %s\n", p.constData()); PathData& data = pathData[p]; p.visit([&data](const Path &pp) { if (pp.isFile()) { //printf("updateDir %s\n", p.constData()); const auto modif = data.modified.find(pp); if (modif == data.modified.end()) { //printf("added\n"); // new file data.added.insert(pp); return Path::Continue; } data.seen.insert(pp); // possibly modified file if (pp.lastModifiedMs() != modif->second) { //printf("modified\n"); // really modified data.changed.insert(pp); } return Path::Continue; } return Path::Recurse; }); Set<Path> removed; // calculate the removed files (modified - seen) const auto send = data.seen.end(); for (const std::pair<Path, uint64_t>& mod : data.modified) { if (data.seen.find(mod.first) == send) { removed.insert(mod.first); } else { // update to our new time data.modified[mod.first] = mod.first.lastModifiedMs(); } } // update the modified structure for (const Path& ap : data.added) { data.modified[ap] = ap.lastModifiedMs(); } for (const Path& rp : removed) { data.modified.erase(rp); } //printf("hei, removed %u, added %u, changed %u\n", removed.size(), data.added.size(), data.changed.size()); if (!removed.empty()) EventLoop::mainEventLoop()->callLaterMove(std::bind(&FileSystemWatcher::pathsRemoved, watcher, std::placeholders::_1), std::move(removed)); if (!data.added.empty()) EventLoop::mainEventLoop()->callLaterMove(std::bind(&FileSystemWatcher::pathsAdded, watcher, std::placeholders::_1), std::move(data.added)); if (!data.changed.empty()) EventLoop::mainEventLoop()->callLaterMove(std::bind(&FileSystemWatcher::pathsModified, watcher, std::placeholders::_1), std::move(data.changed)); data.added.clear(); data.changed.clear(); data.seen.clear(); } changedPaths.clear(); } } slices.clear(); }
main() { Set<int> s; assert(s.size() == 0); assert(s.empty()); s.insert(10); Set<int>::iterator iter = s.begin(); assert(*iter == 10); s.insert(6); s.insert(6); assert(s.count(6) == 1); assert(s.count(10) == 1); assert(s.count(12) == 0); iter = s.begin(); assert(*iter == 6); ++iter; assert(*iter == 10); ++iter; assert(iter == s.end()); s.insert(7); s.insert(9); s.insert(9); s.insert(8); s.insert(11); iter = s.begin(); assert(*iter == 6); ++iter; assert(*iter == 7); ++iter; assert(*iter == 8); ++iter; assert(*iter == 9); ++iter; assert(*iter == 10); ++iter; assert(*iter == 11); Set<int> s2; s2.insert(3); s2.insert(7); s2.insert(-1); s2.insert(16); s2.insert(11); s2.insert(4); iter = s2.find(3); assert(*iter == 3); iter = s2.find(888); assert(iter == s2.end()); s2.erase(7); iter = s2.begin(); assert(*iter == -1); ++iter; assert(*iter == 3); ++iter; assert(*iter == 4); ++iter; assert(*iter == 11); ++iter; assert(*iter == 16); ++iter; assert(iter == s2.end()); s2.erase(16); iter = s2.begin(); assert(*iter == -1); ++iter; assert(*iter == 3); ++iter; assert(*iter == 4); ++iter; assert(*iter == 11); ++iter; assert(iter == s2.end()); s2.erase(3); iter = s2.begin(); assert(*iter == -1); ++iter; assert(*iter == 4); ++iter; assert(*iter == 11); ++iter; assert(iter == s2.end()); s2.erase(11); iter = s2.begin(); assert(*iter == -1); ++iter; assert(*iter == 4); ++iter; assert(iter == s2.end()); s2.erase(-1); iter = s2.begin(); assert(*iter == 4); ++iter; assert(iter == s2.end()); s2.erase(4); iter = s2.begin(); assert(iter == s2.end()); cout << "All tests passed." << endl; }
int main() { //General mutators tests Set s1; s1.insert("focaccia"); assert(!s1.contains("")); s1.insert("tortilla"); s1.insert(""); s1.insert("lavash"); assert(s1.contains("")); s1.erase("focaccia"); assert(s1.size() == 3 && s1.contains("lavash") && s1.contains("tortilla") && s1.contains("")); Set setex; assert(setex.empty()); setex.insert("first"); assert(setex.size() == 1 && setex.contains("first") && !setex.contains("second")); setex.erase("first"); assert(setex.size() == 0); // //swap test Set ss1; ss1.insert("injera"); Set ss2; ss2.insert("matzo"); ss2.insert("dosa"); ss1.swap(ss2); assert(ss1.size() == 2 && ss1.contains("matzo") && ss1.contains("dosa") && ss2.size() == 1 && ss2.contains("injera")); //end swap test //get tests Set ss; ss.insert("A"); ss.insert("C"); ss.insert("A"); ss.insert("B"); string all; for (int k = 0; k < ss.size(); k++) { string x; ss.get(k, x); all += x; } Set SS; SS.insert("pita"); SS.insert("roti"); string test; assert(SS.get(1, test) && (test == "roti" || test == "pita")); string s2; assert(SS.get(1, s2) && s2 == test); Set s; assert(s.empty()); string x = "arepa"; assert(!s.get(42, x) && x == "arepa"); // x unchanged by get failure s.insert("chapati"); assert(s.size() == 1); assert(s.get(0, x) && x == "chapati"); //end get tests cout << "Passed all tests" << endl; }