QuickCppLib 0.10
Eliminate all the tedious hassle when making state-of-the-art C++ 14 - 23 libraries!
Loading...
Searching...
No Matches
Functions
quickcpplib::_xxx::algorithm::string Namespace Reference

Functions

template<class Char >
std::basic_string< Char > tolower (std::basic_string< Char > s)
 Returns an all lower case edition of the input string. i18n aware.
 
template<class Char >
std::basic_string< Char > toupper (std::basic_string< Char > s)
 Returns an all upper case edition of the input string. i18n aware.
 
template<class CharType , class T , typename std::enable_if<(sizeof(T)==1), bool >::type = true, typename std::enable_if<(std::is_trivially_copyable< T >::value), bool >::type = true, typename std::enable_if<(!std::is_const< CharType >::value), bool >::type = true>
size_t to_hex_string (CharType *out, size_t outlen, const T *_in, size_t inlen)
 Converts a number to a hex string. Out buffer can be same as in buffer.
 
template<class CharType , class T , typename std::enable_if<(sizeof(T)==1), bool >::type = true, typename std::enable_if<(std::is_trivially_copyable< T >::value), bool >::type = true, typename std::enable_if<(!std::is_const< CharType >::value), bool >::type = true>
size_t to_hex_string (span::span< CharType > out, const span::span< T > in)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T , typename std::enable_if<(sizeof(T)==1), bool >::type = true, typename std::enable_if<(std::is_trivially_copyable< T >::value), bool >::type = true>
std::string to_hex_string (span::span< T > in)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T , typename std::enable_if<(sizeof(T)==1), bool >::type = true, typename std::enable_if<(std::is_trivially_copyable< T >::value), bool >::type = true>
std::string to_hex_string (const T *in, size_t len)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T , class CharType , typename std::enable_if<(sizeof(T)==1), bool >::type = true, typename std::enable_if<(std::is_trivially_copyable< T >::value), bool >::type = true, typename std::enable_if<(!std::is_const< T >::value), bool >::type = true>
size_t from_hex_string (T *out, size_t outlen, const CharType *in, size_t inlen)
 Converts a hex string to a number. Out buffer can be same as in buffer.
 

Function Documentation

◆ tolower()

template<class Char >
std::basic_string< Char > quickcpplib::_xxx::algorithm::string::tolower ( std::basic_string< Char >  s)

Returns an all lower case edition of the input string. i18n aware.

44 {
45 auto &f = std::use_facet<std::ctype<Char>>(std::locale());
46 std::transform(s.begin(), s.end(), s.begin(), [&](Char c) { return f.tolower(c); });
47 return s;
48 }

◆ toupper()

template<class Char >
std::basic_string< Char > quickcpplib::_xxx::algorithm::string::toupper ( std::basic_string< Char >  s)

Returns an all upper case edition of the input string. i18n aware.

52 {
53 auto &f = std::use_facet<std::ctype<Char>>(std::locale());
54 std::transform(s.begin(), s.end(), s.begin(), [&](Char c) { return f.toupper(c); });
55 return s;
56 }

◆ to_hex_string() [1/4]

template<class CharType , class T , typename std::enable_if<(sizeof(T)==1), bool >::type = true, typename std::enable_if<(std::is_trivially_copyable< T >::value), bool >::type = true, typename std::enable_if<(!std::is_const< CharType >::value), bool >::type = true>
size_t quickcpplib::_xxx::algorithm::string::to_hex_string ( CharType *  out,
size_t  outlen,
const T *  _in,
size_t  inlen 
)
inline

Converts a number to a hex string. Out buffer can be same as in buffer.

Note that the character range used is a 16 item table of:

0123456789abcdef

This lets one pack one byte of input into two bytes of output.

Complexity\nO(N) where N is the length of the number.
Errors returnable\nThrows exception if output buffer is too small for input.
78 {
79 unsigned const char *in = (unsigned const char *) _in;
80 static constexpr char table[] = "0123456789abcdef";
81 if(outlen < inlen * 2)
82#ifdef __cpp_exceptions
83 throw std::invalid_argument("Output buffer too small.");
84#else
85 abort();
86#endif
87 if(inlen >= 2)
88 {
89 for(size_t n = inlen - 2; n <= inlen - 2; n -= 2)
90 {
91 out[n * 2 + 3] = table[in[n + 1] & 0xf];
92 out[n * 2 + 2] = table[(in[n + 1] >> 4) & 0xf];
93 out[n * 2 + 1] = table[in[n] & 0xf];
94 out[n * 2 + 0] = table[(in[n] >> 4) & 0xf];
95 }
96 }
97 if(inlen & 1)
98 {
99 out[1] = table[in[0] & 0xf];
100 out[0] = table[(in[0] >> 4) & 0xf];
101 }
102 return inlen * 2;
103 }

◆ to_hex_string() [2/4]

template<class CharType , class T , typename std::enable_if<(sizeof(T)==1), bool >::type = true, typename std::enable_if<(std::is_trivially_copyable< T >::value), bool >::type = true, typename std::enable_if<(!std::is_const< CharType >::value), bool >::type = true>
size_t quickcpplib::_xxx::algorithm::string::to_hex_string ( span::span< CharType >  out,
const span::span< T >  in 
)
inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

