static double test_clear() { static unsigned const Iterations = 10000; static unsigned const Count = 1000; Set set; initialize<Set>(set); boost::timer::cpu_timer timer; double total_nanos = 0; std::vector<T> data; for(unsigned i = 0; i != Iterations; ++i) { data.clear(); set.clear(); Generator::generate(data, Count); for(typename std::vector<T>::const_iterator iter = data.begin(); iter != data.end(); ++iter) { set.insert(*iter); } timer.start(); set.clear(); total_nanos += timer.elapsed().wall; } return (unsigned)(total_nanos / (Iterations * Count)); }
bool Config::loadSetting(const std::string &line, const std::string &name, Set &var) const { size_t i = isSetting(line, name, "="); if(i != std::string::npos) { var.clear(); var.insert( trim(line.substr(i)) ); return true; } i = isSetting(line, name, "+="); if(i != std::string::npos) { var.insert( trim(line.substr(i)) ); return true; } i = isSetting(line, name, "-="); if(i != std::string::npos) { Set::iterator a = var.find( trim(line.substr(i)) ); if(a != var.end()) { var.erase(a); } return true; } return false; }
static inline void removeOutputs() { std::lock_guard<std::mutex> lock(sOutputsMutex); for (Set<LogOutput*>::const_iterator it = sOutputs.begin(); it != sOutputs.end(); ++it) delete *it; sOutputs.clear(); }
void initMesh(int nc, int p){ graph.clear(); set.clear(); initial.clear(); constraint.clear(); numCir = nc; poly = p; Circle cir = CXY(1); for (int i = 0; i < numCir; ++i){ VT radius = 1 + 2.0 * (float)i/numCir; Circle tcir = cir.dilate( log( radius ) ); for (int j = 0; j < poly; ++j ){ VT theta = TWOPI * j / poly; theta += (rtheta * i * PI/poly); Point p = Round::pnt_cir(tcir, theta ); set.add( p ); } } bool bSwitch = false; for (int j = 0; j < poly; ++j){ int a = j; int b = ( j < poly - 1 ) ? j + 1 : 0; int c = j + poly; //cout << a << " " << b << " " << c << endl; initial.add( Rigid2( set[c], set[a], set[b], bSwitch ) ); bSwitch = !bSwitch; } bSwitch = false; for (int i = 1; i < numCir-1; ++i){ for (int j = 0; j < poly; ++j ){ int a = i * poly + j; int b = a + poly; int c = j < poly -1 ? a + 1 : i * poly; int d = j < poly -1 ? a - poly + 1 : (i-1)*poly; constraint.add( Rigid3( set[b], set[a], set[d], set[c], bSwitch ) ); bSwitch = !bSwitch; } } }
void WatcherThread::clear() { MutexLocker locker(&mutex); flags |= Clear; paths.clear(); CFRunLoopSourceSignal(source); CFRunLoopWakeUp(loop); }
void assign(const Impl* impl) { set_.clear(); const size_t count= impl->set_.size(); for (size_t i= 0; i < count; ++i) add_tag(impl->set_[i]); }
void WatcherData::clear() { std::lock_guard<std::mutex> lock(mutex); flags |= Clear; paths.clear(); CFRunLoopSourceSignal(source); CFRunLoopWakeUp(loop); }
void Config::set(Set &a, const Set &b, bool merge) { if(!merge) { a.clear(); a = b; return; } for(Set::const_iterator i = b.begin(); i != b.end(); ++i) { a.insert(*i); } }
void UndoManager::CalculateSpaceUsage() { TIMER_START( "CalculateSpaceUsage", space_calc ); TrackListOfKindIterator iter(Track::Wave); space.Clear(); space.Add(0, stack.GetCount()); Set s1, s2; Set *prev = &s1; Set *cur = &s2; for (size_t i = 0, cnt = stack.GetCount(); i < cnt; i++) { // Swap map pointers std::swap(cur, prev); // And clean out the NEW current map cur->clear(); // Scan all tracks at current level WaveTrack *wt = (WaveTrack *) iter.First(stack[i]->tracks); while (wt) { // Scan all clips within current track WaveClipList::compatibility_iterator it = wt->GetClipIterator(); while (it) { // Scan all blockfiles within current clip BlockArray *blocks = it->GetData()->GetSequenceBlockArray(); for (size_t b = 0, cnt = blocks->size(); b < cnt; b++) { BlockFile *file = (*blocks)[b].f; // Accumulate space used by the file if the file didn't exist // in the previous level if (prev->count(file) == 0 && cur->count(file) == 0) { space[i] += file->GetSpaceUsage().GetValue(); } // Add file to current set cur->insert(file); } it = it->GetNext(); } wt = (WaveTrack *) iter.Next(); } } TIMER_STOP( space_calc ); }
NodePath Node::get_path_to(const Node *p_node) const { ERR_FAIL_NULL_V(p_node,NodePath()); if (this==p_node) return NodePath("."); Set<const Node*> visited; const Node *n=this; while(n) { visited.insert(n); n=n->data.parent; } const Node *common_parent=p_node; while(common_parent) { if (visited.has(common_parent)) break; common_parent=common_parent->data.parent; } ERR_FAIL_COND_V(!common_parent,NodePath()); //nodes not in the same tree visited.clear(); Vector<StringName> path; n=p_node; while(n!=common_parent) { path.push_back( n->get_name() ); n=n->data.parent; } n=this; StringName up=String(".."); while(n!=common_parent) { path.push_back( up ); n=n->data.parent; } path.invert(); return NodePath(path,false); }
void BVH::trace(RayBuffer& rays, RayStats* stats) const { for(S32 i=0;i<rays.getSize();i++) { Ray ray = rays.getRayForSlot(i); // takes a local copy RayResult& result = rays.getMutableResultForSlot(i); result.clear(); currentTreelet = -2; uniqueTreelets.clear(); if(stats) { stats->platform = m_platform; stats->numRays++; } traceRecursive(m_root, ray,result,rays.getNeedClosestHit(), stats); } }
void TestTools::set_reserve() { Set<int> set; int n = set.capacity(); QVERIFY(n == 0); set.reserve(1000); QVERIFY(set.capacity() >= 1000); for (int i = 0; i < 500; ++i) set.insert(i); QVERIFY(set.capacity() >= 1000); for (int j = 0; j < 500; ++j) set.remove(j); QVERIFY(set.capacity() >= 1000); set.clear(); QVERIFY(set.capacity() == 0); }
static double test_find_failure() { static unsigned const Iterations = 10000; static unsigned const Count = 1000; Set set; initialize<Set>(set); boost::timer::cpu_timer timer; double total_nanos = 0; std::vector<T> data; int found = 0; for(unsigned i = 0; i != Iterations; ++i) { data.clear(); set.clear(); Generator::generate(data, Count); for(typename std::vector<T>::const_iterator iter = data.begin(); iter != data.end(); ++iter) { set.insert(*iter); } data.clear(); Generator::generate(data, Count); timer.start(); for(typename std::vector<T>::const_iterator iter = data.begin(); iter != data.end(); ++iter) { if (set.find(*iter) != set.end()) ++found; } total_nanos += timer.elapsed().wall; } if (found == 123) // never std::cout << "yeah right\n"; return (unsigned)(total_nanos / (Iterations * Count)); }
void init_set() { S.clear(); rec2(0, 0, 0); }
void cleanupLogging() { std::lock_guard<std::mutex> lock(sOutputsMutex); sOutputs.clear(); }
int main() { Set<nodeT *> graph; Map<nodeT *> graphMap; InitGraphics(); SetWindowTitle("Pathfinder"); string backgroundFile; bool timeToQuit = false; cout << "This masterful piece of work is a graph extravaganza!" << endl; while (true) { cout << "Your options are:" << endl; cout << "(1) Choose a new graph data file" << endl; cout << "(2) Find shortest path using Dijkstra's algorithm" << endl; cout << "(3) Compute the minimal spanning tree using Kruskal's algorithm" << endl; cout << "(4) Determine if the graph has cycles" << endl; cout << "(5) Quit" << endl; cout << "Enter choice: "; int choice = GetInteger(); string datafile; void UpdateDisplay(); switch (choice) { case 1: cout << "Enter the name of the data file: "; datafile = GetLine(); //datafile = "Small.txt"; //datafile = "USA.txt"; //datafile = "Stanford.txt"; graph.clear(); graphMap.clear(); backgroundFile = ReadGraph(graph, graphMap, datafile); break; case 2: if (backgroundFile == "") { cout << "No file is specified" << endl; } else { UpdateDisplay(); MovePen(0,0); DrawNamedPicture(backgroundFile); DrawNodesAndArcs(graph); cout << "(2) Finding shortest path using Dijkstra's algorithm" << endl; HandleShortestPath(graph); } break; case 3: if (backgroundFile == "") { cout << "No file is specified" << endl; } else { cout << "(3) Computing the minimal spanning tree using Kruskal's algorithm" << endl; UpdateDisplay(); MovePen(0,0); DrawNamedPicture(backgroundFile); //DrawNodesAndArcs(graph); minimumSpanningTree(graph, graphMap); } break; case 4: if (backgroundFile == "") { cout << "No file is specified" << endl; } else { graphT graph2; graph2.allNodes = graph; cout << "(4) Determining if the graph has cycles" << endl; if (IsCyclicGraph(graph2)) cout << "Yes, it is cyclic" << endl; else cout << "No, it is not cyclic" << endl; } break; case 5: cout << "Thanks for using Pathfinder. Bye!" << endl; timeToQuit = true; break; default: cout << "Invalid choice" << endl; break; } if (timeToQuit) break; } return (0); }
void ServerSocket::getLocalAddresses(Set<Address> &set) const { set.clear(); Address bindAddr = getBindAddress(); #ifdef NO_IFADDRS // Retrieve hostname char hostname[HOST_NAME_MAX]; if(gethostname(hostname,HOST_NAME_MAX)) throw NetException("Cannot retrieve hostname"); // Resolve hostname addrinfo *aiList = NULL; addrinfo aiHints; std::memset(&aiHints, 0, sizeof(aiHints)); aiHints.ai_family = AF_UNSPEC; aiHints.ai_socktype = SOCK_STREAM; aiHints.ai_protocol = 0; aiHints.ai_flags = 0; String service; service << mPort; if(getaddrinfo(hostname, service.c_str(), &aiHints, &aiList) != 0) { LogDebug("ServerSocket", "Local hostname is not resolvable"); if(getaddrinfo("localhost", service.c_str(), &aiHints, &aiList) != 0) { set.insert(bindAddr); return; } } addrinfo *ai = aiList; while(ai) { if(ai->ai_family == AF_INET || ai->ai_family == AF_INET6) { Address addr(ai->ai_addr,ai->ai_addrlen); String host = addr.host(); if(ai->ai_addr->sa_family != AF_INET6 || host.substr(0,4) != "fe80") { if(addr == bindAddr) { set.clear(); set.insert(addr); break; } set.insert(addr); } } ai = ai->ai_next; } freeaddrinfo(aiList); #else ifaddrs *ifas = NULL; if(getifaddrs(&ifas) < 0) throw NetException("Unable to list network interfaces"); ifaddrs *ifa = ifas; while(ifa) { sockaddr *sa = ifa->ifa_addr; if(sa) { socklen_t len = 0; switch(sa->sa_family) { case AF_INET: len = sizeof(sockaddr_in); break; case AF_INET6: len = sizeof(sockaddr_in6); break; } if(len) { Address addr(sa, len); String host = addr.host(); if(host.substr(0,4) != "fe80") { addr.set(host, mPort); if(addr == bindAddr) { set.clear(); set.insert(addr); break; } set.insert(addr); } } } ifa = ifa->ifa_next; } freeifaddrs(ifas); #endif }
static void testInsertErase() { Set<int> set; bool inserted = set.insert(0); ASSERT_always_require2(inserted, "member should have been inserted"); ASSERT_always_require2(!set.isEmpty(), "a singleton set is not empty"); ASSERT_always_require2(set.size() == 1, "a singleton set has one member"); ASSERT_always_require2(set.hull().size() == 1, "singleton set has a singleton hull"); ASSERT_always_require2(set.exists(0), "member zero has been inserted"); ASSERT_always_require2(!set.exists(1), "member one has not been inserted yet"); ASSERT_always_require2(!set.exists(2), "member two has not been inserted yet"); inserted = set.insert(0); // again ASSERT_always_require2(!inserted, "member should have already existed"); ASSERT_always_require2(!set.isEmpty(), "a singleton set is not empty"); ASSERT_always_require2(set.size() == 1, "a singleton set has one member"); ASSERT_always_require2(set.hull().size() == 1, "singleton set has a singleton hull"); ASSERT_always_require2(set.exists(0), "member zero has been inserted"); ASSERT_always_require2(!set.exists(1), "member one has not been inserted yet"); ASSERT_always_require2(!set.exists(2), "member two has not been inserted yet"); inserted = set.insert(1); ASSERT_always_require2(inserted, "member should have been inserted"); ASSERT_always_require2(!set.isEmpty(), "a two-member set is not empty"); ASSERT_always_require2(set.size() == 2, "a two-member set has two members"); ASSERT_always_require2(set.hull().size() == 2, "hull of set {0,1} is [0..1]"); ASSERT_always_require2(set.exists(0), "member zero has been inserted"); ASSERT_always_require2(set.exists(1), "member one has been inserted"); ASSERT_always_require2(!set.exists(2), "member two has not been inserted yet"); inserted = set.insert(2); ASSERT_always_require2(inserted, "member should have been inserted"); ASSERT_always_require2(!set.isEmpty(), "a three-member set is not empty"); ASSERT_always_require2(set.size() == 3, "a three-member set has three members"); ASSERT_always_require2(set.hull().size() == 3, "hull of set {0,1,2} is [0..2]"); ASSERT_always_require2(set.exists(0), "member zero has been inserted"); ASSERT_always_require2(set.exists(1), "member one has been inserted"); ASSERT_always_require2(set.exists(2), "member two has been inserted"); bool erased = set.erase(1); ASSERT_always_require2(erased, "member should have been erased"); ASSERT_always_require2(!set.isEmpty(), "a two-member set is not empty"); ASSERT_always_require2(set.size() == 2, "a two-member set has three members"); ASSERT_always_require2(set.hull().size() == 3, "hull of set {0,2} is [0..2]"); ASSERT_always_require2(set.exists(0), "member zero has been inserted"); ASSERT_always_require2(!set.exists(1), "member one has been erased"); ASSERT_always_require2(set.exists(2), "member two has been inserted"); erased = set.erase(1); // again ASSERT_always_require2(!erased, "member has already been erased"); ASSERT_always_require2(!set.isEmpty(), "a two-member set is not empty"); ASSERT_always_require2(set.size() == 2, "a two-member set has three members"); ASSERT_always_require2(set.hull().size() == 3, "hull of set {0,2} is [0..2]"); ASSERT_always_require2(set.exists(0), "member zero has been inserted"); ASSERT_always_require2(!set.exists(1), "member one has been erased"); ASSERT_always_require2(set.exists(2), "member two has been inserted"); set.clear(); ASSERT_always_require2(set.isEmpty(), "a cleared set is empty"); ASSERT_always_require2(set.size() == 0, "a cleared set has no members"); ASSERT_always_require2(set.hull().isEmpty(), "a cleared set is empty"); ASSERT_always_require2(!set.exists(0), "member zero has been cleared"); ASSERT_always_require2(!set.exists(1), "member one has been cleared"); ASSERT_always_require2(!set.exists(2), "member two has been cleared"); }
void setInt() { Set<int> s; //insert assert("Set::insert()", s.insert(2).second); assert("Set::insert()", s.insert(3).second); assert("Set::insert()", s.insert(4).second); assert("Set::size()", s.size() == 3); //dupe insert Pair<Set<int>::Iterator, bool> res = s.insert(2); assert("Set::insert()", !res.second); assert("Set::insert()", res.first != s.end()); assert("Set::insert()", *res.first == 2); //find Set<int>::Iterator itr = s.find(3); assert("Set::find()", itr != s.end()); assert("Set::find()", *itr == 3); //iterate itr = s.begin(); assert("Set::begin()", itr != s.end()); assert("Set::Iterator", *itr == 2); ++itr; assert("Set::Iterator", *itr == 3); ++itr; assert("Set::Iterator", *itr == 4); ++itr; assert("Set::Iterator", itr == s.end()); //iterator --itr; assert("Set::Iterator--", itr != s.end()); itr--; itr++; itr++; assert("Set::Iterator++", itr == s.end()); itr--; assert("Set::Iterator--", itr != s.end()); //const iterator Set<int>::ConstIterator citr = s.find(3); assert("cSet::find()", citr != s.end()); assert("cSet::find()", *citr == 3); citr = s.begin(); assert("cSet::begin()", citr != s.end()); assert("cSet::Iterator", *citr == 2); ++citr; assert("cSet::Iterator", *citr == 3); ++citr; assert("cSet::Iterator", *citr == 4); ++citr; assert("cSet::Iterator", citr == s.end()); --citr; assert("cSet::Iterator--", citr != s.end()); citr--; citr++; citr++; assert("cSet::Iterator++", citr == s.end()); citr--; assert("cSet::Iterator--", citr != s.end()); //erase assert("Set::erase()", s.erase(3)); assert("Set::erase()", s.size() == 2); //copy constuctor Set<int> copy(s); assert("Set::Set(Set)", copy.size() == 2); //clear s.clear(); assert("Set::clear()", s.size() == 0); itr = s.find(4); assert("Set::clear()", itr == s.end()); assert("Set::clear()", s.begin() == s.end()); //assignment operator s = copy; assert("Set::operator=()", s.size() == 2); }
int main() { Set set; UnorderedSet::bucket_type buckets[10]; UnorderedSet unordered_set(UnorderedSet::bucket_traits(buckets, 10)); const char * const expensive_key = "A long string that avoids small string optimization"; Expensive value(expensive_key); if(get_from_set(expensive_key, set)){ return 1; } if(get_from_uset(expensive_key, unordered_set)){ return 1; } if(get_from_set_optimized(expensive_key, set)){ return 1; } if(get_from_uset_optimized(expensive_key, unordered_set)){ return 1; } Set::iterator setit = set.insert(value).first; UnorderedSet::iterator unordered_setit = unordered_set.insert(value).first; if(!get_from_set(expensive_key, set)){ return 1; } if(!get_from_uset(expensive_key, unordered_set)){ return 1; } if(!get_from_set_optimized(expensive_key, set)){ return 1; } if(!get_from_uset_optimized(expensive_key, unordered_set)){ return 1; } set.erase(setit); unordered_set.erase(unordered_setit); if(!insert_to_set(expensive_key, set)){ return 1; } if(!insert_to_uset(expensive_key, unordered_set)){ return 1; } { Expensive *ptr = &*set.begin(); set.clear(); delete ptr; } { Expensive *ptr = &*unordered_set.begin(); unordered_set.clear(); delete ptr; } if(!insert_to_set_optimized(expensive_key, set)){ return 1; } if(!insert_to_uset_optimized(expensive_key, unordered_set)){ return 1; } { Expensive *ptr = &*set.begin(); set.clear(); delete ptr; } { Expensive *ptr = &*unordered_set.begin(); unordered_set.clear(); delete ptr; } setit = set.insert(value).first; unordered_setit = unordered_set.insert(value).first; if(insert_to_set(expensive_key, set)){ return 1; } if(insert_to_uset(expensive_key, unordered_set)){ return 1; } if(insert_to_set_optimized(expensive_key, set)){ return 1; } if(insert_to_uset_optimized(expensive_key, unordered_set)){ return 1; } set.erase(value); unordered_set.erase(value); return 0; }
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(); }