Polyweb/string.cpp at main · BlueCannonBall/Polyweb · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
#include "string.hpp"
#include <algorithm>
#include <ctype.h>
#include <iterator>
#include <stddef.h>

namespace pw {
    namespace string {
        void trim_right(std::string& str) {
            str.erase(
                std::find_if_not(str.rbegin(), str.rend(), [](char c) -> bool {
                    return isspace((unsigned char) c);
                }).base(),
                str.end());
        }

        void trim_left(std::string& str) {
            str.erase(
                str.begin(),
                std::find_if_not(str.begin(), str.end(), [](char c) -> bool {
                    return isspace((unsigned char) c);
                }));
        }

        void trim(std::string& str) {
            trim_right(str);
            trim_left(str);
        }

        std::string trim_right_copy(std::string str) {
            trim_right(str);
            return str;
        }

        std::string trim_left_copy(std::string str) {
            trim_left(str);
            return str;
        }

        std::string trim_copy(std::string str) {
            trim(str);
            return str;
        }

        void to_lower(std::string& str) noexcept {
            std::transform(str.begin(), str.end(), str.begin(), [](char c) -> char {
                return tolower((unsigned char) c);
            });
        }

        void to_upper(std::string& str) noexcept {
            std::transform(str.begin(), str.end(), str.begin(), [](char c) -> char {
                return toupper((unsigned char) c);
            });
        }

        std::string to_lower_copy(pn::StringView str) {
            std::string ret;
            ret.reserve(str.size());
            std::transform(str.begin(), str.end(), std::back_inserter(ret), [](char c) -> char {
                return tolower((unsigned char) c);
            });
            return ret;
        }

        std::string to_upper_copy(pn::StringView str) {
            std::string ret;
            ret.reserve(str.size());
            std::transform(str.begin(), str.end(), std::back_inserter(ret), [](char c) -> char {
                return toupper((unsigned char) c);
            });
            return ret;
        }

        bool iequals(pn::StringView a, pn::StringView b) noexcept {
            if (a.size() != b.size()) {
                return false;
            }

            for (size_t i = 0; i < a.size(); ++i) {
                if (tolower((unsigned char) a[i]) != tolower((unsigned char) b[i])) {
                    return false;
                }
            }
            return true;
        }

        std::vector<std::string> split(pn::StringView str, char delimiter) {
            std::vector<std::string> ret;
            for (size_t i = 0; i < str.size();) {
                size_t j;
                if ((j = str.find(delimiter, i)) != i) {
                    ret.push_back(str.substr(i, j - i));
                }

                if (j == std::string::npos) {
                    break;
                }
                i = j + 1;
            }
            return ret;
        }

        std::vector<std::string> split_and_trim(pn::StringView str, char delimiter) {
            std::vector<std::string> ret = split(str, delimiter);
            std::for_each(ret.begin(), ret.end(), trim);
            return ret;
        }
    } // namespace string
} // namespace pw