C++ map::cend方法代码示例

int Database::GetRecordByFields(const string tableName, map<string, string> fieldValues, vector< map<string, string> >* out, string sortField, bool bAsc) const
{
	if (!Util::IsLetterNumberDash(tableName) || !Util::IsLetterNumberDash(sortField))
		return 2;

	string order = " ORDER BY " + sortField + (bAsc ? " ASC;" : " DSC;");
	string sql = "SELECT * FROM " + tableName + " WHERE ";

	auto it = fieldValues.cbegin();
	while (it != fieldValues.cend())
	{
		if (!Util::IsLetterNumberDash((*it).first))
			return 2;
		sql.append(Util::ToUpper((*it).first + "='"));
		//*TODO: Check value
		sql.append((*it).second + "'");

		++it;
		if (it != fieldValues.cend())
			sql.append(" AND ");
	}

	sql += order;

	return Exec(sql, out);
}

void map_intersection(map<Key, Value>& lhs, map<Key, Value> const& rhs)
{
    typedef typename map<Key, Value>::iterator input_iterator1;
    typedef typename map<Key, Value>::const_iterator input_iterator2;

    input_iterator1 it1 = lhs.begin();
    input_iterator2 it2 = rhs.cbegin();
    input_iterator1 end1 = lhs.end();
    input_iterator2 end2 = rhs.cend();
    while (it1 != end1 && it2 != end2) {
        if (it1->first == it2->first) {
            it1->second += it2->second;
            ++it1;
            ++it2;
        }
        else {
            if (it1->first < it2->first) {
                ++it1;
            }
            else {
                ++it2;
            }
        }
    }
}

void grouped_vocabulary_tree<Point, K>::merge_maps(map<int, int>& map1, const map<int, int>& map2)
{
    using iter = map<int, int>::iterator;
    using citer = map<int, int>::const_iterator;

    iter it1 = map1.begin();
    citer it2 = map2.cbegin();
    iter end1 = map1.end();
    citer end2 = map2.cend();
    while (it2 != end2) {
        bool done1 = it1 == end1;
        if (!done1 && it1->first == it2->first) { // element already in 1, just increase count
            it1->second += it2->second;
            ++it1;
            ++it2;
        }
        else {
            if (done1 || it1->first > it2->first) {
                // from c++11 docs:
                // The function optimizes its insertion time if position points to the element
                // that will follow the inserted element (or to the end, if it would be the last).
                map1.insert(it1, *it2);
                ++it2;
            }
            else {
                ++it1; // if map1 is large while map2 is small this will not give better than const time insertion
            }
        }
    }
}

void EulerUtils::Display::printMap ( string itemName, const map<string, int>& data ) {
	cout << "in printMap" << endl;
	cout << "Printing " << itemName << "..." << endl;
	for ( auto i = data.cbegin(); i != data.cend(); i++ )
        cout << i->first << ": " << i->second << endl;
    cout << endl;
}

/*! \brief          Convert the name of a colour to a colour
    \param  str     name of a colour
    \return         the colour corresponding to <i>str</i>
*/
const int string_to_colour(const string& str)
{ static const map<string, int> colour_map { { "BLACK",   COLOUR_BLACK },
                                             { "BLUE",    COLOUR_BLUE },
                                             { "CYAN",    COLOUR_CYAN },
                                             { "GREEN",   COLOUR_GREEN },
                                             { "MAGENTA", COLOUR_MAGENTA },
                                             { "RED",     COLOUR_RED },
                                             { "WHITE",   COLOUR_WHITE },
                                             { "YELLOW",  COLOUR_YELLOW }
                                           };

  const string s = to_upper(remove_peripheral_spaces(str));
  const auto cit = colour_map.find(s);

  if (cit != colour_map.cend())
    return cit->second;

// should change this so it works with a colour name and not just a number
  if (begins_with(s, "COLOUR_"))
    return (from_string<int>(substring(s, 7)));

  if (begins_with(s, "COLOR_"))
    return (from_string<int>(substring(s, 6)));

  if (s.find_first_not_of(DIGITS) == string::npos)  // if all digits
    return from_string<int>(s);

  return COLOUR_BLACK;    // default
}

string Story::toString (const map<int, string> &glossary) const
{
	string result = "";
	result += this->timeStamp;
	for (const int wordID : this->words)
		if (glossary.find (wordID) != glossary.cend ())
			result += " " + glossary.find (wordID)->second;
	return result;
}

