Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

migrate StringUtil.h to C++11

Browse Source
This commit is contained in:
Dennis Luxen 2014-05-07 14:12:28 +02:00
parent ea12c6fde6
commit 07e245eb02
1 changed files with 113 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

258
Util/StringUtil.h
View File

@ -25,104 +25,103 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef STRINGUTIL_H_ #ifndef STRINGUTIL_H
#define STRINGUTIL_H_ #define STRINGUTIL_H
#include "../typedefs.h"
#include <boost/algorithm/string.hpp> #include <boost/algorithm/string.hpp>
#include <boost/spirit/include/karma.hpp> #include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/qi.hpp> #include <boost/spirit/include/qi.hpp>
#include <cstdio> #include <cstdio>
#include <cctype> #include <cctype>
#include <string> #include <string>
#include <vector>
// precision: position after decimal point // precision: position after decimal point
// length: maximum number of digits including comma and decimals // length: maximum number of digits including comma and decimals
template< int length, int precision > template <int length, int precision> static inline char *printInt(char *buffer, int value)
static inline char* printInt( char* buffer, int value ) { {
bool minus = false; bool minus = false;
if ( value < 0 ) { if (value < 0)
{
minus = true; minus = true;
value = -value; value = -value;
} }
buffer += length - 1; buffer += length - 1;
for ( int i = 0; i < precision; i++ ) { for (int i = 0; i < precision; i++)
*buffer = '0' + ( value % 10 ); {
*buffer = '0' + (value % 10);
value /= 10; value /= 10;
buffer--; buffer--;
} }
*buffer = '.'; *buffer = '.';
buffer--; buffer--;
for ( int i = precision + 1; i < length; i++ ) { for (int i = precision + 1; i < length; i++)
*buffer = '0' + ( value % 10 ); {
*buffer = '0' + (value % 10);
value /= 10; value /= 10;
if ( value == 0 ) break; if (value == 0)
break;
buffer--; buffer--;
} }
if ( minus ) { if (minus)
{
buffer--; buffer--;
*buffer = '-'; *buffer = '-';
} }
return buffer; return buffer;
} }
static inline void intToString(const int value, std::string & output) { static inline void intToString(const int value, std::string &output)
{
output.clear(); output.clear();
std::back_insert_iterator<std::string> sink(output); std::back_insert_iterator<std::string> sink(output);
boost::spirit::karma::generate(sink, boost::spirit::karma::int_, value); boost::spirit::karma::generate(sink, boost::spirit::karma::int_, value);
} }
static inline void int64ToString(const int64_t value, std::string & output) { static inline void int64ToString(const int64_t value, std::string &output)
{
output.clear(); output.clear();
std::back_insert_iterator<std::string> sink(output); std::back_insert_iterator<std::string> sink(output);
boost::spirit::karma::generate(sink, boost::spirit::karma::long_long, value); boost::spirit::karma::generate(sink, boost::spirit::karma::long_long, value);
} }
static inline int stringToInt(const std::string& input) { static inline int stringToInt(const std::string &input)
std::string::const_iterator first_digit = input.begin(); {
//Delete any trailing white-spaces auto first_digit = input.begin();
while(first_digit != input.end() && std::isspace(*first_digit)) { // Delete any trailing white-spaces
while (first_digit != input.end() && std::isspace(*first_digit))
{
++first_digit; ++first_digit;
} }
int value = 0; int value = 0;
boost::spirit::qi::parse( boost::spirit::qi::parse(first_digit, input.end(), boost::spirit::int_, value);
first_digit,
input.end(),
boost::spirit::int_, value
);
return value; return value;
} }
static inline unsigned stringToUint(const std::string& input) { static inline unsigned stringToUint(const std::string &input)
std::string::const_iterator first_digit = input.begin(); {
//Delete any trailing white-spaces auto first_digit = input.begin();
while(first_digit != input.end() && std::isspace(*first_digit)) { // Delete any trailing white-spaces
while (first_digit != input.end() && std::isspace(*first_digit))
{
++first_digit; ++first_digit;
} }
int value = 0; int value = 0;
boost::spirit::qi::parse( boost::spirit::qi::parse(first_digit, input.end(), boost::spirit::uint_, value);
first_digit,
input.end(),
boost::spirit::uint_, value
);
return value; return value;
} }
static inline uint64_t stringToInt64(const std::string& input) { static inline uint64_t stringToInt64(const std::string &input)
std::string::const_iterator first_digit = input.begin(); {
//Delete any trailing white-spaces auto first_digit = input.begin();
while(first_digit != input.end() && std::isspace(*first_digit)) { // Delete any trailing white-spaces
while (first_digit != input.end() && std::isspace(*first_digit))
{
++first_digit; ++first_digit;
} }
uint64_t value = 0; uint64_t value = 0;
boost::spirit::qi::parse( boost::spirit::qi::parse(first_digit, input.end(), boost::spirit::long_long, value);
first_digit,
input.end(),
boost::spirit::long_long, value
);
return value; return value;
} }
@ -138,7 +137,7 @@ static inline double StringToDouble(const char *p)
} }
while (*p >= '0' && *p <= '9') while (*p >= '0' && *p <= '9')
{ {
r = (r*10.0) + (*p - '0'); r = (r * 10.0) + (*p - '0');
++p; ++p;
} }
if (*p == '.') if (*p == '.')
@ -148,7 +147,7 @@ static inline double StringToDouble(const char *p)
++p; ++p;
while (*p >= '0' && *p <= '9') while (*p >= '0' && *p <= '9')
{ {
f = (f*10.0) + (*p - '0'); f = (f * 10.0) + (*p - '0');
++p; ++p;
++n; ++n;
} }
@ -161,110 +160,81 @@ static inline double StringToDouble(const char *p)
return r; return r;
} }
static inline void doubleToString(const double value, std::string & output){ static inline void doubleToString(const double value, std::string &output)
{
output.clear(); output.clear();
std::back_insert_iterator<std::string> sink(output); std::back_insert_iterator<std::string> sink(output);
boost::spirit::karma::generate(sink, boost::spirit::karma::double_, value); boost::spirit::karma::generate(sink, boost::spirit::karma::double_, value);
} }
static inline void doubleToStringWithTwoDigitsBehindComma( static inline void doubleToStringWithTwoDigitsBehindComma(const double value, std::string &output)
const double value, {
std::string & output
){
// The largest 32-bit integer is 4294967295, that is 10 chars // The largest 32-bit integer is 4294967295, that is 10 chars
// On the safe side, add 1 for sign, and 1 for trailing zero // On the safe side, add 1 for sign, and 1 for trailing zero
char buffer[12] ; char buffer[12];
sprintf(buffer, "%g", value) ; sprintf(buffer, "%g", value);
output = buffer ; output = buffer;
} }
inline void replaceAll( inline void replaceAll(std::string &s, const std::string &sub, const std::string &other)
std::string & s, {
const std::string & sub, boost::replace_all(s, sub, other);
const std::string & other
) {
boost::replace_all(s, sub, other);
} }
inline void stringSplit( inline std::string EscapeJSONString(const std::string &input)
const std::string &s, {
const char delim,
std::vector<std::string>& result
) {
boost::split(result, s, boost::is_any_of(std::string(&delim)));
}
inline std::string EscapeJSONString(const std::string& input) {
std::string output; std::string output;
output.reserve(input.size()); output.reserve(input.size());
for( for (auto iter = input.begin(); iter != input.end(); ++iter)
std::string::const_iterator iter = input.begin(); {
iter != input.end(); switch (iter[0])
++iter {
) { case '\\':
switch (iter[0]) { output += "\\\\";
case '\\': break;
output += "\\\\"; case '"':
break; output += "\\\"";
case '"': break;
output += "\\\""; case '/':
break; output += "\\/";
case '/': break;
output += "\\/"; case '\b':
break; output += "\\b";
case '\b': break;
output += "\\b"; case '\f':
break; output += "\\f";
case '\f': break;
output += "\\f"; case '\n':
break; output += "\\n";
case '\n': break;
output += "\\n"; case '\r':
break; output += "\\r";
case '\r': break;
output += "\\r"; case '\t':
break; output += "\\t";
case '\t': break;
output += "\\t"; default:
break; output += *iter;
default: break;
output += *iter;
break;
} }
} }
return output; return output;
} }
static std::string originals[] = {"&", "\"", "<", ">", "'", "[", "]", "\\"}; static std::string originals[] = {"&", "\"", "<", ">", "'", "[", "]", "\\"};
static std::string entities[] = {"&amp;", "&quot;", "&lt;", "&gt;", "&#39;", "&91;", "&93;", " &#92;" }; static std::string entities[] = {"&amp;", "&quot;", "&lt;", "&gt;",
"&#39;", "&91;", "&93;", " &#92;"};
inline std::string HTMLEntitize( const std::string & input) { inline std::size_t URIDecode(const std::string &input, std::string &output)
std::string result(input); {
for(unsigned i = 0; i < sizeof(originals)/sizeof(std::string); ++i) { auto src_iter = input.begin();
replaceAll(result, originals[i], entities[i]); output.resize(input.size() + 1);
}
return result;
}
inline std::string HTMLDeEntitize( std::string & result) {
for(unsigned i = 0; i < sizeof(originals)/sizeof(std::string); ++i) {
replaceAll(result, entities[i], originals[i]);
}
return result;
}
inline std::size_t URIDecode(const std::string & input, std::string & output) {
std::string::const_iterator src_iter = input.begin();
output.resize(input.size()+1);
std::size_t decoded_length = 0; std::size_t decoded_length = 0;
for( decoded_length = 0; src_iter != input.end(); ++decoded_length ) { for (decoded_length = 0; src_iter != input.end(); ++decoded_length)
if( {
src_iter[0] == '%' && if (src_iter[0] == '%' && src_iter[1] && src_iter[2] && isxdigit(src_iter[1]) &&
src_iter[1] && isxdigit(src_iter[2]))
src_iter[2] && {
isxdigit(src_iter[1]) &&
isxdigit(src_iter[2])
) {
std::string::value_type a = src_iter[1]; std::string::value_type a = src_iter[1];
std::string::value_type b = src_iter[2]; std::string::value_type b = src_iter[2];
a -= src_iter[1] < 58 ? 48 : src_iter[1] < 71 ? 55 : 87; a -= src_iter[1] < 58 ? 48 : src_iter[1] < 71 ? 55 : 87;
@ -279,29 +249,27 @@ inline std::size_t URIDecode(const std::string & input, std::string & output) {
return decoded_length; return decoded_length;
} }
inline std::size_t URIDecodeInPlace(std::string & URI) { inline std::size_t URIDecodeInPlace(std::string &URI) { return URIDecode(URI, URI); }
return URIDecode(URI, URI);
}
inline bool StringStartsWith( inline bool StringStartsWith(const std::string &input, const std::string &prefix)
const std::string & input, {
const std::string & prefix
) {
return boost::starts_with(input, prefix); return boost::starts_with(input, prefix);
} }
inline std::string GetRandomString() { inline std::string GetRandomString()
char s[128]; {
static const char alphanum[] = std::string s;
"0123456789" s.resize(128);
"ABCDEFGHIJKLMNOPQRSTUVWXYZ" static const char alphanum[] = "0123456789"
"abcdefghijklmnopqrstuvwxyz"; "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz";
for (int i = 0; i < 127; ++i) { for (int i = 0; i < 127; ++i)
{
s[i] = alphanum[rand() % (sizeof(alphanum) - 1)]; s[i] = alphanum[rand() % (sizeof(alphanum) - 1)];
} }
s[127] = 0; s[127] = 0;
return std::string(s); return s;
} }
#endif /* STRINGUTIL_H_ */ #endif // STRINGUTIL_H