自学教程：C++ to_lower函数代码示例

void BaseHTMLParser::readUntilEndTag(const std::string& tag_name){        // [42] ETag ::= '</' Name S? '>'        bool found = false;	std::string tmp;	std::string lower_tagname = tag_name;	to_lower(lower_tagname);        while (not found ) {            readUntilDelimiterMark("</");	    tmp = std::string(text.current, tag_name.size());	    if (to_lower(tmp) != lower_tagname) {		    // This is not the tag we are looking for...		    // Keep looking...		    continue;	    }	    text += tag_name.size();	    readSpace();            if (*text != '>'){		std::string msg = "While looking for the EndTag for " +/                                      tag_name;                throw ParserEOFError(msg);	    }            consumeToken(std::string(">"));            // Yeah! The EndTag was found. We are done            found = true;	}}

int		verify_username_by_user_list(void *elem, void *comp){  char		*user = (char*)comp;  t_users      	*elemd = (t_users*)elem;  return (strcmp(to_lower(elemd->username), to_lower(user)) == 0);}

 /**  * Allows to check that the source and target languages are proper,  * as the ones that this server instance supports.  * @param source_lang the source language string, from the job request.  * @param target_lang the target language string, from the job request.  * @throws uva_exception in case the source or target language do not match.  */ void check_source_target_languages(string source_lang, string target_lang) {     //Check for an exact match     if (m_params.m_source_lang != source_lang) {         LOG_DEBUG1 << m_params.m_source_lang << " != " << source_lang << END_LOG;         //If no exact match then lowercase         (void) to_lower(source_lang);         //Check for a match again         if (m_params.m_source_lang_lower != source_lang) {             LOG_DEBUG1 << m_params.m_source_lang_lower << " != " << source_lang << END_LOG;             //If there is still no match then throw              THROW_EXCEPTION(string("Unsupported source language: '") + source_lang +                     string("' the server only supports: '") + m_params.m_source_lang +                     string("'"));         }     }     //Check for an exact match     if (m_params.m_target_lang != target_lang) {         LOG_DEBUG1 << m_params.m_target_lang << " != " << target_lang << END_LOG;         //If no exact match then lowercase         (void) to_lower(target_lang);         //Check for a match again         if (m_params.m_target_lang_lower != target_lang) {             LOG_DEBUG1 << m_params.m_target_lang_lower << " != " << target_lang << END_LOG;             //If there is still no match then throw              THROW_EXCEPTION(string("Unsupported target language: '") + target_lang +                     string("' the server only supports: '") + m_params.m_target_lang +                     string("'"));         }     } }

/*** *** User functions ***/int		verify_username(void *elem, void *comp){  char		*user = (char*)comp;  char		*elemd = (char*)elem;  return (strcmp(to_lower(elemd), to_lower(user)) == 0);}

int main(void){	for(char i = 'a'; i <= 'z'; ++i){		assert(is_alpha(i));		assert(!is_digit(i));		assert(is_lower(i));		assert(!is_upper(i));		assert(to_lower(i) == i);		assert(to_upper(i) != i);	}	for(char i = 'A'; i <= 'Z'; ++i){		assert(is_alpha(i));		assert(!is_digit(i));		assert(!is_lower(i));		assert(is_upper(i));		assert(to_lower(i) != i);		assert(to_upper(i) == i);	}	for(char i = '0'; i <= '9'; ++i){		assert(!is_alpha(i));		assert(is_digit(i));		assert(!is_lower(i));		assert(!is_upper(i));		assert(to_lower(i) == i);		assert(to_upper(i) == i);	}	printf("TEST SUCEEDED/n");	return 0;}

int dircmp_incase(char *s1, char *s2){	char _s1[strlen(s1)+1];	char _s2[strlen(s2)+1];	to_lower(s1, _s1);	to_lower(s2, _s2);	return dircmp(_s1, _s2);}

ini_t read_ini(const std::string& filename){	ini_t ini;	std::ifstream istr(filename.c_str());	if(!istr)		return ini;	std::vector<std::string> lines;	std::string temp;	while(true)	{		if(!std::getline(istr,temp))		{			if(istr.eof())				break;			else				throw std::runtime_error("Error while reading /""+filename+"/".");		}		else		{			lines.push_back(temp);		}	}	istr.close();	for(size_t ii=0;ii<lines.size();++ii)	{		if(lines.size()>0&&lines[ii][0]=='#')			continue;		std::string key;		for(size_t jj=0;jj<lines[ii].size();++jj)		{			if(lines[ii][jj]=='=')				break;			else				key+=lines[ii][jj];		}		std::string value;		for(size_t jj=key.size()+1;jj<lines[ii].size();++jj)			value+=lines[ii][jj];		key=to_lower(strip_whitespace(key));		value=to_lower(strip_whitespace(value));		if(value.size()>0)			ini[key]=value;	}	return ini;}

std::vector<StatusEffect*>::iterator Character::getStatusEffectIterator(const std::string& status){  for (auto it = m_status.begin(); it != m_status.end(); ++it)  {    if (to_lower((*it)->name) == to_lower(status))      return it;  }  return m_status.end();}

static int fstrcmp(const char *s1, ucell fstr){	char *s2 = (char*)cell2pointer(fstr);	while (*s1) {		if ( to_lower(*(s1++)) != to_lower(*(s2++)) )			return -1;	}	return 0;}

voidfbLocaleManager::ReadSystemSettings(){	string systemSettings = C_SYSTEM_SETTINGS;	if(!FileExists(systemSettings.c_str()))	{		systemSettings  = C_ROOTFS;		systemSettings.append(C_SYSTEM_SETTINGS);		if(!FileExists(systemSettings.c_str()))		{			systemSettings.erase();		}	}	if(!systemSettings.empty())	{		FILE* fp;		if ((fp = fopen(systemSettings.c_str(), "r")) != NULL)		{			string language;			string country;			uint16_t bufSize = 80;			char buffer[bufSize];			while (fgets(buffer, bufSize, fp) != NULL && (country.empty() || language.empty()))			{				char* p = strrchr(buffer, '/n');				if (p)				{					*p = '/0';				}				if (strlen(buffer))				{					if (language.empty() && strstr(buffer, C_LOCALE_LANGUAGE_PATTERN) == buffer)					{						language = buffer + strlen(C_LOCALE_LANGUAGE_PATTERN);						language = trim(language);					}					else if (country.empty() && strstr(buffer, C_LOCALE_COUNTRY_PATTERN) == buffer)					{						country = buffer + strlen(C_LOCALE_COUNTRY_PATTERN);						country = trim(country);					}				}			}			if (!language.empty())			{				m_language = to_lower(language);			}			if (!country.empty())			{				m_country = to_lower(country);			}			SetLocale(NULL, NULL);			fclose(fp);		}	}}

static int nocase_strncmp(const char *a, const char *b, size_t len) {  size_t i;  for (i = 0; i < len; ++i, ++a, ++b) {    if (*a != *b && to_lower(*a) != to_lower(*b))      return *a - *b;    if (*a == '/0')      return *b == '/0' ? 0 : -1;  }  return *a != '/0' ? 1 : 0;}

bool string_equal_no_case(char const* s1, char const* s2){    while (to_lower(*s1) == to_lower(*s2))    {        if (*s1 == 0) return true;        ++s1;        ++s2;    }    return false;}

bool string_begins_no_case(char const* s1, char const* s2){    while (*s1 != 0)    {        if (to_lower(*s1) != to_lower(*s2)) return false;        ++s1;        ++s2;    }    return true;}

bool end_with(string fileName, string ext) {    fileName = to_lower(fileName);    ext = to_lower(ext);	if (ext.length() >= fileName.length()) return false;	for (int i=1; i<=ext.length(); i++)		if (fileName[fileName.length()-i] != ext[ext.length()-i]) {			return false;		}	return true;}

std::string http_auth::generate_signature(const swarm::http_request &request, const std::string &key){	const auto &url = request.url();	const auto &query = url.query();	const auto &original_headers = request.headers().all();	std::vector<swarm::headers_entry> headers;	for (auto it = original_headers.begin(); it != original_headers.end(); ++it) {		std::string name = to_lower(it->first);		if (name.compare(0, 6, "x-ell-") == 0) {			headers.emplace_back(std::move(name), it->second);		}	}	std::sort(headers.begin(), headers.end());	std::vector<std::pair<std::string, std::string> > query_items;	for (size_t i = 0; i < query.count(); ++i) {		const auto &item = query.item(i);		query_items.emplace_back(to_lower(item.first), item.second);	}	std::sort(query_items.begin(), query_items.end());	swarm::url result_url;	result_url.set_path(url.path());	for (auto it = query_items.begin(); it != query_items.end(); ++it) {		result_url.query().add_item(it->first, it->second);	}	std::string text = request.method();	text += '/n';	text += result_url.to_string();	text += '/n';	for (auto it = headers.begin(); it != headers.end(); ++it) {		text += it->first;		text += ':';		text += it->second;		text += '/n';	}	check_hash(key);	check_hash(text);	dnet_raw_id signature;	char signature_str[DNET_ID_SIZE * 2 + 1];	dnet_digest_auth_transform_raw(text.c_str(), text.size(), key.c_str(), key.size(), signature.id, DNET_ID_SIZE);	dnet_dump_id_len_raw(signature.id, DNET_ID_SIZE, signature_str);	return signature_str;}

void PlayerCharacter::equip(const std::string& equipmentSlot, const std::string& itemName){  if (itemName.empty())  {    m_equipment.erase(to_lower(equipmentSlot));  }  else  {    m_equipment[to_lower(equipmentSlot)] = create_item(itemName, 1);  }}

voidfbLocaleManager::Init(){	m_language = C_DEFAULT_LANGUAGE;	m_country  = C_DEFAULT_COUNTRY;	to_lower(m_language);	to_lower(m_country);	SetLocale(NULL, NULL);	m_default = m_locale;	ReadSystemSettings();}

void robot_config_t::from_file(const std::string& filename){	ini_t ini=read_ini(filename);	for(ini_t::const_iterator iter=ini.begin();iter!=ini.end();++iter)	{		if(keys_m.count(to_lower(iter->first))>0)			keys_m[to_lower(iter->first)]=to_lower(iter->second);		else			throw std::runtime_error("Unrecognized ini argument /""+iter->first+"/"./n");	}	validate();}

bool Dictionary::DeleteAWord(string word){  vector<string> wordsVect;  bool wordFound = false;  word = to_lower(word);  string nextWord;  ifstream fin;  ofstream fout;  string file = fileName(word);  fin.open(file.c_str());  fin >> nextWord;  while(fin){    if(fin.eof())      break;    wordsVect.push_back(to_lower(nextWord));    fin >> nextWord;  }  fin.close();  for(int x = 0; x < wordsVect.size(); x++){    //check if word exists in file    if(wordsVect[x] == word){      cout << "ERASING: " << wordsVect[x] << endl;      //erase word from vector      wordsVect.erase(wordsVect.begin() + x);      //decrement word counts      numOfWordsInFile[toupper(fileName(word)[0]-65)]--;      totalWordsInDict--;      wordFound = true;    }  }  //open file and discard previous contents  fout.open(file.c_str(), ofstream::trunc);  //write vector to file  for(int x = 0; x < wordsVect.size(); x++){    if(x == wordsVect.size())      fout << wordsVect[x];    else      fout << wordsVect[x] << " ";  }    fout.close();  if(wordFound == true)    return(success);  else    return(failure);}

bool icompare(const std::string& str, const std::string& ref) {    size_t s1 = str.size();    size_t s2 = ref.size();    if(s1 != s2) {        return false;    }    const char* ch1 = str.c_str();    const char* ch2 = ref.c_str();    for(size_t i=0;i<s1;++i) {        if(to_lower(ch1[i]) != to_lower(ch2[i])) {            return false;        }    }    return true;}

 void makeName() {     fName = "rotated_rects";     if (fAA) {         fName.append("_aa");     } else {         fName.append("_bw");     }     switch (fColorType) {         case kConstantOpaque_ColorType:             fName.append("_same_opaque");             break;         case kConstantTransparent_ColorType:             fName.append("_same_transparent");             break;         case kChangingOpaque_ColorType:             fName.append("_changing_opaque");             break;         case kChangingTransparent_ColorType:             fName.append("_changing_transparent");             break;         case kAlternatingOpaqueAndTransparent_ColorType:             fName.append("_alternating_transparent_and_opaque");             break;     }     fName.appendf("_%s", to_lower(SkXfermode::ModeName(fMode)).c_str()); }

bool trie_tree_check_string(trie_tree* tree, tchar* str){  assert(tree);  assert(str);  int state_index, base_index = 0;  bool is_replace = false;  while( str[base_index] )  {    trie_tree_clear_state(tree);    state_index = base_index;    while( str[state_index] )    {      TRIE_STATE state = trie_tree_check_state(tree, to_lower(str[state_index]));      if( state == STATE_NULL )        break;      if( state == STATE_WORD )      {        for(int replace_index = base_index; replace_index<=state_index; replace_index++)          str[replace_index] = L'*';        is_replace = true;        base_index = state_index;        break;      }      if( state == STATE_WORD_PREFIX)      {        for(int replace_index = base_index; replace_index<=state_index; replace_index++)          str[replace_index] = L'*';        is_replace = true;      }      state_index++;    }    base_index++;  }  return is_replace;}

CGOGN_IO_API std::string  vtk_data_type_to_cgogn_name_of_type(const std::string& vtk_type_str){	const std::string& data_type = to_lower(vtk_type_str);	static const std::map<std::string, std::string> type_map{		{"char", name_of_type(int8())},		{"int8", name_of_type(int8())},		{"unsigned_char", name_of_type(uint8())},		{"uint8", name_of_type(uint8())},		{"short", name_of_type(int16())},		{"int16", name_of_type(int16())},		{"unsigned_short", name_of_type(uint16())},		{"uint16", name_of_type(uint16())},		{"int", name_of_type(int32())},		{"int32", name_of_type(int32())},		{"unsigned_int", name_of_type(uint32())},		{"uint32", name_of_type(uint32())},		{"long", name_of_type(int64())},		{"int64", name_of_type(int64())},		{"unsigned_long", name_of_type(uint64())},		{"uint64", name_of_type(uint64())},		{"float", name_of_type(float32())},		{"float32", name_of_type(float32())},		{"double", name_of_type(float64())},		{"float64", name_of_type(float64())}	};	const auto it = type_map.find(data_type);	if ( it != type_map.end())		return it->second;	cgogn_log_error("vtk_data_type_to_cgogn_name_of_type") << "Unknown vtk type /"" << vtk_type_str << "/".";	return std::string();}

void robot_config_t::validate(){	for(key_t::const_iterator iter=keys_m.begin();iter!=keys_m.end();++iter)		keys_m[iter->first]=to_lower(iter->second);	for(size_t ii=0;ii<keys_m["robot"].size();++ii)		if(keys_m["robot"][ii]=='//')			keys_m["robot"][ii]='/';	if(to_bool(keys_m["sim"]))	{		keys_m["delay_ms"]="100";		keys_m["baudrate"]="0";	}	if(to_bool(keys_m["local"]))		keys_m["superstar"]="http://localhost:8081";	if(to_bool(keys_m["dev"]))		keys_m["superstar"]="http://test.robotmoose.com";	// if(keys_m["superstar"].size()>0&&keys_m["superstar"][keys_m["superstar"].size()-1]!='/')	// 	keys_m["superstar"]+='/';	size_t slashes=0;	for(size_t ii=0;ii<keys_m["robot"].size();++ii)		if(keys_m["robot"][ii]=='/')			++slashes;	if(slashes!=2)		throw std::runtime_error("Invalid robot name /""+keys_m["robot"]+"/" - should be in the format /"school/name/".");}

voidg_scanner_scope_add_symbol (GScanner	*scanner,			    guint	 scope_id,			    const gchar	*symbol,			    gpointer	 value){  GScannerKey	*key;    g_return_if_fail (scanner != NULL);  g_return_if_fail (symbol != NULL);    key = g_scanner_lookup_internal (scanner, scope_id, symbol);    if (!key)    {      key = g_new (GScannerKey, 1);      key->scope_id = scope_id;      key->symbol = g_strdup (symbol);      key->value = value;      if (!scanner->config->case_sensitive)	{	  gchar *c;	  	  c = key->symbol;	  while (*c != 0)	    {	      *c = to_lower (*c);	      c++;	    }	}      g_hash_table_insert (scanner->symbol_table, key, key);    }  else    key->value = value;}

static inline GScannerKey*g_scanner_lookup_internal (GScanner	*scanner,			   guint	 scope_id,			   const gchar	*symbol){  GScannerKey	*key_p;  GScannerKey key;    key.scope_id = scope_id;    if (!scanner->config->case_sensitive)    {      gchar *d;      const gchar *c;            key.symbol = g_new (gchar, strlen (symbol) + 1);      for (d = key.symbol, c = symbol; *c; c++, d++)	*d = to_lower (*c);      *d = 0;      key_p = g_hash_table_lookup (scanner->symbol_table, &key);      g_free (key.symbol);    }  else    {      key.symbol = (gchar*) symbol;      key_p = g_hash_table_lookup (scanner->symbol_table, &key);    }    return key_p;}

uint32_tconvert_string_to_hexadecimal(_IN_ const char *str){    uint32_t value = 0;    uint32_t multiplier = 1;    for (const char *p = str + strlen(str) - 1; p >= str; p --) {	int c = *p;	if (!is_xdigit(c)) {	    FDC_ASSERT(p == str + 1 && c == 'x' && str[0] == '0',		       str[0], str[1]);	    break;	}	if (is_digit(c)) {	    value += (c - '0') * multiplier;	} else {	    value += (to_lower(c) - 'a' + 10) * multiplier;	}	multiplier *= 16;    }    return value;}

/** * Returns true if word is in dictionary else false. */bool check(const char* word){    char* lower_case = to_lower((char*) word);    // index into our hashtable    int index = hash_function(lower_case);    node* check = NULL;    check = hashtable[index];    while(check != NULL)    {        if(strcmp((const char*) check->word, lower_case) == 0)        {            free(lower_case);            return true;        }        else            check = check->next;    }    free(lower_case);    return false;}