int Database::AddRecord(const string tableName, const map<string, string> newEntry)
{
	if (!Util::IsLetterNumberDash(tableName))
		return 2;

	string sql = "INSERT INTO " + tableName + " (";
	
	auto it = newEntry.cbegin();
	while(it != newEntry.cend())
	{
		if (!Util::IsLetterNumberDash((*it).first))
			return 2;

		if (Util::ToUpper((*it).first).compare("ID") == 0)
		{
			++it;
			continue;
		}

		sql.append(Util::ToUpper((*it).first));

		++it;
		if (it != newEntry.cend())
			sql.append(",");
		else
			sql.append(") ");
	}

	sql.append("VALUES(");
	it = newEntry.cbegin();
	while (it != newEntry.cend())
	{
		//*TODO: Check values
		sql.append("'" + (*it).second + "'");

		++it;
		if (it != newEntry.cend())
			sql.append(",");
		else
			sql.append(");");
	}

	return Exec(sql);
}

 Id getOrCreateId(const Name& u) {
   auto u_it = names.find(u);
   if( u_it != names.cend() )
     return u_it->second;
   else {
     Id u_id = (unsigned) nodes.size();
     nodes.push_back(Node(u));
     names.insert(make_pair(u, u_id));
     return u_id;
   }
 }

// --------------------------------------------------------------------------
inline
std::string
provider::realm () const
// --------------------------------------------------------------------------
{
  map::const_iterator it = m_req.find("realm");

  if (it != m_req.cend())
  {
    return it->second;
  }

  return "";
}

void Model::AddFeasCat(map<string, int> feaofcat, string catname,int threshold)
{
	auto itfc = feaofcat.cbegin();
	int count = 1;
	while (itfc != feaofcat.cend())
	{
		if (itfc->second <= threshold)
		{
			++itfc;
			continue;
		}
		stringstream query;
		query<< "insert into fc (feature,cat,count) values ('" << itfc->first << "','" << catname << "'," << itfc->second << ")";
		this->ExecuteSQL(query.str().c_str());
		++itfc;
	}
}

std::string RelationManager::showMap(const map<const Class *, set<const Class *> > &map, std::string msg) const
{
	std::string s;

	if (map.empty()) return "";

	if (msg != "")
		s.append(msg + "\n");
	for (auto i = map.cbegin(); i != map.cend(); i++) {
		s.append(i->first->getName() + ": ");
		for (auto j = i->second.cbegin(); j != i->second.cend(); j++)
			s.append((*j)->getName() + " ");
		s.append("\n");
	}

	return s.append("\n");
}

double getOpValue(const string &token){
	//cout<<"GetOpValue="<<token<<endl;
	switch(checkOpType(token)){
		case pure_number:
			return stod(token);
		case identifier:
			{
				auto it=variable.find(token);
				if(it==variable.cend()){
					variable[token]=0.0;
					return 0.0;
				}else
					return it->second;
			}
		case syntax_error:;
	}
}

	bool evaluate(const Point& inputPos, const Direction* inputDir, Point& outputPos, const Direction*& outputDir) const
	{
		if (inputDir == nullptr)
		{
			return false;
		}
		FlowConstIterator it = flows_.find(inputDir);
		if (it != flows_.cend())
		{
			outputDir = &(it->second->opposite());
			outputPos = inputPos + *it->second;
			return true;
		}
		else
		{
			return false;
		}
	}

/* Set 'tfidf', based on corpus */
void Story::setTFIDFBasedOnCorpus (const vector<Story> &corpus,
								   const map<int, set<int>> &storiesIndexWithCertainWord)
{
	if (this->termFrequency.empty ())
		this->setTermFrequency ();

	this->tfidf = this->termFrequency;
	for (map<int, double>::iterator iter = this->tfidf.begin ();
		 iter != this->tfidf.end (); ++iter) {
		if (storiesIndexWithCertainWord.find (iter->first) != storiesIndexWithCertainWord.cend ()) {
			double idf = 0.0;
			double storiesWithWord = 0.0;
			storiesWithWord = storiesIndexWithCertainWord.find (iter->first)->second.size ();
			idf = log (corpus.size () / storiesWithWord);
			iter->second *= idf;
		}
	}
}

bool compatibleVM(solution antSol,int i,ll n,int j,Server s,map<ll,qualifiedVM> omega)
{
    ll remCPU=s.ThreshCPU,remMEM=s.ThreshMEM;
	if(antSol.array[i]==-1 && (omega.find((ll)i)==omega.cend()))
	{
		for(register int k=0;k<n;k++)
		{
			if(antSol.array[k]!=-1 && antSol.array[k]==j)
			{
				remCPU-=(vm[k].CPU);
				remMEM-=(vm[k].MEM);
			}
		}
		if(remCPU>vm[i].CPU && remMEM>vm[i].MEM)
		{
			return true;
		}
		else return false;
	}
	return false;
}