//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);
}
}
