void IniSetting::ParserCallback::onPopEntry( const std::string &key, const std::string &value, const std::string &offset, void *arg) { Variant *arr = (Variant*)arg; forceToArray(*arr); bool oEmpty = offset.empty(); // Substitution copy or symlink // Offset come in like: hhvm.a.b\0c\0@ // Check for `\0` because it is possible, although unlikely, to have // something like hhvm.a.b[c@]. Thus we wouldn't want to make a substitution. if (!oEmpty && (offset.size() == 1 || offset[offset.size() - 2] == '\0') && (offset.back() == '@' || offset.back() == ':')) { makeSettingSub(key, offset, value, *arr); } else { // Normal array value String skey(key); auto& hash = arr->toArrRef().lvalAt(skey); forceToArray(hash); if (!oEmpty) { // a[b] makeArray(hash, offset, value); } else { // a[] hash.toArrRef().append(value); } } }
bool CreditCard::Validate(std::string creditCardNumber) { unsigned int sum=0; bool toggle=true; unsigned int otherCheckDigit=creditCardNumber.back() - '0'; unsigned int myCheckDigit=0; creditCardNumber.pop_back(); while(!creditCardNumber.empty()) { unsigned int temp=creditCardNumber.back() - '0'; //saves last digit if (toggle) { temp= temp*2; if (temp>=10) temp=temp-9; } sum=sum+temp; toggle=!toggle; creditCardNumber.pop_back(); //deletes last digit } myCheckDigit= (sum*9)%10; return (otherCheckDigit==myCheckDigit); }
long long toNum(std::string str, int type = 0) { int len = str.length(); long long ret = 0; if (len < 1) return 0; if (canBeNum(str) == false) return 0; std::stringstream ss; bool negative = false; if (str.front() == '-') { str.erase(0, 1); negative = true; len--; } else if (str.front() == '+') { str.erase(0, 1); len--; } switch (type) { case 0: if (len == 0) return 0; if (str.back() == 'h' || str.back() == 'H') { str.erase(len - 1, 1); ss << std::hex << str; ss >> ret; } else if (str.front() == '0' && len > 1)
void basic_configuration::set_workspace(std::string path) { if (path.back() != '/' && path.back() != '\\') path.push_back('/'); pimpl->workspace_path = path; }
bool ConfigReader::parse_obj(const std::string &key, std::string &obj, std::string &err) { std::vector<std::string> items; std::string okey, oval; std::unordered_map<std::string, std::string> map; size_t ind; /* remove surrounding braces and whitespace */ obj = obj.substr(1); remove_leading(obj); while (obj.back() != '}') obj.pop_back(); obj.pop_back(); while (isspace(obj.back())) obj.pop_back(); utils::split(obj, '\n', items); for (std::string s : items) { if ((ind = s.find('=')) == std::string::npos) { err = "unrecognized token in list -- "; for (ind = 0; !isspace(s[ind]); ++ind) err += s[ind]; return false; } okey = s.substr(0, ind); while (isspace(okey.back())) okey.pop_back(); oval = parse_string(s); map[okey] = oval; } olistmap[key].emplace_back(map); return true; }
void bebopftp::downloadMedia(std::string bebop_ip, std::string download_to, bool erase) { if(download_to.back() != '/' && download_to.back() != '\\') { download_to.append("/"); } nsFTP::CFTPClient ftpClient; nsFTP::CLogonInfo logonInfo(bebop_ip); ftpClient.Login(logonInfo); nsFTP::TFTPFileStatusShPtrVec list; ftpClient.List(BEBOP_MEDIA_LOCATION, list); for(nsFTP::TFTPFileStatusShPtrVec::iterator it=list.begin(); it!=list.end(); it++) { std::cout << "Downloading " << (*it)->Name() << " into " << download_to << std::endl; ftpClient.DownloadFile(BEBOP_MEDIA_LOCATION + (*it)->Name(), download_to + (*it)->Name()); if(erase) { ftpClient.Delete(BEBOP_MEDIA_LOCATION + (*it)->Name()); } } ftpClient.Logout(); std::cout << "Done." << std::endl; }
/* * GetLastPathComponent * @path: Path to get the last component from * @return: Returns the last path component position in the string */ inline std::string::size_type GetLastPathComponent(std::string path) { // Remove any slash at the end of the string, so our finding can be safe while(path.back() == '/' || path.back() == '\\') path.pop_back(); // Do the search size_t pos = path.find_last_of("/\\"); return (pos == path.npos? 0 : pos + 1); }
std::string getFullPath(const std::string& parentDir, const std::string& name) { std::string full = parentDir; if (parentDir.back() != '/' && parentDir.back() != '\\') { return parentDir + "\\" + name; } else { return parentDir + name; } }
static void ensure_trailing_separators(std::string& local_path, std::string& remote_path) { if (!adb_is_separator(local_path.back())) { local_path.push_back(OS_PATH_SEPARATOR); } if (remote_path.back() != '/') { remote_path.push_back('/'); } }
void Talkbot::normalize(std::string& sentence) const { if(not sentence.empty()) { if(std::islower(sentence[0])) sentence[0] = std::toupper(sentence[0]); if(sentence.back() != '.' and sentence.back() != '!' and sentence.back() != '?') sentence.push_back('.'); } }
/* * NormalizePath * Normalizates a path string, so for example: * "somefolder/something" will output "somefolder\\something" * "SOMEfoldER/something/" will output "somefolder\\something" * "somefolder\\something" will output "somefolder\\something" * etc */ inline std::string NormalizePath(std::string path) { std::replace(path.begin(), path.end(), '/', '\\'); // Replace all '/' with '\\' tolower(path); // tolower the strings (Windows paths are case insensitive) while(path.back() == '/' || path.back() == '\\') // We don't want a slash at the end of the folder path path.pop_back(); // .. trim(path); // Trim the string... return path; }
LODEN_CORE_EXPORT std::string joinPath(const std::string &path1, const std::string &path2) { if (path1.empty()) return path2; if (isAbsolutePath(path2)) return path2; if(path1.back() == '/' || path1.back() == '\\') return path1 + path2; return path1 + "/" + path2; }
bool GenericSocket::receive(int timeout, std::string &reply, int expected, bool raw) { int length; int run; struct pollfd pfd = { .fd = fd, .events = POLLIN | POLLERR | POLLHUP, .revents = 0 }; char buffer[8192]; reply.clear(); for(run = 8; run > 0; run--) { if(poll(&pfd, 1, timeout) != 1) return(false); if(pfd.revents & (POLLERR | POLLHUP)) return(false); if((length = read(fd, buffer, sizeof(buffer) - 1)) < 0) return(false); if(length == 0) { if(reply.length() == 0) // ignore terminating empty udp packed from previous output continue; else break; } reply.append(buffer, (size_t)length); if((expected > 0) && (expected > length)) expected -= length; else break; } if(reply.back() == '\n') reply.pop_back(); if(!raw && (reply.back() == '\r')) reply.pop_back(); return(true); } static std::string sha_hash_to_text(const unsigned char *hash) { unsigned int current; std::stringstream hash_string; for(current = 0; current < SHA_DIGEST_LENGTH; current++) hash_string << std::hex << std::setw(2) << std::setfill('0') << (unsigned int)hash[current]; return(hash_string.str()); }
void SplitGltfAttribute(std::string attribute, std::string *semanticName, DWORD *semanticIndex) { *semanticIndex = 0; if (isdigit(attribute.back())) { *semanticIndex = attribute.back() - '0'; attribute.pop_back(); if (attribute.back() == '_') attribute.pop_back(); } *semanticName = attribute; }
bool attributeHasAnnotation( const std::string& annotation, const std::string& attributeName, std::string* comment) { // Unqualified actions must compare directly e.g. we don't want to return a match for // for 'CAPA:suppress' when the annotation is 'CAPA::suppress[foo]' if(attributeName.find('[') == std::string::npos) { return attributeName == annotation; } // Otherwise, check if the attributeName is a prefix of the annotation // We need to check prefix and not equality in case there's a comment if(annotation.length() < attributeName.length() || !std::equal(attributeName.begin(), attributeName.end(), annotation.begin())) { return false; } // The attributes match. // Try to pick out a comment if we need to if(comment != nullptr) { const auto commentStart = annotation.find('[', attributeName.length()); if(commentStart != std::string::npos && annotation.back() == ']') { *comment = annotation.substr(commentStart + 1, annotation.length() - commentStart - 2); } } return true; }
//-----------------------------------------------------------------// bool initialize(const std::string& root) { root_path_ = root; if(!root_path_.empty()) { if(root_path_.back() != '/') root_path_ += '/'; if(!utils::is_directory(root)) { std::cerr << "Warrning: fontfile path is not directory (" << root << ")" << std::endl; return false; } } else { std::cerr << "Warrning: fontfile root path to empty." << std::endl; return false; } // make home path auto p = getenv("HOME"); if(p != nullptr) { home_path_ = p; home_path_ += '/'; } FT_Error error = FT_Init_FreeType(&library_); if(error) { std::cerr << "FT Library init error: " << static_cast<int>(error) << std::endl; return false; } double angle = (0.0 / 360) * 2.0 * 3.14159265398979; matrix_.xx = static_cast<FT_Fixed>( cos( angle ) * 0x10000L ); matrix_.xy = static_cast<FT_Fixed>(-sin( angle ) * 0x10000L ); matrix_.yx = static_cast<FT_Fixed>( sin( angle ) * 0x10000L ); matrix_.yy = static_cast<FT_Fixed>( cos( angle ) * 0x10000L ); return true; }
std::string lastDigit(std::string const& encoding) const{ if(encoding.empty()){ return ""; } //return encoding.substr(encoding.length()-1); return std::string(1, encoding.back()); }
bool addon_filename_legal(const std::string& name) { if(name.empty() || name.back() == '.' || name.find("..") != std::string::npos || name.size() > 255) { return false; } else { // NOTE: We can't use filesystem::base_name() here, since it returns // the filename up to the *last* dot. "CON.foo.bar" in // "CON.foo.bar.baz" is still redirected to "CON" on Windows; // the base_name() approach would cause the name to not match // any entries on our blacklist. // Do also note that we're relying on the next check after this // to flag the name as illegal if it contains a ':' -- a // trailing colon is a valid way to refer to DOS device names, // meaning that e.g. "CON:" is equivalent to "CON". const std::string stem = boost::algorithm::to_upper_copy(name.substr(0, name.find('.')), std::locale::classic()); if(dos_device_names.find(stem) != dos_device_names.end()) { return false; } const ucs4::string name_ucs4 = unicode_cast<ucs4::string>(name); const std::string name_utf8 = unicode_cast<utf8::string>(name_ucs4); if(name != name_utf8){ // name is invalid UTF-8 return false; } return std::find_if(name_ucs4.begin(), name_ucs4.end(), addon_filename_ucs4char_illegal()) == name_ucs4.end(); } }
bool TRPLoader::Install(std::string dest, bool show) { if (!trp_f.IsOpened()) { return false; } if (!dest.empty() && dest.back() != '/') { dest += '/'; } if (!Emu.GetVFS().ExistsDir(dest)) { Emu.GetVFS().CreateDir(dest); } for (const TRPEntry& entry : m_entries) { char* buffer = new char [(u32)entry.size]; trp_f.Seek(entry.offset); trp_f.Read(buffer, entry.size); vfsFile(dest + entry.name, fom::rewrite).Write(buffer, entry.size); delete[] buffer; } return true; }
std::string Model::cleanNamespaceTrailingChars(std::string ns) { static const std::set<char> IGNORED_LAST_CHARS = {'#', ':', '/'}; if ( IGNORED_LAST_CHARS.count(ns.back()) ) { ns.pop_back(); } return ns; }
bool check() { CHECK(value.size() == 300); CHECK(value.front() == 'b' && value.back() == 'b'); CHECK(i_wanna_be_big[0] == 'k' && i_wanna_be_big[50] == 'k'); return true; }
bool fortifiedString(const std::string & s) { if (isDigit(s)) return true ; linbox_check(!s.empty()); return s.front() == '\"' && s.back() == '\"' ; }
std::pair<std::string, std::string> spool_info::add_file(std::string filename, uid_t uid) { int id = ++num_files; if (!free_ids.empty()) { // If there's an id in the pool of free ids, use it. id = free_ids.back(); free_ids.pop_back(); } // Make a unique filename based on its id. Appending the id is fine. // That's because since ids are unique, two file names will never // end in the same character. if (filename == "/" || filename.empty()) { std::cout << filename << ": X Bad filename" << std::endl; return std::make_pair("", ""); } else if (filename.back() == '/') filename.erase(filename.end() - 1); auto idx = filename.find_last_of('/'); if (idx == std::string::npos) idx = 0; else idx++; auto unique_filename = filename.substr(idx) + "_" + std::to_string(id); files.insert(std::make_pair(std::to_string(id), spool_info::file(unique_filename, uid))); return std::make_pair(std::to_string(id), unique_filename); }
uint32_t install_(const std::string& fpath) { unit_map_cit cit = unit_map_.find(fpath); if(cit != unit_map_.end()) { // find it !, To be not install. return 0; } auto tpath = strip_last_of_delimita_path(fpath); auto bpath = get_file_path(tpath); bpath += '/'; unit_map_it it = unit_map_.find(bpath); if(it != unit_map_.end()) { unit_t& t = it->second; std::string name = get_file_name(tpath); if(fpath.back() == '/') name += '/'; t.install_child(name); } uint32_t hnd = handle_set_.create(); unit_t u; u.set_id(hnd); unit_map_.emplace(fpath, u); return hnd; }
std::string InProcClientWrapper::assembleSetResourceUri(std::string uri, const QueryParamsMap& queryParams) { if(uri.back() == '/') { uri.resize(uri.size()-1); } ostringstream paramsList; if(queryParams.size() > 0) { paramsList << '?'; } for(auto& param : queryParams) { paramsList << param.first <<'='<<param.second<<';'; } std::string queryString = paramsList.str(); if(queryString.back() == ';') { queryString.resize(queryString.size() - 1); } std::string ret = uri + queryString; return ret; }
char CreditCard::generateCheckSum(std::string numbers) { unsigned int sum=0; bool toggle=true; unsigned int checkDigit=0; while(!numbers.empty()) { unsigned int temp=numbers.back() - '0'; //saves last digit if (toggle) { temp= temp*2; if (temp>=10) temp=temp-9; } sum=sum+temp; toggle=!toggle; numbers.pop_back(); //deletes last digit } checkDigit= (sum*9)%10; return checkDigit+'0'; }
bool Directory::mkpath(const std::string& path) { if(path.empty()) return false; /* If path contains trailing slash, strip it */ if(path.back() == '/') return mkpath(path.substr(0, path.size()-1)); /* If the directory exists, done */ if(fileExists(path)) return true; /* If parent directory doesn't exist, create it */ const std::string parentPath = Directory::path(path); if(!parentPath.empty() && !fileExists(parentPath) && !mkpath(parentPath)) return false; /* Create directory, return true if successfully created or already exists */ /* Unix, Emscripten */ #if defined(CORRADE_TARGET_UNIX) || defined(CORRADE_TARGET_EMSCRIPTEN) const int ret = mkdir(path.data(), 0777); return ret == 0; /* Windows (not Store/Phone) */ #elif defined(CORRADE_TARGET_WINDOWS) && !defined(CORRADE_TARGET_WINDOWS_RT) return CreateDirectory(path.data(), nullptr) != 0 || GetLastError() == ERROR_ALREADY_EXISTS; /* Not implemented elsewhere */ #else Warning() << "Utility::Directory::mkdir(): not implemented on this platform"; return false; #endif }
bool OOFEMTXTDataReader :: giveRawLineFromInput(std :: ifstream &stream, int &lineNum, std :: string &line) { // // reads one line from inputStream - for private use only. // do { lineNum++; std :: getline(stream, line); if ( !stream ) { return false; } if ( line.length() > 0 ) { if ( line.back() == '\\' ) { std :: string continuedLine; do { lineNum++; std :: getline(stream, continuedLine); if ( !stream ) { return false; } line.pop_back(); line += continuedLine; } while ( continuedLine.back() == '\\' ); } } } while ( line.length() == 0 || line [ 0 ] == '#' ); // skip comments return true; }
void snap::Excerpt::highlight_word(std::string w) { if (w.size() == 0 || w == "*" || w == "**") { return; } bool pre_wild_card = false; bool post_wild_card = false; if (w.front() == '*') { pre_wild_card = true; } if (w.back() == '*') { post_wild_card = true; } this -> search_strings.push_back(w); std::string w_trimmed = boost::algorithm::trim_copy_if(w, boost::algorithm::is_any_of("*")); std::transform(w_trimmed.begin(), w_trimmed.end(), w_trimmed.begin(), ::tolower); std::string lower_text(text); std::transform(lower_text.begin(), lower_text.end(), lower_text.begin(), ::tolower); int offset = 0; int left_shift = 24; int right_shift = 7; int current_pos = 0; while ((current_pos = lower_text.find(w_trimmed, current_pos)) != -1) { bool highlight = true; if (current_pos != 0 && !pre_wild_card && !(isspace(lower_text[current_pos-1]) || ispunct(lower_text[current_pos-1]))) { highlight = false; } if (current_pos + w_trimmed.length() != lower_text.length() && !post_wild_card && !(isspace(lower_text[current_pos + w_trimmed.length()]) || ispunct(lower_text[current_pos + w_trimmed.length()]))) { highlight = false; } if (highlight) { (this -> text).insert(current_pos + offset, "<span style=\"color:red\">"); offset += left_shift; (this -> text).insert(current_pos + w_trimmed.length() + offset, "</span>"); offset += right_shift; } current_pos += w_trimmed.size(); } }
void File::write_line(const std::string& line) const { if(good()){ f_->write(line.c_str(), line.size()); if (line.back() != '\n') f_->write("\n", 1); } }