void Console::exec(std::string cmd) { StrVec args; if(cmd.find(' ') != std::string::npos) { args.push_back(cmd.substr(cmd.find(' ') + 1, cmd.size() - cmd.find(' '))); cmd = cmd.substr(0, cmd.find(' ')); while(args.back().find(' ') != std::string::npos) { args.push_back(args.back().substr(args.back().find(' ') + 1 , args.size() - args.back().find(' '))); args.at(args.size() - 1) = args.at(args.size() - 1).substr(0, args.at(args.size() - 1).find(' ') - 1); } } if(commands.find(cmd) == commands.end()) { addString("Command '" + cmd + "' not found"); return; } if(!commands[cmd].exec(args)) addString("Wrong number of arguments for command '" + cmd + "'."); }
void CorbaNotifyUtils::getORBOptions(const std::string &appName,const std::string &orbOptions, int &orbArgc,ACE_TCHAR*** orbArgv) { StrVec ORBOptionsVec; size_t ini = orbOptions.find_first_not_of(" \t"); size_t end; while(ini != std::string::npos) { end = orbOptions.find_first_of(" \t", ini + 1); if(end != std::string::npos) { ORBOptionsVec.push_back(orbOptions.substr(ini, end - ini)); ini = orbOptions.find_first_not_of(" \t", end); } else { ORBOptionsVec.push_back(orbOptions.substr(ini)); ini = std::string::npos; } } int i = 1; orbArgc = ORBOptionsVec.size() + 1; *orbArgv = new ACE_TCHAR*[orbArgc]; (*orbArgv)[0] = new ACE_TCHAR[appName.size() + 1]; strncpy((*orbArgv)[0], appName.c_str(), appName.size()); (*orbArgv)[0][appName.size()] = '\0'; for(StrVec::const_iterator it = ORBOptionsVec.begin(); it != ORBOptionsVec.end(); ++it, ++i) { (*orbArgv)[i] = new ACE_TCHAR[it->size() + 1]; strncpy((*orbArgv)[i], it->c_str(), it->size()); (*orbArgv)[i][it->size()] = '\0'; ACE_DEBUG((LM_INFO, "%T ORB option: %s\n", (*orbArgv)[i])); } }
int main() { StrVec sv; print(sv); sv.push_back("s1"); print(sv); sv.push_back("s2"); print(sv); sv.push_back("s3"); print(sv); sv.push_back("s4"); print(sv); sv.push_back("s5"); print(sv); { StrVec sv2(sv); print(sv2); sv2.push_back("s6"); print(sv); print(sv2); sv.pop_back(); print(sv); print(sv2); sv = sv2; print(sv); print(sv2); } sv.reserve(sv.capacity() / 2); print(sv); sv.reserve(sv.capacity() * 2); print(sv); sv.resize(sv.size() + 2); print(sv); sv.resize(sv.size() + 2, "s7"); print(sv); sv.resize(sv.size() - 2); print(sv); sv.resize(sv.size() - 2, "s7"); print(sv); return 0; }
void ParseBufVC(char* buf, const string& filter_modules, const string& filter_disabled, const string& filter_headers) { static bool ignore_files=false; string line(buf); switch(BufState) { case 0: // expect filter start (set state to 1) or just a line (state =0) { if(line.find("<Filter")!=-1) BufState++; ProjLines.push_back(line); break; } case 1: // found filter, read the name and maybe start ignoring files, state++ { int from=line.find("\"")+1; int to=line.find("\"",from); string name=line.substr(from,to-from); if(name==filter_modules || name==filter_headers || name==filter_disabled) { ProjAssoc[ProjLines.size()+4]=name; ignore_files=true; } BufState++; ProjLines.push_back(line); break; } case 2: // state++ case 3: // state++ case 4: // state++ { BufState++; ProjLines.push_back(line); break; } case 5: // expect file or end of filter (back to 0, stop ignoring files) { // end of filter? if(line.find("</Filter>")!=-1) { BufState=0; ignore_files=false; ProjLines.push_back(line); break; } // file, pass } case 6: // state++ case 7: // state++ case 8: // state++ { if(!ignore_files) ProjLines.push_back(line); BufState++; if(BufState>8) BufState=5; break; } default: ; } }
int main() { StrVec str; str.push_back("adf"); str.push_back("sdfd"); for (auto i = str.begin(); i != str.end(); ++i) cout << *i << ends; cout << endl; return 0; }
int main() { StrVec words; words.push_back("ss"); words.push_back("sb"); words.push_back("asf"); words.push_back("safasfd"); words.push_back("asfas"); std::cout<<words.size()<<std::endl; //words = StrVec(); //words = words; std::cout<<"cap "<<words.capacity()<<std::endl; std::cout<<"sz "<<words.size()<<std::endl; for_each(words.begin(), words.end(), [](const std::string &s){std::cout<<s<<std::endl;}); std::cout<<"exit"<<std::endl; }
void cGRASS::breakDir(string Dir) { StrVec Vec; Vec.clear(); char dir[255]; strcpy(dir,Dir.c_str()); char * t; string temp; printf ("Splitting string \"%s\" into tokens:\n",dir); t = strtok (dir,"/"); while (t != NULL) { temp = t; Vec.push_back(temp); t = strtok (NULL, "/"); } MapSet = Vec[Vec.size()-1]; Location = Vec[Vec.size()-2]; GDBase = ""; for (uint i = 0; i < Vec.size()-2; i++) { GDBase = GDBase + "/" + Vec[i]; } // printf(MapSet); // printf(Location); // printf(GDBase); }
template<> StrVec GncDbiProviderImpl<DbType::DBI_MYSQL>::get_index_list (dbi_conn conn) { StrVec retval; const char* errmsg; auto tables = get_table_list(conn, ""); for (auto table_name : tables) { auto result = dbi_conn_queryf (conn, "SHOW INDEXES IN %s WHERE Key_name != 'PRIMARY'", table_name.c_str()); if (dbi_conn_error (conn, &errmsg) != DBI_ERROR_NONE) { PWARN ("Index Table Retrieval Error: %s on table %s\n", errmsg, table_name.c_str()); continue; } while (dbi_result_next_row (result) != 0) { std::string index_name {dbi_result_get_string_idx (result, 3)}; retval.push_back(index_name + " " + table_name); } dbi_result_free (result); } return retval; }
StrVec split_path (const char* path) { StrVec rv; std::string pstr = path; std::string::size_type pos, ppos = 0; while ((pos = pstr.find (PATH_SEPARATOR, ppos)) != std::string::npos) { if (pos != ppos || ppos == 0) rv.push_back (pstr.substr (ppos, pos - ppos)); ppos = pos + 1; } if (ppos < pstr.length ()) rv.push_back (pstr.substr (ppos, pstr.length () - ppos)); return rv; }
extern StrVec string_util::split(const string &source,const string &split) { string::size_type number=count_occur(source,split); if(number==0) { StrVec result; result.push_back(source); return result; } vector<string> result; string::size_type start=0; string::size_type stop=0; string inner; while(true) { stop=source.find(split,start); if(stop==string::npos) { result.push_back(source.substr(start)); break; } else { result.push_back(source.substr(start,stop-start)); start=stop+split.size(); } } return result; }
int main() { StrVec v = {"Gone", "with", "the"}; v.push_back("winds"); for_each(v.begin(), v.end(), [](const string &s) {cout << s << " ";}); cout << endl; return 0; }
StrVec getVec(istream &is) { StrVec svec; string s; while (is >> s) svec.push_back(s); return svec; }
size_t Data::newEntry(const std::string& key, const SLStore& dv) { KeyIdx ki(key, m_keyIdx.size()); KeyIdxVec::iterator it = std::upper_bound(m_keyIdx.begin(), m_keyIdx.end(), ki, key_less); m_keys.push_back(key); m_varData.push_back(dv); m_keyIdx.insert(it, ki); return ki.second; }
int main() { StrVec vec = { "aaa", "bbb", "ccc" }; cout << vec.size() << " " << vec.capacity() << endl; vec.push_back("ddd"); vec.print(); system("pause"); return 0; }
StrVec getVec(std::istream &is) { StrVec svec; std::string s; while (is >> s) svec.push_back(s); // this is where move is necessary return svec; }
int main() { string temp[] = {"one", "two", "three"}; StrVec sv(temp, temp + sizeof(temp)/sizeof(*temp)); // run the string empty funciton on the first element in sv if (!sv[0].empty()) sv[0] = "None"; // assign a new value to the first string // we'll call getVec a couple of times // and will read the same file each time ifstream in("data/storyDataFile"); StrVec svec = getVec(in); print(svec); in.close(); cout << "copy " << svec.size() << endl; StrVec svec2 = svec; print(svec2); cout << "assign" << endl; StrVec svec3; svec3 = svec2; print(svec3); StrVec v1, v2; v1 = v2; // v2 is an lvalue; copy assignment in.open("data/storyDataFile"); v2 = getVec(in); // getVec(in) is an rvalue; move assignment in.close(); StrVec vec; // empty StrVec string s = "some string or another"; vec.push_back(s); // calls push_back(const string&) vec.push_back("done"); // calls push_back(string&&) return 0; }
static void test_strVec() { StrVec v; v.push_back("wang"); v.push_back("hou"); v.push_back("ren"); #if __cplusplus > 201103L for_each(v.begin(), v.end(), [](auto &it) {cout << it << " "; }), cout << endl; #endif StrVec v2 = std::move(v); #if __cplusplus > 201103L for_each(v2.begin(), v2.end(), [](auto &it) {cout << it << " "; }), cout << endl; #endif { v2 = std::move(v2); } v = v2; StrVec v3 = v; // v.operator=(v2); // StrVec().operator=(v2); }
void append(const std::string& word) { std::string lower; cybozu::ToLower(lower, word); std::pair<Str2Int::iterator, bool> ret = word2id_.insert(Str2Int::value_type(lower, (int)id2word_.size())); //printf("word=%s, id=%d, ret=%d\n", ret.first->first.c_str(), ret.first->second, ret.second); if (ret.second) { id2word_.push_back(lower); df_.resize(id2word_.size()); } if (set_.insert(word).second) { df_[ret.first->second]++; } }
void EventsGenerator::desiresCB(const hbba_msgs::DesiresSet::ConstPtr& msg) { typedef std::vector<std::string> StrVec; typedef std::list<std::string> StrList; typedef std::vector<hbba_msgs::Desire> DesVec; typedef std::map<std::string,std::string> TypeMap; const DesVec& desires = msg->desires; TypeMap typeMap; StrVec ids; ids.reserve(desires.size()); for (DesVec::const_iterator d = desires.begin(); d != desires.end(); ++d) { ids.push_back(d->id); typeMap[d->id] = d->type; } // First, remove desires not in it the current desires set. StrList del; for (Model::const_iterator i = model_.begin(); i != model_.end(); ++i) { const std::string& id = i->first; if (std::find(ids.begin(), ids.end(), id) == ids.end()) del.push_back(id); } for (StrList::const_iterator i = del.begin(); i != del.end(); ++i) { const std::string& id = *i; event(id, model_[id].type, hbba_msgs::Event::DES_OFF); if (model_[id].flags & FLAG_INT) event(id, model_[id].type, hbba_msgs::Event::INT_OFF); if (model_[id].flags & FLAG_EXP) event(id, model_[id].type, hbba_msgs::Event::EXP_OFF); model_.erase(id); } // Then, generate events for new desires. for (StrVec::const_iterator i = ids.begin(); i != ids.end(); ++i) { const std::string& id = *i; if (model_.find(id) == model_.end()) { model_[id].flags = FLAG_NONE; model_[id].type = typeMap[id]; //set type in the model event(id, model_[id].type, hbba_msgs::Event::DES_ON); } } }
static StrVec conn_get_table_list (dbi_conn conn, const std::string& dbname, const std::string& table) { StrVec retval; const char* tableptr = (table.empty() ? nullptr : table.c_str()); auto tables = dbi_conn_get_table_list (conn, dbname.c_str(), tableptr); while (dbi_result_next_row (tables) != 0) { std::string table_name {dbi_result_get_string_idx (tables, 1)}; retval.push_back(table_name); } dbi_result_free (tables); return retval; }
void App::loadSearthPaths(const rapidjson::Document & doc) { StrVec paths; std::string prefix; // slave paths depend on resolution, so we need to add prefix if (_resolution == Resolution::REGULAR_RES) { paths.push_back(REGULAR_RESOLUTION_PATH); prefix = REGULAR_RESOLUTION_PATH + "/"; } else { paths.push_back(RETINA_RESOLUTION_PATH); prefix = RETINA_RESOLUTION_PATH + "/"; } const rapidjson::Value & genPathArr = doc["generalSearchPaths"]; for (rapidjson::SizeType i = 0; i < genPathArr.Size(); ++i) { std::string path = genPathArr[i].GetString(); paths.push_back(path); } const rapidjson::Value & slavePathArr = doc["slaveSearchPaths"]; for (rapidjson::SizeType i = 0; i < slavePathArr.Size(); ++i) { std::string path = prefix + slavePathArr[i].GetString(); paths.push_back(path); } for (auto it = paths.begin(); it != paths.end(); ++it) { std::stringstream ss; ss << "Path added: " << *it; CCLOG(ss.str().c_str()); } FileUtils::getInstance()->setSearchPaths(paths); }
int strsplit_slash(string& st, StrVec& vec) { vec.clear(); int last_pos=0; int pos=0; int max_pos=st.size(); while(pos<max_pos) { last_pos=pos; while(st[pos]!='/' && pos<max_pos) pos++; vec.push_back(st.substr(last_pos,pos-last_pos)); while(st[pos]=='/' && pos<max_pos) pos++; } return vec.size(); }
Option(int argc, const char *const argv[]) { cybozu::Option opt; std::string charSetFile; std::string dicFile; bool debug; opt.appendOpt(&charSetFile, "", "cf", "char set file"); opt.appendOpt(&threadNum, 4, "t", "thread num"); opt.appendOpt(&dicFile, "", "d", "dictionary file"); opt.appendOpt(&passLen, 0, "l", "length of pass"); opt.appendBoolOpt(&debug, "v", "verbose message"); opt.appendHelp("h"); opt.appendParam(&encFile, "encrypted file"); if (!opt.parse(argc, argv)) { opt.usage(); exit(1); } if (debug) ms::setDebug(1); if (charSetFile.empty()) { charSet = "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "0123456789-_"; } else { std::ifstream ifs(charSetFile.c_str(), std::ios::binary); if (!std::getline(ifs, charSet)) { fprintf(stderr, "can't read char set file [%s]\n", charSetFile.c_str()); exit(1); } trim(charSet); } if (!dicFile.empty()) { std::ifstream ifs(dicFile.c_str(), std::ios::binary); std::string line; while (std::getline(ifs, line)) { trim(line); toUtf8(line); passSet.push_back(line); } if (passSet.empty()) { fprintf(stderr, "can't read dicFile [%s]\n", dicFile.c_str()); exit(1); } std::sort(passSet.begin(), passSet.end(), &lessByLength); } if (ms::isDebug()) { opt.put(); } }
int main() { StrVec vec; vec.reserve(6); std::cout << "capacity(reserve to 6): " << vec.capacity() << std::endl; vec.reserve(4); std::cout << "capacity(reserve to 4): " << vec.capacity() << std::endl; vec.push_back("hello"); vec.push_back("world"); vec.resize(4); for (auto i = vec.begin(); i != vec.end(); ++i) std::cout << *i << std::endl; std::cout << "-EOF-" << std::endl; vec.resize(1); for (auto i = vec.begin(); i != vec.end(); ++i) std::cout << *i << std::endl; std::cout << "-EOF-" << std::endl; StrVec vec_list{ "hello", "world", "pezy" }; for (auto i = vec_list.begin(); i != vec_list.end(); ++i) std::cout << *i << " "; std::cout << std::endl; // Test operator== const StrVec const_vec_list{ "hello", "world", "pezy" }; if (vec_list == const_vec_list) for (const auto &str : const_vec_list) std::cout << str << " "; std::cout << std::endl; // Test operator< const StrVec const_vec_list_small{ "hello", "pezy", "ok" }; std::cout << (const_vec_list_small < const_vec_list) << std::endl; // Test [] std::cout << const_vec_list_small[1] << std::endl; }
StrVec read_list (const char* fname) { StrVec rv; LineReader rd (fname); char *l, *lc; while ((l = rd.nextLine ())) { // find first token and add to rv while (*l && isspace (*l)) l ++; if (!*l) continue; lc = l + 1; while (*lc && !isspace (*lc)) lc ++; *lc = 0; rv.push_back (l); } rd.close (); return rv; }
StrVec RedisClient::SMembers(const std::string& key){ StrVec vec; if(key.empty()) return vec; std::stringstream sm; sm << "SMEMBERS " << key; redisReply *redis_reply = RedoCommand(sm.str(),REDIS_REPLY_ARRAY); if ( redis_reply ) { for (size_t i=0; i<redis_reply->elements; ++i) { auto reply = redis_reply->element[i]; if (reply->type == REDIS_REPLY_STRING) { vec.push_back(reply->str); } } } freeReplyObject_Safe(redis_reply); return vec; }
StrVec RedisClient::HKeys(const std::string & hask_name){ StrVec vec; if(hask_name.empty()) return vec; std::stringstream sm; sm << "HKEYS " << hask_name; redisReply *redis_reply = RedoCommand(sm.str(),REDIS_REPLY_ARRAY); if ( redis_reply ) { for (size_t i=0; i<redis_reply->elements; ++i) { auto reply = redis_reply->element[i]; if (reply->type == REDIS_REPLY_STRING) { vec.push_back(reply->str); } } } freeReplyObject_Safe(redis_reply); return vec; }
StrVec RedisClient::ZRevrange(const std::string& key, const int start, const int stop){ StrVec vec; if(key.empty()) return vec; std::stringstream sm; sm << "ZREVRANGE " << key << " " << start << " " << stop; redisReply *redis_reply = RedoCommand(sm.str(),REDIS_REPLY_ARRAY); if ( redis_reply ) { for (uint32_t i=0 ; i<redis_reply->elements; i++ ) { auto reply = redis_reply->element[i]; if (reply!=NULL && reply->type==REDIS_REPLY_STRING) { vec.push_back(reply->str); } } } freeReplyObject_Safe(redis_reply); return vec; }
template<> StrVec GncDbiProviderImpl<DbType::DBI_SQLITE>::get_index_list (dbi_conn conn) { StrVec retval; const char* errmsg; dbi_result result = dbi_conn_query (conn, "SELECT name FROM sqlite_master WHERE type = 'index' AND name NOT LIKE 'sqlite_autoindex%'"); if (dbi_conn_error (conn, &errmsg) != DBI_ERROR_NONE) { PWARN ("Index Table Retrieval Error: %s\n", errmsg); return retval; } while (dbi_result_next_row (result) != 0) { std::string index_name {dbi_result_get_string_idx (result, 1)}; retval.push_back(index_name); } dbi_result_free (result); return retval; }
bool loadKeywordFile(const std::string& keyFile) { std::ifstream ifs(keyFile.c_str(), std::ios::binary); if (!ifs) return false; std::string word; while (std::getline(ifs, word)) { size_t pos = word.find('\t'); if (pos == std::string::npos) break; word.resize(pos); std::pair<Str2Int::iterator, bool> ret = word2id_.insert(Str2Int::value_type(word, (int)id2word_.size())); if (ret.second) { id2word_.push_back(word); } else { fprintf(stderr, "ERR already set %s\n", word.c_str()); } } df_.resize(id2word_.size()); fprintf(stderr, "#word = %d\n", (int)df_.size()); return true; }