dl
dl_string.h
浏览该文件的文档.
1
21#pragma once
22#include <array>
23#include <string>
24#include <system_error>
25
26#include <fmt/format.h>
27
28#include "memory/dl_code_cvt.h"
29#include "dl_range.h"
30#include "math/dl_algorithm.h"
31#include "io/dl_log.h"
32#include "base/dl_type_def.h"
33#include "base/dl_vector2.h"
34#include "base/dl_array2.h"
35#include "memory/dl_buffer.h"
36
37namespace dl
38{
39
40
41// unordered_map支持 string_view
42struct string_hash
43{
44 using hash_type = std::hash<std::string_view>;
45 using is_transparent = void;
46
47 std::size_t operator()(const char* str) const { return hash_type{}(str); }
48 std::size_t operator()(std::string_view str) const { return hash_type{}(str); }
49 std::size_t operator()(std::string const& str) const { return hash_type{}(str); }
50};
51
52//-----------------------------字符串连接-------------------
53inline std::string& operator+=(std::string& a, std::string_view b)
54{
55 a.append(b);
56 return a;
57}
58inline std::string operator+(const std::string& a, std::string_view b)
59{
60 std::string ret{ a };
61 return ret += b;
62}
63inline std::string operator+(std::string_view a, std::string_view b)
64{
65 std::string ret{ a };
66 return ret += b;
67}
72template<typename T>
73std::string to_string(T v)
74{
75 if constexpr (std::is_floating_point_v<T>)
76 {
77 return fmt::format("{:.2f}", v);
78 }
79 else
80 return std::to_string(v);
81}
82
86template<typename T, size_t N>
87std::string to_string(const std::array<T, N>& arr, std::string_view delimiter = ", ")
88{
89 static_assert(N != 0);
90 std::string ret;
91 for (size_t i = 0; i < N - 1; ++i)
92 {
93 ret += dl::to_string(arr[i]);
94 ret += delimiter;
95 }
96 ret += dl::to_string(arr[N - 1]);
97 return ret;
98}
99
101std::string to_string(std::error_code code);
102
103
107template<>
108std::string to_string<BufferView>(BufferView buf);
109template<>
110inline std::string to_string<Buffer>(Buffer buf)
111{
112 return to_string(BufferView{ buf });
113}
114
118std::string to_string_check(BufferView buf);
119
123std::string to_string_hex(BufferView buf, bool add_tag = false);
124
125
126
127namespace String
128{
132inline Float toFloat(std::string_view str)
133{
134 if constexpr (std::is_same_v<Float, float>)
135 return stof(std::string{str});
136 else if constexpr (std::is_same_v<Float, double>)
137 return stod(std::string{str});
138}
143inline int toInt(std::string_view str, int default_v = 0)
144{
145 try
146 {
147 return std::stoi(str.data());
148 }
149 catch (...)
150 {
151 return default_v;
152 }
153}
158inline int64_t toInt64(std::string_view str, int64_t default_v = 0)
159{
160 try
161 {
162 return std::stoll(str.data());
163 }
164 catch (...)
165 {
166 return default_v;
167 }
168}
172inline bool getInt(std::string_view str, int& ret)
173{
174 try
175 {
176 ret = std::stoi(str.data());
177 }
178 catch (...)
179 {
180 return false;
181 }
182 return true;
183}
184
188template<std::size_t N>
189std::array<int, N> toPoint(std::string_view str, char d = ',')
190{
191 std::vector<std::string> vec;
192 split(std::string(str), d, vec);
193 assert(vec.size() == N);
194 return { stoi(vec[0]), stoi(vec[1]) };
195}
199template<std::size_t N>
200std::array<Float, N> toPosition(std::string_view str, char d = ',')
201{
202 std::vector<std::string> vec;
203 split(std::string(str), d, vec);
204 assert(vec.size() == N);
205 return { toFloat(vec[0]), toFloat(vec[1]) };
206}
207
208inline Point2 toPoint2(std::string_view str, char d = ',')
209{
210 return toPoint<2>(str, d);
211}
212inline Position toPosition2(std::string_view str, char d = ',')
213{
214 return toPosition<2>(str, d);
215}
216
220constexpr std::string_view GetNotFileName()
221{
222 return R"(<>/\|:"*?)";
223}
224
228inline void EraseNotFileName(std::string& name)
229{
230 Erase::Match(name, std::string{ String::GetNotFileName() });
231}
232
236inline void ToLower(std::string& str)
237{
238 std::transform(str.begin(), str.end(), str.begin(), ::tolower);
239}
240
244inline std::string ToLower(const std::string& str)
245{
246 std::string ret = str;
247 std::transform(ret.begin(), ret.end(), ret.begin(), ::tolower);
248 return ret;
249}
253inline void ToUpper(std::string& str)
254{
255 std::transform(str.begin(), str.end(), str.begin(), ::toupper);
256}
260inline std::string ToUpper(std::string_view str)
261{
262 std::string ret{ str };
263 ToUpper(ret);
264 return ret;
265}
269inline bool EqualToLower(std::string_view a, std::string_view b)
270{
271 if (a.size() != b.size())
272 return false;
273 if (a.empty())
274 return true;
275 for (size_t i = 0; i < a.size(); ++i)
276 {
277 if (std::tolower(a[i]) != std::tolower(b[i]))
278 return false;
279 }
280 return true;
281}
282
286inline std::string Splicing(const std::vector<std::string>& vec,
287 std::string_view delimiter = ", ", std::string_view end = "")
288{
289 if (vec.empty())
290 return {};
291 if (vec.size() == 1)
292 return vec[0] + end;
293
294 std::string ret;
295 for (size_t i = 0; i < vec.size() - 1; ++i)
296 {
297 ret += vec[i];
298 ret += delimiter;
299 }
300 ret += vec[vec.size() - 1];
301 ret += end;
302 return ret;
303}
307inline bool IsBlank(char ch)
308{
309 return ch == ' '
310 || ch == '\n'
311 || ch == '\t';
312}
313
317inline bool IsBlank(std::string_view str)
318{
319 for (char ch : str)
320 {
321 if (!IsBlank(ch))
322 return false;
323 }
324 return true;
325}
326
331inline std::string EraseCharAll(std::string_view str, std::string_view vec_char)
332{
333 std::string ret;
334 for (auto& iter : str)
335 {
336 if (Every::NotEqual(vec_char, iter))
337 ret.push_back(iter);
338 }
339 return ret;
340}
345inline std::string EraseCharN(std::string_view str, std::string_view vec_char, size_t n = 1)
346{
347 std::string ret;
348
349 for (auto& iter : str)
350 {
351 if (n && Any::Equal(vec_char, iter))
352 {
353 --n;
354 continue;
355 }
356 else
357 ret.push_back(iter);
358 }
359 return ret;
360}
365inline std::string EraseCharHead(std::string_view str, std::string_view vec_char)
366{
367 std::string ret;
368
369 bool check = true;
370 for (auto& iter : str)
371 {
372 if (check)
373 {
374 if (Any::Equal(vec_char, iter))
375 ;// 需要删除,仍需判断
376 else
377 {
378 check = false;
379 ret.push_back(iter);
380 }
381 }
382 else
383 ret.push_back(iter);
384 }
385 return ret;
386}
390inline std::string EraseBlank(std::string_view str)
391{
392 return EraseCharAll(str, " \t\n");
393}
397inline std::string EraseBlankN(std::string_view str, size_t n = 1)
398{
399 return EraseCharN(str, " \t\n", n);
400}
404inline std::string EraseBlankHead(std::string_view str)
405{
406 return EraseCharHead(str, " \t\n");
407}
408
412inline std::string GetUtf8ByWchar(wchar_t wc, size_t offset)
413{
414 // 某些平台wchar_t是4字节,必须使用u32string
415 std::u32string s{ (char32_t)(wc + offset) };
416
417 return CodeCvt::Utf32ToUtf8(s);
418}
419
420
424//string GetAscii()
425//{
426// string str_ascii = format("ascii表:\n0 -> /0[t_8]");
427// for (char ch = 1; ch < 128; ++ch)
428// {
429// if (ch == '\n')
430// str_ascii += format("{} -> {}[t_8]", to_string(ch), "/n");
431// else if (ch == '\t')
432// str_ascii += format("{} -> {}[t_8]", to_string(ch), "/t");
433// else if (ch == '[')
434// str_ascii += format("{} -> {}[t_8]", to_string(ch), "[l]");
435// else if (ch == ']')
436// str_ascii += format("{} -> {}[t_8]", to_string(ch), "[r]");
437// else
438// str_ascii += format("{} -> {}[t_8]", to_string(ch), char(ch));
439//
440// if ((ch - 1) % 6 == 0)
441// str_ascii += "\n";
442// }
443// return str_ascii;
444//}
445
449std::string Sprintf(const char* format, ...);
450
454template<typename T>
455std::string SplitIntegerToThousands(T integer)
456{
457 return r_insert_per_num(to_string(integer), ',', 3);
458}
459
463inline std::vector<std::string> Split(const std::string& str, char d)
464{
465 std::vector<std::string> ret;
466 split(str, d, ret);
467 return ret;
468}
469
473inline std::vector<std::string> Split(const std::string& str, const std::string& d)
474{
475 std::vector<std::string> ret;
476 split_sub(str, d, ret);
477 return ret;
478}
479
486inline std::vector<std::string_view> SplitViewNoEmpty(std::string_view str, std::string_view vec_ch)
487{
488 std::vector<std::string_view> ret;
489 size_t beg = 0;
490 size_t cur = 0;
491 for (; cur < str.size(); ++cur)
492 {
493 if (Any::Equal(vec_ch, str[cur]))
494 {
495 if (beg != cur)
496 ret.push_back({ str.data() + beg, str.data() + cur });
497 beg = cur + 1;
498 }
499 }
500 if (beg != cur)
501 ret.push_back({ str.data() + beg, str.data() + cur });
502 return ret;
503}
504inline std::vector<std::string_view> SplitViewNoEmpty(std::string_view str,
505 const std::vector<char>& vec_ch)
506{
507 return SplitViewNoEmpty(str, std::string_view{ vec_ch.data(), vec_ch.size() });
508}
515inline std::vector<std::string_view> SplitView(std::string_view str, std::string_view vec_ch)
516{
517 std::vector<std::string_view> ret;
518 size_t beg = 0;
519 size_t cur = 0;
520 for (; cur < str.size(); ++cur)
521 {
522 if (Any::Equal(vec_ch, str[cur]))
523 {
524 if (beg != cur)
525 ret.push_back({ str.data() + beg, str.data() + cur });
526 else
527 ret.push_back({});
528 beg = cur + 1;
529 }
530 }
531 if (beg != cur)
532 ret.push_back({ str.data() + beg, str.data() + cur });
533 else
534 ret.push_back({});
535 return ret;
536}
537inline std::vector<std::string_view> SplitView(std::string_view str,
538 const std::vector<char>& vec_ch)
539{
540 return SplitView(str, std::string_view{ vec_ch.data(), vec_ch.size() });
541}
545inline std::vector<std::string> SplitNoEmpty(const std::string& str, char d)
546{
547 std::vector<std::string> ret;
548 split_no_empty(str, d, ret);
549 return ret;
550}
551
552inline void TestSplit()
553{
554 std::string str0 = "0,1,2,,3";
555 std::string str1 = ",0,1,2,,3,";
556 std::string str2 = ",,0,1,2,,3,";
557
558 using namespace std::literals;
559 {
560 std::vector<std::string_view> vec0 = SplitView(str0, ","sv);
561 std::vector<std::string_view> vec1 = SplitView(str1, ","sv);
562 std::vector<std::string_view> vec2 = SplitView(str2, ","sv);
563
564 assert(vec0[0] == "0" && vec0[1] == "1" && vec0[2] == "2" && vec0[3] == "" && vec0[4] == "3");
565 assert(vec1[0] == "" && vec1[1] == "0" && vec1[2] == "1" && vec1[3] == "2" && vec1[4] == ""
566 && vec1[5] == "3" && vec1[6] == "");
567 assert(vec2[0] == "" && vec2[1] == "" && vec2[2] == "0" && vec2[3] == "1" && vec2[4] == "2"
568 && vec2[5] == "" && vec2[6] == "3" && vec2[7] == "");
569 }
570
571
572 {
573 std::vector<std::string_view> vec0 = SplitViewNoEmpty(str0, ","sv);
574 std::vector<std::string_view> vec1 = SplitViewNoEmpty(str1, ","sv);
575 std::vector<std::string_view> vec2 = SplitViewNoEmpty(str2, ","sv);
576
577 assert(vec0[0] == "0" && vec0[1] == "1" && vec0[2] == "2" && vec0[3] == "3");
578 assert(vec1[0] == "0" && vec1[1] == "1" && vec1[2] == "2" && vec1[3] == "3");
579 assert(vec2[0] == "0" && vec2[1] == "1" && vec2[2] == "2" && vec2[3] == "3");
580 }
581}
582
587inline void EraseExtension(std::string& path_name)
588{
589 if (Erase::TailFromLast(path_name, '.'))
590 path_name.pop_back();
591}
592[[nodiscard]]
593inline std::string EraseExtension(std::string_view path_name)
594{
595 std::string ret = std::string{ path_name };
596 EraseExtension(ret);
597 return ret;
598}
599
606inline void ReplaceExtension(std::string& path_name, std::string_view fmt)
607{
608 if (Erase::TailFromLast(path_name, '.'))
609 {
610 path_name += fmt;
611 return;
612 }
613 path_name += ".";
614 path_name += std::string{ fmt };
615}
616[[nodiscard]]
617inline std::string ReplaceExtension(std::string_view path_name, std::string_view fmt)
618{
619 std::string ret = std::string{ path_name };
620 ReplaceExtension(ret, fmt);
621 return ret;
622}
623
628inline void EraseFilename(std::string& path_name)
629{
630 if (!Erase::TailFromLast(path_name, '/'))
631 log_err0("不是一个有效路径!");
632}
633[[nodiscard]]
634inline std::string EraseFilename(std::string_view path_name)
635{
636 std::string ret = std::string{ path_name };
637 EraseFilename(ret);
638 return ret;
639}
640
647inline bool IsRelativePath(std::string_view path_name)
648{
649 if (path_name.empty())
650 return true;
651
652 if (path_name[0] == '/')
653 return false;
654
655 size_t len = (std::min)(path_name.size(), (size_t)12);
656 for (size_t i = 0; i < len; ++i)
657 {
658 if (path_name[i] == ':')
659 return false;
660 }
661 return true;
662}
663
664
674bool GetPathAndRes(
675 std::string_view path_root, std::string_view path_name,
676 std::string& path_real, std::string& res_name,
677 std::string_view name = "");
678
679
685std::string GetResName(
686 std::string_view path_root,
687 std::string_view path_name);
688
689
696std::string CvtRelativePath(std::string path_cur, std::string_view path);
697
702inline void CvtPathSeparator(std::string& path)
703{
704 Every::Replace(path, '\\', '/');
705}
706[[nodiscard]]
707inline std::string CvtPathSeparator(std::string_view path)
708{
709 std::string ret{ path };
710 CvtPathSeparator(ret);
711 return ret;
712}
717inline void CvtPathSeparatorBack(std::string& path)
718{
719 Every::Replace(path, '/', '\\');
720}
721[[nodiscard]]
722inline std::string CvtPathSeparatorBack(std::string_view path)
723{
724 std::string ret{ path };
725 CvtPathSeparatorBack(ret);
726 return ret;
727}
732inline std::string CvtLineBreak(std::string_view str)
733{
734 std::string ret;
735 for (auto& iter : str)
736 {
737 if(iter == '\r')
738 continue;
739 ret.push_back(iter);
740 }
741 return ret;
742}
743
744
748inline bool HasNumber(std::string_view str)
749{
750 return Any::Yes(str, isdigit);
751}
752
756inline bool HasLetter(std::string_view str)
757{
758 return Any::Yes(str, isalpha);
759}
764template<size_t W, size_t H>
765std::array<std::string, H> FormatString2(const Array2<std::string, W, H>& arr)
766{
767 //每一列得到一个最大宽度
768 std::array<size_t, W> mul_col{};
769 for (size_t j = 0; j < H; ++j)
770 {
771 for (size_t i = 0; i < W; ++i)
772 {
773 if (arr[j][i].size() > mul_col[i])
774 mul_col[i] = arr[j][i].size();
775 }
776 }
777 //合并每行
778 std::array<std::string, H> ret;
779 for (size_t i = 0; i < W; ++i)
780 {
781 std::string fmt = std::string("{:<") + std::to_string(mul_col[i] + 1) + "}";
782 for (size_t j = 0; j < H; ++j)
783 {
784 ret[j] += fmt::vformat(fmt, fmt::make_format_args(arr[j][i]));
785 }
786 }
787 return ret;
788}
789
794std::vector<std::string> FormatString2(const Vector2<std::string>& arr);
795
796
797
798//----------------------------其余范围操作封装----------------------------
799inline bool IsSub(std::string_view str, std::string_view str_sub)
800{
801 return Sub::IsSub(str, str_sub);
802}
803
804}
805
806}
807
808
809namespace dl
810{
811
812
813inline std::string to_string(const Vector2<std::string>& vec2)
814{
815 return String::Splicing(String::FormatString2(vec2), "\n");
816}
817
818//#if (DL_PLATFORM == DL_PLATFORM_WIN32)
820//* @brief array的format特化
821//* @note
822//*/
823//template<typename T, size_t N, typename CharT>
824//struct std::formatter<std::array<T, N>, CharT> : std::formatter<std::string, CharT>
825//{
826// template <typename FormatParseContext>
827// auto parse(FormatParseContext& pc)
828// {
829// return pc.end();
830// }
831//
832// template<typename FormatContext>
833// auto format(array<T, N> t, FormatContext& fc)
834// {
835// if constexpr (N == 2)
836// return std::formatter<std::string, CharT>::format(
837// std::format("{}, {}", t[0], t[1]), fc);
838// if constexpr (N == 3)
839// return std::formatter<std::string, CharT>::format(
840// std::format("{}, {}, {}", t[0], t[1], t[2]), fc);
841// if constexpr (N == 4)
842// return std::formatter<std::string, CharT>::format(
843// std::format("{}, {}, {}, {}", t[0], t[1], t[2], t[3]), fc);
844// }
845//};
846//#endif
847}
2维array
表示一段内存
编码转换
日志系统
范围操作
通用类型定义
2维vector
bool IsSub(const T &a, const T &b)
子串匹配
Definition: dl_range_sub.h:24
Definition: dl_array2.h:18
T r_insert_per_num(const T &container, V v, size_t per_num)
从后面往前,隔n个元素就插入1个值,首尾不会出现分割符
Definition: dl_algorithm.h:261
std::string to_string(const SpriteID &id)
Definition: dl_sprite.h:50
void split_no_empty(const T &container, V delimiter, std::vector< T > &ret)
以 元素 分割 容器
Definition: dl_algorithm.h:355
float Float
Definition: dl_type_def.h:37
void split_sub(const T &container, const T &delimiter, std::vector< T > &ret)
以 子串 分割 容器
Definition: dl_algorithm.h:401
std::array< int, 2 > Point2
Definition: dl_type_def.h:20
constexpr std::array< Point::value_type, N > toPoint(const std::array< T, N > &a)
转换到Point,已知长度
void split(const T &container, V delimiter, std::vector< T > &ret)
以 元素 分割 容器
Definition: dl_algorithm.h:299
constexpr std::array< T, N > operator+(const std::array< T, N > &a, const std::array< T, N > &b)
Definition: dl_type_op.h:29
constexpr std::array< Position::value_type, N > toPosition(const std::array< T, N > &a)
转换到Position,已知长度
std::span< std::byte > BufferView
Definition: dl_buffer.h:22
std::vector< std::byte > Buffer
Definition: dl_buffer.h:21
constexpr std::array< T, N > & operator+=(std::array< T, N > &a, const std::array< T, N > &b)
Definition: dl_type_op.h:21
Position2 Position
Definition: dl_type_def.h:43
void log_err0(std::string_view str, const std::source_location location=std::source_location::current())