dl
dl_string.h
浏览该文件的文档.
1
21#pragma once
22#include <array>
23#include <string>
24#include <system_error>
25#include <charconv>
26
27#include <fmt/format.h>
28
29#include "memory/dl_code_cvt.h"
30#include "dl_range.h"
31#include "math/dl_algorithm.h"
32#include "io/dl_log.h"
33#include "base/dl_type_def.h"
34#include "base/dl_vector2.h"
35#include "base/dl_array2.h"
36#include "memory/dl_buffer.h"
37
38namespace dl
39{
40
41
42// unordered_map支持 string_view
44{
45 using hash_type = std::hash<std::string_view>;
46 using is_transparent = void;
47
48 std::size_t operator()(const char* str) const { return hash_type{}(str); }
49 std::size_t operator()(std::string_view str) const { return hash_type{}(str); }
50 std::size_t operator()(std::string const& str) const { return hash_type{}(str); }
51};
52
53//-----------------------------字符串连接-------------------
54inline std::string& operator+=(std::string& a, std::string_view b)
55{
56 a.append(b);
57 return a;
58}
59inline std::string operator+(const std::string& a, std::string_view b)
60{
61 std::string ret{ a };
62 return ret += b;
63}
64inline std::string operator+(std::string_view a, std::string_view b)
65{
66 std::string ret{ a };
67 return ret += b;
68}
69
73template<IsBase T>
74std::string to_string(T v)
75{
76 if constexpr (std::is_floating_point_v<T>)
77 {
78 return fmt::format("{:.2f}", v);
79 }
80 else
81 return std::to_string(v);
82}
83
84inline std::string to_string(const std::string& str)
85{
86 return str;
87}
88
92template<typename T, size_t N>
93std::string to_string(const std::array<T, N>& arr, std::string_view delimiter = ", ")
94{
95 static_assert(N != 0);
96 std::string ret;
97 for (size_t i = 0; i < N - 1; ++i)
98 {
99 ret += dl::to_string(arr[i]);
100 ret += delimiter;
101 }
102 ret += dl::to_string(arr[N - 1]);
103 return ret;
104}
105template<typename T, size_t N>
106std::string to_string(const Array<T, N>& arr, std::string_view delimiter = ", ")
107{
108 static_assert(N != 0);
109 std::string ret;
110 for (size_t i = 0; i < N - 1; ++i)
111 {
112 ret += dl::to_string(arr[i]);
113 ret += delimiter;
114 }
115 ret += dl::to_string(arr[N - 1]);
116 return ret;
117}
118template<typename T, size_t N>
119std::string to_string(const ArrayS2<T, N>& arr, std::string_view delimiter = ", ")
120{
121 static_assert(N != 0);
122 std::string ret;
123 for (size_t i = 0; i < N - 1; ++i)
124 {
125 ret += dl::to_string(arr.x[i]);
126 ret += delimiter;
127 ret += dl::to_string(arr.y[i]);
128 ret += delimiter;
129 }
130 ret += dl::to_string(arr.x[N - 1]);
131 ret += delimiter;
132 ret += dl::to_string(arr.y[N - 1]);
133 return ret;
134}
135
138template<typename T>
139std::string to_string(const std::vector<T>& vec, std::string_view delimiter = ", ")
140{
141 if (vec.empty())
142 return {};
143 std::string ret;
144 for (size_t i = 0; i < vec.size() - 1; ++i)
145 {
146 ret += dl::to_string(vec[i]);
147 ret += delimiter;
148 }
149 ret += dl::to_string(vec[vec.size() - 1]);
150 return ret;
151}
152
154std::string to_string(std::error_code code);
155
157std::string to_string(std::exception& e);
158
162std::string to_string(BufferView buf);
163
164inline std::string to_string(Buffer buf)
165{
166 return to_string(BufferView{ buf });
167}
168
172std::string to_string_check(BufferView buf, bool tips = true);
173
177std::string to_string_hex(BufferView buf, bool add_tag = false);
178
182template<size_t N>
183std::string to_string_hex(std::array<std::byte, N> buf, bool add_tag = false)
184{
185 return to_string_hex(std::span<std::byte>(buf), add_tag);
186}
187
191std::string to_string_auto(BufferView buf, bool add_tag = false);
192
199
200namespace String
201{
202
207 inline Float toFloat(std::string_view str, Float default_v = 0)
208 {
209#if DL_PLATFORM != DL_PLATFORM_APPLE
210 std::from_chars(str.data(), str.data() + str.size(), default_v);
211 return default_v;
212#else
213 if (str.empty())
214 return default_v;
215
216 if constexpr (std::is_same_v<Float, float>)
217 {
218 try
219 {
220 return std::stof(str.data());
221 }
222 catch (...)
223 {
224 return default_v;
225 }
226 }
227 else if constexpr (std::is_same_v<Float, double>)
228 {
229 try
230 {
231 return std::stod(str.data());
232 }
233 catch (...)
234 {
235 return default_v;
236 }
237 }
238#endif
239 }
240
244 inline int toInt(std::string_view str, int default_v = 0)
245 {
246#if DL_PLATFORM != DL_PLATFORM_APPLE
247 std::from_chars(str.data(), str.data() + str.size(), default_v);
248 return default_v;
249#else
250 try
251 {
252 return std::stoi(str.data());
253 }
254 catch (...)
255 {
256 return default_v;
257 }
258#endif
259 }
260
264 inline int64_t toInt64(std::string_view str, int64_t default_v = 0)
265 {
266#if DL_PLATFORM != DL_PLATFORM_APPLE
267 std::from_chars(str.data(), str.data() + str.size(), default_v);
268 return default_v;
269#else
270 try
271 {
272 return std::stoll(str.data());
273 }
274 catch (...)
275 {
276 return default_v;
277 }
278#endif
279 }
280
283 inline bool getInt(std::string_view str, int& ret)
284 {
285
286#if DL_PLATFORM != DL_PLATFORM_APPLE
287 std::from_chars_result r = std::from_chars(str.data(), str.data() + str.size(), ret);
288 return r.ec == std::errc();
289#else
290 try
291 {
292 ret = std::stoi(str.data());
293 }
294 catch (...)
295 {
296 return false;
297 }
298 return true;
299#endif
300 }
301
305template<std::size_t N>
306Array<int, N> toPoint(std::string_view str, char d = ',')
307{
308 std::vector<std::string_view> vec;
309 split(str, d, vec);
310 if (vec.size() == 0)
311 {
312 log_warn("分割后数量为0!");
313 return {};
314 }
315 else if (vec.size() == 1)
316 {
317 log_warn("分割后数量为1!");
318 return { toInt(vec[0]) , 0};
319 }
320 return { toInt(vec[0]), toInt(vec[1]) };
321}
322
325template<std::size_t N>
326Array<Float, N> toPosition(std::string_view str, char d = ',')
327{
328 std::vector<std::string_view> vec;
329 split(str, d, vec);
330 if (vec.size() == 0)
331 {
332 log_warn("分割后数量为0!");
333 return {};
334 }
335 else if (vec.size() == 1)
336 {
337 log_warn("分割后数量为1!");
338 return { toFloat(vec[0]) , 0 };
339 }
340 return { toFloat(vec[0]), toFloat(vec[1]) };
341}
342
343inline Point2 toPoint2(std::string_view str, char d = ',')
344{
345 return toPoint<2>(str, d);
346}
347inline Position toPosition2(std::string_view str, char d = ',')
348{
349 return toPosition<2>(str, d);
350}
351
355constexpr StringType GetType(std::string_view str)
356{
357 bool has_dot = false;
358 for (size_t i = 0; i < str.size(); ++i)
359 {
360 const char& ch = str[i];
361 if (std::isdigit(ch))
362 continue;
363 else if (i == 0 && (ch == '+' || ch == '-'))
364 continue;
365 else if (!has_dot && ch == '.')
366 {
367 has_dot = true;
368 continue;
369 }
370 else
371 return StringType::NORMAL;
372 }
373 return has_dot ? StringType::FLOAT : StringType::INTGER;
374}
375
378inline std::string AddQuotes(std::string_view str, char quotes = '\"')
379{
380 std::string ret;
381 ret.reserve(str.size() + 2);
382 ret += quotes;
383 ret += str;
384 ret += quotes;
385 return ret;
386}
387
390size_t Wcwidth(wchar_t ch);
395std::string FillEndl(std::string_view str, char ch = ' ');
399constexpr std::string_view GetNotFileName()
400{
401 return R"(<>/\|:"*?)";
402}
403
407inline void EraseNotFileName(std::string& name)
408{
409 Erase::Match(name, std::string{ String::GetNotFileName() });
410}
411
415inline void ToLower(std::string& str)
416{
417 std::transform(str.begin(), str.end(), str.begin(), ::tolower);
418}
419
423inline std::string ToLower(const std::string& str)
424{
425 std::string ret = str;
426 std::transform(ret.begin(), ret.end(), ret.begin(), ::tolower);
427 return ret;
428}
432inline void ToUpper(std::string& str)
433{
434 std::transform(str.begin(), str.end(), str.begin(), ::toupper);
435}
439inline std::string ToUpper(std::string_view str)
440{
441 std::string ret{ str };
442 ToUpper(ret);
443 return ret;
444}
448inline bool EqualToLower(std::string_view a, std::string_view b)
449{
450 if (a.size() != b.size())
451 return false;
452 if (a.empty())
453 return true;
454 for (size_t i = 0; i < a.size(); ++i)
455 {
456 if (std::tolower(a[i]) != std::tolower(b[i]))
457 return false;
458 }
459 return true;
460}
461
465inline std::string Splicing(const std::vector<std::string>& vec,
466 std::string_view delimiter = ", ", std::string_view end = "")
467{
468 if (vec.empty())
469 return {};
470 if (vec.size() == 1)
471 return vec[0] + end;
472
473 std::string ret;
474 for (size_t i = 0; i < vec.size() - 1; ++i)
475 {
476 ret += vec[i];
477 ret += delimiter;
478 }
479 ret += vec[vec.size() - 1];
480 ret += end;
481 return ret;
482}
486inline bool IsBlank(char ch)
487{
488 return ch == ' '
489 || ch == '\n'
490 || ch == '\t';
491}
492
496inline bool IsBlank(std::string_view str)
497{
498 for (char ch : str)
499 {
500 if (!IsBlank(ch))
501 return false;
502 }
503 return true;
504}
505
510inline std::string EraseCharAll(std::string_view str, std::string_view vec_char)
511{
512 std::string ret;
513 for (auto& iter : str)
514 {
515 if (Every::NotEqual(vec_char, iter))
516 ret.push_back(iter);
517 }
518 return ret;
519}
524inline std::string EraseCharN(std::string_view str, std::string_view vec_char, size_t n = 1)
525{
526 std::string ret;
527
528 for (auto& iter : str)
529 {
530 if (n && Any::Equal(vec_char, iter))
531 {
532 --n;
533 continue;
534 }
535 else
536 ret.push_back(iter);
537 }
538 return ret;
539}
544inline std::string EraseCharHead(std::string_view str, std::string_view vec_char)
545{
546 std::string ret;
547
548 bool check = true;
549 for (auto& iter : str)
550 {
551 if (check)
552 {
553 if (Any::Equal(vec_char, iter))
554 ;// 需要删除,仍需判断
555 else
556 {
557 check = false;
558 ret.push_back(iter);
559 }
560 }
561 else
562 ret.push_back(iter);
563 }
564 return ret;
565}
569inline std::string EraseBlank(std::string_view str)
570{
571 return EraseCharAll(str, " \t\n");
572}
576inline std::string EraseBlankN(std::string_view str, size_t n = 1)
577{
578 return EraseCharN(str, " \t\n", n);
579}
583inline std::string EraseBlankHead(std::string_view str)
584{
585 return EraseCharHead(str, " \t\n");
586}
590inline std::string EraseEndl(std::string_view str)
591{
592 if (str.empty())
593 return {};
594
595 size_t i = str.size() - 1;
596 for (; i >= 0; --i)
597 {
598 if (str[i] != '\n' && str[i] != '\r')
599 break;
600 }
601 return { str.data(), str.data() + i + 1 };
602}
603
607inline std::string GetUtf8ByWchar(wchar_t wc, size_t offset = 0)
608{
609 // 某些平台wchar_t是4字节,必须使用u32string
610 std::u32string s{ (char32_t)(wc + offset) };
611
612 return CodeCvt::Utf32ToUtf8(s);
613}
614
615
619//string GetAscii()
620//{
621// string str_ascii = format("ascii表:\n0 -> /0[t_8]");
622// for (char ch = 1; ch < 128; ++ch)
623// {
624// if (ch == '\n')
625// str_ascii += format("{} -> {}[t_8]", to_string(ch), "/n");
626// else if (ch == '\t')
627// str_ascii += format("{} -> {}[t_8]", to_string(ch), "/t");
628// else if (ch == '[')
629// str_ascii += format("{} -> {}[t_8]", to_string(ch), "[l]");
630// else if (ch == ']')
631// str_ascii += format("{} -> {}[t_8]", to_string(ch), "[r]");
632// else
633// str_ascii += format("{} -> {}[t_8]", to_string(ch), char(ch));
634//
635// if ((ch - 1) % 6 == 0)
636// str_ascii += "\n";
637// }
638// return str_ascii;
639//}
640
644std::string Sprintf(const char* format, ...);
645
649template<typename T>
650std::string SplitIntegerToThousands(T integer)
651{
652 return r_insert_per_num(to_string(integer), ',', 3);
653}
654
658inline std::vector<std::string> Split(const std::string& str, char d)
659{
660 std::vector<std::string> ret;
661 split(str, d, ret);
662 return ret;
663}
664inline std::vector<std::string_view> Split(std::string_view str, char d)
665{
666 std::vector<std::string_view> ret;
667 split(str, d, ret);
668 return ret;
669}
670
674inline std::vector<std::string> Split(const std::string& str, const std::string& d)
675{
676 std::vector<std::string> ret;
677 split_sub(str, d, ret);
678 return ret;
679}
680inline std::vector<std::string_view> Split(std::string_view str, std::string_view d)
681{
682 std::vector<std::string_view> ret;
683 split_sub(str, d, ret);
684 return ret;
685}
686
693inline std::vector<std::string_view> SplitViewNoEmpty(std::string_view str, std::string_view vec_ch)
694{
695 std::vector<std::string_view> ret;
696 size_t beg = 0;
697 size_t cur = 0;
698 for (; cur < str.size(); ++cur)
699 {
700 if (Any::Equal(vec_ch, str[cur]))
701 {
702 if (beg != cur)
703 ret.push_back({ str.data() + beg, str.data() + cur });
704 beg = cur + 1;
705 }
706 }
707 if (beg != cur)
708 ret.push_back({ str.data() + beg, str.data() + cur });
709 return ret;
710}
711inline std::vector<std::string_view> SplitViewNoEmpty(std::string_view str,
712 const std::vector<char>& vec_ch)
713{
714 return SplitViewNoEmpty(str, std::string_view{ vec_ch.data(), vec_ch.size() });
715}
722inline std::vector<std::string_view> SplitView(std::string_view str, std::string_view vec_ch)
723{
724 std::vector<std::string_view> ret;
725 size_t beg = 0;
726 size_t cur = 0;
727 for (; cur < str.size(); ++cur)
728 {
729 if (Any::Equal(vec_ch, str[cur]))
730 {
731 if (beg != cur)
732 ret.push_back({ str.data() + beg, str.data() + cur });
733 else
734 ret.push_back({});
735 beg = cur + 1;
736 }
737 }
738 if (beg != cur)
739 ret.push_back({ str.data() + beg, str.data() + cur });
740 else
741 ret.push_back({});
742 return ret;
743}
744inline std::vector<std::string_view> SplitView(std::string_view str,
745 const std::vector<char>& vec_ch)
746{
747 return SplitView(str, std::string_view{ vec_ch.data(), vec_ch.size() });
748}
752inline std::vector<std::string> SplitNoEmpty(const std::string& str, char d)
753{
754 std::vector<std::string> ret;
755 split_no_empty(str, d, ret);
756 return ret;
757}
758
763inline void EraseExtension(std::string& path_name)
764{
765 if (Erase::TailFromLast(path_name, '.'))
766 path_name.pop_back();
767}
768[[nodiscard]]
769inline std::string EraseExtension(std::string_view path_name)
770{
771 std::string ret = std::string{ path_name };
772 EraseExtension(ret);
773 return ret;
774}
775
782inline void ReplaceExtension(std::string& path_name, std::string_view fmt)
783{
784 if (Erase::TailFromLast(path_name, '.'))
785 {
786 path_name += fmt;
787 return;
788 }
789 path_name += ".";
790 path_name += std::string{ fmt };
791}
792[[nodiscard]]
793inline std::string ReplaceExtension(std::string_view path_name, std::string_view fmt)
794{
795 std::string ret = std::string{ path_name };
796 ReplaceExtension(ret, fmt);
797 return ret;
798}
799
804inline void EraseFilename(std::string& path_name)
805{
806 if (!Erase::TailFromLast(path_name, '/'))
807 log_err0("不是一个有效路径!");
808}
809[[nodiscard]]
810inline std::string EraseFilename(std::string_view path_name)
811{
812 std::string ret = std::string{ path_name };
813 EraseFilename(ret);
814 return ret;
815}
816
820inline std::string GetFileStem(std::string_view path_name)
821{
822 std::string name{ path_name };
823 Erase::HeadFromLast(name, '/');
824 if (Erase::TailFromLast(name, '.'))
825 name.pop_back();
826 return name;
827}
831inline std::string ErasePath(std::string_view path_name, std::string_view path)
832{
833 std::string ret{ path_name };
834 Erase::HeadSub(ret, std::string{ path });
835 return ret;
836}
837
843
844inline bool IsRelativePath(std::string_view path_name)
845{
846 if (path_name.empty())
847 return true;
848
849 if (path_name[0] == '/')
850 return false;
851
852 size_t len = (std::min)(path_name.size(), (size_t)12);
853 for (size_t i = 0; i < len; ++i)
854 {
855 if (path_name[i] == ':')
856 return false;
857 }
858 return true;
859}
860
861
871bool GetPathAndRes(
872 std::string_view path_root, std::string_view path_name,
873 std::string& path_real, std::string& res_name,
874 std::string_view name = "");
875
876
882std::string GetResName(
883 std::string_view path_root,
884 std::string_view path_name);
885
886
893std::string CvtRelativePath(std::string path_cur, std::string_view path);
894
899inline void CvtPathSeparator(std::string& path)
900{
901 Every::Replace(path, '\\', '/');
902}
903[[nodiscard]]
904inline std::string CvtPathSeparator(std::string_view path)
905{
906 std::string ret{ path };
907 CvtPathSeparator(ret);
908 return ret;
909}
914inline void CvtPathSeparatorBack(std::string& path)
915{
916 Every::Replace(path, '/', '\\');
917}
918[[nodiscard]]
919inline std::string CvtPathSeparatorBack(std::string_view path)
920{
921 std::string ret{ path };
922 CvtPathSeparatorBack(ret);
923 return ret;
924}
929inline std::string CvtLineBreak(std::string_view str)
930{
931 std::string ret;
932 for (auto& iter : str)
933 {
934 if(iter == '\r')
935 continue;
936 ret.push_back(iter);
937 }
938 return ret;
939}
940
941
945inline bool HasNumber(std::string_view str)
946{
947 return Any::Yes(str, isdigit);
948}
949
953inline bool HasLetter(std::string_view str)
954{
955 return Any::Yes(str, isalpha);
956}
957
961std::vector<std::string> ParseCommand(std::string_view cmd);
962
967template<size_t W, size_t H>
968Array<std::string, H> FormatString2(const Array2<std::string, W, H>& arr)
969{
970 //每一列得到一个最大宽度
971 Array<size_t, W> mul_col{};
972 for (size_t j = 0; j < H; ++j)
973 {
974 for (size_t i = 0; i < W; ++i)
975 {
976 if (arr[j][i].size() > mul_col[i])
977 mul_col[i] = arr[j][i].size();
978 }
979 }
980 //合并每行
981 Array<std::string, H> ret;
982 for (size_t i = 0; i < W; ++i)
983 {
984 std::string fmt = std::string("{:<") + std::to_string(mul_col[i] + 1) + "}";
985 for (size_t j = 0; j < H; ++j)
986 {
987 ret[j] += fmt::vformat(fmt, fmt::make_format_args(arr[j][i]));
988 }
989 }
990 return ret;
991}
992
997std::vector<std::string> FormatString2(const Vector2<std::string>& arr);
998
999
1000
1001//----------------------------其余范围操作封装----------------------------
1002inline bool IsSub(std::string_view str, std::string_view str_sub)
1003{
1004 return Sub::IsSub(str, str_sub);
1005}
1006
1007inline bool IsBegin(std::string_view str, std::string_view str_sub)
1008{
1009 return Sub::IsBegin(str, str_sub);
1010}
1011inline std::string_view Range(std::string_view str, char a, char b)
1012{
1013 return Sub::Range(str, a, b);
1014}
1015
1016}
1017
1018}
1019
1020
1021namespace dl
1022{
1023
1024
1025inline std::string to_string(const Vector2<std::string>& vec2)
1026{
1027 return String::Splicing(String::FormatString2(vec2), "\n");
1028}
1029
1030
1031//#if (DL_PLATFORM == DL_PLATFORM_WIN32)
1033//* @brief array的format特化
1034//* @note
1035//*/
1036//template<typename T, size_t N, typename CharT>
1037//struct std::formatter<Array<T, N>, CharT> : std::formatter<std::string, CharT>
1038//{
1039// template <typename FormatParseContext>
1040// auto parse(FormatParseContext& pc)
1041// {
1042// return pc.end();
1043// }
1044//
1045// template<typename FormatContext>
1046// auto format(array<T, N> t, FormatContext& fc)
1047// {
1048// if constexpr (N == 2)
1049// return std::formatter<std::string, CharT>::format(
1050// std::format("{}, {}", t[0], t[1]), fc);
1051// if constexpr (N == 3)
1052// return std::formatter<std::string, CharT>::format(
1053// std::format("{}, {}, {}", t[0], t[1], t[2]), fc);
1054// if constexpr (N == 4)
1055// return std::formatter<std::string, CharT>::format(
1056// std::format("{}, {}, {}, {}", t[0], t[1], t[2], t[3]), fc);
1057// }
1058//};
1059//#endif
1060}
1061
1062
1063
1064
1065
1066namespace fmt
1067{
1068 //
1069 template <typename T>
1070 struct formatter<dl::Array<T, 2>>
1071 {
1072 // 解析格式化参数(这里简化,不处理自定义格式)
1073 constexpr auto parse(fmt::format_parse_context& ctx) -> decltype(ctx.begin())
1074 {
1075 // 检查是否有多余的格式符
1076 auto it = ctx.begin();
1077 if (it != ctx.end() && *it != '}')
1078 throw fmt::format_error("invalid format specifier for dl::Array<T, 2>");
1079 return it;
1080 }
1081
1082 // 格式化逻辑
1083 template <typename FormatContext>
1084 auto format(const dl::Array<T, 2>& arr, FormatContext& ctx) const -> decltype(ctx.out())
1085 {
1086 return fmt::format_to(ctx.out(), "{}, {}", arr.x, arr.y);
1087 }
1088 };
1089
1090 //
1091 template <typename T>
1092 struct formatter<dl::Array<T, 3>>
1093 {
1094 constexpr auto parse(fmt::format_parse_context& ctx) -> decltype(ctx.begin())
1095 {
1096 auto it = ctx.begin();
1097 if (it != ctx.end() && *it != '}')
1098 throw fmt::format_error("invalid format specifier for dl::Array<T, 3>");
1099 return it;
1100 }
1101
1102 template <typename FormatContext>
1103 auto format(const dl::Array<T, 3>& arr, FormatContext& ctx) const -> decltype(ctx.out())
1104 {
1105 return fmt::format_to(ctx.out(), "{}, {}, {}", arr.x, arr.y, arr.z);
1106 }
1107 };
1108
1109 //
1110 template <typename T>
1111 struct formatter<dl::Array<T, 4>>
1112 {
1113 constexpr auto parse(fmt::format_parse_context& ctx) -> decltype(ctx.begin())
1114 {
1115 auto it = ctx.begin();
1116 if (it != ctx.end() && *it != '}')
1117 throw fmt::format_error("invalid format specifier for dl::Array<T, 4>");
1118 return it;
1119 }
1120
1121 template <typename FormatContext>
1122 auto format(const dl::Array<T, 4>& arr, FormatContext& ctx) const -> decltype(ctx.out())
1123 {
1124 return fmt::format_to(ctx.out(), "{}, {}, {}, {}", arr.x, arr.y, arr.z, arr.w);
1125 }
1126 };
1127 //
1128 template <size_t N>
1129 struct formatter<dl::StringN<N>>
1130 {
1131 // 解析格式化参数(这里简化,不处理自定义格式)
1132 constexpr auto parse(fmt::format_parse_context& ctx) -> decltype(ctx.begin())
1133 {
1134 // 检查是否有多余的格式符
1135 auto it = ctx.begin();
1136 if (it != ctx.end() && *it != '}')
1137 throw fmt::format_error("invalid format specifier for dl::Array<T, 2>");
1138 return it;
1139 }
1140
1141 // 格式化逻辑
1142 template <typename FormatContext>
1143 auto format(const dl::StringN<N>& str, FormatContext& ctx) const -> decltype(ctx.out())
1144 {
1145 return fmt::format_to(ctx.out(), "{}", str.c_str());
1146 }
1147 };
1148}
定长字符串
2维array
表示一段内存
编码转换
日志系统
#define log_warn(...)
范围操作
通用类型定义
2维vector
bool Equal(const C &container, const V &v)
判断容器任意元素等于某值
bool Yes(const C &container, F func)
判断容器任意元素满足条件
std::string Utf32ToUtf8(std::u32string_view str)
字符串转换:utf32 -> utf8
void Match(T &a, const T &b)
从容器a中移除 存在于容器b的元素
bool HeadSub(T &a, const T &b)
移除子串,第一个
bool TailFromLast(T &container, const V &a)
从容器container中移除 最后 匹配到的a元素 之后(不包含a)的所有元素,如果没有匹配到,则什么都不做。
bool HeadFromLast(T &container, const V &a)
从容器container中移除 最后 匹配到的a元素 之前(包含a)的所有元素,如果没有匹配到,则什么都不做。
void Replace(C &c, const V &v, const V &v_new)
替换容器所有元素都等于某值
bool NotEqual(const C &container, const V &v)
判断容器所有元素都 不等于某值
字符串操作
Array< Float, N > toPosition(std::string_view str, char d=',')
字符串 -> Position
Position toPosition2(std::string_view str, char d=',')
Array< int, N > toPoint(std::string_view str, char d=',')
字符串 -> Point
bool getInt(std::string_view str, int &ret)
转为整数,失败不修改原值
int toInt(std::string_view str, int default_v=0)
转为整数,失败返回设定的默认值
constexpr std::string_view GetNotFileName()
返回不能作为文件名的字符
Float toFloat(std::string_view str, Float default_v=0)
字符串 -> Float
constexpr StringType GetType(std::string_view str)
返回字符串类型
std::string FillEndl(std::string_view str, char ch=' ')
多行文本填充字符至一样宽(控制台显示优化)
std::string AddQuotes(std::string_view str, char quotes='\"')
两侧添加引号
size_t Wcwidth(wchar_t ch)
获取宽字符宽度(控制台显示优化)
Point2 toPoint2(std::string_view str, char d=',')
int64_t toInt64(std::string_view str, int64_t default_v=0)
转为整数,失败返回设定的默认值
bool IsSub(const T &a, const T &b)
子串匹配
T Range(const T &c, const V &a, const V &b)
区间匹配
bool IsBegin(const T &a, const T &b)
子串匹配
Position2 Position
T r_insert_per_num(const T &container, V v, size_t per_num)
从后面往前,隔n个元素就插入1个值,首尾不会出现分割符
std::span< std::byte > BufferView
void split_no_empty(const T &container, V delimiter, std::vector< T > &ret)
以 元素 分割 容器
float Float
void split_sub(const T &container, const T &delimiter, std::vector< T > &ret)
以 子串 分割 容器
std::vector< std::byte > Buffer
std::string to_string(T v)
to_string包装
void split(const T &container, V delimiter, std::vector< T > &ret)
以 元素 分割 容器
constexpr ArrayS2< T, N > & operator+=(ArrayS2< T, N > &a, const Array< T, 2 > &b)
constexpr ArrayS2< T, N > operator+(const ArrayS2< T, N > &a, const Array< T, 2 > &b)
Array< int, 2 > Point2
std::string to_string_auto(BufferView buf, bool add_tag=false)
buf转为字符串,若不为utf8则转为16进制
std::string to_string_check(BufferView buf, bool tips=true)
buf转为utf8字符串(进行检查)
void log_err0(std::string_view str, const std::source_location location=std::source_location::current())
std::string to_string_hex(BufferView buf, bool add_tag=false)
buf转为16进制字符串
std::size_t operator()(std::string_view str) const
std::hash< std::string_view > hash_type
std::size_t operator()(const char *str) const
std::size_t operator()(std::string const &str) const
auto format(const dl::Array< T, 2 > &arr, FormatContext &ctx) const -> decltype(ctx.out())
constexpr auto parse(fmt::format_parse_context &ctx) -> decltype(ctx.begin())
constexpr auto parse(fmt::format_parse_context &ctx) -> decltype(ctx.begin())
auto format(const dl::Array< T, 3 > &arr, FormatContext &ctx) const -> decltype(ctx.out())
constexpr auto parse(fmt::format_parse_context &ctx) -> decltype(ctx.begin())
auto format(const dl::Array< T, 4 > &arr, FormatContext &ctx) const -> decltype(ctx.out())
constexpr auto parse(fmt::format_parse_context &ctx) -> decltype(ctx.begin())
auto format(const dl::StringN< N > &str, FormatContext &ctx) const -> decltype(ctx.out())