StringType/StringType.cpp at master · glutolik/StringType · 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
#include "StringType.h"

bool like( const StringType& str, const StringType& pattern, char escape, bool ignorecase){
    size_t n = pattern.get_size();
    size_t m = str.get_size();
    std::string m_str = str.get_str();
    std::string m_pattern = pattern.get_str();

    if(ignorecase){
        std::transform(m_str.begin(), m_str.end(), m_str.begin(), tolower);
        std::transform(m_pattern.begin(), m_pattern.end(), m_pattern.begin(), tolower);
    }
    return str_like(m_str, m_pattern);
}

bool str_like(const std::string& m_str, const std::string& m_pattern){
    size_t i = 0;
    if(m_pattern.length() == 0 && m_str.length() != 0){
        return 0;
    }
    else if(m_pattern.length() == 0 && m_str.length() == 0){
        return 1;
    }
    else if(m_pattern[0] == '%'){
        if(m_str.length() != 0){
            for(i = 0; i <=
             m_str.length(); ++i){
                if(str_like(m_str.substr(i, m_str.length() - i), m_pattern.substr(1, m_pattern.length() - 1)) == 1){
                    return 1;
                }
            }
            return 0;
        }
        else{
            return str_like(m_str, m_pattern.substr(1, m_pattern.length() - 1));
        }
    }
    else if(m_pattern[0] == '_'){
        if(m_str.length() == 0)
            return 0;
        else
            return str_like(m_str.substr(1, m_str.length() - 1), m_pattern.substr(1, m_pattern.length() - 1));
    }
    else if(m_pattern[0] == m_str[0]){
        return str_like(m_str.substr(1, m_str.length() - 1), m_pattern.substr(1, m_pattern.length() - 1));
    }
    else
        return 0;
}

bool stack_like( const StringType& str, const StringType& pattern, char escape, bool ignorecase){
    size_t n = pattern.get_size();
    size_t m = str.get_size();
    std::string m_str = str.get_str();
    std::string m_pattern = pattern.get_str();

    if(ignorecase){
        std::transform(m_str.begin(), m_str.end(), m_str.begin(), tolower);
        std::transform(m_pattern.begin(), m_pattern.end(), m_pattern.begin(), tolower);
    }
    return stack_str_like(m_str, m_pattern);
}

bool stack_str_like(const std::string& m_str, const std::string& m_pattern){
    size_t i = 0;
    std::stack<std::pair<std::string, std::string>>  pattern_stack;
    std::string st_str, st_pattern;
    pattern_stack.push(std::make_pair(m_str, m_pattern));

    while(!pattern_stack.empty()){
        st_str = pattern_stack.top().first;
        st_pattern = pattern_stack.top().second;
        pattern_stack.pop();

        if(st_pattern.length() == 0 && st_str.length() == 0){
            return 1;
        }
        else if(st_pattern[0] == '%' && st_pattern.length() != 0){
            if(st_str.length() != 0){
                for(i = 0; i <= st_str.length(); ++i){
                    pattern_stack.push(std::make_pair(st_str.substr(i, st_str.length() - i), st_pattern.substr(1, st_pattern.length() - 1)));
                }
            }
            else{
                pattern_stack.push(std::make_pair(st_str, st_pattern.substr(1, st_pattern.length() - 1)));
            }
        }
        else if(st_pattern[0] == '_'){
            if(st_str.length() != 0)
                pattern_stack.push(std::make_pair(st_str.substr(1, st_str.length() - 1), st_pattern.substr(1, st_pattern.length() - 1)));
        }
        else if(st_pattern[0] == st_str[0]){
            pattern_stack.push(std::make_pair(st_str.substr(1, st_str.length() - 1), st_pattern.substr(1, st_pattern.length() - 1)));
        }
    }
    return 0;
}

bool Like::match(const StringType& str) const{
    return like(str, pattern);
}