1 /*
2 * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #ifndef TSTRINGS_H
27 #define TSTRINGS_H
28
29 #ifdef _MSC_VER
30 # define TSTRINGS_WITH_WCHAR
31 #endif
32
33 #ifdef TSTRINGS_WITH_WCHAR
34 #include <windows.h>
35 #include <tchar.h>
36 // Want compiler issue C4995 warnings for encounters of deprecated functions.
37 #include <strsafe.h>
38 #endif
39
40 // STL's string header depends on deprecated functions.
41 // We don't care about warnings from STL header, so disable them locally.
42 #ifdef _MSC_VER
43 # pragma warning(push)
44 # pragma warning(disable:4995)
45 #endif
46
47 #include <string>
48 #include <sstream>
49 #include <iostream>
50 #include <vector>
51
52 #ifdef _MSC_VER
53 # pragma warning(pop)
54 #endif
55
56
57 #ifndef _T
58 # define _T(x) x
59 #endif
60
61
62 #ifdef TSTRINGS_WITH_WCHAR
63 typedef std::wstring tstring;
64 typedef std::wostringstream tostringstream;
65 typedef std::wistringstream tistringstream;
66 typedef std::wstringstream tstringstream;
67 typedef std::wistream tistream;
68 typedef std::wostream tostream;
69 typedef std::wiostream tiostream;
70 typedef std::wios tios;
71 #else
72 typedef std::string tstring;
73 typedef std::ostringstream tostringstream;
74 typedef std::istringstream tistringstream;
75 typedef std::stringstream tstringstream;
76 typedef std::istream tistream;
77 typedef std::ostream tostream;
78 typedef std::iostream tiostream;
79 typedef std::ios tios;
80
81 typedef const char* LPCTSTR;
82 typedef char TCHAR;
83 #endif
84
85 // frequently used "array of tstrings" type
86 typedef std::vector<tstring> tstring_array;
87
88 namespace tstrings {
89 tstring unsafe_format(tstring::const_pointer format, ...);
90
91 enum CompareType {CASE_SENSITIVE, IGNORE_CASE};
92 bool equals(const tstring& a, const tstring& b, const CompareType ct=CASE_SENSITIVE);
93 bool startsWith(const tstring &str, const tstring &substr, const CompareType ct=CASE_SENSITIVE);
94 bool endsWith(const tstring &str, const tstring &substr, const CompareType ct=CASE_SENSITIVE);
95
96 enum SplitType {ST_ALL, ST_EXCEPT_EMPTY_STRING};
97 void split(tstring_array &strVector, const tstring &str,
98 const tstring &delimiter, const SplitType st = ST_ALL);
99 inline tstring_array split(const tstring &str, const tstring &delimiter, const SplitType st = ST_ALL) {
100 tstring_array result;
101 split(result, str, delimiter, st);
102 return result;
103 }
104 tstring trim(const tstring& str, const tstring& whitespace = _T(" \t"));
105
106 /**
107 * Writes sequence of values from [b, e) range into string buffer inserting
108 * 'delimiter' after each value except of the last one.
109 * Returns contents of string buffer.
110 */
111 template <class It>
112 tstring join(It b, It e, const tstring& delimiter=tstring()) {
113 tostringstream buf;
114 if (b != e) {
115 for (;;) {
116 buf << *b;
117 if (++b == e) {
118 break;
119 }
120 buf << delimiter;
121 }
122 }
123 return buf.str();
124 }
125
126 tstring toLower(const tstring& str);
127
128 tstring replace(const tstring &str, const tstring &search, const tstring &replace);
129 }
130
131
132 namespace tstrings {
133 inline std::string toUtf8(const std::string& utf8str) { return utf8str; }
134
135 #ifdef TSTRINGS_WITH_WCHAR
136 // conversion to Utf8
137 std::string toUtf8(const std::wstring& utf16str);
138
139 // conversion to Utf16
140 std::wstring toUtf16(const std::string& utf8str);
141
142 inline std::wstring fromUtf8(const std::string& utf8str) { return toUtf16(utf8str); }
143
144 #else
145 inline std::string fromUtf8(const std::string& utf8str) { return utf8str; }
146 #endif
147 } // namespace tstrings
148
149
150 namespace tstrings {
151 namespace format_detail {
152
153 template <class T>
154 struct str_arg_value {
155 const tstring value;
156
157 str_arg_value(const std::string& v): value(fromUtf8(v)) {
158 }
159
160 #ifdef TSTRINGS_WITH_WCHAR
161 str_arg_value(const std::wstring& v): value(v) {
162 }
163 #endif
164
165 tstring::const_pointer operator () () const {
166 return value.c_str();
167 }
168 };
169
170 template <>
171 struct str_arg_value<tstring> {
172 const tstring::const_pointer value;
173
174 str_arg_value(const tstring& v): value(v.c_str()) {
175 }
176
177 str_arg_value(tstring::const_pointer v): value(v) {
178 }
179
180 tstring::const_pointer operator () () const {
181 return value;
182 }
183 };
184
185 inline str_arg_value<std::string> arg(const std::string& v) {
186 return v;
187 }
188
189 inline str_arg_value<std::string> arg(std::string::const_pointer v) {
190 return (v ? v : "(null)");
191 }
192
193 #ifdef TSTRINGS_WITH_WCHAR
194 inline str_arg_value<std::wstring> arg(const std::wstring& v) {
195 return v;
196 }
197
198 inline str_arg_value<std::wstring> arg(std::wstring::const_pointer v) {
199 return (v ? v : L"(null)");
200 }
201 #else
202 void arg(const std::wstring&); // Compilation error by design.
203 void arg(std::wstring::const_pointer); // Compilation error by design.
204 #endif
205
206 template <class T>
207 struct arg_value {
208 arg_value(const T v): v(v) {
209 }
210 T operator () () const {
211 return v;
212 }
213 private:
214 const T v;
215 };
216
217 inline arg_value<int> arg(int v) {
218 return v;
219 }
220 inline arg_value<unsigned> arg(unsigned v) {
221 return v;
222 }
223 inline arg_value<long> arg(long v) {
224 return v;
225 }
226 inline arg_value<unsigned long> arg(unsigned long v) {
227 return v;
228 }
229 inline arg_value<long long> arg(long long v) {
230 return v;
231 }
232 inline arg_value<unsigned long long> arg(unsigned long long v) {
233 return v;
234 }
235 inline arg_value<float> arg(float v) {
236 return v;
237 }
238 inline arg_value<double> arg(double v) {
239 return v;
240 }
241 inline arg_value<bool> arg(bool v) {
242 return v;
243 }
244 inline arg_value<const void*> arg(const void* v) {
245 return v;
246 }
247
248 } // namespace format_detail
249 } // namespace tstrings
250
251
252 namespace tstrings {
253 template <class T, class T2, class T3, class T4, class T5, class T6, class T7>
254 inline tstring format(const tstring& fmt, const T& v, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7) {
255 return unsafe_format(fmt.c_str(), format_detail::arg(v)(),
256 format_detail::arg(v2)(),
257 format_detail::arg(v3)(),
258 format_detail::arg(v4)(),
259 format_detail::arg(v5)(),
260 format_detail::arg(v6)(),
261 format_detail::arg(v7)());
262 }
263
264 template <class T, class T2, class T3, class T4, class T5, class T6>
265 inline tstring format(const tstring& fmt, const T& v, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6) {
266 return unsafe_format(fmt.c_str(), format_detail::arg(v)(),
267 format_detail::arg(v2)(),
268 format_detail::arg(v3)(),
269 format_detail::arg(v4)(),
270 format_detail::arg(v5)(),
271 format_detail::arg(v6)());
272 }
273
274 template <class T, class T2, class T3, class T4, class T5>
275 inline tstring format(const tstring& fmt, const T& v, const T2& v2, const T3& v3, const T4& v4, const T5& v5) {
276 return unsafe_format(fmt.c_str(), format_detail::arg(v)(),
277 format_detail::arg(v2)(),
278 format_detail::arg(v3)(),
279 format_detail::arg(v4)(),
280 format_detail::arg(v5)());
281 }
282
283 template <class T, class T2, class T3, class T4>
284 inline tstring format(const tstring& fmt, const T& v, const T2& v2, const T3& v3, const T4& v4) {
285 return unsafe_format(fmt.c_str(), format_detail::arg(v)(),
286 format_detail::arg(v2)(),
287 format_detail::arg(v3)(),
288 format_detail::arg(v4)());
289 }
290
291 template <class T, class T2, class T3>
292 inline tstring format(const tstring& fmt, const T& v, const T2& v2, const T3& v3) {
293 return unsafe_format(fmt.c_str(), format_detail::arg(v)(),
294 format_detail::arg(v2)(),
295 format_detail::arg(v3)());
296 }
297
298 template <class T, class T2>
299 inline tstring format(const tstring& fmt, const T& v, const T2& v2) {
300 return unsafe_format(fmt.c_str(), format_detail::arg(v)(),
301 format_detail::arg(v2)());
302
303 }
304
305 template <class T>
306 inline tstring format(const tstring& fmt, const T& v) {
307 return unsafe_format(fmt.c_str(), format_detail::arg(v)());
308 }
309 } // namespace tstrings
310
311
312 namespace tstrings {
313 /**
314 * Buffer that accepts both std::wstring and std::string instances doing
315 * encoding conversions behind the scenes. All std::string-s assumed to be
316 * UTF8-encoded, all std::wstring-s assumed to be UTF16-encoded.
317 */
318 class any {
319 public:
320 any() {
321 }
322
323 any(std::string::const_pointer msg) {
324 data << fromUtf8(msg);
325 }
326
327 any(const std::string& msg) {
328 data << fromUtf8(msg);
329 }
330
331 #ifdef TSTRINGS_WITH_WCHAR
332 any(std::wstring::const_pointer msg) {
333 data << msg;
334 }
335
336 any(const std::wstring& msg) {
337 data << msg;
338 }
339
340 any& operator << (const std::wstring& v) {
341 data << v;
342 return *this;
343 }
344
345 // need this specialization instead std::wstring::pointer,
346 // otherwise LPWSTR is handled as abstract pointer (void*)
347 any& operator << (LPWSTR v) {
348 data << (v ? v : L"NULL");
349 return *this;
350 }
351
352 // need this specialization instead std::wstring::const_pointer,
353 // otherwise LPCWSTR is handled as abstract pointer (const void*)
354 any& operator << (LPCWSTR v) {
355 data << (v ? v : L"NULL");
356 return *this;
357 }
358
359 std::wstring wstr() const {
360 return data.str();
361 }
362 #endif
363
364 template <class T>
365 any& operator << (T v) {
366 data << v;
367 return *this;
368 }
369
370 any& operator << (tostream& (*pf)(tostream&)) {
371 data << pf;
372 return *this;
373 }
374
375 any& operator << (tios& (*pf)(tios&)) {
376 data << pf;
377 return *this;
378 }
379
380 any& operator << (std::ios_base& (*pf)(std::ios_base&)) {
381 data << pf;
382 return *this;
383 }
384
385 std::string str() const {
386 return toUtf8(data.str());
387 }
388
389 tstring tstr() const {
390 return data.str();
391 }
392
393 private:
394 tostringstream data;
395 };
396
397 inline tstring to_tstring(const any& val) {
398 return val.tstr();
399 }
400 } // namespace tstrings
401
402
403 inline std::ostream& operator << (std::ostream& os, const tstrings::any& buf) {
404 os << buf.str();
405 return os;
406 }
407
408 #ifdef TSTRINGS_WITH_WCHAR
409 inline std::wostream& operator << (std::wostream& os, const tstrings::any& buf) {
410 os << buf.wstr();
411 return os;
412 }
413 #endif
414
415 #endif //TSTRINGS_H