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
102template<typename T>
103std::string to_string_ex(const std::vector<T>& vec, std::string_view delimiter = ", ")
104{
105 if (vec.empty())
106 return {};
107 std::string ret;
108 for (size_t i = 0; i < vec.size() - 1; ++i)
109 {
110 ret += dl::to_string(vec[i]);
111 ret += delimiter;
112 }
113 ret += dl::to_string(vec[vec.size() - 1]);
114 return ret;
115}
116
118std::string to_string(std::error_code code);
119
120
124template<>
126template<>
127inline std::string to_string<Buffer>(Buffer buf)
128{
129 return to_string(BufferView{ buf });
130}
131
135std::string to_string_check(BufferView buf, bool tips = true);
136
140std::string to_string_hex(BufferView buf, bool add_tag = false);
141
145std::string to_string_auto(BufferView buf, bool add_tag = false);
146
153
154namespace String
155{
159inline Float toFloat(std::string_view str)
160{
161 if constexpr (std::is_same_v<Float, float>)
162 return stof(std::string{str});
163 else if constexpr (std::is_same_v<Float, double>)
164 return stod(std::string{str});
165}
166
170inline int toInt(std::string_view str, int default_v = 0)
171{
172 try
173 {
174 return std::stoi(str.data());
175 }
176 catch (...)
177 {
178 return default_v;
179 }
180}
181
185inline int64_t toInt64(std::string_view str, int64_t default_v = 0)
186{
187 try
188 {
189 return std::stoll(str.data());
190 }
191 catch (...)
192 {
193 return default_v;
194 }
195}
196
199inline bool getInt(std::string_view str, int& ret)
200{
201 try
202 {
203 ret = std::stoi(str.data());
204 }
205 catch (...)
206 {
207 return false;
208 }
209 return true;
210}
211
215template<std::size_t N>
216std::array<int, N> toPoint(std::string_view str, char d = ',')
217{
218 std::vector<std::string> vec;
219 split(std::string(str), d, vec);
220 assert(vec.size() == N);
221 return { stoi(vec[0]), stoi(vec[1]) };
222}
223
226template<std::size_t N>
227std::array<Float, N> toPosition(std::string_view str, char d = ',')
228{
229 std::vector<std::string> vec;
230 split(std::string(str), d, vec);
231 assert(vec.size() == N);
232 return { toFloat(vec[0]), toFloat(vec[1]) };
233}
234
235inline Point2 toPoint2(std::string_view str, char d = ',')
236{
237 return toPoint<2>(str, d);
238}
239inline Position toPosition2(std::string_view str, char d = ',')
240{
241 return toPosition<2>(str, d);
242}
243
247constexpr StringType GetType(std::string_view str)
248{
249 bool has_dot = false;
250 for (size_t i = 0; i < str.size(); ++i)
251 {
252 const char& ch = str[i];
253 if (std::isdigit(ch))
254 continue;
255 else if (i == 0 && (ch == '+' || ch == '-'))
256 continue;
257 else if (!has_dot && ch == '.')
258 {
259 has_dot = true;
260 continue;
261 }
262 else
263 return StringType::NORMAL;
264 }
265 return has_dot ? StringType::FLOAT : StringType::INTGER;
266}
267
268inline std::string AddQuotes(std::string_view str, char quotes = '\"')
269{
270 std::string ret;
271 ret.reserve(str.size() + 2);
272 ret += quotes;
273 ret += str;
274 ret += quotes;
275 return ret;
276}
277
281constexpr std::string_view GetNotFileName()
282{
283 return R"(<>/\|:"*?)";
284}
285
289inline void EraseNotFileName(std::string& name)
290{
291 Erase::Match(name, std::string{ String::GetNotFileName() });
292}
293
297inline void ToLower(std::string& str)
298{
299 std::transform(str.begin(), str.end(), str.begin(), ::tolower);
300}
301
305inline std::string ToLower(const std::string& str)
306{
307 std::string ret = str;
308 std::transform(ret.begin(), ret.end(), ret.begin(), ::tolower);
309 return ret;
310}
314inline void ToUpper(std::string& str)
315{
316 std::transform(str.begin(), str.end(), str.begin(), ::toupper);
317}
321inline std::string ToUpper(std::string_view str)
322{
323 std::string ret{ str };
324 ToUpper(ret);
325 return ret;
326}
330inline bool EqualToLower(std::string_view a, std::string_view b)
331{
332 if (a.size() != b.size())
333 return false;
334 if (a.empty())
335 return true;
336 for (size_t i = 0; i < a.size(); ++i)
337 {
338 if (std::tolower(a[i]) != std::tolower(b[i]))
339 return false;
340 }
341 return true;
342}
343
347inline std::string Splicing(const std::vector<std::string>& vec,
348 std::string_view delimiter = ", ", std::string_view end = "")
349{
350 if (vec.empty())
351 return {};
352 if (vec.size() == 1)
353 return vec[0] + end;
354
355 std::string ret;
356 for (size_t i = 0; i < vec.size() - 1; ++i)
357 {
358 ret += vec[i];
359 ret += delimiter;
360 }
361 ret += vec[vec.size() - 1];
362 ret += end;
363 return ret;
364}
368inline bool IsBlank(char ch)
369{
370 return ch == ' '
371 || ch == '\n'
372 || ch == '\t';
373}
374
378inline bool IsBlank(std::string_view str)
379{
380 for (char ch : str)
381 {
382 if (!IsBlank(ch))
383 return false;
384 }
385 return true;
386}
387
392inline std::string EraseCharAll(std::string_view str, std::string_view vec_char)
393{
394 std::string ret;
395 for (auto& iter : str)
396 {
397 if (Every::NotEqual(vec_char, iter))
398 ret.push_back(iter);
399 }
400 return ret;
401}
406inline std::string EraseCharN(std::string_view str, std::string_view vec_char, size_t n = 1)
407{
408 std::string ret;
409
410 for (auto& iter : str)
411 {
412 if (n && Any::Equal(vec_char, iter))
413 {
414 --n;
415 continue;
416 }
417 else
418 ret.push_back(iter);
419 }
420 return ret;
421}
426inline std::string EraseCharHead(std::string_view str, std::string_view vec_char)
427{
428 std::string ret;
429
430 bool check = true;
431 for (auto& iter : str)
432 {
433 if (check)
434 {
435 if (Any::Equal(vec_char, iter))
436 ;// 需要删除,仍需判断
437 else
438 {
439 check = false;
440 ret.push_back(iter);
441 }
442 }
443 else
444 ret.push_back(iter);
445 }
446 return ret;
447}
451inline std::string EraseBlank(std::string_view str)
452{
453 return EraseCharAll(str, " \t\n");
454}
458inline std::string EraseBlankN(std::string_view str, size_t n = 1)
459{
460 return EraseCharN(str, " \t\n", n);
461}
465inline std::string EraseBlankHead(std::string_view str)
466{
467 return EraseCharHead(str, " \t\n");
468}
469
473inline std::string GetUtf8ByWchar(wchar_t wc, size_t offset)
474{
475 // 某些平台wchar_t是4字节,必须使用u32string
476 std::u32string s{ (char32_t)(wc + offset) };
477
478 return CodeCvt::Utf32ToUtf8(s);
479}
480
481
485//string GetAscii()
486//{
487// string str_ascii = format("ascii表:\n0 -> /0[t_8]");
488// for (char ch = 1; ch < 128; ++ch)
489// {
490// if (ch == '\n')
491// str_ascii += format("{} -> {}[t_8]", to_string(ch), "/n");
492// else if (ch == '\t')
493// str_ascii += format("{} -> {}[t_8]", to_string(ch), "/t");
494// else if (ch == '[')
495// str_ascii += format("{} -> {}[t_8]", to_string(ch), "[l]");
496// else if (ch == ']')
497// str_ascii += format("{} -> {}[t_8]", to_string(ch), "[r]");
498// else
499// str_ascii += format("{} -> {}[t_8]", to_string(ch), char(ch));
500//
501// if ((ch - 1) % 6 == 0)
502// str_ascii += "\n";
503// }
504// return str_ascii;
505//}
506
510std::string Sprintf(const char* format, ...);
511
515template<typename T>
516std::string SplitIntegerToThousands(T integer)
517{
518 return r_insert_per_num(to_string(integer), ',', 3);
519}
520
524inline std::vector<std::string> Split(const std::string& str, char d)
525{
526 std::vector<std::string> ret;
527 split(str, d, ret);
528 return ret;
529}
530inline std::vector<std::string_view> Split(std::string_view str, char d)
531{
532 std::vector<std::string_view> ret;
533 split(str, d, ret);
534 return ret;
535}
536
540inline std::vector<std::string> Split(const std::string& str, const std::string& d)
541{
542 std::vector<std::string> ret;
543 split_sub(str, d, ret);
544 return ret;
545}
546inline std::vector<std::string_view> Split(std::string_view str, std::string_view d)
547{
548 std::vector<std::string_view> ret;
549 split_sub(str, d, ret);
550 return ret;
551}
552
559inline std::vector<std::string_view> SplitViewNoEmpty(std::string_view str, std::string_view vec_ch)
560{
561 std::vector<std::string_view> ret;
562 size_t beg = 0;
563 size_t cur = 0;
564 for (; cur < str.size(); ++cur)
565 {
566 if (Any::Equal(vec_ch, str[cur]))
567 {
568 if (beg != cur)
569 ret.push_back({ str.data() + beg, str.data() + cur });
570 beg = cur + 1;
571 }
572 }
573 if (beg != cur)
574 ret.push_back({ str.data() + beg, str.data() + cur });
575 return ret;
576}
577inline std::vector<std::string_view> SplitViewNoEmpty(std::string_view str,
578 const std::vector<char>& vec_ch)
579{
580 return SplitViewNoEmpty(str, std::string_view{ vec_ch.data(), vec_ch.size() });
581}
588inline std::vector<std::string_view> SplitView(std::string_view str, std::string_view vec_ch)
589{
590 std::vector<std::string_view> ret;
591 size_t beg = 0;
592 size_t cur = 0;
593 for (; cur < str.size(); ++cur)
594 {
595 if (Any::Equal(vec_ch, str[cur]))
596 {
597 if (beg != cur)
598 ret.push_back({ str.data() + beg, str.data() + cur });
599 else
600 ret.push_back({});
601 beg = cur + 1;
602 }
603 }
604 if (beg != cur)
605 ret.push_back({ str.data() + beg, str.data() + cur });
606 else
607 ret.push_back({});
608 return ret;
609}
610inline std::vector<std::string_view> SplitView(std::string_view str,
611 const std::vector<char>& vec_ch)
612{
613 return SplitView(str, std::string_view{ vec_ch.data(), vec_ch.size() });
614}
618inline std::vector<std::string> SplitNoEmpty(const std::string& str, char d)
619{
620 std::vector<std::string> ret;
621 split_no_empty(str, d, ret);
622 return ret;
623}
624
625inline void TestSplit()
626{
627 std::string str0 = "0,1,2,,3";
628 std::string str1 = ",0,1,2,,3,";
629 std::string str2 = ",,0,1,2,,3,";
630
631 using namespace std::literals;
632 {
633 std::vector<std::string_view> vec0 = SplitView(str0, ","sv);
634 std::vector<std::string_view> vec1 = SplitView(str1, ","sv);
635 std::vector<std::string_view> vec2 = SplitView(str2, ","sv);
636
637 assert(vec0[0] == "0" && vec0[1] == "1" && vec0[2] == "2" && vec0[3] == "" && vec0[4] == "3");
638 assert(vec1[0] == "" && vec1[1] == "0" && vec1[2] == "1" && vec1[3] == "2" && vec1[4] == ""
639 && vec1[5] == "3" && vec1[6] == "");
640 assert(vec2[0] == "" && vec2[1] == "" && vec2[2] == "0" && vec2[3] == "1" && vec2[4] == "2"
641 && vec2[5] == "" && vec2[6] == "3" && vec2[7] == "");
642 }
643
644
645 {
646 std::vector<std::string_view> vec0 = SplitViewNoEmpty(str0, ","sv);
647 std::vector<std::string_view> vec1 = SplitViewNoEmpty(str1, ","sv);
648 std::vector<std::string_view> vec2 = SplitViewNoEmpty(str2, ","sv);
649
650 assert(vec0[0] == "0" && vec0[1] == "1" && vec0[2] == "2" && vec0[3] == "3");
651 assert(vec1[0] == "0" && vec1[1] == "1" && vec1[2] == "2" && vec1[3] == "3");
652 assert(vec2[0] == "0" && vec2[1] == "1" && vec2[2] == "2" && vec2[3] == "3");
653 }
654}
655
660inline void EraseExtension(std::string& path_name)
661{
662 if (Erase::TailFromLast(path_name, '.'))
663 path_name.pop_back();
664}
665[[nodiscard]]
666inline std::string EraseExtension(std::string_view path_name)
667{
668 std::string ret = std::string{ path_name };
669 EraseExtension(ret);
670 return ret;
671}
672
679inline void ReplaceExtension(std::string& path_name, std::string_view fmt)
680{
681 if (Erase::TailFromLast(path_name, '.'))
682 {
683 path_name += fmt;
684 return;
685 }
686 path_name += ".";
687 path_name += std::string{ fmt };
688}
689[[nodiscard]]
690inline std::string ReplaceExtension(std::string_view path_name, std::string_view fmt)
691{
692 std::string ret = std::string{ path_name };
693 ReplaceExtension(ret, fmt);
694 return ret;
695}
696
701inline void EraseFilename(std::string& path_name)
702{
703 if (!Erase::TailFromLast(path_name, '/'))
704 log_err0("不是一个有效路径!");
705}
706[[nodiscard]]
707inline std::string EraseFilename(std::string_view path_name)
708{
709 std::string ret = std::string{ path_name };
710 EraseFilename(ret);
711 return ret;
712}
713
717inline std::string GetFileStem(std::string_view path_name)
718{
719 std::string name{ path_name };
720 Erase::HeadFromLast(name, '/');
721 if (Erase::TailFromLast(name, '.'))
722 name.pop_back();
723 return name;
724}
725
731
732inline bool IsRelativePath(std::string_view path_name)
733{
734 if (path_name.empty())
735 return true;
736
737 if (path_name[0] == '/')
738 return false;
739
740 size_t len = (std::min)(path_name.size(), (size_t)12);
741 for (size_t i = 0; i < len; ++i)
742 {
743 if (path_name[i] == ':')
744 return false;
745 }
746 return true;
747}
748
749
759bool GetPathAndRes(
760 std::string_view path_root, std::string_view path_name,
761 std::string& path_real, std::string& res_name,
762 std::string_view name = "");
763
764
770std::string GetResName(
771 std::string_view path_root,
772 std::string_view path_name);
773
774
781std::string CvtRelativePath(std::string path_cur, std::string_view path);
782
787inline void CvtPathSeparator(std::string& path)
788{
789 Every::Replace(path, '\\', '/');
790}
791[[nodiscard]]
792inline std::string CvtPathSeparator(std::string_view path)
793{
794 std::string ret{ path };
795 CvtPathSeparator(ret);
796 return ret;
797}
802inline void CvtPathSeparatorBack(std::string& path)
803{
804 Every::Replace(path, '/', '\\');
805}
806[[nodiscard]]
807inline std::string CvtPathSeparatorBack(std::string_view path)
808{
809 std::string ret{ path };
810 CvtPathSeparatorBack(ret);
811 return ret;
812}
817inline std::string CvtLineBreak(std::string_view str)
818{
819 std::string ret;
820 for (auto& iter : str)
821 {
822 if(iter == '\r')
823 continue;
824 ret.push_back(iter);
825 }
826 return ret;
827}
828
829
833inline bool HasNumber(std::string_view str)
834{
835 return Any::Yes(str, isdigit);
836}
837
841inline bool HasLetter(std::string_view str)
842{
843 return Any::Yes(str, isalpha);
844}
845
849std::vector<std::string> ParseCommand(std::string_view cmd);
850
855template<size_t W, size_t H>
856std::array<std::string, H> FormatString2(const Array2<std::string, W, H>& arr)
857{
858 //每一列得到一个最大宽度
859 std::array<size_t, W> mul_col{};
860 for (size_t j = 0; j < H; ++j)
861 {
862 for (size_t i = 0; i < W; ++i)
863 {
864 if (arr[j][i].size() > mul_col[i])
865 mul_col[i] = arr[j][i].size();
866 }
867 }
868 //合并每行
869 std::array<std::string, H> ret;
870 for (size_t i = 0; i < W; ++i)
871 {
872 std::string fmt = std::string("{:<") + std::to_string(mul_col[i] + 1) + "}";
873 for (size_t j = 0; j < H; ++j)
874 {
875 ret[j] += fmt::vformat(fmt, fmt::make_format_args(arr[j][i]));
876 }
877 }
878 return ret;
879}
880
885std::vector<std::string> FormatString2(const Vector2<std::string>& arr);
886
887
888
889//----------------------------其余范围操作封装----------------------------
890inline bool IsSub(std::string_view str, std::string_view str_sub)
891{
892 return Sub::IsSub(str, str_sub);
893}
894
895inline bool IsBegin(std::string_view str, std::string_view str_sub)
896{
897 return Sub::IsBegin(str, str_sub);
898}
899inline std::string_view Range(std::string_view str, char a, char b)
900{
901 return Sub::Range(str, a, b);
902}
903
904}
905
906}
907
908
909namespace dl
910{
911
912
913inline std::string to_string(const Vector2<std::string>& vec2)
914{
915 return String::Splicing(String::FormatString2(vec2), "\n");
916}
917
918
919//#if (DL_PLATFORM == DL_PLATFORM_WIN32)
921//* @brief array的format特化
922//* @note
923//*/
924//template<typename T, size_t N, typename CharT>
925//struct std::formatter<std::array<T, N>, CharT> : std::formatter<std::string, CharT>
926//{
927// template <typename FormatParseContext>
928// auto parse(FormatParseContext& pc)
929// {
930// return pc.end();
931// }
932//
933// template<typename FormatContext>
934// auto format(array<T, N> t, FormatContext& fc)
935// {
936// if constexpr (N == 2)
937// return std::formatter<std::string, CharT>::format(
938// std::format("{}, {}", t[0], t[1]), fc);
939// if constexpr (N == 3)
940// return std::formatter<std::string, CharT>::format(
941// std::format("{}, {}, {}", t[0], t[1], t[2]), fc);
942// if constexpr (N == 4)
943// return std::formatter<std::string, CharT>::format(
944// std::format("{}, {}, {}, {}", t[0], t[1], t[2], t[3]), fc);
945// }
946//};
947//#endif
948}
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)的所有元素,如果没有匹配到,则什么都不做。
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)
判断容器所有元素都 不等于某值
字符串操作
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)
以 元素 分割 容器
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)
以 元素 分割 容器
std::string operator+(const std::string &a, std::string_view b)
std::string to_string_auto(BufferView buf, bool add_tag=false)
buf转为字符串,若不为utf8则转为16进制
std::string & operator+=(std::string &a, std::string_view b)
std::string to_string_check(BufferView buf, bool tips=true)
buf转为utf8字符串(进行检查)
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::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