C++ tr1::unordered_map类代码示例

static std::string encode(const std::string& s,const std::tr1::unordered_map<char,std::string>& charToAscii){
  if(s.empty()) return "";
  size_t i=s.length()-1;
  std::string ret;
  while(true){
    const std::tr1::unordered_map<char,std::string>::const_iterator iter=charToAscii.find(s[i]);
    if(iter!=charToAscii.end()) ret.append(iter->second);
    else throw std::runtime_error("char not found");
    if(i==0) break;
    i--;
  }
  return ret;
};

bool suisto_get_since( std::string stream_name, uint64_t ts, std::vector<entry_t*>& out ){	
	std::tr1::unordered_map< std::string, Stream  >::iterator it;

	it = streams.find( stream_name );

	if( it == streams.end() ){
		return false;
		}	
	
	out = (it->second).since( ts );
		
	return true;
	}

  void muladd(const fv_t &fv, const int y, float scale) {
    for (size_t i = 0; i < fv.size(); i++) {
	  int key = fv[i].first;
      float x_i = fv[i].second;

	  std::tr1::unordered_map<int, float>::iterator wit = w.find(key);
      if (wit != w.end()) {
		wit->second += y * x_i * scale;
      } else {
        w[key] = y * x_i * scale;
      }
    }
  };

  float dotproduct(const fv_t& fv) {
    float m = 0.0;
    size_t fv_size = fv.size();
    for (size_t i = 0; i < fv_size; i++) {
	  int key = fv[i].first;
      float x_i = fv[i].second;
	  std::tr1::unordered_map<int, float>::iterator wit = w.find(key);
      if (wit != w.end()) {
        m +=  x_i * wit->second;
      }
    }
    return m;
  };

bool suisto_get_latest( std::string stream_name, size_t max_entries, std::vector<entry_t*>& out ){	
	std::tr1::unordered_map< std::string, Stream  >::iterator it;

	it = streams.find( stream_name );

	if( it == streams.end() ){
		return false;
		}	
		
	out = (it->second).latest( max_entries );
		
	return true;
	}

bool suisto_create_stream( std::string stream_name ){
	std::tr1::unordered_map< std::string, Stream  >::iterator it;

	it = streams.find( stream_name );

	if( it != streams.end() ){
		return false;
		}	
	
	
	streams[ stream_name ] = Stream();

	return true;
	}

  void l1_regularize(const int iter) {
	float lambda_hat = get_eta(iter) * lambda;

	std::tr1::unordered_map<int, float> tmp = w;
	std::tr1::unordered_map<int, float>::iterator it = tmp.begin();
	for (; it != tmp.end(); it++) {
	  int key = it->first;
	  std::tr1::unordered_map<int, float>::iterator wit = w.find(key);
	  float aaa = wit->second;
	  wit->second = clip_by_zero(wit->second, lambda_hat);
	  if (fabsf(aaa) < lambda_hat) {
		w.erase(wit);
	  } 
	}
  };

std::tr1::shared_ptr<WordTagFreqs> ModelPrivate::readLexicon(
	std::istream &lexiconStream,
	std::tr1::unordered_map<std::string, size_t> const &tagNumbers)
{
	std::tr1::shared_ptr<WordTagFreqs> lexicon(
		new WordTagFreqs);

	std::string line;
	while (std::getline(lexiconStream, line)) {
		std::istringstream lineStream(line);

		// Read line items.
		std::vector<std::string> lineItems;
		copy(std::istream_iterator<std::string>(lineStream),
			std::istream_iterator<std::string>(),
			std::back_inserter(lineItems));

		if (lineItems.size() == 0 || (lineItems.size() - 1) % 2 != 0)
		  throw std::runtime_error(std::string("Invalid lexicon entry: ") + line);

		std::string word = lineItems[0];

		for (size_t i = 1; i < lineItems.size(); i += 2) {
			std::istringstream freqStream(lineItems[i + 1]);
			size_t freq;
			freqStream >> freq;
			size_t tag = tagNumbers.find(lineItems[i])->second;
			(*lexicon)[word][tag] = freq;
		}
	}

	return lexicon;
}