112 {
113 return to_hex_string(out.data(), out.size(), in.data(), in.size());
114 }
quickcpplib::_xxx::algorithm::string::to_hex_string
size_t to_hex_string(CharType *out, size_t outlen, const T *_in, size_t inlen)
Converts a number to a hex string. Out buffer can be same as in buffer.
Definition string.hpp:77

◆ to_hex_string() [3/4]

template<class T , typename std::enable_if<(sizeof(T)==1), bool >::type = true, typename std::enable_if<(std::is_trivially_copyable< T >::value), bool >::type = true>
std::string quickcpplib::_xxx::algorithm::string::to_hex_string ( span::span< T >  in)
inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

119 {
120 std::string out(in.size() * 2, ' ');
121 to_hex_string(const_cast<char *>(out.data()), out.size(), in.data(), in.size());
122 return out;
123 }

◆ to_hex_string() [4/4]

template<class T , typename std::enable_if<(sizeof(T)==1), bool >::type = true, typename std::enable_if<(std::is_trivially_copyable< T >::value), bool >::type = true>
std::string quickcpplib::_xxx::algorithm::string::to_hex_string ( const T *  in,
size_t  len 
)
inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

128 {
129 std::string out(len * 2, ' ');
130 to_hex_string(const_cast<char *>(out.data()), out.size(), in, len);
131 return out;
132 }
len
EXECINFO_DECL _Check_return_ _In_ size_t len
Definition execinfo_win64.h:55

◆ from_hex_string()

template<class T , class CharType , typename std::enable_if<(sizeof(T)==1), bool >::type = true, typename std::enable_if<(std::is_trivially_copyable< T >::value), bool >::type = true, typename std::enable_if<(!std::is_const< T >::value), bool >::type = true>
size_t quickcpplib::_xxx::algorithm::string::from_hex_string ( T *  out,
size_t  outlen,
const CharType *  in,
size_t  inlen 
)
inline

Converts a hex string to a number. Out buffer can be same as in buffer.

Note that this routine is about 43% slower than to_hex_string(), half of which is due to input validation.

Complexity\nO(N) where N is the length of the string.
Errors returnable\nThrows exception if output buffer is too small for input or input size is not multiple of two.
146 {
147 if(inlen % 2)
148#ifdef __cpp_exceptions
149 throw std::invalid_argument("Input buffer not multiple of two.");
150#else
151 abort();
152#endif
153 if(outlen < inlen / 2)
154#ifdef __cpp_exceptions
155 throw std::invalid_argument("Output buffer too small.");
156#else
157 abort();
158#endif
159 bool is_invalid = false;
160 auto fromhex = [&is_invalid](CharType c) -> unsigned char
161 {
162#if 1
163 // ASCII starting from 48 is 0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
164 // 48 65 97
165 static constexpr unsigned char table[] = {
166 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, // +10 = 58
167 255, 255, 255, 255, 255, 255, 255, // +7 = 65
168 10, 11, 12, 13, 14, 15, // +6 = 71
169 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
170 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, // +26 = 97
171 10, 11, 12, 13, 14, 15};
172 unsigned char r = 255;
173 if(c >= 48 && c <= 102)
174 r = table[c - 48];
175 if(r == 255)
176 is_invalid = true;
177 return r;
178#else
179 if(c >= '0' && c <= '9')
180 return c - '0';
181 if(c >= 'a' && c <= 'f')
182 return c - 'a' + 10;
183 if(c >= 'A' && c <= 'F')
184 return c - 'A' + 10;
185#ifdef __cpp_exceptions
186 throw std::invalid_argument("Input is not hexadecimal.");
187#else
188 abort();
189#endif
190#endif
191 };
192 const auto bulklen = inlen / 2 - (inlen / 2) % 4;
193 if(bulklen >= 4)
194 {
195 for(size_t n = 0; n < bulklen; n += 4)
196 {
197 unsigned char c[8];
198 c[0] = fromhex(in[n * 2]);
199 c[1] = fromhex(in[n * 2 + 1]);
200 c[2] = fromhex(in[n * 2 + 2]);
201 c[3] = fromhex(in[n * 2 + 3]);
202 out[n] = (T) ((c[0] << 4) | c[1]);
203 c[4] = fromhex(in[n * 2 + 4]);
204 c[5] = fromhex(in[n * 2 + 5]);
205 out[n + 1] = (T) ((c[2] << 4) | c[3]);
206 c[6] = fromhex(in[n * 2 + 6]);
207 c[7] = fromhex(in[n * 2 + 7]);
208 out[n + 2] = (T) ((c[4] << 4) | c[5]);
209 out[n + 3] = (T) ((c[6] << 4) | c[7]);
210 }
211 }
212 for(size_t n = bulklen; n < inlen / 2; n++)
213 {
214 auto c1 = fromhex(in[n * 2]), c2 = fromhex(in[n * 2 + 1]);
215 out[n] = (T) ((c1 << 4) | c2);
216 }
217 if(is_invalid)
218#ifdef __cpp_exceptions
219 throw std::invalid_argument("Input is not hexadecimal.");
220#else
221 abort();
222#endif
223 return inlen / 2;
224 }