//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
}
//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;
}
/* 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;
}
// Maps highest frequency of codons to each amino acid
vector<float> CodonFrequency::createMaxMap(multimap<char, pair<int, float> > AAtoCodonMap){
// cout << "------maxFreq------" << endl;
vector<float> maxMap;
float maxFreq;
// Loops through all amino acids
// If char rep of AA exists
// Calculate highest frequency to maxMap
for (char AA = 'A'; AA <= 'Z'; AA++) {
int addressAA = AA - 65;
if (AA == 'B' || AA == 'J' || AA == 'O' || AA == 'U' || AA == 'X') {
maxMap.push_back(-1);
// continue;
}
else if (AAtoCodonMap.count(AA) > 1) {
maxFreq = findMax(AAtoCodonMap, AA);
maxMap.push_back(maxFreq);
// continue;
} else if (AAtoCodonMap.count(AA) == 1) {
maxMap.push_back(AAtoCodonMap.find(AA)->second.second);
}
// to print values: comment out the continues in if statements
// cout << addressAA << " " << AA << " " << maxMap[addressAA] << endl;
}
return maxMap;
}
int get(int key){
multimap<int, V2C>::iterator it = key2Value2Count.find(key);
if(it != key2Value2Count.end())
{
V2C& tmp = it->second;
#if 0
pair <multimap<int,int>::iterator, multimap<int,int>::iterator> ret;
ret = count2Key.equal_range(tmp.count);
for(multimap<int,int>::iterator it=ret.first; it!=ret.second;++it)
{
if(it->second == key)
{
count2Key.erase(it);
tmp.count++;
count2Key.insert(pair<int, int>(tmp.count, key));
break;
}
}
#endif
count2Key.erase(tmp.it);
list<int>::iterator iit = count2Key.insert(count2Key.end(),key);
tmp.it=iit;
#if 0
cout << "cache hit" << key << endl;
#endif
return tmp.value;
}
else
{
// cout << "cache miss" << key << endl;
return -1;
}
}
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 whoReq(struct request_who *rw)
{
string username = getUserOfCurrAddr();
struct sockaddr_in address;
string chaNel = (string)(rw->req_channel);
multimap<string, struct sockaddr_in>::iterator ui = userToAddrStrct.find(username);
map<string,vector<pair<string,struct sockaddr_in> > >::iterator vi;
if((vi = chanTlkUser.find(chaNel)) == chanTlkUser.end()) {
return -1;
}
int numCHAN = (vi->second).size();
vector<pair<string,struct sockaddr_in> > v = vi->second;
address = ui->second;
struct text_who *msg = (struct text_who*)malloc(sizeof(struct text_who)+(numCHAN* sizeof(struct user_info)));
msg->txt_type= TXT_WHO;
msg->txt_nusernames = numCHAN;
const char* str = chaNel.c_str();
strcpy(msg->txt_channel, str);
for (int i = 0; i<v.size(); i++) {
const char* tstr = v[i].first.c_str();
strcpy(((msg->txt_users)+i)->us_username, tstr);
}
int size = sizeof(struct sockaddr);
int res= sendto(sockfd, msg, (sizeof(struct text_who)+(numCHAN* sizeof(struct user_info))), 0, (struct sockaddr*)&address, size);
if (res == -1) {
return -1;
}
free(msg);
return 0;
}
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 copyrandom(struct node *newnode,struct node *root)
{
if(root==NULL)
return;
multimap<struct node *,struct node *>::iterator i;
i=m.find(root->random);
newnode->random=i->second;
copyrandom(newnode->left,root->left);
copyrandom(newnode->right,root->right);
}
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);
}
}
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 printmultimap(multimap <string, string> &authors)
{
typedef multimap <string, string>::size_type sz_type;
sz_type co = authors.count("Barth, John");
//cout << count;
multimap <string, string>::iterator iter = authors.find("Barth, John");
for (sz_type cnt = 0; cnt != co; ++cnt,++iter)
{
cout << iter->first << ":--->" << iter->second << endl;
}
}
//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);
}
}
//check if current request address is valid or exist in map
int checkValidAddr(struct request *r)
{
string realAddrString = getAddr_string();
string smiAddrString = getSemiAddr_string();
map<pair<string,string>,string>::iterator it = addrToUser.find(pair<string,string>(realAddrString,smiAddrString));
if(it == addrToUser.end()) {
cout << "super baddd addressss mann\n";
cout << realAddrString << " that THING\n";
return -1;
}
return 0;
}
void solve(multimap<string, string>& dic, string seq, string ans)
{
for (unsigned int i = 1; i <= seq.size(); ++i) {
string h = seq.substr(0, i), rem = seq.substr(i);
for (multimap<string, string>::iterator it = dic.find(h); it != dic.end() && (*it).first == h; ++it) {
if (rem.empty())
cout << ans << (*it).second << "." << endl;
else
solve(dic, rem, ans + (*it).second + " ");
}
}
return;
}
// Maps average frequency of codons to each amino acid
vector<float> CodonFrequency::createAvgMap(multimap<char, pair<int, float> > AAtoCodonMap) {
// cout << "------avgFreq------" << endl;
int addressAA;
int codonPerAA; // Numbers of codons that code for an amino acid
float sumFreq; // Sum of codon frequencies for an amino acid
float avgFreq; // sumFreq/codonPerAA to calculate average frequency for an amino acid
vector<float> avgMap;
for (char AA = 'A'; AA <= 'Z'; AA++) {
addressAA = AA-65;
codonPerAA = 0;
sumFreq = 0;
avgFreq = 0;
if (AA == 'B' || AA == 'J' || AA == 'O' || AA == 'U' || AA == 'X') {
avgMap.push_back(-1);
// continue;
}
else if (AAtoCodonMap.count(AA) > 1) {
pair< multimap<char, pair<int, float> >::iterator,
multimap<char, pair<int, float> >::iterator> ret;
ret = AAtoCodonMap.equal_range(AA);
for (multimap<char, pair<int, float> >::iterator it = ret.first; it != ret.second; ++it) {
// cout << AA << " " << it->second.second << endl;
sumFreq += it->second.second;
codonPerAA++;
}
avgFreq = sumFreq/codonPerAA;
// cout << sumFreq << " / " << codonPerAA << " = " << avgFreq << endl;
avgMap.push_back(avgFreq);
// continue;
} else if (AAtoCodonMap.count(AA) == 1) {
avgMap.push_back(AAtoCodonMap.find(AA)->second.second);
// continue;
}
// cout << addressAA << " " << AA << " " << avgMap[addressAA] << endl;
}
return avgMap;
}
void CCacheThread::SetOnlyValueProcess(const multimap<unsigned int, string> &mapRequestValue, multimap<unsigned int, string> &mapStoredValue)
{
CVS_XLOG(XLOG_DEBUG, "CCacheThread::%s\n", __FUNCTION__);
multimap<unsigned int, string>::iterator itr;
multimap<unsigned int, string>::const_iterator citr;
for (citr = mapRequestValue.begin(); citr != mapRequestValue.end(); ++citr)
{
itr = mapStoredValue.find(citr->first);
if (itr == mapStoredValue.end())
{
mapStoredValue.insert(make_pair(citr->first, citr->second));
}
else
{
itr->second = citr->second;
}
}
}
TImage* TImageManager::loadImage (const string& rktNAME, const string& rktFORMAT)
{
string tFileName;
TImageData* ptImageData;
TImage* ptImage = NULL;
cout << "Loading image : " << rktNAME << endl;
bool gAbsolutePath = ( rktNAME[0] == '/' );
if ( gAbsolutePath )
{
ptImage = TImageManager::_load (rktNAME, rktFORMAT);
}
else
{
multimap<string, string>::const_iterator iter;
iter = tConfigData.find ("TexturePath");
while ( ( iter != tConfigData.end() ) && ( (*iter).first == "TexturePath" ) )
{
if ( FileExists ((*iter).second + "/" + rktNAME) )
{
ptImage = TImageManager::_load ((*iter).second + "/" + rktNAME, rktFORMAT);
break;
}
iter++;
}
}
if ( ptImage )
{
ptImageData = new TImageData();
ptImageData->ptImage = ptImage;
ptImageData->gLoaded = true;
tImageDataMap [rktNAME] = ptImageData;
}
return ptImage;
} /* loadImage() */
//handle login requests
int listReq(struct request_list *rl)
{
string username = getUserOfCurrAddr();
struct sockaddr_in address;
multimap<string, struct sockaddr_in>::iterator ui = userToAddrStrct.find(username);
int numCHAN = channels.size();
address = ui->second;
struct text_list *msg = (struct text_list*)malloc((sizeof(struct text_list)+(numCHAN *sizeof(struct channel_info))));
msg->txt_type= TXT_LIST;
msg->txt_nchannels = numCHAN;
for (int i = 0; i<channels.size(); i++) {
const char* tstr = channels[i].c_str();
strcpy(((msg->txt_channels)+i)->ch_channel, tstr);
}
int size = sizeof(struct sockaddr);
int res= sendto(sockfd, msg, (sizeof(struct text_list)+(numCHAN *sizeof(struct channel_info))), 0, (struct sockaddr*)&address, size);
if (res == -1) {
return -1;
}
free(msg);
return 0;
}
//handle login requests
int leaveReq(struct request_leave *rl)
{
string username = getUserOfCurrAddr();
struct sockaddr_in reqAddr = getAddrStruct();
string chaNel = (string)(rl->req_channel);
multimap<string, struct sockaddr_in>::iterator ui = userToAddrStrct.find(username);
struct sockaddr_in address = ui->second;
map<string,vector<pair<string,struct sockaddr_in> > >::iterator vi;
if((vi = chanTlkUser.find(chaNel)) == chanTlkUser.end()) {
return -1;
}
vector<pair<string,struct sockaddr_in> > v = vi->second;
for(int vecI=0; vecI<v.size(); vecI++) {
if(v[vecI].first == username) {
if(checkAddrEq(v[vecI].second, reqAddr) == 0) {
v.erase (v.begin()+vecI);
}
}
}
chanTlkUser.erase(vi);
if(v.size() != 0) {
chanTlkUser.insert(pair<string,vector<pair<string,struct sockaddr_in> > >(chaNel,v));
return 0;
} else {
for(int i=0; i<channels.size(); i++) {
if(channels[i] == chaNel) {
channels.erase(channels.begin()+i);
}
}
}
vector<string> chanTlk = usrTlkChan[username];
for(int vv=0; vv<chanTlk.size(); vv++) {
if(chanTlk[vv] == chaNel) {
chanTlk.erase(chanTlk.begin()+vv);
}
}
usrTlkChan[username] = chanTlk;
return 0;
}
void preprocess() {
for (int i = 0; i < raw_heads.size(); i++) {
raw_head_to_body.insert(pair<int,int>(toInt((Lit) raw_heads[i]), i));
}
for (int i = 0; i < raw_heads.size(); i++) {
if (raw_posb[i].size() == 1 && raw_negb[i].size() == 0) {
if (raw_head_to_body.count(toInt((Lit) raw_posb[i][0])) == 1) {
int r = raw_head_to_body.find(toInt((Lit) raw_posb[i][0]))->second;
raw_bl[i] = raw_posb[i][0];
raw_posb[r].copyTo(raw_posb[i]);
raw_negb[r].copyTo(raw_negb[i]);
raw_heads[r] = bv_false;
}
}
}
for (int i = 0; i < raw_heads.size(); i++) {
if (raw_heads[i] == bv_false) continue;
getId(raw_heads[i]);
}
}
//handle login requests
int listReq(struct request_list *rl)
{
struct sockaddr* address;
multimap<string, pair<string,string> >::iterator ui = userToAddr.find(getUserOfCurrAddr());
pair<string,string> tad = ui->second;
string ad = tad.second;
char *s= (char*) malloc(sizeof(char)*BUFLEN);
strncpy(s, ad.c_str(), strlen(ad.c_str()));
inet_pton(AF_INET, s, &address);
struct text_list *msg= (struct text_list*) malloc(sizeof(struct text_list) + BUFLEN);
msg->txt_type= htonl(TXT_LIST);
msg->txt_nchannels = htonl(channels.size());
for (int i = 0; i < channels.size(); i++) {
strncpy(msg->txt_channels[i].ch_channel, channels[i].c_str(), CHANNEL_MAX);
}
int size = sizeof(struct sockaddr);
int res= sendto(sockfd, msg, sizeof(struct text_list), 0, address, size);
if (res == -1) {
cout << "sendto very badd \n";
//return -1;
}
free(msg);
return 0;
}
void CCacheThread::CasValueProcess(const multimap<unsigned int, string> &mapRequestValue, multimap<unsigned int, string> &mapStoredValue)
{
CVS_XLOG(XLOG_DEBUG, "CCacheThread::%s\n", __FUNCTION__);
multimap<unsigned int, string>::iterator itr;
multimap<unsigned int, string>::const_iterator citr;
for (citr=mapRequestValue.begin(); citr!=mapRequestValue.end(); ++citr)
{
itr = mapStoredValue.find(citr->first);
if(itr==mapStoredValue.end())
{
mapStoredValue.insert(make_pair(citr->first, citr->second));
}
else
{
unsigned int dwStoreValue = atoi(itr->second.c_str());
unsigned int dwNeedAddValue = atoi(citr->second.c_str());
dwStoreValue += dwNeedAddValue;
char szTemp[32] = {0};
snprintf(szTemp, sizeof(szTemp), "%d", dwStoreValue);
itr->second = szTemp;
}
}
}
bool hasOpt(multimap<string,string>&optmap,const string& key){
return !(optmap.find(key)==optmap.end());
}
set<string> calc_first(string symbol)
{
//cout<<"Symbol: "<<symbol<<endl;
if(symbol.compare("$")==0)
{
set<string> ftemp;
ftemp.insert("$");
vector<string>::iterator ite=find(first_recursed.begin(),first_recursed.end(),symbol);
if(ite!=first_recursed.end())
first_recursed.erase(ite);
return ftemp;
}
else if(find(t.begin(),t.end(),symbol)!=t.end())
{
set<string> ftemp;
ftemp.insert(symbol);
vector<string>::iterator ite=find(first_recursed.begin(),first_recursed.end(),symbol);
if(ite!=first_recursed.end())
first_recursed.erase(ite);
return ftemp;
}
set<string> final_set;
multimap<string,string>::iterator it;
it = rules.find(symbol);
string token;
vector<string> tokens;
while(it!=rules.end() && (it->first).compare(symbol)==0)
{
token.clear();
tokens.clear();
for(int i = 0; i < (it->second).size(); i++)
{
if((it->second)[i]!=' ' && i!=(it->second).size()-1)
{
token.push_back((it->second)[i]);
}
else
{
if(i==(it->second).size()-1)
token.push_back((it->second)[i]);
tokens.push_back(token);
token.clear();
}
}
set<string> returned_fset;
//cout<<"token-0: "<<tokens[0]<<" "<<tokens.size()<<endl;
vector<string>::iterator ite=find(first_recursed.begin(),first_recursed.end(),tokens[0]);
if(ite!=first_recursed.end())
{
}
else
{
first_recursed.push_back(tokens[0]);
returned_fset = calc_first(tokens[0]);
}
int j=0;
int cnt=0;
for(j = 1; j < tokens.size(); j++)
{
//cout<<j<<" "<<tokens[j]<<endl;
nullable_recursed.push_back(tokens[j-1]);
if(is_nullable(tokens[j-1]))
{
cnt++;
vector<string>::iterator ite=find(first_recursed.begin(),first_recursed.end(),tokens[j]);
if(ite!=first_recursed.end())
{
}
else
{
first_recursed.push_back(tokens[j]);
Union(returned_fset,calc_first(tokens[j]),returned_fset);
}
}
else
break;
}
if(cnt==tokens.size())
{
returned_fset.insert("$");
}
Union(returned_fset,final_set,final_set);
//cout<<"Inc it"<<endl;
it++;
}
//cout<<"returning"<<endl;
map< string,set<string> > :: iterator iter = first_sets.find(symbol);
if(iter!=first_sets.end())
{
Union(final_set,first_sets[symbol],final_set);
first_sets[symbol] = final_set;
}
else
{
first_sets[symbol] = final_set;
}
vector<string>::iterator ite=find(first_recursed.begin(),first_recursed.end(),symbol);
if(ite!=first_recursed.end())
first_recursed.erase(ite);
return final_set;
}
void left_factor()
{
/*************************************/
/* Algorithm
/* Generate all the prefixes of
all the rules.
/* Take each prefix one by one
/* Check if it is the common
/* prefix of atleast two of the
/* rules.
/* Update the longest common prefix.*/
/*************************************/
bool non_terminal_used;
string RHS;
string pre;
multimap<string,string>::iterator it;
string new_left_rule;
// for(int i=0;i<prefixes.size();i++)
// {
// cout<<"Prefix:"<<prefixes[i]<<endl;
// }
string prefix_of_rhs;
int len_of_prefix;
int len_of_longest_prefix;
string longest_prefix; // keeps track of what is the longest prefix.
int longest_prefix_index=-1;
int count_of_matches; // keeps track of how many rules match for a given prefix.
string left,remaining; // left holds the prefix. // remaining holds the remaining RHS.
string new_non_terminal;
for(int n=0;n<n_t.size();n++)
{
memset(is_considered,0,sizeof(is_considered));
memset(is_matched,0,sizeof(is_matched));
prefixes.clear();
current_non_term_rules.clear();
it=rules.find(n_t[n]);
for(;it!=rules.end() && ((*it).first.compare(n_t[n])==0);it++)
{
current_non_term_rules.insert(pair<string,string>((*it).first,(*it).second));
}
for(it=current_non_term_rules.begin();it!=current_non_term_rules.end();it++)
{
pre.clear();
RHS=(*it).second;
//cout<<(*it).first<<"-->"<<(*it).second<<endl;
//cout<<RHS.size();
for(int i=0;i<RHS.size();i++)
{
pre.clear();
for(int j=0;j<=i;j++)
{
pre.push_back(RHS[j]);
}
if(find(prefixes.begin(),prefixes.end(),pre)==prefixes.end())
prefixes.push_back(pre);
}
}
// for(it=current_non_term_rules.begin();it!=current_non_term_rules.end();it++)
// {
// cout<<(*it).first<<"-->"<<(*it).second;
// }
for(int m=0;m<current_non_term_rules.size();m++)
{
//cout<<"Round "<<m<<endl;
longest_prefix.clear();
for(int i=0;i<prefixes.size();i++)
{
//cout<<"Current Prefix:"<<prefixes[i]<<endl;
len_of_prefix=prefixes[i].size();
count_of_matches=0;
for(it=current_non_term_rules.begin();it!=current_non_term_rules.end();it++)
{
// if(is_matched[it-rules.begin()])
// continue;
prefix_of_rhs.clear();
RHS.clear();
RHS=(*it).second;
//cout<<(*it).first<<"-->"<<(*it).second<<endl;
if(RHS.size()<len_of_prefix|| is_considered[distance(current_non_term_rules.begin(),it)])
continue;
for(int j=0;j<len_of_prefix;j++)
{
prefix_of_rhs.push_back(RHS[j]);
}
//cout<<"Prefix of RHS:"<<prefix_of_rhs<<endl;
if(prefix_of_rhs.compare(prefixes[i])==0)
{
//cout<<prefix_of_rhs<<"matched with "<<prefixes[i]<<endl;
//cout<<"Rule No:"<<distance(rules.begin(),it)<<endl;
is_matched[i][distance(current_non_term_rules.begin(),it)]=true;
count_of_matches++;
}
}
// cout<<"RUles after longest prefix"<<endl;
// for(it=rules.begin();it!=rules.end();it++)
// {
// cout<<"Rule No:"<<<<"-"<<(*it).first<<"-->"<<(*it).second<<endl;
// }
//cout<<"Prefix is:"<<prefixes[i]<<" has count:"<<count_of_matches<<endl;
if(count_of_matches>1 && prefixes[i].size()>=1)
{
if(longest_prefix.size()<prefixes[i].size())
{
longest_prefix.clear();
longest_prefix=prefixes[i];
longest_prefix_index=i;
}
}
}
//cout<<"Index:"<<longest_prefix_index<<"and longest prefix is :"<<longest_prefix<<"!"<<endl;
if(longest_prefix_index!=-1 && longest_prefix.size()>=1)
{
/* Get rules which matched the longest prefix.*/
non_terminal_used=false;
new_non_terminal=next_nt_string();
for(int j=0;j<current_non_term_rules.size();j++)
{
if(is_matched[longest_prefix_index][j] && !is_considered[j])
{
non_terminal_used=true;
it=current_non_term_rules.begin();
advance(it,j);
RHS=(*it).second;
//cout<<"Rule No:"<<j<<"-"<<(*it).first<<"-->"<<(*it).second<<endl;
len_of_longest_prefix=longest_prefix.size();
left.clear();
remaining.clear();
for(int k=0;k<len_of_longest_prefix;k++)
{
left.push_back(RHS[k]);
}
if(RHS[len_of_longest_prefix]==' ')
len_of_longest_prefix++;
for(int k=len_of_longest_prefix;k<RHS.size();k++)
{
remaining.push_back(RHS[k]);
}
if(remaining.size()==0)
remaining="$"; //epsilon.
//cout<<"Remaining:"<<remaining<<" and new non terminal: "<<new_non_terminal<<endl;
/* Erase the current rule an push back the new rule in rules.*/
assert(left.compare(longest_prefix)==0);
//cout<<"Prefix:"<<left<<"and remaining: "<<remaining<<endl;
new_left_rule.clear();
if(longest_prefix[longest_prefix.size()-1]!=' ')
new_left_rule.append(longest_prefix).append(" ").append(new_non_terminal);
else
new_left_rule.append(longest_prefix).append(new_non_terminal);
left_factored_rules.insert(pair<string,string>(new_non_terminal,remaining));
is_considered[distance(current_non_term_rules.begin(),it)]=true;
//rules.erase(it);
}
}
if(non_terminal_used)
{
left_factored_rules.insert(pair<string,string>((*it).first,new_left_rule));
left_fact_n_t.push_back(new_non_terminal);
}
}
}
update_rules(is_considered);
}
multimap<string,string>::iterator iter;
for(iter=left_factored_rules.begin();iter!=left_factored_rules.end();iter++)
{
cout<<(*iter).first<<"-->"<<(*iter).second<<endl;
}
}
/// insert binary operator specified by oit into Shunting-Yard
void insert_binaryoper(postfix_t &out, stack<token_t> &s, decltype(opers)::iterator oit)
{
while (!s.empty())
{
bool found = false; // stack top element is operator
int tprec; // prec of stack top element
auto range = opers.equal_range(s.top().first);
for (auto oit2 = range.first; oit2 != range.second; ++oit2)
{
if (s.top().second == (oit2->second.unary ? 1 : 2)) // find the correct arity version of the operator
{
tprec = oit2->second.prec;
found = true;
break;
}
}
if ((found && ((!oit->second.right && oit->second.prec == tprec) || (oit->second.prec < tprec))) || (!found && funcs.find(s.top().first) != funcs.end()))
out.push_back(pop(s));
else
break;
}
s.push(token_t(oit->first, 2));
}
bool ProcessConfigFile (const string& rktCONFIG, multimap<string, string>& rtMAP)
{
string tOptionName, tOptionValue;
ifstream tConfigFile;
char* pcBuffer = new char[200];
tConfigFile.open (rktCONFIG.c_str());
if ( !tConfigFile )
{
return false;
}
// Reads configuration file line by line
while ( !tConfigFile.eof() )
{
Byte J;
bool gAppend;
tOptionName = "";
tOptionValue = "";
gAppend = false;
tConfigFile.getline (pcBuffer, 200);
// Checks for an empty line
if ( strlen (pcBuffer) == 0 )
{
continue;
}
// Checks for a comment
if ( pcBuffer[0] == '#' )
{
continue;
}
// Gets option name (until the first occurrence of character '=')
for (J = 0; ( ( J < strlen (pcBuffer) ) && ( pcBuffer[J] != '=' ) ) ;J++)
{
tOptionName += pcBuffer[J];
}
// Checks if the line contains no '=' character
if ( J == strlen (pcBuffer) )
{
continue;
}
// Checks if we are adding a new value for that option, or substituting previous ones
if ( ( J > 0 ) && ( pcBuffer[J - 1] == '+' ) )
{
tOptionName = tOptionName.substr (0, J - 1);
gAppend = true;
}
// Gets option value (until the end of the line)
for (J++; ( J < strlen (pcBuffer) ) ;J++)
{
tOptionValue += pcBuffer[J];
}
if ( !gAppend )
{
// Removes every previous option with the same name
multimap<string, string>::iterator iter;
while ( (iter = rtMAP.find (tOptionName)) != rtMAP.end() )
{
rtMAP.erase (iter);
}
}
if( tOptionValue[0] != '/' )
{
tOptionValue = _tLocalPath + tOptionValue;
}
// Inserts a new option entry in the map
rtMAP.insert (pair<const string, string> (tOptionName, tOptionValue));
}
tConfigFile.close();
delete pcBuffer;
return true;
} /* ProcessConfigFile() */
int main (int argc, char *argv[])
{
ofstream tLogFile;
TScene* ptScene;
char acTimeString [30];
time_t tBaseTime, tInitTime, tRenderTime, tPostProcessTime;
GlobalClassManager = new TClassManager();
_tProgramName = "render";
ProcessCommandLine (argc, argv);
SetPaths();
if ( !FileExists (_tLocalPath + "config") )
{
cerr << "WARNING: No configuration file in " << _tLocalPath << endl;
}
else
{
if ( !ProcessConfigFile (_tLocalPath + "config", tConfigData) )
{
cerr << "ERROR: Couldn't read configuration file." << endl;
exit (1);
}
}
// for (multimap<string, string>::const_iterator iter = tConfigData.begin(); ( iter != tConfigData.end() ) ;iter++)
// {
// cout << (*iter).first << " = " << (*iter).second << endl;
// }
multimap<string, string>::const_iterator iter = tConfigData.find ("PluginConfigFile");
string tPluginConfigFile = ( iter != tConfigData.end() ) ? (*iter).second : _tLocalPath + "pluginrc";
if ( !FileExists (tPluginConfigFile) )
{
cerr << "ERROR: Plugin configuration file '" << tPluginConfigFile << "' does not exist." << endl;
exit (1);
}
cout << "Loading plugins..." << endl;
tPluginManager.initialize (tPluginConfigFile, 0);
TGradient::_initialize();
TImageManager::_initialize();
TSceneManager::_initialize();
tImageManager.initialize();
if ( !TSceneManager::_knownFormat (_tInputFileFormat) )
{
cout << "ERROR: Scene format not supported" << endl;
exit (1);
}
cout << "Parsing..." << endl;
ptScene = TSceneManager::_load (_tInputFileName, _tInputFileFormat);
if ( !ptScene )
{
cerr << "Error parsing input file" << endl;
exit (1);
}
//
// Uncomment next line for debug information on the whole scene.
//
// ptScene->printDebug();
tBaseTime = time (NULL);
cout << "Initializing..." << endl;
if(!ptScene->initialize())
{
cerr << "Initialization failed!" << endl;
exit (1);
}
tInitTime = time (NULL);
cout << "Rendering..." << endl;
ptScene->render (&FinishedLine);
tRenderTime = time (NULL);
cout << "Postprocessing..." << endl;
ptScene->postprocess();
tPostProcessTime = time (NULL);
cout << "Saving..." << endl;
if ( !ptScene->saveImage() )
{
cout << "Could not save image file" << endl;
}
ptScene->finalize();
cout << endl;
cout << " Total ellapsed time : " << difftime (tPostProcessTime, tBaseTime) << " secs" << endl;
cout << " - Initialization . . . " << difftime (tInitTime, tBaseTime) << " secs" << endl;
cout << " - Render . . . " << difftime (tRenderTime, tInitTime) << " secs" << endl;
cout << " - Postprocessing . . . " << difftime (tPostProcessTime, tRenderTime) << " secs" << endl;
cout << "";
if ( _gKeepLog )
{
strftime (acTimeString, 30, "%b %d %H:%M:%S", localtime (&tBaseTime));
tLogFile.open (_tLogFileName.c_str(), ios::out | ios::binary | ios::app);
tLogFile << acTimeString << " " << _tInputFileName << ", " << difftime (tPostProcessTime, tBaseTime) << " seconds" << endl;
tLogFile.close();
}
delete GlobalClassManager;
return 0;
} /* main() */
/// convert infix string into postfix token list
postfix_t infix2postfix(string in)
{
postfix_t out;
stack<token_t> s;
token_t lasttok;
for (auto it = in.cbegin(); it != in.cend();)
{
const unsigned int i = it - in.cbegin(); // index of current character for parse_error purposes
static const string spaces = " \t\r\n";
if (spaces.find(*it) != string::npos)
{
++it;
continue;
}
/*cout << string(it, in.cend()) << endl;
cout << lasttok.first << "/" << lasttok.second << endl;
if (!s.empty())
cout << s.top().first << "/" << s.top().second << endl;*/
// try to parse number
static const string numbers = "0123456789.";
auto it2 = it;
for (; it2 != in.cend() && numbers.find(*it2) != string::npos; ++it2); // TODO: find_first_not_of
if (it2 != it)
{
if (lasttok.first == ")" || (opers.find(lasttok.first) == opers.end() && funcs.find(lasttok.first) != funcs.end()) || lasttok.second == -1)
throw parse_error("Missing operator", i);
out.push_back(lasttok = token_t(string(it, it2), -1));
it = it2;
continue;
}
// try to parse operator
auto lastoper = opers.find(lasttok.first);
bool lunary = lasttok.first == "" || lasttok.first == "(" || lasttok.first == "," || (lastoper != opers.end() && !(lastoper->second.unary && lastoper->second.right)); // true if operator at current location would be left unary
/*cout << unary << endl;
cout << endl;*/
auto oit = opers.begin();
for (; oit != opers.end(); ++oit)
{
if (equal(oit->first.begin(), oit->first.end(), it) && (oit->second.unary == lunary || (oit->second.unary && oit->second.right)))
break;
}
if (oit != opers.end())
{
if (lunary)
{
s.push(lasttok = token_t(oit->first, 1));
}
else if (oit->second.unary && oit->second.right) // right unary operator
{
// allow right unary operators to be used on constants and apply higher prec operators before
while (!s.empty())
{
token_t tok = s.top();
auto oit2 = find_oper(tok.first, true);
if ((oit2 != opers.end() && oit2->second.prec > oit->second.prec) || (oit2 == opers.end() && funcs.find(tok.first) != funcs.end()))
out.push_back(pop(s));
else
break;
}
out.push_back(lasttok = token_t(oit->first, 1)); // needs stack popping before?
}
else
{
insert_binaryoper(out, s, oit);
lasttok = token_t(oit->first, 2);
}
it += oit->first.size();
continue;
}
// try to parse function
auto fit = funcs.begin();
for (; fit != funcs.end(); ++fit)
{
if (opers.find(fit->first) == opers.end() && equal(fit->first.begin(), fit->first.end(), it))
break;
}
if (fit != funcs.end())
{
if (lasttok.first == ")" || (opers.find(lasttok.first) == opers.end() && funcs.find(lasttok.first) != funcs.end()))
throw parse_error("Missing operator", i);
else if (lasttok.second == -1)
insert_implicitmult(out, s);
s.push(lasttok = token_t(fit->first, 0));
it += fit->first.size();
continue;
}
// try to parse function argument separator
if (*it == ',')
{
if (lasttok.first == "(" || lasttok.first == ",")
throw parse_error("Missing argument", i);
bool found = false;
while (!s.empty())
{
token_t tok = s.top();
if (tok.first == "(")
{
found = true;
break;
}
else
{
out.push_back(tok);
s.pop();
}
}
if (!found)
throw parse_error("Found ',' not inside function arguments", i);
s.top().second++; // increase number of arguments in current parenthesis
lasttok = token_t(",", 0);
++it;
continue;
}
if (*it == '(')
{
if (lasttok.second == -1 || lasttok.first == ")")
insert_implicitmult(out, s);
s.push(lasttok = token_t("(", 1));
++it;
continue;
}
if (*it == ')')
{
if (lasttok.first == "(" || lasttok.first == ",")
throw parse_error("Missing argument", i);
bool found = false;
while (!s.empty())
{
token_t tok = s.top();
if (tok.first == "(")
{
found = true;
break;
}
else
{
out.push_back(tok);
s.pop();
}
}
if (!found)
throw parse_error("Found excess '('", i);
token_t tok = pop(s); // pop '('
if (!s.empty() && opers.find(s.top().first) == opers.end() && funcs.find(s.top().first) != funcs.end()) // if parenthesis part of function arguments
out.push_back(token_t(pop(s).first, tok.second));
lasttok = token_t(")", 0);
++it;
continue;
}
throw parse_error("Unknown token found", i);
}
while (!s.empty())
{
token_t tok = pop(s);
if (tok.first == "(")
throw parse_error("Found unclosed '('", in.size());
out.push_back(tok);
}
return out;
}
