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}
99
101std::string to_string(std::error_code code);
102
103
107template<>
109template<>
110inline std::string to_string<Buffer>(Buffer buf)
111{
112 return to_string(BufferView{ buf });
113}
114
119
123std::string to_string_hex(BufferView buf, bool add_tag = false);
124
125
132
133namespace String
134{
138inline Float toFloat(std::string_view str)
139{
140 if constexpr (std::is_same_v<Float, float>)
141 return stof(std::string{str});
142 else if constexpr (std::is_same_v<Float, double>)
143 return stod(std::string{str});
144}
145
149inline int toInt(std::string_view str, int default_v = 0)
150{
151 try
152 {
153 return std::stoi(str.data());
154 }
155 catch (...)
156 {
157 return default_v;
158 }
159}
160
164inline int64_t toInt64(std::string_view str, int64_t default_v = 0)
165{
166 try
167 {
168 return std::stoll(str.data());
169 }
170 catch (...)
171 {
172 return default_v;
173 }
174}
175
178inline bool getInt(std::string_view str, int& ret)
179{
180 try
181 {
182 ret = std::stoi(str.data());
183 }
184 catch (...)
185 {
186 return false;
187 }
188 return true;
189}
190
194template<std::size_t N>
195std::array<int, N> toPoint(std::string_view str, char d = ',')
196{
197 std::vector<std::string> vec;
198 split(std::string(str), d, vec);
199 assert(vec.size() == N);
200 return { stoi(vec[0]), stoi(vec[1]) };
201}
202
205template<std::size_t N>
206std::array<Float, N> toPosition(std::string_view str, char d = ',')
207{
208 std::vector<std::string> vec;
209 split(std::string(str), d, vec);
210 assert(vec.size() == N);
211 return { toFloat(vec[0]), toFloat(vec[1]) };
212}
213
214inline Point2 toPoint2(std::string_view str, char d = ',')
215{
216 return toPoint<2>(str, d);
217}
218inline Position toPosition2(std::string_view str, char d = ',')
219{
220 return toPosition<2>(str, d);
221}
222
226constexpr StringType GetType(std::string_view str)
227{
228 bool has_dot = false;
229 for (size_t i = 0; i < str.size(); ++i)
230 {
231 const char& ch = str[i];
232 if (std::isdigit(ch))
233 continue;
234 else if (i == 0 && (ch == '+' || ch == '-'))
235 continue;
236 else if (!has_dot && ch == '.')
237 {
238 has_dot = true;
239 continue;
240 }
241 else
242 return StringType::NORMAL;
243 }
244 return has_dot ? StringType::FLOAT : StringType::INTGER;
245}
246
247inline std::string AddQuotes(std::string_view str, char quotes = '\"')
248{
249 std::string ret;
250 ret.reserve(str.size() + 2);
251 ret += quotes;
252 ret += str;
253 ret += quotes;
254 return ret;
255}
256
260constexpr std::string_view GetNotFileName()
261{
262 return R"(<>/\|:"*?)";
263}
264
268inline void EraseNotFileName(std::string& name)
269{
270 Erase::Match(name, std::string{ String::GetNotFileName() });
271}
272
276inline void ToLower(std::string& str)
277{
278 std::transform(str.begin(), str.end(), str.begin(), ::tolower);
279}
280
284inline std::string ToLower(const std::string& str)
285{
286 std::string ret = str;
287 std::transform(ret.begin(), ret.end(), ret.begin(), ::tolower);
288 return ret;
289}
293inline void ToUpper(std::string& str)
294{
295 std::transform(str.begin(), str.end(), str.begin(), ::toupper);
296}
300inline std::string ToUpper(std::string_view str)
301{
302 std::string ret{ str };
303 ToUpper(ret);
304 return ret;
305}
309inline bool EqualToLower(std::string_view a, std::string_view b)
310{
311 if (a.size() != b.size())
312 return false;
313 if (a.empty())
314 return true;
315 for (size_t i = 0; i < a.size(); ++i)
316 {
317 if (std::tolower(a[i]) != std::tolower(b[i]))
318 return false;
319 }
320 return true;
321}
322
326inline std::string Splicing(const std::vector<std::string>& vec,
327 std::string_view delimiter = ", ", std::string_view end = "")
328{
329 if (vec.empty())
330 return {};
331 if (vec.size() == 1)
332 return vec[0] + end;
333
334 std::string ret;
335 for (size_t i = 0; i < vec.size() - 1; ++i)
336 {
337 ret += vec[i];
338 ret += delimiter;
339 }
340 ret += vec[vec.size() - 1];
341 ret += end;
342 return ret;
343}
347inline bool IsBlank(char ch)
348{
349 return ch == ' '
350 || ch == '\n'
351 || ch == '\t';
352}
353
357inline bool IsBlank(std::string_view str)
358{
359 for (char ch : str)
360 {
361 if (!IsBlank(ch))
362 return false;
363 }
364 return true;
365}
366
371inline std::string EraseCharAll(std::string_view str, std::string_view vec_char)
372{
373 std::string ret;
374 for (auto& iter : str)
375 {
376 if (Every::NotEqual(vec_char, iter))
377 ret.push_back(iter);
378 }
379 return ret;
380}
385inline std::string EraseCharN(std::string_view str, std::string_view vec_char, size_t n = 1)
386{
387 std::string ret;
388
389 for (auto& iter : str)
390 {
391 if (n && Any::Equal(vec_char, iter))
392 {
393 --n;
394 continue;
395 }
396 else
397 ret.push_back(iter);
398 }
399 return ret;
400}
405inline std::string EraseCharHead(std::string_view str, std::string_view vec_char)
406{
407 std::string ret;
408
409 bool check = true;
410 for (auto& iter : str)
411 {
412 if (check)
413 {
414 if (Any::Equal(vec_char, iter))
415 ;// 需要删除,仍需判断
416 else
417 {
418 check = false;
419 ret.push_back(iter);
420 }
421 }
422 else
423 ret.push_back(iter);
424 }
425 return ret;
426}
430inline std::string EraseBlank(std::string_view str)
431{
432 return EraseCharAll(str, " \t\n");
433}
437inline std::string EraseBlankN(std::string_view str, size_t n = 1)
438{
439 return EraseCharN(str, " \t\n", n);
440}
444inline std::string EraseBlankHead(std::string_view str)
445{
446 return EraseCharHead(str, " \t\n");
447}
448
452inline std::string GetUtf8ByWchar(wchar_t wc, size_t offset)
453{
454 // 某些平台wchar_t是4字节,必须使用u32string
455 std::u32string s{ (char32_t)(wc + offset) };
456
457 return CodeCvt::Utf32ToUtf8(s);
458}
459
460
464//string GetAscii()
465//{
466// string str_ascii = format("ascii表:\n0 -> /0[t_8]");
467// for (char ch = 1; ch < 128; ++ch)
468// {
469// if (ch == '\n')
470// str_ascii += format("{} -> {}[t_8]", to_string(ch), "/n");
471// else if (ch == '\t')
472// str_ascii += format("{} -> {}[t_8]", to_string(ch), "/t");
473// else if (ch == '[')
474// str_ascii += format("{} -> {}[t_8]", to_string(ch), "[l]");
475// else if (ch == ']')
476// str_ascii += format("{} -> {}[t_8]", to_string(ch), "[r]");
477// else
478// str_ascii += format("{} -> {}[t_8]", to_string(ch), char(ch));
479//
480// if ((ch - 1) % 6 == 0)
481// str_ascii += "\n";
482// }
483// return str_ascii;
484//}
485
489std::string Sprintf(const char* format, ...);
490
494template<typename T>
495std::string SplitIntegerToThousands(T integer)
496{
497 return r_insert_per_num(to_string(integer), ',', 3);
498}
499
503inline std::vector<std::string> Split(const std::string& str, char d)
504{
505 std::vector<std::string> ret;
506 split(str, d, ret);
507 return ret;
508}
509inline std::vector<std::string_view> Split(std::string_view str, char d)
510{
511 std::vector<std::string_view> ret;
512 split(str, d, ret);
513 return ret;
514}
515
519inline std::vector<std::string> Split(const std::string& str, const std::string& d)
520{
521 std::vector<std::string> ret;
522 split_sub(str, d, ret);
523 return ret;
524}
525inline std::vector<std::string_view> Split(std::string_view str, std::string_view d)
526{
527 std::vector<std::string_view> ret;
528 split_sub(str, d, ret);
529 return ret;
530}
531
538inline std::vector<std::string_view> SplitViewNoEmpty(std::string_view str, std::string_view vec_ch)
539{
540 std::vector<std::string_view> ret;
541 size_t beg = 0;
542 size_t cur = 0;
543 for (; cur < str.size(); ++cur)
544 {
545 if (Any::Equal(vec_ch, str[cur]))
546 {
547 if (beg != cur)
548 ret.push_back({ str.data() + beg, str.data() + cur });
549 beg = cur + 1;
550 }
551 }
552 if (beg != cur)
553 ret.push_back({ str.data() + beg, str.data() + cur });
554 return ret;
555}
556inline std::vector<std::string_view> SplitViewNoEmpty(std::string_view str,
557 const std::vector<char>& vec_ch)
558{
559 return SplitViewNoEmpty(str, std::string_view{ vec_ch.data(), vec_ch.size() });
560}
567inline std::vector<std::string_view> SplitView(std::string_view str, std::string_view vec_ch)
568{
569 std::vector<std::string_view> ret;
570 size_t beg = 0;
571 size_t cur = 0;
572 for (; cur < str.size(); ++cur)
573 {
574 if (Any::Equal(vec_ch, str[cur]))
575 {
576 if (beg != cur)
577 ret.push_back({ str.data() + beg, str.data() + cur });
578 else
579 ret.push_back({});
580 beg = cur + 1;
581 }
582 }
583 if (beg != cur)
584 ret.push_back({ str.data() + beg, str.data() + cur });
585 else
586 ret.push_back({});
587 return ret;
588}
589inline std::vector<std::string_view> SplitView(std::string_view str,
590 const std::vector<char>& vec_ch)
591{
592 return SplitView(str, std::string_view{ vec_ch.data(), vec_ch.size() });
593}
597inline std::vector<std::string> SplitNoEmpty(const std::string& str, char d)
598{
599 std::vector<std::string> ret;
600 split_no_empty(str, d, ret);
601 return ret;
602}
603
604inline void TestSplit()
605{
606 std::string str0 = "0,1,2,,3";
607 std::string str1 = ",0,1,2,,3,";
608 std::string str2 = ",,0,1,2,,3,";
609
610 using namespace std::literals;
611 {
612 std::vector<std::string_view> vec0 = SplitView(str0, ","sv);
613 std::vector<std::string_view> vec1 = SplitView(str1, ","sv);
614 std::vector<std::string_view> vec2 = SplitView(str2, ","sv);
615
616 assert(vec0[0] == "0" && vec0[1] == "1" && vec0[2] == "2" && vec0[3] == "" && vec0[4] == "3");
617 assert(vec1[0] == "" && vec1[1] == "0" && vec1[2] == "1" && vec1[3] == "2" && vec1[4] == ""
618 && vec1[5] == "3" && vec1[6] == "");
619 assert(vec2[0] == "" && vec2[1] == "" && vec2[2] == "0" && vec2[3] == "1" && vec2[4] == "2"
620 && vec2[5] == "" && vec2[6] == "3" && vec2[7] == "");
621 }
622
623
624 {
625 std::vector<std::string_view> vec0 = SplitViewNoEmpty(str0, ","sv);
626 std::vector<std::string_view> vec1 = SplitViewNoEmpty(str1, ","sv);
627 std::vector<std::string_view> vec2 = SplitViewNoEmpty(str2, ","sv);
628
629 assert(vec0[0] == "0" && vec0[1] == "1" && vec0[2] == "2" && vec0[3] == "3");
630 assert(vec1[0] == "0" && vec1[1] == "1" && vec1[2] == "2" && vec1[3] == "3");
631 assert(vec2[0] == "0" && vec2[1] == "1" && vec2[2] == "2" && vec2[3] == "3");
632 }
633}
634
639inline void EraseExtension(std::string& path_name)
640{
641 if (Erase::TailFromLast(path_name, '.'))
642 path_name.pop_back();
643}
644[[nodiscard]]
645inline std::string EraseExtension(std::string_view path_name)
646{
647 std::string ret = std::string{ path_name };
648 EraseExtension(ret);
649 return ret;
650}
651
658inline void ReplaceExtension(std::string& path_name, std::string_view fmt)
659{
660 if (Erase::TailFromLast(path_name, '.'))
661 {
662 path_name += fmt;
663 return;
664 }
665 path_name += ".";
666 path_name += std::string{ fmt };
667}
668[[nodiscard]]
669inline std::string ReplaceExtension(std::string_view path_name, std::string_view fmt)
670{
671 std::string ret = std::string{ path_name };
672 ReplaceExtension(ret, fmt);
673 return ret;
674}
675
680inline void EraseFilename(std::string& path_name)
681{
682 if (!Erase::TailFromLast(path_name, '/'))
683 log_err0("不是一个有效路径!");
684}
685[[nodiscard]]
686inline std::string EraseFilename(std::string_view path_name)
687{
688 std::string ret = std::string{ path_name };
689 EraseFilename(ret);
690 return ret;
691}
692
698
699inline bool IsRelativePath(std::string_view path_name)
700{
701 if (path_name.empty())
702 return true;
703
704 if (path_name[0] == '/')
705 return false;
706
707 size_t len = (std::min)(path_name.size(), (size_t)12);
708 for (size_t i = 0; i < len; ++i)
709 {
710 if (path_name[i] == ':')
711 return false;
712 }
713 return true;
714}
715
716
726bool GetPathAndRes(
727 std::string_view path_root, std::string_view path_name,
728 std::string& path_real, std::string& res_name,
729 std::string_view name = "");
730
731
737std::string GetResName(
738 std::string_view path_root,
739 std::string_view path_name);
740
741
748std::string CvtRelativePath(std::string path_cur, std::string_view path);
749
754inline void CvtPathSeparator(std::string& path)
755{
756 Every::Replace(path, '\\', '/');
757}
758[[nodiscard]]
759inline std::string CvtPathSeparator(std::string_view path)
760{
761 std::string ret{ path };
762 CvtPathSeparator(ret);
763 return ret;
764}
769inline void CvtPathSeparatorBack(std::string& path)
770{
771 Every::Replace(path, '/', '\\');
772}
773[[nodiscard]]
774inline std::string CvtPathSeparatorBack(std::string_view path)
775{
776 std::string ret{ path };
777 CvtPathSeparatorBack(ret);
778 return ret;
779}
784inline std::string CvtLineBreak(std::string_view str)
785{
786 std::string ret;
787 for (auto& iter : str)
788 {
789 if(iter == '\r')
790 continue;
791 ret.push_back(iter);
792 }
793 return ret;
794}
795
796
800inline bool HasNumber(std::string_view str)
801{
802 return Any::Yes(str, isdigit);
803}
804
808inline bool HasLetter(std::string_view str)
809{
810 return Any::Yes(str, isalpha);
811}
812
816std::vector<std::string> ParseCommand(std::string_view cmd);
817
822template<size_t W, size_t H>
823std::array<std::string, H> FormatString2(const Array2<std::string, W, H>& arr)
824{
825 //每一列得到一个最大宽度
826 std::array<size_t, W> mul_col{};
827 for (size_t j = 0; j < H; ++j)
828 {
829 for (size_t i = 0; i < W; ++i)
830 {
831 if (arr[j][i].size() > mul_col[i])
832 mul_col[i] = arr[j][i].size();
833 }
834 }
835 //合并每行
836 std::array<std::string, H> ret;
837 for (size_t i = 0; i < W; ++i)
838 {
839 std::string fmt = std::string("{:<") + std::to_string(mul_col[i] + 1) + "}";
840 for (size_t j = 0; j < H; ++j)
841 {
842 ret[j] += fmt::vformat(fmt, fmt::make_format_args(arr[j][i]));
843 }
844 }
845 return ret;
846}
847
852std::vector<std::string> FormatString2(const Vector2<std::string>& arr);
853
854
855
856//----------------------------其余范围操作封装----------------------------
857inline bool IsSub(std::string_view str, std::string_view str_sub)
858{
859 return Sub::IsSub(str, str_sub);
860}
861
862inline bool IsBegin(std::string_view str, std::string_view str_sub)
863{
864 return Sub::IsBegin(str, str_sub);
865}
866inline std::string_view Range(std::string_view str, char a, char b)
867{
868 return Sub::Range(str, a, b);
869}
870
871}
872
873}
874
875
876namespace dl
877{
878
879
880inline std::string to_string(const Vector2<std::string>& vec2)
881{
882 return String::Splicing(String::FormatString2(vec2), "\n");
883}
884
885//#if (DL_PLATFORM == DL_PLATFORM_WIN32)
887//* @brief array的format特化
888//* @note
889//*/
890//template<typename T, size_t N, typename CharT>
891//struct std::formatter<std::array<T, N>, CharT> : std::formatter<std::string, CharT>
892//{
893// template <typename FormatParseContext>
894// auto parse(FormatParseContext& pc)
895// {
896// return pc.end();
897// }
898//
899// template<typename FormatContext>
900// auto format(array<T, N> t, FormatContext& fc)
901// {
902// if constexpr (N == 2)
903// return std::formatter<std::string, CharT>::format(
904// std::format("{}, {}", t[0], t[1]), fc);
905// if constexpr (N == 3)
906// return std::formatter<std::string, CharT>::format(
907// std::format("{}, {}, {}", t[0], t[1], t[2]), fc);
908// if constexpr (N == 4)
909// return std::formatter<std::string, CharT>::format(
910// std::format("{}, {}, {}, {}", t[0], t[1], t[2], t[3]), fc);
911// }
912//};
913//#endif
914}
2维array
表示一段内存
编码转换
日志系统
范围操作
通用类型定义
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 TailFromLast(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)
判断容器所有元素都 不等于某值
std::array< int, N > toPoint(std::string_view str, char d=',')
字符串 -> Point
Position toPosition2(std::string_view str, char d=',')
bool getInt(std::string_view str, int &ret)
转为整数,失败不修改原值
int toInt(std::string_view str, int default_v=0)
转为整数,失败返回设定的默认值
constexpr std::string_view GetNotFileName()
返回不能作为文件名的字符
constexpr StringType GetType(std::string_view str)
返回字符串类型
std::string AddQuotes(std::string_view str, char quotes='\"')
Point2 toPoint2(std::string_view str, char d=',')
int64_t toInt64(std::string_view str, int64_t default_v=0)
转为整数,失败返回设定的默认值
std::array< Float, N > toPosition(std::string_view str, char d=',')
字符串 -> Position
Float toFloat(std::string_view str)
字符串 -> Float
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
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)
以 元素 分割 容器
std::string operator+(const std::string &a, std::string_view b)
std::string & operator+=(std::string &a, std::string_view b)
std::array< int, 2 > Point2
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::string to_string_check(BufferView buf)
buf转为utf8字符串(进行检查)
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