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(const 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 upper = false, bool add_tag = false);
178
182template<size_t N>
183std::string to_string_hex(const std::array<std::byte, N>& buf, bool upper = false, bool add_tag = false)
184{
185 return to_string_hex(CreateBufferView(buf), add_tag);
186}
187
191std::string to_string_auto(BufferView buf, bool add_tag = false);
192
199
200namespace String
201{
206inline Float toFloat(std::string_view str, Float default_v = 0)
207{
208#if DL_PLATFORM != DL_PLATFORM_APPLE
209 std::from_chars(str.data(), str.data() + str.size(), default_v);
210 return default_v;
211#else
212 if (str.empty())
213 return default_v;
214
215 if constexpr (std::is_same_v<Float, float>)
216 {
217 try
218 {
219 return std::stof(str.data());
220 }
221 catch (...)
222 {
223 return default_v;
224 }
225 }
226 else if constexpr (std::is_same_v<Float, double>)
227 {
228 try
229 {
230 return std::stod(str.data());
231 }
232 catch (...)
233 {
234 return default_v;
235 }
236 }
237#endif
238}
239
242inline bool IsBlank(char ch)
243{
244 return ch == ' '
245 || ch == '\n'
246 || ch == '\t';
247}
248
252inline bool IsBlank(std::string_view str)
253{
254 for (char ch : str)
255 {
256 if (!IsBlank(ch))
257 return false;
258 }
259 return true;
260}
261
265inline std::string_view EraseBlankBoth(std::string_view str)
266{
267 auto iter = str.begin();
268 while (iter != str.end() && IsBlank(*iter))
269 {
270 ++iter;
271 }
272 auto iter1 = str.rbegin();
273 while (iter1 != str.rend() && IsBlank(*iter1))
274 {
275 ++iter1;
276 }
277
278 return { iter, iter1.base() };
279}
280
284inline int toInt(std::string_view str, int default_v = 0)
285{
286#if DL_PLATFORM != DL_PLATFORM_APPLE
287 std::from_chars(str.data(), str.data() + str.size(), default_v);
288 return default_v;
289#else
290 try
291 {
292 return std::stoi(str.data());
293 }
294 catch (...)
295 {
296 return default_v;
297 }
298#endif
299}
300
304inline int64_t toInt64(std::string_view str, int64_t default_v = 0)
305{
306#if DL_PLATFORM != DL_PLATFORM_APPLE
307 std::from_chars(str.data(), str.data() + str.size(), default_v);
308 return default_v;
309#else
310 try
311 {
312 return std::stoll(str.data());
313 }
314 catch (...)
315 {
316 return default_v;
317 }
318#endif
319}
320
323inline bool getInt(std::string_view str, int& ret)
324{
325
326#if DL_PLATFORM != DL_PLATFORM_APPLE
327 std::from_chars_result r = std::from_chars(str.data(), str.data() + str.size(), ret);
328 return r.ec == std::errc();
329#else
330 try
331 {
332 ret = std::stoi(str.data());
333 }
334 catch (...)
335 {
336 return false;
337 }
338 return true;
339#endif
340}
341
344inline bool getByte(std::string_view str, std::byte& ret)
345{
346
347#if DL_PLATFORM != DL_PLATFORM_APPLE
348 uint8_t v;
349 std::from_chars_result r = std::from_chars(str.data(), str.data() + str.size(), v, 16);
350 if (r.ec != std::errc())
351 return false;
352 ret = (std::byte)v;
353 return true;
354#else
355 try
356 {
357 ret = std::stoi(str.data(), nullptr, 16);
358 }
359 catch (...)
360 {
361 return false;
362 }
363 return true;
364#endif
365}
366
369template<std::size_t N>
370Array<int, N> toPoint(std::string_view str, char d = ',')
371{
372 std::vector<std::string_view> vec;
373 split_no_empty(str, d, vec);
374 if (vec.size() != N)
375 {
376 log_warn("分割后数量不匹配,将丢弃或填充0:{}/{}", vec.size(), N);
377 vec.resize(N);
378 }
379
380 Array<int, N> ret;
381 for (size_t i = 0; i < N; ++i)
382 {
383 std::string_view s = EraseBlankBoth(vec[i]);
384 ret[i] = toInt(s);
385 }
386 return ret;
387}
388
391template<std::size_t N>
392Array<Float, N> toPosition(std::string_view str, char d = ',')
393{
394 std::vector<std::string_view> vec;
395 split_no_empty(str, d, vec);
396 if (vec.size() != N)
397 {
398 log_warn("分割后数量不匹配,将丢弃或填充0:{}/{}", vec.size(), N);
399 vec.resize(N);
400 }
401
402 Array<Float, N> ret;
403 for (size_t i = 0; i < N; ++i)
404 {
405 std::string_view s = EraseBlankBoth(vec[i]);
406 ret[i] = toFloat(s);
407 }
408 return ret;
409}
410
411inline Point2 toPoint2(std::string_view str, char d = ',')
412{
413 return toPoint<2>(str, d);
414}
415inline Position toPosition2(std::string_view str, char d = ',')
416{
417 return toPosition<2>(str, d);
418}
419
423constexpr StringType GetType(std::string_view str)
424{
425 bool has_dot = false;
426 for (size_t i = 0; i < str.size(); ++i)
427 {
428 const char& ch = str[i];
429 if (std::isdigit(ch))
430 continue;
431 else if (i == 0 && (ch == '+' || ch == '-'))
432 continue;
433 else if (!has_dot && ch == '.')
434 {
435 has_dot = true;
436 continue;
437 }
438 else
439 return StringType::NORMAL;
440 }
441 return has_dot ? StringType::FLOAT : StringType::INTGER;
442}
443
446inline std::string AddQuotes(std::string_view str, char quotes = '\"')
447{
448 std::string ret;
449 ret.reserve(str.size() + 2);
450 ret += quotes;
451 ret += str;
452 ret += quotes;
453 return ret;
454}
455
458size_t Wcwidth(wchar_t ch);
463std::string FillEndl(std::string_view str, char ch = ' ');
467constexpr std::string_view GetNotFileName()
468{
469 return R"(<>/\|:"*?)";
470}
471
475inline void EraseNotFileName(std::string& name)
476{
477 Erase::Match(name, std::string{ String::GetNotFileName() });
478}
479
483inline void ToLower(std::string& str)
484{
485 std::transform(str.begin(), str.end(), str.begin(), ::tolower);
486}
487
491inline std::string ToLower(const std::string& str)
492{
493 std::string ret = str;
494 std::transform(ret.begin(), ret.end(), ret.begin(), ::tolower);
495 return ret;
496}
500inline void ToUpper(std::string& str)
501{
502 std::transform(str.begin(), str.end(), str.begin(), ::toupper);
503}
507inline std::string ToUpper(std::string_view str)
508{
509 std::string ret{ str };
510 ToUpper(ret);
511 return ret;
512}
516inline bool EqualToLower(std::string_view a, std::string_view b)
517{
518 if (a.size() != b.size())
519 return false;
520 if (a.empty())
521 return true;
522 for (size_t i = 0; i < a.size(); ++i)
523 {
524 if (std::tolower(a[i]) != std::tolower(b[i]))
525 return false;
526 }
527 return true;
528}
529
533inline std::string Splicing(const std::vector<std::string>& vec,
534 std::string_view delimiter = ", ", std::string_view end = "")
535{
536 if (vec.empty())
537 return {};
538 if (vec.size() == 1)
539 return vec[0] + end;
540
541 std::string ret;
542 for (size_t i = 0; i < vec.size() - 1; ++i)
543 {
544 ret += vec[i];
545 ret += delimiter;
546 }
547 ret += vec[vec.size() - 1];
548 ret += end;
549 return ret;
550}
555inline std::string EraseCharAll(std::string_view str, std::string_view vec_char)
556{
557 std::string ret;
558 for (auto& iter : str)
559 {
560 if (Every::NotEqual(vec_char, iter))
561 ret.push_back(iter);
562 }
563 return ret;
564}
569inline std::string EraseCharN(std::string_view str, std::string_view vec_char, size_t n = 1)
570{
571 std::string ret;
572
573 for (auto& iter : str)
574 {
575 if (n && Any::Equal(vec_char, iter))
576 {
577 --n;
578 continue;
579 }
580 else
581 ret.push_back(iter);
582 }
583 return ret;
584}
589inline std::string EraseCharHead(std::string_view str, std::string_view vec_char)
590{
591 std::string ret;
592
593 bool check = true;
594 for (auto& iter : str)
595 {
596 if (check)
597 {
598 if (Any::Equal(vec_char, iter))
599 ;// 需要删除,仍需判断
600 else
601 {
602 check = false;
603 ret.push_back(iter);
604 }
605 }
606 else
607 ret.push_back(iter);
608 }
609 return ret;
610}
614inline std::string EraseBlank(std::string_view str)
615{
616 return EraseCharAll(str, " \t\n");
617}
621inline std::string EraseBlankN(std::string_view str, size_t n = 1)
622{
623 return EraseCharN(str, " \t\n", n);
624}
628inline std::string EraseBlankHead(std::string_view str)
629{
630 return EraseCharHead(str, " \t\n");
631}
635inline std::string EraseEndl(std::string_view str)
636{
637 if (str.empty())
638 return {};
639
640 size_t i = str.size() - 1;
641 for (; i >= 0; --i)
642 {
643 if (str[i] != '\n' && str[i] != '\r')
644 break;
645 }
646 return { str.data(), str.data() + i + 1 };
647}
648
652inline std::string GetUtf8ByWchar(wchar_t wc, size_t offset = 0)
653{
654 // 某些平台wchar_t是4字节,必须使用u32string
655 std::u32string s{ (char32_t)(wc + offset) };
656
657 return CodeCvt::Utf32ToUtf8(s);
658}
659
660
664//string GetAscii()
665//{
666// string str_ascii = format("ascii表:\n0 -> /0[t_8]");
667// for (char ch = 1; ch < 128; ++ch)
668// {
669// if (ch == '\n')
670// str_ascii += format("{} -> {}[t_8]", to_string(ch), "/n");
671// else if (ch == '\t')
672// str_ascii += format("{} -> {}[t_8]", to_string(ch), "/t");
673// else if (ch == '[')
674// str_ascii += format("{} -> {}[t_8]", to_string(ch), "[l]");
675// else if (ch == ']')
676// str_ascii += format("{} -> {}[t_8]", to_string(ch), "[r]");
677// else
678// str_ascii += format("{} -> {}[t_8]", to_string(ch), char(ch));
679//
680// if ((ch - 1) % 6 == 0)
681// str_ascii += "\n";
682// }
683// return str_ascii;
684//}
685
689std::string Sprintf(const char* format, ...);
690
694template<typename T>
695std::string SplitIntegerToThousands(T integer)
696{
697 return r_insert_per_num(to_string(integer), ',', 3);
698}
699
703inline std::vector<std::string> Split(const std::string& str, char d)
704{
705 std::vector<std::string> ret;
706 split(str, d, ret);
707 return ret;
708}
709inline std::vector<std::string_view> SplitView(std::string_view str, char d)
710{
711 std::vector<std::string_view> ret;
712 split(str, d, ret);
713 return ret;
714}
715
719inline std::vector<std::string> Split(const std::string& str, const std::string& d)
720{
721 std::vector<std::string> ret;
722 split_sub(str, d, ret);
723 return ret;
724}
725inline std::vector<std::string_view> SplitView(std::string_view str, std::string_view d)
726{
727 std::vector<std::string_view> ret;
728 split_sub(str, d, ret);
729 return ret;
730}
731
735inline std::vector<std::string> SplitNoEmpty(const std::string& str, char d)
736{
737 std::vector<std::string> ret;
738 split_no_empty(str, d, ret);
739 return ret;
740}
741
745inline std::vector<std::string_view> SplitViewNoEmpty(std::string_view str, char d)
746{
747 std::vector<std::string_view> ret;
748 split_no_empty(str, d, ret);
749 return ret;
750}
751
752
759inline std::vector<std::string_view> SplitViewNoEmpty(std::string_view str, std::string_view vec_ch)
760{
761 std::vector<std::string_view> ret;
762 size_t beg = 0;
763 size_t cur = 0;
764 for (; cur < str.size(); ++cur)
765 {
766 if (Any::Equal(vec_ch, str[cur]))
767 {
768 if (beg != cur)
769 ret.push_back({ str.data() + beg, str.data() + cur });
770 beg = cur + 1;
771 }
772 }
773 if (beg != cur)
774 ret.push_back({ str.data() + beg, str.data() + cur });
775 return ret;
776}
777inline std::vector<std::string_view> SplitViewNoEmpty(std::string_view str,
778 const std::vector<char>& vec_ch)
779{
780 return SplitViewNoEmpty(str, std::string_view{ vec_ch.data(), vec_ch.size() });
781}
783//* @brief 处理子字符串(通过特定字符分割)
784//* @param[in] str 整个字符串
785//* @param[in] vec_ch 匹配的字符
786//* @note 连续匹配返回空串
787//*/
788//inline std::vector<std::string_view> SplitView(std::string_view str, std::string_view vec_ch)
789//{
790// std::vector<std::string_view> ret;
791// size_t beg = 0;
792// size_t cur = 0;
793// for (; cur < str.size(); ++cur)
794// {
795// if (Any::Equal(vec_ch, str[cur]))
796// {
797// if (beg != cur)
798// ret.push_back({ str.data() + beg, str.data() + cur });
799// else
800// ret.push_back({});
801// beg = cur + 1;
802// }
803// }
804// if (beg != cur)
805// ret.push_back({ str.data() + beg, str.data() + cur });
806// else
807// ret.push_back({});
808// return ret;
809//}
810//inline std::vector<std::string_view> SplitView(std::string_view str,
811// const std::vector<char>& vec_ch)
812//{
813// return SplitView(str, std::string_view{ vec_ch.data(), vec_ch.size() });
814//}
815
816
817
822inline void EraseExtension(std::string& path_name)
823{
824 if (Erase::TailFromLast(path_name, '.'))
825 path_name.pop_back();
826}
827[[nodiscard]]
828inline std::string EraseExtension(std::string_view path_name)
829{
830 std::string ret = std::string{ path_name };
831 EraseExtension(ret);
832 return ret;
833}
834
841inline void ReplaceExtension(std::string& path_name, std::string_view fmt)
842{
843 if (Erase::TailFromLast(path_name, '.'))
844 {
845 path_name += fmt;
846 return;
847 }
848 path_name += ".";
849 path_name += std::string{ fmt };
850}
851[[nodiscard]]
852inline std::string ReplaceExtension(std::string_view path_name, std::string_view fmt)
853{
854 std::string ret = std::string{ path_name };
855 ReplaceExtension(ret, fmt);
856 return ret;
857}
858
863inline void EraseFilename(std::string& path_name)
864{
865 if (!Erase::TailFromLast(path_name, '/'))
866 log_err0("不是一个有效路径!");
867}
868[[nodiscard]]
869inline std::string EraseFilename(std::string_view path_name)
870{
871 std::string ret = std::string{ path_name };
872 EraseFilename(ret);
873 return ret;
874}
875
879inline std::string GetFileStem(std::string_view path_name)
880{
881 std::string name{ path_name };
882 Erase::HeadFromLast(name, '/');
883 if (Erase::TailFromLast(name, '.'))
884 name.pop_back();
885 return name;
886}
890inline std::string ErasePath(std::string_view path_name, std::string_view path)
891{
892 std::string ret{ path_name };
893 Erase::HeadSub(ret, std::string{ path });
894 return ret;
895}
896
902
903inline bool IsRelativePath(std::string_view path_name)
904{
905 if (path_name.empty())
906 return true;
907
908 if (path_name[0] == '/')
909 return false;
910
911 size_t len = (std::min)(path_name.size(), (size_t)12);
912 for (size_t i = 0; i < len; ++i)
913 {
914 if (path_name[i] == ':')
915 return false;
916 }
917 return true;
918}
919
920
930bool GetPathAndRes(
931 std::string_view path_root, std::string_view path_name,
932 std::string& path_real, std::string& res_name,
933 std::string_view name = "");
934
935
941std::string GetResName(
942 std::string_view path_root,
943 std::string_view path_name);
944
945
952std::string CvtRelativePath(std::string path_cur, std::string_view path);
953
958inline void CvtPathSeparator(std::string& path)
959{
960 Every::Replace(path, '\\', '/');
961}
962[[nodiscard]]
963inline std::string CvtPathSeparator(std::string_view path)
964{
965 std::string ret{ path };
966 CvtPathSeparator(ret);
967 return ret;
968}
973inline void CvtPathSeparatorBack(std::string& path)
974{
975 Every::Replace(path, '/', '\\');
976}
977[[nodiscard]]
978inline std::string CvtPathSeparatorBack(std::string_view path)
979{
980 std::string ret{ path };
981 CvtPathSeparatorBack(ret);
982 return ret;
983}
988inline std::string CvtLineBreak(std::string_view str)
989{
990 std::string ret;
991 for (auto& iter : str)
992 {
993 if(iter == '\r')
994 continue;
995 ret.push_back(iter);
996 }
997 return ret;
998}
999
1000
1004inline bool HasNumber(std::string_view str)
1005{
1006 return Any::Yes(str, isdigit);
1007}
1008
1012inline bool HasLetter(std::string_view str)
1013{
1014 return Any::Yes(str, isalpha);
1015}
1016
1020std::vector<std::string> ParseCommand(std::string_view cmd);
1021
1026template<size_t W, size_t H>
1027Array<std::string, H> FormatString2(const Array2<std::string, W, H>& arr)
1028{
1029 //每一列得到一个最大宽度
1030 Array<size_t, W> mul_col{};
1031 for (size_t j = 0; j < H; ++j)
1032 {
1033 for (size_t i = 0; i < W; ++i)
1034 {
1035 if (arr[j][i].size() > mul_col[i])
1036 mul_col[i] = arr[j][i].size();
1037 }
1038 }
1039 //合并每行
1040 Array<std::string, H> ret;
1041 for (size_t i = 0; i < W; ++i)
1042 {
1043 std::string fmt = std::string("{:<") + std::to_string(mul_col[i] + 1) + "}";
1044 for (size_t j = 0; j < H; ++j)
1045 {
1046 ret[j] += fmt::vformat(fmt, fmt::make_format_args(arr[j][i]));
1047 }
1048 }
1049 return ret;
1050}
1051
1056std::vector<std::string> FormatString2(const Vector2<std::string>& arr);
1057
1058
1059
1060//----------------------------其余范围操作封装----------------------------
1061inline bool IsSub(std::string_view str, std::string_view str_sub)
1062{
1063 return Sub::IsSub(str, str_sub);
1064}
1065
1066inline bool IsBegin(std::string_view str, std::string_view str_sub)
1067{
1068 return Sub::IsBegin(str, str_sub);
1069}
1070inline std::string_view Range(std::string_view str, char a, char b)
1071{
1072 return Sub::Range(str, a, b);
1073}
1074
1075}
1076
1077}
1078
1079
1080namespace dl
1081{
1082
1083
1084inline std::string to_string(const Vector2<std::string>& vec2)
1085{
1086 return String::Splicing(String::FormatString2(vec2), "\n");
1087}
1088
1089
1090//#if (DL_PLATFORM == DL_PLATFORM_WIN32)
1092//* @brief array的format特化
1093//* @note
1094//*/
1095//template<typename T, size_t N, typename CharT>
1096//struct std::formatter<Array<T, N>, CharT> : std::formatter<std::string, CharT>
1097//{
1098// template <typename FormatParseContext>
1099// auto parse(FormatParseContext& pc)
1100// {
1101// return pc.end();
1102// }
1103//
1104// template<typename FormatContext>
1105// auto format(array<T, N> t, FormatContext& fc)
1106// {
1107// if constexpr (N == 2)
1108// return std::formatter<std::string, CharT>::format(
1109// std::format("{}, {}", t[0], t[1]), fc);
1110// if constexpr (N == 3)
1111// return std::formatter<std::string, CharT>::format(
1112// std::format("{}, {}, {}", t[0], t[1], t[2]), fc);
1113// if constexpr (N == 4)
1114// return std::formatter<std::string, CharT>::format(
1115// std::format("{}, {}, {}, {}", t[0], t[1], t[2], t[3]), fc);
1116// }
1117//};
1118//#endif
1119}
1120
1121
1122
1123
1124
1125namespace fmt
1126{
1127 //
1128 template <typename T>
1129 struct formatter<dl::Array<T, 2>>
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::Array<T, 2>& arr, FormatContext& ctx) const -> decltype(ctx.out())
1144 {
1145 return fmt::format_to(ctx.out(), "{}, {}", arr.x, arr.y);
1146 }
1147 };
1148
1149 //
1150 template <typename T>
1151 struct formatter<dl::Array<T, 3>>
1152 {
1153 constexpr auto parse(fmt::format_parse_context& ctx) -> decltype(ctx.begin())
1154 {
1155 auto it = ctx.begin();
1156 if (it != ctx.end() && *it != '}')
1157 throw fmt::format_error("invalid format specifier for dl::Array<T, 3>");
1158 return it;
1159 }
1160
1161 template <typename FormatContext>
1162 auto format(const dl::Array<T, 3>& arr, FormatContext& ctx) const -> decltype(ctx.out())
1163 {
1164 return fmt::format_to(ctx.out(), "{}, {}, {}", arr.x, arr.y, arr.z);
1165 }
1166 };
1167
1168 //
1169 template <typename T>
1170 struct formatter<dl::Array<T, 4>>
1171 {
1172 constexpr auto parse(fmt::format_parse_context& ctx) -> decltype(ctx.begin())
1173 {
1174 auto it = ctx.begin();
1175 if (it != ctx.end() && *it != '}')
1176 throw fmt::format_error("invalid format specifier for dl::Array<T, 4>");
1177 return it;
1178 }
1179
1180 template <typename FormatContext>
1181 auto format(const dl::Array<T, 4>& arr, FormatContext& ctx) const -> decltype(ctx.out())
1182 {
1183 return fmt::format_to(ctx.out(), "{}, {}, {}, {}", arr.x, arr.y, arr.z, arr.w);
1184 }
1185 };
1186 //
1187 template <size_t N>
1188 struct formatter<dl::StringN<N>>
1189 {
1190 // 解析格式化参数(这里简化,不处理自定义格式)
1191 constexpr auto parse(fmt::format_parse_context& ctx) -> decltype(ctx.begin())
1192 {
1193 // 检查是否有多余的格式符
1194 auto it = ctx.begin();
1195 if (it != ctx.end() && *it != '}')
1196 throw fmt::format_error("invalid format specifier for dl::Array<T, 2>");
1197 return it;
1198 }
1199
1200 // 格式化逻辑
1201 template <typename FormatContext>
1202 auto format(const dl::StringN<N>& str, FormatContext& ctx) const -> decltype(ctx.out())
1203 {
1204 return fmt::format_to(ctx.out(), "{}", str.c_str());
1205 }
1206 };
1207}
定长字符串
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
bool IsBlank(char ch)
字符串为空白字符,一般意义上( \t空格)
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)
获取宽字符宽度(控制台显示优化)
std::string_view EraseBlankBoth(std::string_view str)
字符串删除首尾空字符
Point2 toPoint2(std::string_view str, char d=',')
int64_t toInt64(std::string_view str, int64_t default_v=0)
转为整数,失败返回设定的默认值
bool getByte(std::string_view str, std::byte &ret)
转为单个字节,需要十六进制,失败不修改原值
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个值,首尾不会出现分割符
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)
以 子串 分割 容器
void log_err0(std::string_view str, DL_SOURCE_LOCATION)
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字符串(进行检查)
std::string to_string_hex(BufferView buf, bool upper=false, bool add_tag=false)
buf转为16进制字符串
BufferView CreateBufferView(const Buffer &buf)
创建buffer视图(右值不能默认转换)
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())