//handle login requests int logoutReq(struct request_logout *rl) { string realAddrString = getAddr_string(); string username = getUserOfCurrAddr(); string tmpaddr; map<string, struct sockaddr_in>::iterator sockIt = userToAddrStrct.find(username); userToAddrStrct.erase(sockIt); multimap<pair<string,string>, string>::iterator i; for(i=addrToUser.begin(); i!=addrToUser.end(); i++) { if(i->second == username) { tmpaddr = i->first.first; cout << "deleting 1 \n"; addrToUser.erase(i); } } multimap<string, pair<string,string> >::iterator ii; for(ii=userToAddr.begin(); ii!=userToAddr.end(); ii++) { if(ii->first == username) { cout << "deleting 2 \n"; userToAddr.erase(ii); } } // look for user in channel listen //look for user in channel talk map<string,string>::iterator git; git = usrTlkChan.find(username); if(git != usrTlkChan.end()) { cout << "deleting 5 \n"; usrTlkChan.erase(username); } //erase user on channels in chanTlkUser for(int ick=0; ick<channels.size(); ick++) { cout << "in outerr \n"; map<string,vector<string> >::iterator itck = chanTlkUser.find(channels[ick]); vector<string> usersC = itck->second; for(int j=0; j<usersC.size(); j++) { if(usersC[j] == username) { cout << "deleting user: "******" \n"; usersC.erase(usersC.begin()+j); } } chanTlkUser.erase(itck); chanTlkUser.insert(pair<string,vector<string> >(channels[ick],usersC)); } return 0; }
void DFHack::EventManager::unregisterAll(Plugin* plugin) { for ( auto i = handlers[EventType::TICK].find(plugin); i != handlers[EventType::TICK].end(); i++ ) { if ( (*i).first != plugin ) break; //shenanigans to avoid concurrent modification EventHandler getRidOf = (*i).second; bool didSomething; do { didSomething = false; for ( auto j = tickQueue.begin(); j != tickQueue.end(); j++ ) { EventHandler candidate = (*j).second; if ( getRidOf != candidate ) continue; tickQueue.erase(j); didSomething = true; break; } } while(didSomething); } for ( size_t a = 0; a < (size_t)EventType::EVENT_MAX; a++ ) { handlers[a].erase(plugin); } return; }
void delete_author(multimap<string, string> &books, const string &name){ auto p = books.equal_range(name); if (p.first == p.second) cout << "No author named " << name << endl; else books.erase(p.first, p.second); }
/* Look for mime handler in pool */ static RecollFilter *getMimeHandlerFromCache(const string& key) { PTMutexLocker locker(o_handlers_mutex); string xdigest; MD5HexPrint(key, xdigest); LOGDEB(("getMimeHandlerFromCache: %s cache size %u\n", xdigest.c_str(), o_handlers.size())); multimap<string, RecollFilter *>::iterator it = o_handlers.find(key); if (it != o_handlers.end()) { RecollFilter *h = it->second; hlruit_tp it1 = find(o_hlru.begin(), o_hlru.end(), it); if (it1 != o_hlru.end()) { o_hlru.erase(it1); } else { LOGERR(("getMimeHandlerFromCache: lru position not found\n")); } o_handlers.erase(it); LOGDEB(("getMimeHandlerFromCache: %s found size %u\n", xdigest.c_str(), o_handlers.size())); return h; } LOGDEB(("getMimeHandlerFromCache: %s not found\n", xdigest.c_str())); return 0; }
void timeout_alarm(int) { cout << "!timeout alarm" << endl; struct timeval tv; struct timezone tz; multimap<long, client_timeout>::iterator i; long ts; for (i = timestamp_map.begin(); i != timestamp_map.end();) { gettimeofday(&tv, &tz); // pobranie aktualnego czasu ts = tv.tv_sec * 1000 + tv.tv_usec / 1000; // zamiana na ms if (i->first > ts) break; map<int, resource_clients>::iterator j = resource_map.find( i->second.resource_id); list<client>::iterator k = find_by_pid(j->second.waiting_clients, i->second.pid); j->second.waiting_clients.erase(k); // usuniecie klienta z kolejki oczekujacych send_response(i->second.pid, TIMEDOUT); timestamp_map.erase(i++); // usuniecie klienta z kolejki timeout try_grant(j); // proba przydzielenia zasobu } if (!timestamp_map.empty()) { useconds_t alrm = (i->first - ts) * 1000; ualarm(alrm, 0); } cout << "!end of timeout alarm" << endl; }
int fun(){ int i; for(i=1;i<root;i++){ if(freq[i] ==0 ){ leaf.push(i); } } int f, p; i = 0; while(! leaf.empty() ){ f = leaf.top(); leaf.pop(); p = node[i]; edge.insert( make_pair(p, f) ); if(--freq[p] == 0 && p < root-1){ leaf.push(p); } i++; } edge.erase(0); printf("("); traceback(root-1); printf(")\n"); edge.clear(); }
static void manageTickEvent(color_ostream& out) { if (!df::global::world) return; unordered_set<EventHandler> toRemove; int32_t tick = df::global::world->frame_counter; while ( !tickQueue.empty() ) { if ( tick < (*tickQueue.begin()).first ) break; EventHandler handle = (*tickQueue.begin()).second; tickQueue.erase(tickQueue.begin()); handle.eventHandler(out, (void*)tick); toRemove.insert(handle); } if ( toRemove.empty() ) return; for ( auto a = handlers[EventType::TICK].begin(); a != handlers[EventType::TICK].end(); ) { EventHandler handle = (*a).second; if ( toRemove.find(handle) == toRemove.end() ) { a++; continue; } a = handlers[EventType::TICK].erase(a); toRemove.erase(handle); if ( toRemove.empty() ) break; } }
void set(int key, int value) { multimap<int, V2C>::iterator it = key2Value2Count.find(key); if(it != key2Value2Count.end()) { V2C& tmp = it->second; tmp.value = value; get(key); } else { if(count >= max) { list<int>::iterator cit=count2Key.begin(); // cout << "cache eviction: " << *cit << endl; key2Value2Count.erase(*cit); count2Key.erase(cit); count--; } list<int>::iterator iit = count2Key.insert(count2Key.end(),key); V2C tmp; tmp.value = value; tmp.it = iit; // cout << "xxxx" <<*iit<<endl; key2Value2Count.insert(pair<int, V2C>(key, tmp)); count++; } }
//handle login requests int logoutReq(struct request_logout *rl) { string username = getUserOfCurrAddr(); multimap<string, struct sockaddr_in>::iterator sockIt = userToAddrStrct.find(username); userToAddrStrct.erase(sockIt); map<string,vector<string> >::iterator git; git = usrTlkChan.find(username); if(git != usrTlkChan.end()) { usrTlkChan.erase(username); } //erase user on channels in chanTlkUser //for(int ick=0; ick<channels.size(); ick++) { map<string,vector<pair<string,struct sockaddr_in> > >::iterator sat; for(sat=chanTlkUser.begin(); sat != chanTlkUser.end(); sat++) { map<string,vector<pair<string,struct sockaddr_in> > >::iterator itck = chanTlkUser.find(sat->first); vector<pair<string,struct sockaddr_in> > usersC = itck->second; for(int j=0; j<usersC.size(); j++) { if(usersC[j].first == username) { usersC.erase(usersC.begin()+j); } } chanTlkUser.erase(itck); chanTlkUser.insert(pair<string,vector<pair<string,struct sockaddr_in> > >(sat->first,usersC)); } return 0; }
void solve(string cur) { // cout << cur << endl; while (true) { pair<trav_it, trav_it> ret = trav.equal_range(cur); if (ret.first == ret.second) break; else { // cout << "\tnot yet" << endl; trav_it to_del=ret.first; string next = ret.first->second; for (trav_it it = ret.first; it != ret.second; ++it) { if (it->second < next) { next = it->second; to_del = it; } } // cout << "\t" << next << endl; trav.erase(to_del); solve(next); } } ans.push_back(cur); }
void CDetCandit::Erasing_Prescribed_Candidates(multimap<double, size_t>& FeedbackCase_mm) { if((int)FeedbackCase_mm.size() > FEEDBACK_CASES_NUM){ for(int num = FeedbackCase_mm.size() - FEEDBACK_CASES_NUM; num > 0; num--){ FeedbackCase_mm.erase(FeedbackCase_mm.begin()); } } }
void setResponseHeader(const char* name, const char* value) { HTTPResponse::setResponseHeader(name, value); // Set for later. if (value) m_headers.insert(make_pair(name,value)); else m_headers.erase(name); }
void erase_from_timestamp_map(pid_t pid, int resource_id) { for (multimap<long, client_timeout>::iterator i = timestamp_map.begin(); i != timestamp_map.end(); ++i) { if (i->second.pid == pid && i->second.resource_id == resource_id) { timestamp_map.erase(i); break; } } // ewentualnie przestawic alarm }
void eraseName(multimap<string, string>& m_map) { string authorname; cout << "Which author do you want to delete ?" << endl; cin >> authorname; multimap<string, string>::iterator it = m_map.find(authorname); if (it != m_map.end()) m_map.erase(authorname); else cout << "Can't find the author !" << endl; }
void balance(int id){ auto count = flat_tree.count(id);; if (count > max_items_per_quad) { int target_depth = get_depth(id) + logn(count, 4); for (auto&a : query_quad(id)) { //flat_tree.insert({}) insert(id, positions[id], target_depth); } flat_tree.erase(id); // erase all by key, can also erase iterator } }
static void removeFromTickQueue(EventHandler getRidOf) { for ( auto j = tickQueue.find(getRidOf.freq); j != tickQueue.end(); ) { if ( (*j).first > getRidOf.freq ) break; if ( (*j).second != getRidOf ) { j++; continue; } j = tickQueue.erase(j); } }
// function removes least popular playlist from the database if there are more than 1024 playlists void removeLeastPopular(){ if( playlistDB.size() >= 1024 ){ multimap<int, string>:: iterator popIter = popularityDB.begin(); // first playlist of the popularityDB is the least popular unordered_map<string, int>:: iterator playlistIter; //look for least popular playlist and remove it playlistIter = playlistDB.find(popIter -> second); // get pointer to least popular playlist in playlist databse playlistDB.erase(playlistIter); // erase the playlist from playlistDB popularityDB.erase(popIter); // erase the playlist from popularity database } }
//O(logn) void Library::markRead(string titleToMark){ map<string,string>::iterator it = unreadKeyTitle.find(titleToMark); string toFind = it->second; multimap<string,string>::iterator i = unreadKeyAuth.find(toFind); if (it!=unreadKeyTitle.end()){ read.insert(pair<string, string>(it->second, it->first)); cout << "You've read " << '\"' << it->first << "!" << '\"' << endl; unreadKeyAuth.erase(i); unreadKeyTitle.erase(it); } }
static void manageTickEvent(color_ostream& out) { uint32_t tick = DFHack::World::ReadCurrentYear()*ticksPerYear + DFHack::World::ReadCurrentTick(); while ( !tickQueue.empty() ) { if ( tick < (*tickQueue.begin()).first ) break; EventHandler handle = (*tickQueue.begin()).second; tickQueue.erase(tickQueue.begin()); handle.eventHandler(out, (void*)tick); } }
void deleteAuthor(multimap<string, string> &db, string author) { pair<db_iter, db_iter> range = db.equal_range(author); if (range.first != range.second) { cout << "author: " << author << " found and del" << endl; } else { cout << "author: " << author << " not found" << endl; } db.erase(range.first, range.second); }
void eraseName(multimap<string, string>& m_map) { string authorname; cout << "Which author do you want to delete ?" << endl; cin >> authorname; pair<multimap<string, string>::iterator, multimap<string, string>::iterator> it = m_map.equal_range(authorname); if (it.first != it.second){ m_map.erase(it.first, it.second); } else cout << "Can't find the author !" << endl; }
void solve() { int i, j, cnt = 0; for (i = 0; i < n; i++) { tr[i].get(); ev[cnt++] = EVENT(i, tr[i].p1.x, IN); ev[cnt++] = EVENT(i, tr[i].p2.x, CH); ev[cnt++] = EVENT(i, tr[i].p3.x, OUT); } sort(ev, ev + cnt); T.clear(); T.insert(make_pair(SEG(POINT(-INF, -INF), POINT(INF, -INF), -1), 1)); T.insert(make_pair(SEG(POINT(-INF, INF), POINT(INF, INF), -1), 0)); curx = 0, ans = 1; for (i = 0; i < cnt && ans != -1; i++) { j = ev[i].id, curx = ev[i].x; if (ev[i].type == IN) { tr[j].p12 = T.insert(make_pair(SEG(tr[j].p1, tr[j].p2, j), 0)); tr[j].p13 = T.insert(make_pair(SEG(tr[j].p1, tr[j].p3, j), 0)); if (!isok(tr[j].p12) || !isok(tr[j].p13)) ans = -1; else { IT t = tr[j].p12; if (++t == tr[j].p13) update(tr[j].p12, tr[j].p13); else update(tr[j].p13, tr[j].p12); } } else if (ev[i].type == CH) { if (!isok(tr[j].p12)) ans = -1; else { tr[j].p23 = T.insert(make_pair(SEG(tr[j].p2, tr[j].p3, j), tr[j].p12->second)); T.erase(tr[j].p12); if (!isok(tr[j].p23)) ans = -1; } } else if (ev[i].type == OUT) { if (!isok(tr[j].p13) || !isok(tr[j].p23)) ans = -1; else T.erase(tr[j].p13), T.erase(tr[j].p23); } } if (ans == -1) printf("ERROR\n"); else printf("%d shades\n", ans); }
void IO::Reaction::checkForThirdBody(multimap<string, double>& species) { multimap<string,double>::iterator iter; for (iter = species.begin(); iter != species.end(); ++iter) { if(iter->first == "M") { flagThirdBody_ = true; species.erase(iter); break; } } }
void DyckGraph::removeFromWorkList(multimap<DyckVertex*, void*>& list, DyckVertex* v, void* l) { typedef multimap<DyckVertex*, void*>::iterator CIT; typedef pair<CIT, CIT> Range; Range range = list.equal_range(v); CIT next = range.first; while (next != range.second) { if ((next)->second == l) { list.erase(next); return; } next++; } }
void erase(multimap<Seg, Triangle*>::iterator it) { multimap<Seg, Triangle*>::iterator jt, kt; jt = prevNode(it), kt = nextNode(it); if (jt->first.tid != it->first.tid && (it->first).intersect(jt->first)) status = 1; if (kt->first.tid != it->first.tid && (it->first).intersect(kt->first)) status = 1; if (kt->first.tid != jt->first.tid && (jt->first).intersect(kt->first)) status = 1; S.erase(it); }
//devuelve la suma de los elementos de 'mi_multimap' que usan 'llave' como llave int sumaElementosMultimap(multimap<string, int> mi_multimap, string llave) { int cont = 0; // Creo una variable cont while(mi_multimap.count(llave) != 0) //mientras el conteo de las llaves no sea cero { int c = mi_multimap.find(llave)-> second; //La variable c toma el valor del segundo elemento de la llave cont = cont + c; //Suma los valores mi_multimap.erase(mi_multimap.find(llave)); //se borra el ultimo elemento } return cont; //devuelve la suma }
void removeWeight(const K& key) { auto weightIter = keyWeightMap_.find(key); auto const weight = weightIter->second; keyWeightMap_.erase(weightIter); auto ret = weightKeyMap_.equal_range(weight); for (auto iter=ret.first; iter!=ret.second; ++iter) if (iter->second == key) { weightKeyMap_.erase(iter); return; } assert(false); }
void updatePlaylistPopularity(int oldPopularity, string playlistName, int newPopularity){ typedef multimap<int, string>:: iterator iterator; std::pair<iterator, iterator> iterpair = popularityDB.equal_range(oldPopularity); // erase playlist with old popularity iterator it = iterpair.first; for (; it != iterpair.second; ++it) { if( it -> second == playlistName) { popularityDB.erase(it); break; } } // insert playlist with updated popularity popularityDB.insert( std::pair<int,string>(newPopularity, playlistName) ); }
void eliminate_left_recursion(multimap<string,string> &rules) { //cout<<"Left Recurse"<<endl; multimap<string,string>::iterator it; multimap<string,string>::iterator it1; string non_term,non_term_1; string RHS,leftmost,RHS1,remaining; const char *rhs; //string tok_rhs; char *tok_rhs; char r[1000]; string new_rhs; for(int i=0;i<n_t.size();i++) { for(int j=0;j<i;j++) { it=rules.find(n_t[i]); non_term=(*it).first; for(;it!=rules.end() && (((*it).first.compare(non_term))==0);it++) { RHS=(*it).second; rhs=RHS.c_str(); strcpy(r,rhs); tok_rhs=strtok(r," "); remaining.copy(r,strlen(r)); leftmost.copy(tok_rhs,strlen(tok_rhs)); if(leftmost.compare(n_t[j])==0) { new_rhs.clear(); it1=rules.find(n_t[j]); non_term_1=(*it1).first; for(;it1!=rules.end() && (((*it1).first.compare(non_term_1))==0);it1++) { RHS1=(*it1).second; new_rhs.append(RHS1).append(remaining); rules.erase(it); rules.insert(pair<string,string>(non_term,new_rhs)); } } } } eliminate_immediate_left_recursion(rules,i); } }
void TiKNeighborhood::verifyKCandidateNeighborsForward ( const vector<KNeighborhoodPoint>& dataset , KNeighborhoodPoint& point , vector<KNeighborhoodPoint>::iterator& pointForwardIt , bool& forwardSearch , multimap<double, vector<KNeighborhoodPoint>::iterator, DistanceComparator>& kNeighborhood , unsigned long k , unsigned long& realDistanceCalculationsCounter){ double distance; unsigned long i; while(forwardSearch && ((pointForwardIt->distance[0] - point.distance[0]) <= point.eps)){ distance = Point::minkowskiDistance((*pointForwardIt), point, 2); realDistanceCalculationsCounter++; if(distance < point.eps){ i = getKeysNr(kNeighborhood, point.eps); if((kNeighborhood.size() - i) >= (k - 1)){ kNeighborhood.erase(point.eps); kNeighborhood.insert(pair<double, vector<KNeighborhoodPoint>::iterator>(distance, pointForwardIt)); point.eps = getMaxDistance(kNeighborhood); } else{ kNeighborhood.insert(pair<double, vector<KNeighborhoodPoint>::iterator>(distance, pointForwardIt)); } } else if(distance == point.eps){ kNeighborhood.insert(pair<double, vector<KNeighborhoodPoint>::iterator>(distance, pointForwardIt)); } forwardSearch = followingPoint(dataset, pointForwardIt); } }