void m_dccchat::dccListen(std::string id, Socket* listenSocket) {
	std::tr1::unordered_map<std::string, std::vector<std::string> >::iterator ourReportingModules = reportingModules.find(id);
	while (true) {
		if (!listenSocket->isConnected())
			break;
		std::string receivedMsg = listenSocket->receive();
		std::cout << "DCC " << id << ":" << receivedMsg << std::endl;
		std::tr1::unordered_map<std::string, Module*> modules = getModules(); // get a new one each time in case it is updated
		for (std::tr1::unordered_map<std::string, std::string>::iterator hookIter = moduleTriggers.begin(); hookIter != moduleTriggers.end(); ++hookIter) {
			if (hookIter->first == receivedMsg.substr(0, receivedMsg.find_first_of(' '))) {
				bool alreadyReporting = false;
				for (unsigned int i = 0; i < ourReportingModules->second.size(); i++) {
					if (ourReportingModules->second[i] == hookIter->second) {
						alreadyReporting = true;
						break;
					}
				}
				if (!alreadyReporting)
					ourReportingModules->second.push_back(hookIter->second);
			}
		}
		for (unsigned int i = 0; i < ourReportingModules->second.size(); i++) {
			std::tr1::unordered_map<std::string, Module*>::iterator modIter = modules.find(ourReportingModules->second[i]);
			if (modIter == modules.end())
				ourReportingModules->second.erase(ourReportingModules->second.begin()+i);
			else {
				std::vector<std::string> modSupports = modIter->second->supports();
				for (unsigned int i = 0; i < modSupports.size(); i++) {
					if (modSupports[i] == "DCC_CHAT") {
						dccChat* dccMod = (dccChat*)modIter->second;
						dccMod->onDCCReceive(id, receivedMsg);
						break;
					}
				}
			}
		}
	}
	std::tr1::unordered_map<std::string, Module*> modules = getModules();
	for (unsigned int i = 0; i < reportingModules.size(); i++) {
		std::tr1::unordered_map<std::string, Module*>::iterator modIter = modules.find(ourReportingModules->second[i]);
		dccChat* dccMod = (dccChat*) modIter->second;
		dccMod->onDCCEnd(id); // call the DCC end hook for each watching module as the DCC session ends
	}
	delete listenSocket;
	activeConnections.erase(id);
}

void m_dccchat::unhookDCCSession(std::string modName, std::string dccid) {
	std::tr1::unordered_map<std::string, std::vector<std::string> >::iterator reportingModIter = reportingModules.find(dccid);
	if (reportingModIter == reportingModules.end())
		return;
	for (unsigned int i = 0; i < reportingModIter->second.size(); i++) {
		if (reportingModIter->second[i] == modName)
			reportingModIter->second.erase(reportingModIter->second.begin()+i);
	}
}

bool suisto_add_post( std::string stream_name, std::string post_content ){
	std::tr1::unordered_map< std::string, Stream  >::iterator it;

	it = streams.find( stream_name );

	if( it == streams.end() ){
		return false;
		}	
	
	entry_t *entry = new entry_t;
	entry->id = Clock::next();
	entry->timestamp = generate_timestamp( entry->id );

	posts[entry->id] = escape_string( post_content );

	(it->second).add( entry );

	return true;
	}

    double Modularity::getQualityScore(const Graph * graph, std::tr1::unordered_map<uint32_t, Community*>& communities, double gamma)
    {
     //	const uint32_t communityNum = communities.size();

	    double Q = 0.0;
	    uint32_t edge_num = graph->edge_num_;
        std::tr1::unordered_map<uint32_t, Community*>::iterator itr;
	    for(itr=communities.begin(); itr!=communities.end(); itr++)
	    {
            Community * community = itr->second;
		    uint32_t in_degree = community->in_degree_;
		    uint32_t total_degree = community->total_degree_;

		    Q += ((double)in_degree)/(2*(double)edge_num) - pow((double)total_degree/((double)(2*edge_num)), 2);
            //printf("Q: %f, indegree: %u, total: %u, edgenum: %u\n",Q,in_degree, total_degree, edge_num);
	    }
			std::cout << "Q: \t" << Q << "\n";

	    return Q;
    }

inline void operator<< (object::with_zone& o, const std::tr1::unordered_map<K,V>& v)
{
	o.type = type::MAP;
	if(v.empty()) {
		o.via.map.ptr  = NULL;
		o.via.map.size = 0;
	} else {
		object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
		object_kv* const pend = p + v.size();
		o.via.map.ptr  = p;
		o.via.map.size = v.size();
		typename std::tr1::unordered_map<K,V>::const_iterator it(v.begin());
		do {
			p->key = object(it->first, o.zone);
			p->val = object(it->second, o.zone);
			++p;
			++it;
		} while(p < pend);
	}
}

std::string resolve(size_t len,const std::string& s,std::tr1::unordered_map<std::string,int> count){
  count.clear();
  if(s.length()<len) throw std::runtime_error("err");
  if(s.length()==len) return s;
  const size_t maxIndex=s.length()-len;
  std::tr1::unordered_map<std::string,int>::iterator end=count.end();
  int maxCount=1;
  std::string maxStr=s.substr(0,3);
  for(size_t i=1;i!=maxIndex;++i){
    const std::string substr=s.substr(i,len);
    std::tr1::unordered_map<std::string,int>::iterator iter=count.find(substr);
    if(iter!=end){
      if(++iter->second > maxCount){
	maxCount=iter->second;
	maxStr=substr;
      }      
    }
    else count[substr]=1;
  }
  return maxStr;
}

static std::string decode(const std::string& s,const std::tr1::unordered_map<std::string,char>& asciiToChar){
  if(!isDigit(s)) 
    throw std::runtime_error("err");
  std::string ret;
  for(size_t i=0;i+1<s.length();){
    std::string key;
    if(s[i+1]<='2'){
      if(i+2>=s.length()) throw std::runtime_error("err");
      key=s.substr(i,3);
      i+=3;
    } else{
      key=s.substr(i,2);
      i+=2;
    }
    const std::tr1::unordered_map<std::string,char>::const_iterator iter=asciiToChar.find(key);
    if(iter!=asciiToChar.end())
      ret.append(1,iter->second);
    else throw std::runtime_error("num not found");
  }
  std::reverse(ret.begin(),ret.end());
  return ret;
}