// Trim trailing space characters
string openm::trimRight(const string & i_str, const locale & i_locale)
{
for (string::const_reverse_iterator revIt = i_str.rbegin(); revIt != i_str.rend(); ++revIt) {
if (!isspace<char>(*revIt, i_locale)) return i_str.substr(0, i_str.rend() - revIt);
}
return ""; // string is empty or has only space chars
}
string findLastWord(const string& s){
auto first=find_if(s.rbegin(),s.rend(),::isalpha);
auto last=find_if_not(first,s.rend(),::isalpha);
string result(first,last);
reverse(result.begin(),result.end());
return result;
}
string nextPermutation(string s)
{
if (s.size() <= 1)
return s;
string::reverse_iterator i;
string::reverse_iterator j;
for (j = s.rbegin(), i = s.rbegin() + 1; i != s.rend(); ++i, ++j)
{
if (*i < *j)
break;
}
if (i == s.rend())
{
reverse(s.begin(), s.end());
return s;
}
for (j = s.rbegin(); ; ++j)
{
if(*i < *j)
break;
}
swap(*j, *i);
reverse(i--, s.rbegin() - 1);
return s;
}
bigint::bigint (const string& that) {
auto itor = that.cbegin();
if (itor != that.cend() and *itor == '_') {
negative = true;
++itor;
}
/*
int newval = 0;
while (itor != that.end()) newval = newval * 10 + *itor++ - '0';
//long_value = isnegative ? - newval : + newval;
long_value = negative ? - newval : + newval;
DEBUGF ('~', this << " -> " << long_value)
*/
string::const_reverse_iterator rit = that.rbegin();
string::const_reverse_iterator last_digit;
if (negative){ last_digit = that.rend() - 1;}
else {last_digit = that.rend();}
while (rit != last_digit){
big_value.push_back(*rit - '0');
++rit;
}
}
bool sensor_plugin_loader::get_paths_from_dir(const string &dir_path, vector<string> &hal_paths, vector<string> &sensor_paths)
{
const string PLUGIN_POSTFIX = ".so";
const string HAL_POSTFIX = "_hal.so";
DIR *dir = NULL;
struct dirent *dir_entry = NULL;
dir = opendir(dir_path.c_str());
if (!dir) {
ERR("Failed to open dir: %s", dir_path.c_str());
return false;
}
string name;
while (dir_entry = readdir(dir)) {
name = string(dir_entry->d_name);
if (equal(PLUGIN_POSTFIX.rbegin(), PLUGIN_POSTFIX.rend(), name.rbegin())) {
if (equal(HAL_POSTFIX.rbegin(), HAL_POSTFIX.rend(), name.rbegin()))
hal_paths.push_back(dir_path + "/" + name);
else
sensor_paths.push_back(dir_path + "/" + name);
}
}
closedir(dir);
return true;
}
string addBinary(string a, string b) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
if(a.length() == 0)
{
return b;
}
else if(b.length() == 0)
{
return a;
}
if(a.length() > b.length())
{
int times = a.length() - b.length();
while(times > 0)
{
string temp0 = "0";
b = temp0+b;
times --;
}
}
else if(a.length() < b.length())
{
int times = b.length() - a.length();
while(times > 0)
{
string temp0 = "0";
a = temp0+a;
times --;
}
}
string::reverse_iterator i = a.rbegin();
string::reverse_iterator j = b.rbegin();
int next =0;
string s;
string digit;
for ( ;i != a.rend() && j!=b.rend(); ++i,++j)
{
int num = *i-'0'+*j -'0'+next;
if(num >= 2)
{
num = num -2;
next = 1;
}
else
{
next =0;
}
digit = string(1,num+'0');
s = digit+s;
}
if(next != 0)
{
digit = string(1,next+'0');
s = digit+s;
}
return s;
}
bool FileSystem::base_to_uppercase(string& str, int count)
{
if (count <= 0) return true;
int todo = count;
// Go backwards.
string::reverse_iterator X;
for(X = str.rbegin(); X != str.rend(); ++X)
{
// Stop at separator.
if (*X == '/' || *X == '\\' || *X == ':')
todo--;
if (todo <= 0)
break;
#if (defined(BEOS) || defined(OPENBSD) || defined(CYGWIN) || defined(__MORPHOS__))
if ((*X >= 'a') && (*X <= 'z')) *X -= 32;
#else
*X = static_cast<char>(std::toupper(*X));
#endif
}
if (X == str.rend())
todo--; // start of pathname counts as separator too
// false if it didn't reach 'count' parts
return (todo <= 0);
}
string addBinary(string a, string b) {
string r_a(a.rbegin(), a.rend()), r_b(b.rbegin(), b.rend());
string ret;
string::const_iterator iter_a, iter_b;
int carry = 0, sum = 0;
for(iter_a = r_a.begin(), iter_b = r_b.begin(); iter_a != r_a.end() && iter_b != r_b.end(); ++iter_a, ++iter_b) {
sum = carry + _atoi(*iter_a) + _atoi(*iter_b);
carry = sum / 2;
ret.push_back(_itoa(sum % 2));
}
while(iter_a != r_a.end()) {
sum = carry + _atoi(*iter_a);
carry = sum / 2;
ret.push_back(_itoa(sum % 2));
++iter_a;
}
while(iter_b != r_b.end()) {
sum = carry + _atoi(*iter_b);
carry = sum / 2;
ret.push_back(_itoa(sum % 2));
++iter_b;
}
if(carry) //don't forget the last carry
ret.push_back(_itoa(carry));
return string(ret.rbegin(), ret.rend());
}
string addBinary(string a, string b)
{
string result;
string::reverse_iterator va = a.rbegin();
string::reverse_iterator vb = b.rbegin();
int carry = 0;
while (true)
{
bool looping = (carry != 0);
if (va != a.rend())
{
looping = true;
carry += (va[0] == '1') ? 1 : 0;
++va;
}
if (vb != b.rend())
{
looping = true;
carry += (vb[0] == '1') ? 1 : 0;
++vb;
}
if (!looping) break;
result += '0' + (carry & 0x1);
carry >>= 1;
}
if (result.length() != 0)
{
reverse(result.begin(), result.end());
}
else result += '0'; // handle empty input
return result;
}
int lengthOfLastWord(string s)
{
auto it=s.rbegin();
while(it<s.rend()&&*it==' ')++it;
auto begin=it;
while(it<s.rend()&&*it!=' ')++it;
auto end=it;
return static_cast<int>(end-begin);
}
bool ends(const string &src, const string &pat) {
auto a = src.rbegin();
auto b = pat.rbegin();
while (a != src.rend() && b != pat.rend()) {
if (*a != *b) return false;
a++; b++;
}
return b == pat.rend();
}
deci::deci(string s)
{
NLS_SWAP_IN;
decimales = NULL;
try
{
string::reverse_iterator it = s.rbegin();
storage::iterator ut;
bool recule = false;
unsigned char tmp = 0xFF;
U_I size = s.size() / 2;
if(s.size() % 2 != 0)
size++;
if(size == 0) // empty string
throw Erange("deci::deci(string s)", gettext("an empty string is an invalid argument"));
decimales = new (get_pool()) storage(size);
if(decimales == NULL)
throw Ememory("deci::deci(string s)");
decimales->clear(0xFF); // FF is not a valid couple of decimal digit
ut = decimales->rbegin();
while(it != s.rend() || recule)
{
if(recule)
{
if(it != s.rend())
set_left(tmp, digit_htoc(*it));
else
set_left(tmp, 0xF);
if(ut == decimales->rend())
throw SRC_BUG;
*(ut--) = tmp;
}
else
set_right(tmp, digit_htoc(*it));
recule = ! recule;
if(it != s.rend())
it++; // it is a reverse iterator thus ++ for going backward
}
reduce();
}
catch(...)
{
if(decimales != NULL)
delete decimales;
NLS_SWAP_OUT;
throw;
}
NLS_SWAP_OUT;
}
bool HttpClient::download(string url, string folder)
{
// try guess filename from the url
auto pos = find(url.rbegin(), url.rend(), '/');
string name = url.substr(distance(pos, url.rend()));
if (folder.back() != kPathSeparator) folder += kPathSeparator;
return downloadAs(url, folder + name);
}
string multiplye(string num1, string num2) {
int carry = 0;
string ret;
char tmp;
vector<string> mediators;
for(string::reverse_iterator i=num1.rbegin(); i!=num1.rend(); i++) {
int multiplier1 = *i - '0';
string mediator;
for(int k=0; k<i-num1.rbegin(); k++) {
mediator.push_back('0');
}
for(string::reverse_iterator j=num2.rbegin(); j!=num2.rend(); j++) {
int multiplier2 = *j - '0';
int product = multiplier1*multiplier2;
tmp = (product+carry)%10+'0';
mediator.insert(mediator.begin(),tmp);
carry = (product+carry)/10;
}
if(carry>0) {
tmp = carry + '0';
mediator.insert(mediator.begin(),tmp);
}
mediators.push_back(mediator);
carry =0;
}
carry = 0;
tmp = '0';
bool a= false;
while(true) {
int sum=0;
if(mediators.size()>0) {
for(vector<string>::iterator i=mediators.begin(); i!=mediators.end(); i++) {
int addend =(*i).back()-'0';
sum +=addend;
(*i).pop_back();
if((*i).size()==0) {
mediators.erase(i);
i--;
}
}
tmp = (sum+carry)%10+'0';
ret.insert(ret.begin(),tmp);
carry = (sum+carry)/10;
}
else {
if(carry>0) {
tmp = carry+'0';
ret.insert(ret.begin(),tmp);
}
break;
}
}
return ret;
}
void StrUtils::trimright( string& s )
{
string::difference_type dt;
string::reverse_iterator it;
for( it = s.rbegin(); it != s.rend(); it++ )
if( !StrUtils::isspace( *it ) )
break;
dt = s.rend() - it;
s.erase( s.begin() + dt, s.end() );
}
std::string spider::Path::getExtension(std::string const& path) {
using std::find;
using std::string;
string const fileName = getFileName(path);
string::const_reverse_iterator rposition = find(fileName.rbegin(), fileName.rend(), '.');
if (rposition == fileName.rend()) {
return "";
}
string::const_iterator position = rposition.base();
string extension(position, fileName.end());
return extension;
}
void trim_back(string& line)
{
string::reverse_iterator it2 = line.rbegin();
size_t start_erase = line.size()-1;
if(it2 == line.rend())
return;
if(!isspace(*(it2++)))
return;
while((it2 != line.rend()) && isspace(*it2))
start_erase--, it2++;
line.erase(start_erase);
}
num num::operator+(num & r)
{
num rs;
string rrs;
string::reverse_iterator it1 = n.rbegin();
string::reverse_iterator it2 = r.n.rbegin();
int jin = 0;
while (it1 != n.rend() || it2 != r.n.rend())
{
int temp = 0;
if (it1 != n.rend())
{
temp += (*it1 - '0')*sgn;
++it1;
}
if (it2 != r.n.rend())
{
temp += (*it2 - '0')*r.sgn;
++it2;
}
temp += jin;
jin = temp / 10;
if (temp < 0)
jin = -1;
if (temp < 0)
temp += 10;
rrs.push_back(temp % 10 + '0');
}
if (jin > 0)
rrs.push_back('1');
if (jin < 0)
rs.sgn = -1;
else
rs.sgn = 1;
if (rs.sgn>0)
{
for (string::reverse_iterator it = rrs.rbegin();it != rrs.rend();++it)
{
rs.n.push_back(*it);
}
}
int i = rs.n.find_first_not_of('0');
rs.n.erase(0, i);
if (rs.n.empty())
rs.sgn = 0;
return rs;
}
extern int stringisuffcmp(const string& s1, const string& s2)
{
string::const_reverse_iterator r1 = s1.rbegin(), re1 = s1.rend(),
r2 = s2.rbegin(), re2 = s2.rend();
while (r1 != re1 && r2 != re2) {
char c1 = ::toupper(*r1);
char c2 = ::toupper(*r2);
if (c1 != c2) {
return c1 > c2 ? 1 : -1;
}
++r1;
++r2;
}
return 0;
}
bool tratarStrings( string &s1, string &s2 ) {
string::reverse_iterator rit1, rit2;
for( rit1 = s1.rbegin(), rit2 = s2.rbegin(); rit1 != s1.rend() && rit2 != s2.rend() ; ++rit1, ++rit2 ) {
if( *rit1 != *rit2 ) {
return false;
}
}
if( s2.size() > s1.size() ) {
return false;
}
return true;
}
// see https://stackoverflow.com/questions/216823/whats-the-best-way-to-trim-stdstring
string rtrim(string s) {
s.erase(std::find_if(s.rbegin(), s.rend(), [](unsigned char ch) {
return !std::isspace(ch);
}).base(), s.end());
return s;
}
//-----------------------------------------------------------------------------
string trim(const string &s)
{
size_t start_index = 0;
for(auto iter = s.begin();iter!=s.end();++iter)
{
if((*iter == ' ')||(*iter=='\n')||(*iter=='\t'))
{
start_index++;
continue;
}
else break;
}
size_t stop_index = 0;
for(auto iter = s.rbegin();iter!=s.rend();++iter)
{
if((*iter == ' ')||(*iter=='\n')||(*iter=='\t'))
{
stop_index++;
continue;
}
else break;
}
return string(s,start_index,(s.size()-stop_index-start_index));
}
// removes leading and trailing whitespaces
void trim(string& s) {
auto not_space = [](char c) { return isspace(c) == 0; };
// trim left
s.erase(s.begin(), find_if(s.begin(), s.end(), not_space));
// trim right
s.erase(find_if(s.rbegin(), s.rend(), not_space).base(), s.end());
}
string sum(string num1, string num2) {
if (num1.size() < num2.size())
swap(num1, num2);
string result = "0";
result += num1;
int carry = 0;
auto it2 = num2.rbegin(), itr = result.rbegin();
while (it2 != num2.rend()) {
int sum = *it2 - '0' + *itr - '0' + carry;
*itr = sum % 10 + '0';
carry = sum / 10;
++it2, ++itr;
}
while (carry) {
int sum = *itr - '0' + carry;
*itr = sum % 10 + '0';
carry = sum / 10;
++itr;
}
if (result[0] == '0')
return result.substr(1);
return result;
}
string reverse_str(string word) {
string rWord;
for (string::reverse_iterator it=word.rbegin(); it != word.rend(); it++) {
rWord += *it;
}
return rWord;
}
string reverseString(string s) {
string ans;
for(string::reverse_iterator iter = s.rbegin(); iter != s.rend(); iter++){
ans += *iter;
}
return ans;
}
int romanToInt(string s) {
unordered_map<char, int> mp = {
{'I', 1},
{'V', 5},
{'X', 10},
{'L', 50},
{'C', 100},
{'D', 500},
{'M', 1000}
};
int last = 0;
int ans = 0;
for(auto it = s.rbegin(); it != s.rend(); ++it) {
auto c = *it;
if(mp.count(c)) {
if(last != 0 && mp[c] < last) {
ans -= mp[c];
last = 0;
} else {
ans += mp[c];
last = mp[c];
}
} else {
last = 0;
}
}
return ans;
}
//------------------------------------------------------------------------------
// unpaddedPosMapEnd -- makes a map from padded to unpadded dna position:
// positons of pads are assigned the base towards the end
//------------------------------------------------------------------------------
vector<int> unpaddedPosMapEnd(const string dna) {
// output map
vector<int> posMap;
// unpad dna
string dnaUnpadded = unpadDna(dna);
// variables
int up = dnaUnpadded.size()+1;
for(string::const_reverse_iterator iter = dna.rbegin(); iter != dna.rend(); iter++) {
char b = *iter;
// if pad character
if (b == '*' or b == '-') {
posMap.push_back(up);
}
else {
up--;
posMap.push_back(up);
}
}
// reverse order
std::reverse(posMap.begin(), posMap.end());
// return
return posMap;
}
void reverseComplement(string &str) {
string out;
out.resize(str.length(), ' ');
string::reverse_iterator it;
string::iterator oit;
for (it = str.rbegin(), oit = out.begin(); it != str.rend(); it++, oit++) {
char c = toupper(*it);
//*oit = c;
switch (c) {
case 'A':
*oit = 'T';
break;
case 'T':
*oit = 'A';
break;
case 'G':
*oit = 'C';
break;
case 'C':
*oit = 'G';
break;
default:
*oit = c;
break;
}
}
//cout << str << endl << out << endl;
str = out;
}
string Roman::unsignedToRoman(unsigned decimalNumber)
{
string returnRomanValue;
map<unsigned, string> romanValue;
romanValue[1] = "I";
romanValue[4] = "IV";
romanValue[5] = "V";
romanValue[9] = "IX";
romanValue[10] = "X";
romanValue[40] = "XL";
romanValue[50] = "L";
romanValue[100] = "C";
romanValue[400] = "CD";
romanValue[500] = "D";
romanValue[900] = "CM";
romanValue[1000] = "M";
map<unsigned, string>::reverse_iterator it = romanValue.rbegin();
for (; it != romanValue.rend(); it++) {
int randomShitNumber = floor(decimalNumber / (*it).first);
if (randomShitNumber > 0) {
for (int n = 0; n < randomShitNumber; n++)
returnRomanValue += (*it).second;
}
decimalNumber -= randomShitNumber * (*it).first;
}
return returnRomanValue;
}
