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
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}
68
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}
99template<typename T, size_t N>
100std::string to_string(const Array<T, N>& arr, std::string_view delimiter = ", ")
101{
102 static_assert(N != 0);
103 std::string ret;
104 for (size_t i = 0; i < N - 1; ++i)
105 {
106 ret += dl::to_string(arr[i]);
107 ret += delimiter;
108 }
109 ret += dl::to_string(arr[N - 1]);
110 return ret;
111}
112template<typename T, size_t N>
113std::string to_string(const ArrayS2<T, N>& arr, std::string_view delimiter = ", ")
114{
115 static_assert(N != 0);
116 std::string ret;
117 for (size_t i = 0; i < N - 1; ++i)
118 {
119 ret += dl::to_string(arr.x[i]);
120 ret += delimiter;
121 ret += dl::to_string(arr.y[i]);
122 ret += delimiter;
123 }
124 ret += dl::to_string(arr.x[N - 1]);
125 ret += delimiter;
126 ret += dl::to_string(arr.y[N - 1]);
127 return ret;
128}
129
132template<typename T>
133std::string to_string_ex(const std::vector<T>& vec, std::string_view delimiter = ", ")
134{
135 if (vec.empty())
136 return {};
137 std::string ret;
138 for (size_t i = 0; i < vec.size() - 1; ++i)
139 {
140 ret += dl::to_string(vec[i]);
141 ret += delimiter;
142 }
143 ret += dl::to_string(vec[vec.size() - 1]);
144 return ret;
145}
146
148std::string to_string(std::error_code code);
149
150
154template<>
156template<>
157inline std::string to_string<Buffer>(Buffer buf)
158{
159 return to_string(BufferView{ buf });
160}
161
165std::string to_string_check(BufferView buf, bool tips = true);
166
170std::string to_string_hex(BufferView buf, bool add_tag = false);
171
175std::string to_string_auto(BufferView buf, bool add_tag = false);
176
183
184namespace String
185{
190inline Float toFloat(std::string_view str, Float default_v = 0)
191{
192 std::from_chars(str.data(), str.data() + str.size(), default_v);
193 return default_v;
194}
195
199inline int toInt(std::string_view str, int default_v = 0)
200{
201 std::from_chars(str.data(), str.data() + str.size(), default_v);
202 return default_v;
203}
204
208inline int64_t toInt64(std::string_view str, int64_t default_v = 0)
209{
210 std::from_chars(str.data(), str.data() + str.size(), default_v);
211 return default_v;
212}
213
216inline bool getInt(std::string_view str, int& ret)
217{
218 std::from_chars_result r = std::from_chars(str.data(), str.data() + str.size(), ret);
219 return r.ec == std::errc();
220}
221
225template<std::size_t N>
226Array<int, N> toPoint(std::string_view str, char d = ',')
227{
228 std::vector<std::string_view> vec;
229 split(str, d, vec);
230 if (vec.size() == 0)
231 {
232 log_warn("分割后数量为0!");
233 return {};
234 }
235 else if (vec.size() == 1)
236 {
237 log_warn("分割后数量为1!");
238 return { toInt(vec[0]) , 0};
239 }
240 return { toInt(vec[0]), toInt(vec[1]) };
241}
242
245template<std::size_t N>
246Array<Float, N> toPosition(std::string_view str, char d = ',')
247{
248 std::vector<std::string_view> vec;
249 split(str, d, vec);
250 if (vec.size() == 0)
251 {
252 log_warn("分割后数量为0!");
253 return {};
254 }
255 else if (vec.size() == 1)
256 {
257 log_warn("分割后数量为1!");
258 return { toFloat(vec[0]) , 0 };
259 }
260 return { toFloat(vec[0]), toFloat(vec[1]) };
261}
262
263inline Point2 toPoint2(std::string_view str, char d = ',')
264{
265 return toPoint<2>(str, d);
266}
267inline Position toPosition2(std::string_view str, char d = ',')
268{
269 return toPosition<2>(str, d);
270}
271
275constexpr StringType GetType(std::string_view str)
276{
277 bool has_dot = false;
278 for (size_t i = 0; i < str.size(); ++i)
279 {
280 const char& ch = str[i];
281 if (std::isdigit(ch))
282 continue;
283 else if (i == 0 && (ch == '+' || ch == '-'))
284 continue;
285 else if (!has_dot && ch == '.')
286 {
287 has_dot = true;
288 continue;
289 }
290 else
291 return StringType::NORMAL;
292 }
293 return has_dot ? StringType::FLOAT : StringType::INTGER;
294}
295
298inline std::string AddQuotes(std::string_view str, char quotes = '\"')
299{
300 std::string ret;
301 ret.reserve(str.size() + 2);
302 ret += quotes;
303 ret += str;
304 ret += quotes;
305 return ret;
306}
307
310size_t Wcwidth(wchar_t ch);
315std::string FillEndl(std::string_view str, char ch = ' ');
319constexpr std::string_view GetNotFileName()
320{
321 return R"(<>/\|:"*?)";
322}
323
327inline void EraseNotFileName(std::string& name)
328{
329 Erase::Match(name, std::string{ String::GetNotFileName() });
330}
331
335inline void ToLower(std::string& str)
336{
337 std::transform(str.begin(), str.end(), str.begin(), ::tolower);
338}
339
343inline std::string ToLower(const std::string& str)
344{
345 std::string ret = str;
346 std::transform(ret.begin(), ret.end(), ret.begin(), ::tolower);
347 return ret;
348}
352inline void ToUpper(std::string& str)
353{
354 std::transform(str.begin(), str.end(), str.begin(), ::toupper);
355}
359inline std::string ToUpper(std::string_view str)
360{
361 std::string ret{ str };
362 ToUpper(ret);
363 return ret;
364}
368inline bool EqualToLower(std::string_view a, std::string_view b)
369{
370 if (a.size() != b.size())
371 return false;
372 if (a.empty())
373 return true;
374 for (size_t i = 0; i < a.size(); ++i)
375 {
376 if (std::tolower(a[i]) != std::tolower(b[i]))
377 return false;
378 }
379 return true;
380}
381
385inline std::string Splicing(const std::vector<std::string>& vec,
386 std::string_view delimiter = ", ", std::string_view end = "")
387{
388 if (vec.empty())
389 return {};
390 if (vec.size() == 1)
391 return vec[0] + end;
392
393 std::string ret;
394 for (size_t i = 0; i < vec.size() - 1; ++i)
395 {
396 ret += vec[i];
397 ret += delimiter;
398 }
399 ret += vec[vec.size() - 1];
400 ret += end;
401 return ret;
402}
406inline bool IsBlank(char ch)
407{
408 return ch == ' '
409 || ch == '\n'
410 || ch == '\t';
411}
412
416inline bool IsBlank(std::string_view str)
417{
418 for (char ch : str)
419 {
420 if (!IsBlank(ch))
421 return false;
422 }
423 return true;
424}
425
430inline std::string EraseCharAll(std::string_view str, std::string_view vec_char)
431{
432 std::string ret;
433 for (auto& iter : str)
434 {
435 if (Every::NotEqual(vec_char, iter))
436 ret.push_back(iter);
437 }
438 return ret;
439}
444inline std::string EraseCharN(std::string_view str, std::string_view vec_char, size_t n = 1)
445{
446 std::string ret;
447
448 for (auto& iter : str)
449 {
450 if (n && Any::Equal(vec_char, iter))
451 {
452 --n;
453 continue;
454 }
455 else
456 ret.push_back(iter);
457 }
458 return ret;
459}
464inline std::string EraseCharHead(std::string_view str, std::string_view vec_char)
465{
466 std::string ret;
467
468 bool check = true;
469 for (auto& iter : str)
470 {
471 if (check)
472 {
473 if (Any::Equal(vec_char, iter))
474 ;// 需要删除,仍需判断
475 else
476 {
477 check = false;
478 ret.push_back(iter);
479 }
480 }
481 else
482 ret.push_back(iter);
483 }
484 return ret;
485}
489inline std::string EraseBlank(std::string_view str)
490{
491 return EraseCharAll(str, " \t\n");
492}
496inline std::string EraseBlankN(std::string_view str, size_t n = 1)
497{
498 return EraseCharN(str, " \t\n", n);
499}
503inline std::string EraseBlankHead(std::string_view str)
504{
505 return EraseCharHead(str, " \t\n");
506}
507
511inline std::string GetUtf8ByWchar(wchar_t wc, size_t offset = 0)
512{
513 // 某些平台wchar_t是4字节,必须使用u32string
514 std::u32string s{ (char32_t)(wc + offset) };
515
516 return CodeCvt::Utf32ToUtf8(s);
517}
518
519
523//string GetAscii()
524//{
525// string str_ascii = format("ascii表:\n0 -> /0[t_8]");
526// for (char ch = 1; ch < 128; ++ch)
527// {
528// if (ch == '\n')
529// str_ascii += format("{} -> {}[t_8]", to_string(ch), "/n");
530// else if (ch == '\t')
531// str_ascii += format("{} -> {}[t_8]", to_string(ch), "/t");
532// else if (ch == '[')
533// str_ascii += format("{} -> {}[t_8]", to_string(ch), "[l]");
534// else if (ch == ']')
535// str_ascii += format("{} -> {}[t_8]", to_string(ch), "[r]");
536// else
537// str_ascii += format("{} -> {}[t_8]", to_string(ch), char(ch));
538//
539// if ((ch - 1) % 6 == 0)
540// str_ascii += "\n";
541// }
542// return str_ascii;
543//}
544
548std::string Sprintf(const char* format, ...);
549
553template<typename T>
554std::string SplitIntegerToThousands(T integer)
555{
556 return r_insert_per_num(to_string(integer), ',', 3);
557}
558
562inline std::vector<std::string> Split(const std::string& str, char d)
563{
564 std::vector<std::string> ret;
565 split(str, d, ret);
566 return ret;
567}
568inline std::vector<std::string_view> Split(std::string_view str, char d)
569{
570 std::vector<std::string_view> ret;
571 split(str, d, ret);
572 return ret;
573}
574
578inline std::vector<std::string> Split(const std::string& str, const std::string& d)
579{
580 std::vector<std::string> ret;
581 split_sub(str, d, ret);
582 return ret;
583}
584inline std::vector<std::string_view> Split(std::string_view str, std::string_view d)
585{
586 std::vector<std::string_view> ret;
587 split_sub(str, d, ret);
588 return ret;
589}
590
597inline std::vector<std::string_view> SplitViewNoEmpty(std::string_view str, std::string_view vec_ch)
598{
599 std::vector<std::string_view> ret;
600 size_t beg = 0;
601 size_t cur = 0;
602 for (; cur < str.size(); ++cur)
603 {
604 if (Any::Equal(vec_ch, str[cur]))
605 {
606 if (beg != cur)
607 ret.push_back({ str.data() + beg, str.data() + cur });
608 beg = cur + 1;
609 }
610 }
611 if (beg != cur)
612 ret.push_back({ str.data() + beg, str.data() + cur });
613 return ret;
614}
615inline std::vector<std::string_view> SplitViewNoEmpty(std::string_view str,
616 const std::vector<char>& vec_ch)
617{
618 return SplitViewNoEmpty(str, std::string_view{ vec_ch.data(), vec_ch.size() });
619}
626inline std::vector<std::string_view> SplitView(std::string_view str, std::string_view vec_ch)
627{
628 std::vector<std::string_view> ret;
629 size_t beg = 0;
630 size_t cur = 0;
631 for (; cur < str.size(); ++cur)
632 {
633 if (Any::Equal(vec_ch, str[cur]))
634 {
635 if (beg != cur)
636 ret.push_back({ str.data() + beg, str.data() + cur });
637 else
638 ret.push_back({});
639 beg = cur + 1;
640 }
641 }
642 if (beg != cur)
643 ret.push_back({ str.data() + beg, str.data() + cur });
644 else
645 ret.push_back({});
646 return ret;
647}
648inline std::vector<std::string_view> SplitView(std::string_view str,
649 const std::vector<char>& vec_ch)
650{
651 return SplitView(str, std::string_view{ vec_ch.data(), vec_ch.size() });
652}
656inline std::vector<std::string> SplitNoEmpty(const std::string& str, char d)
657{
658 std::vector<std::string> ret;
659 split_no_empty(str, d, ret);
660 return ret;
661}
662
663inline void TestSplit()
664{
665 std::string str0 = "0,1,2,,3";
666 std::string str1 = ",0,1,2,,3,";
667 std::string str2 = ",,0,1,2,,3,";
668
669 using namespace std::literals;
670 {
671 std::vector<std::string_view> vec0 = SplitView(str0, ","sv);
672 std::vector<std::string_view> vec1 = SplitView(str1, ","sv);
673 std::vector<std::string_view> vec2 = SplitView(str2, ","sv);
674
675 assert(vec0[0] == "0" && vec0[1] == "1" && vec0[2] == "2" && vec0[3] == "" && vec0[4] == "3");
676 assert(vec1[0] == "" && vec1[1] == "0" && vec1[2] == "1" && vec1[3] == "2" && vec1[4] == ""
677 && vec1[5] == "3" && vec1[6] == "");
678 assert(vec2[0] == "" && vec2[1] == "" && vec2[2] == "0" && vec2[3] == "1" && vec2[4] == "2"
679 && vec2[5] == "" && vec2[6] == "3" && vec2[7] == "");
680 }
681
682
683 {
684 std::vector<std::string_view> vec0 = SplitViewNoEmpty(str0, ","sv);
685 std::vector<std::string_view> vec1 = SplitViewNoEmpty(str1, ","sv);
686 std::vector<std::string_view> vec2 = SplitViewNoEmpty(str2, ","sv);
687
688 assert(vec0[0] == "0" && vec0[1] == "1" && vec0[2] == "2" && vec0[3] == "3");
689 assert(vec1[0] == "0" && vec1[1] == "1" && vec1[2] == "2" && vec1[3] == "3");
690 assert(vec2[0] == "0" && vec2[1] == "1" && vec2[2] == "2" && vec2[3] == "3");
691 }
692}
693
698inline void EraseExtension(std::string& path_name)
699{
700 if (Erase::TailFromLast(path_name, '.'))
701 path_name.pop_back();
702}
703[[nodiscard]]
704inline std::string EraseExtension(std::string_view path_name)
705{
706 std::string ret = std::string{ path_name };
707 EraseExtension(ret);
708 return ret;
709}
710
717inline void ReplaceExtension(std::string& path_name, std::string_view fmt)
718{
719 if (Erase::TailFromLast(path_name, '.'))
720 {
721 path_name += fmt;
722 return;
723 }
724 path_name += ".";
725 path_name += std::string{ fmt };
726}
727[[nodiscard]]
728inline std::string ReplaceExtension(std::string_view path_name, std::string_view fmt)
729{
730 std::string ret = std::string{ path_name };
731 ReplaceExtension(ret, fmt);
732 return ret;
733}
734
739inline void EraseFilename(std::string& path_name)
740{
741 if (!Erase::TailFromLast(path_name, '/'))
742 log_err0("不是一个有效路径!");
743}
744[[nodiscard]]
745inline std::string EraseFilename(std::string_view path_name)
746{
747 std::string ret = std::string{ path_name };
748 EraseFilename(ret);
749 return ret;
750}
751
755inline std::string GetFileStem(std::string_view path_name)
756{
757 std::string name{ path_name };
758 Erase::HeadFromLast(name, '/');
759 if (Erase::TailFromLast(name, '.'))
760 name.pop_back();
761 return name;
762}
766inline std::string ErasePath(std::string_view path_name, std::string_view path)
767{
768 std::string ret;
769 Erase::HeadSub(ret, std::string{ path });
770 return ret;
771}
772
778
779inline bool IsRelativePath(std::string_view path_name)
780{
781 if (path_name.empty())
782 return true;
783
784 if (path_name[0] == '/')
785 return false;
786
787 size_t len = (std::min)(path_name.size(), (size_t)12);
788 for (size_t i = 0; i < len; ++i)
789 {
790 if (path_name[i] == ':')
791 return false;
792 }
793 return true;
794}
795
796
806bool GetPathAndRes(
807 std::string_view path_root, std::string_view path_name,
808 std::string& path_real, std::string& res_name,
809 std::string_view name = "");
810
811
817std::string GetResName(
818 std::string_view path_root,
819 std::string_view path_name);
820
821
828std::string CvtRelativePath(std::string path_cur, std::string_view path);
829
834inline void CvtPathSeparator(std::string& path)
835{
836 Every::Replace(path, '\\', '/');
837}
838[[nodiscard]]
839inline std::string CvtPathSeparator(std::string_view path)
840{
841 std::string ret{ path };
842 CvtPathSeparator(ret);
843 return ret;
844}
849inline void CvtPathSeparatorBack(std::string& path)
850{
851 Every::Replace(path, '/', '\\');
852}
853[[nodiscard]]
854inline std::string CvtPathSeparatorBack(std::string_view path)
855{
856 std::string ret{ path };
857 CvtPathSeparatorBack(ret);
858 return ret;
859}
864inline std::string CvtLineBreak(std::string_view str)
865{
866 std::string ret;
867 for (auto& iter : str)
868 {
869 if(iter == '\r')
870 continue;
871 ret.push_back(iter);
872 }
873 return ret;
874}
875
876
880inline bool HasNumber(std::string_view str)
881{
882 return Any::Yes(str, isdigit);
883}
884
888inline bool HasLetter(std::string_view str)
889{
890 return Any::Yes(str, isalpha);
891}
892
896std::vector<std::string> ParseCommand(std::string_view cmd);
897
902template<size_t W, size_t H>
903Array<std::string, H> FormatString2(const Array2<std::string, W, H>& arr)
904{
905 //每一列得到一个最大宽度
906 Array<size_t, W> mul_col{};
907 for (size_t j = 0; j < H; ++j)
908 {
909 for (size_t i = 0; i < W; ++i)
910 {
911 if (arr[j][i].size() > mul_col[i])
912 mul_col[i] = arr[j][i].size();
913 }
914 }
915 //合并每行
916 Array<std::string, H> ret;
917 for (size_t i = 0; i < W; ++i)
918 {
919 std::string fmt = std::string("{:<") + std::to_string(mul_col[i] + 1) + "}";
920 for (size_t j = 0; j < H; ++j)
921 {
922 ret[j] += fmt::vformat(fmt, fmt::make_format_args(arr[j][i]));
923 }
924 }
925 return ret;
926}
927
932std::vector<std::string> FormatString2(const Vector2<std::string>& arr);
933
934
935
936//----------------------------其余范围操作封装----------------------------
937inline bool IsSub(std::string_view str, std::string_view str_sub)
938{
939 return Sub::IsSub(str, str_sub);
940}
941
942inline bool IsBegin(std::string_view str, std::string_view str_sub)
943{
944 return Sub::IsBegin(str, str_sub);
945}
946inline std::string_view Range(std::string_view str, char a, char b)
947{
948 return Sub::Range(str, a, b);
949}
950
951}
952
953}
954
955
956namespace dl
957{
958
959
960inline std::string to_string(const Vector2<std::string>& vec2)
961{
962 return String::Splicing(String::FormatString2(vec2), "\n");
963}
964
965
966//#if (DL_PLATFORM == DL_PLATFORM_WIN32)
968//* @brief array的format特化
969//* @note
970//*/
971//template<typename T, size_t N, typename CharT>
972//struct std::formatter<Array<T, N>, CharT> : std::formatter<std::string, CharT>
973//{
974// template <typename FormatParseContext>
975// auto parse(FormatParseContext& pc)
976// {
977// return pc.end();
978// }
979//
980// template<typename FormatContext>
981// auto format(array<T, N> t, FormatContext& fc)
982// {
983// if constexpr (N == 2)
984// return std::formatter<std::string, CharT>::format(
985// std::format("{}, {}", t[0], t[1]), fc);
986// if constexpr (N == 3)
987// return std::formatter<std::string, CharT>::format(
988// std::format("{}, {}, {}", t[0], t[1], t[2]), fc);
989// if constexpr (N == 4)
990// return std::formatter<std::string, CharT>::format(
991// std::format("{}, {}, {}, {}", t[0], t[1], t[2], t[3]), fc);
992// }
993//};
994//#endif
995}
996
997
998
999
1000
1001namespace fmt
1002{
1003 //
1004 template <typename T>
1005 struct formatter<dl::Array<T, 2>>
1006 {
1007 // 解析格式化参数(这里简化,不处理自定义格式)
1008 constexpr auto parse(fmt::format_parse_context& ctx) -> decltype(ctx.begin())
1009 {
1010 // 检查是否有多余的格式符
1011 auto it = ctx.begin();
1012 if (it != ctx.end() && *it != '}')
1013 throw fmt::format_error("invalid format specifier for dl::Array<T, 2>");
1014 return it;
1015 }
1016
1017 // 格式化逻辑
1018 template <typename FormatContext>
1019 auto format(const dl::Array<T, 2>& arr, FormatContext& ctx) const -> decltype(ctx.out())
1020 {
1021 return fmt::format_to(ctx.out(), "{}, {}", arr.x, arr.y);
1022 }
1023 };
1024
1025 //
1026 template <typename T>
1027 struct formatter<dl::Array<T, 3>>
1028 {
1029 constexpr auto parse(fmt::format_parse_context& ctx) -> decltype(ctx.begin())
1030 {
1031 auto it = ctx.begin();
1032 if (it != ctx.end() && *it != '}')
1033 throw fmt::format_error("invalid format specifier for dl::Array<T, 3>");
1034 return it;
1035 }
1036
1037 template <typename FormatContext>
1038 auto format(const dl::Array<T, 3>& arr, FormatContext& ctx) const -> decltype(ctx.out())
1039 {
1040 return fmt::format_to(ctx.out(), "{}, {}, {}", arr.x, arr.y, arr.z);
1041 }
1042 };
1043
1044 //
1045 template <typename T>
1046 struct formatter<dl::Array<T, 4>>
1047 {
1048 constexpr auto parse(fmt::format_parse_context& ctx) -> decltype(ctx.begin())
1049 {
1050 auto it = ctx.begin();
1051 if (it != ctx.end() && *it != '}')
1052 throw fmt::format_error("invalid format specifier for dl::Array<T, 4>");
1053 return it;
1054 }
1055
1056 template <typename FormatContext>
1057 auto format(const dl::Array<T, 4>& arr, FormatContext& ctx) const -> decltype(ctx.out())
1058 {
1059 return fmt::format_to(ctx.out(), "{}, {}, {}, {}", arr.x, arr.y, arr.z, arr.w);
1060 }
1061 };
1062
1063}
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)
以 元素 分割 容器
std::string to_string_ex(const std::vector< T > &vec, std::string_view delimiter=", ")
vector通用to_string
float Float
std::string to_string< BufferView >(BufferView buf)
buf转为utf8字符串(不进行检查)
std::string to_string< Buffer >(Buffer buf)
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())