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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
#include "string.hpp"
#include <algorithm>
#include <ctype.h>
#include <iterator>
#include <stddef.h>

namespace pw {
    namespace string {
        bool starts_with(pn::StringView str, pn::StringView beginning) {
            if (str.size() < beginning.size() || beginning.empty()) {
                return false;
            }

            for (size_t i = 0; i < beginning.size(); ++i) {
                if (str[i] != beginning[i]) {
                    return false;
                }
            }
            return true;
        }

        bool ends_with(pn::StringView str, pn::StringView ending) {
            if (str.size() < ending.size() || ending.empty()) {
                return false;
            }

            size_t difference = str.size() - ending.size();
            for (size_t i = 0; i < ending.size(); ++i) {
                if (str[difference + i] != ending[i]) {
                    return false;
                }
            }
            return true;
        }

        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) {
            std::transform(str.begin(), str.end(), str.begin(), [](char c) -> char {
                return tolower((unsigned char) c);
            });
        }

        void to_upper(std::string& str) {
            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) {
            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