StrVec read_lists (const StrVec& fnames) { StrVec rv; StrVec::const_iterator itr = fnames.begin (); while (itr != fnames.end ()) { StrVec vals = read_list (*itr); std::copy (vals.begin (), vals.end (), std::back_inserter (rv)); itr ++; } return rv; }
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); } } }
bool operator==(const StrVec& lhs, const StrVec& rhs) { if(lhs.size() != rhs.size()) { return false; } for(auto itrL=lhs.begin(), itrR=rhs.begin(); itrL!=lhs.end(), itrR!=rhs.end(); itrL++, itrR++) { if(itrL != itrR) { return false; } } return true; }
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])); } }
bool TestPathops::process () { #ifdef _MSC_VER const char* paths [] = {"\\kokos\\banan", "d:\\Encyclopedia\\Data\\Genomes\\E.coli.K12\\proteins\\fasta\\", "", "\\", "\\ananas\\", NULL}; #else const char* paths [] = {"/kokos/banan", "~/Encyclopedia/Data/Genomes/E.coli.K12/proteins/fasta/", "", "/", "/ananas/", NULL}; #endif const char** path = paths; for (; *path != NULL; path ++) { o_ << "Path " << *path << std::endl; StrVec comps = split_path (*path); o_ << "path " << *path << ", " << comps.size () << " components" << std::endl; StrVec::const_iterator i = comps.begin (); for (;i < comps.end (); i ++) o_ << " '" << (*i).c_str () << "'" << std::endl; std::string rejoined = join_path (comps); o_ << " Rejoined: " << rejoined.c_str () << std::endl; } std::string jp = join_path ("kokos", "banan", "ananas", "yabloko", NULL); o_ << jp.c_str () << std::endl; jp = join_path ("", "kokos", NULL); o_ << jp.c_str () << std::endl; jp = join_path ("", NULL); o_ << jp.c_str () << std::endl; jp = join_path ("kokos", NULL); o_ << jp.c_str () << std::endl; jp = join_path (NULL); o_ << jp.c_str () << std::endl; return true; }
StrVec::StrVec(const StrVec &s) { using namespace std; auto newdata = alloc_n_copy(s.begin(), s.end()); elements = newdata.first; first_free = cap = newdata.second; }
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::StrVec(const StrVec& orig) { // call alloc_n_copy to allocate space and copy data auto newData = alloc_n_copy(orig.begin(), orig.end()); // update pointers elements = newData.first; first_free = cap = newData.second; }
void display(const StrVec &s) { for (auto p = s.begin(); p != s.end(); ++p) { std::cout << *p << " "; } std::cout << std::endl; }
bool operator>=(const StrVec &lhs, const StrVec &rhs) { auto sz = lhs.size() < rhs.size() ? lhs.size() : rhs.size(); auto pl = lhs.begin(), pr = rhs.begin(); while (sz-- && *pl == *pr) ++pl, ++pr; return sz ? *pl >= *pr : pr == rhs.end(); }
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; }
bool operator==(const StrVec &lhs, const StrVec &rhs) { if (lhs.size() != rhs.size()) return false; for (auto pl = lhs.begin(), pr = rhs.begin(); pl != lhs.end(); ) if (*pl != *pr) return false; return true; }
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; }
std::string make_temp_fname (const char* tmpdir, const char* prefix) { // if directory not passed in, guess one std::string tn = temp_dir (tmpdir);; // if prefix not passed in, use default if (!prefix) prefix = DEFAULT_TEMP_FILE_PREFIX; // get temp directory listing StrVec dircontent = listdir (tn); // find all entries matching prefix and having numeric postfix, get list of numbers UintSet postfixes; unsigned prefix_len = prefix ? strlen (prefix) : 0; for (StrVec::iterator ii = dircontent.begin (); ii != dircontent.end (); ii ++) { // check if prefix matches if (prefix_len && (ii->substr (0, prefix_len) != prefix)) continue; // check if postfix is numeric and get the number unsigned number = 0; std::string::iterator sitr; for (sitr = ii->begin () + prefix_len; sitr != ii->end (); sitr ++) { number *= 10; if (!isdigit (*sitr)) break; else number += *sitr - '0'; } if (sitr != ii->end ()) continue; // store number to postfixes set postfixes.insert (number); } // now retrieve the numbers using first gap // make a set for quick presence check unsigned prev = 0; for (UintSet::iterator nitr = postfixes.begin (); nitr != postfixes.end (); nitr ++) if (prev + 1 < *nitr) break; // found the gap in sequence else prev = *nitr; if (prev == std::numeric_limits<unsigned>::max ()) // just for sanity :) ers << "No more temp file names available for prefix " << (prefix ? prefix : "") << " in directory " << tn << Throw; // prev + 1 is the right number std::ostringstream name (tn, std::ios::out | std::ios::app); name << PATH_SEPARATOR; if (prefix) name << prefix; name << prev + 1; return name.str (); }
//! copy constructor StrVec::StrVec(const StrVec &s) { /** * @brief newData is a pair of pointers pointing to newly allocated and copied * range : [b, e) */ std::pair<std::string*, std::string*> newData = alloc_n_copy(s.begin(), s.end()); element = newData.first; first_free = cap = newData.second; }
void GncSqlBackend::ObjectBackendRegistry::load_remaining(GncSqlBackend* sql_be) { for (auto entry : m_registry) { std::string type; GncSqlObjectBackendPtr obe = nullptr; std::tie(type, obe) = entry; /* Don't need to load anything if it has already been loaded with * the fixed order. */ if (std::find(fixed_load_order.begin(), fixed_load_order.end(), type) != fixed_load_order.end()) continue; if (std::find(business_fixed_load_order.begin(), business_fixed_load_order.end(), type) != business_fixed_load_order.end()) continue; obe->load_all (sql_be); } }
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; }
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(); } }
// 全テーブルを取得し、string t と一致するテーブルのみを削除 static void initTableFunc(std::string t, HbaseClient client) { std::cout << "scanning tables..." << std::endl; StrVec tables; client.getTableNames(tables); for (StrVec::const_iterator it = tables.begin(); it != tables.end(); ++it) { std::cout << " found: " << *it << std::endl; if (t == *it) { if (client.isTableEnabled(*it)) { std::cout << " disabling table: " << *it << std::endl; client.disableTable(*it); } std::cout << " deleting table: " << *it << std::endl; client.deleteTable(*it); } } }
std::string join_path (StrVec components) { std::string rv = EMPTY_STR; StrVec::const_iterator itr = components.begin (); int prevlen = 0; bool firstcomp = true; for (;itr != components.end (); itr ++) { if (prevlen || (itr != components.begin () && firstcomp)) rv += PATH_SEPARATOR; rv += *itr; prevlen = (*itr).length (); if (itr != components.begin ()) firstcomp = false; } if (!rv.length ()) rv += PATH_SEPARATOR; return rv; }
bool TestFileUtils :: process () { std::string fname = fixture_.dirname (); fname += path_separator (); fname += "*.txt"; StrVec sv; expand_wildcards (fname.c_str (), sv); StrVec::iterator itr = sv.begin (); for (; itr != sv.end (); itr ++) { o_ << (*itr).c_str () << std::endl; } if (!sv.size ()) { o_ << "No files to test reader" << std::endl; return false; } LineReader lr (sv.front ().c_str ()); char* ln; int no = 0; int slen = 0; time_t st = time (NULL); while ((ln = lr.nextLine ())) { ++ no; slen += strlen (ln); //if (strlen (ln) > 100) o_ << ln; if (no % 100000 == 0) { int td = time (NULL) - st; double rd = double (slen) / (1024*1024); o_ << "\rline " << no << ", " << rd << " Mb, average speed " << rd / (td?td:1) << " Mb/s " << std::flush; } } time_t et = time (NULL); lr.close (); return true; }
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); }
int count(vector <string> answer) { int ans = 0; int N = (int)answer.size(), M = (int)answer[0].length(); for (int b = 0; b < (1 << M); ++b) { StrVec v = answer; for (int i = 0; i < M; ++i) { if ((1 << i) & b) { for (int j = 0; j < N; ++j) { v[j][i] = ' '; } } } sort(v.begin(), v.end()); int i; for (i = 1; i < N; ++i) { if (v[i - 1].compare(v[i]) == 0) { break; } } ans += i >= N; } return ans; }
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); }
StrVec::StrVec(const StrVec& rhs) { range_initialize(rhs.begin(), rhs.end()); }
bool operator>(const StrVec &s1, const StrVec &s2) { return std::lexicographical_compare(s2.begin(), s2.end(), s1.begin(), s1.end()); }
extern "C" int test_table() { char buf[8][1024]; int i; bool isFramed = false; bool tmptable = false; boost::shared_ptr<TTransport> socket(new TSocket("localhost", 9090)); boost::shared_ptr<TTransport> transport; if (isFramed) { transport.reset(new TFramedTransport(socket)); } else { transport.reset(new TBufferedTransport(socket)); } boost::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport)); const std::map<Text, Text> dummyAttributes; // see HBASE-6806 HBASE-4658 HbaseClient client(protocol); try { transport->open(); std::string t[]= {"T1","T2","T3","T4","T5","T6","T7","T8"}; StrVec tables; client.getTableNames(tables); for(i=0; i<8; i++) { tmptable = false; StrVec::const_iterator it = tables.begin(); for (StrVec::const_iterator it = tables.begin(); it != tables.end(); ++it) { if (t[i] == *it) { tmptable = true; } } if(!tmptable)//创建表 { ColVec columns; columns.push_back(ColumnDescriptor()); columns.back().name = "PROTOCOL"; columns.push_back(ColumnDescriptor()); columns.back().name = "INPUT_SNMP"; columns.push_back(ColumnDescriptor()); columns.back().name = "OUTPUT_SNMP"; columns.push_back(ColumnDescriptor()); columns.back().name = "IN_PKTS"; columns.push_back(ColumnDescriptor()); columns.back().name = "IN_BYTES"; columns.push_back(ColumnDescriptor()); columns.back().name = "SRC_TOS"; columns.push_back(ColumnDescriptor()); columns.back().name = "SRC_AS"; columns.push_back(ColumnDescriptor()); columns.back().name = "DST_AS"; columns.push_back(ColumnDescriptor()); columns.back().name = "TCP_FLAGS"; std::cout << "creating table: " << t[i] << std::endl; try { client.createTable(t[i], columns); } catch (const AlreadyExists &ae) { std::cerr << "WARN: " << ae.message << std::endl; } } } } catch (const TException &tx) { std::cerr << "ERROR: " << tx.what() << std::endl; } return 0; }
// copy controls StrVec(const StrVec &rhs) { auto vec = alloc_and_copy(rhs.begin(), rhs.end()); element_ = vec.first; free_ = cap_ = vec.second; }
StrVec::StrVec(const StrVec &rhs) { auto newdata = alloc_n_copy(rhs.begin(), rhs.end()); elements = newdata.first; first_free = cap = newdata.second; }
bool operator==(const StrVec& lhs, const StrVec& rhs) { return ((lhs.size()==rhs.size())&&equal(lhs.begin(), lhs.end(), rhs.begin())); }