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
|
/*
* Basic implementation of string_view
*
* (C) 2015 Julian Andres Klode <jak@debian.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
#if !defined(APT_STRINGVIEW_H)
#define APT_STRINGVIEW_H
#include <apt-pkg/macros.h>
#include <string>
#include <string.h>
namespace APT {
/**
* \brief Simple subset of std::string_view from C++17
*
* This is an internal implementation of the subset of std::string_view
* used by APT. It is not meant to be used in programs, only inside the
* library for performance critical paths.
*/
class StringView {
const char *data_;
size_t size_;
public:
static constexpr size_t npos = static_cast<size_t>(-1);
static_assert(APT::StringView::npos == std::string::npos, "npos values are different");
/* Constructors */
constexpr StringView() : data_(""), size_(0) {}
constexpr StringView(const char *data, size_t size) : data_(data), size_(size) {}
StringView(const char *data) : data_(data), size_(strlen(data)) {}
StringView(std::string const & str): data_(str.data()), size_(str.size()) {}
/* Viewers */
constexpr StringView substr(size_t pos, size_t n = npos) const {
return StringView(data_ + pos, n > (size_ - pos) ? (size_ - pos) : n);
}
size_t find(int c, size_t pos) const {
if (pos == 0)
return find(c);
size_t const found = substr(pos).find(c);
if (found == npos)
return npos;
return pos + found;
}
size_t find(int c) const {
const char *found = static_cast<const char*>(memchr(data_, c, size_));
if (found == NULL)
return npos;
return found - data_;
}
size_t rfind(int c, size_t pos) const {
if (pos == npos)
return rfind(c);
return APT::StringView(data_, pos).rfind(c);
}
size_t rfind(int c) const {
const char *found = static_cast<const char*>(memrchr(data_, c, size_));
if (found == NULL)
return npos;
return found - data_;
}
/* Conversions */
std::string to_string() const {
return std::string(data_, size_);
}
/* Comparisons */
int compare(size_t pos, size_t n, StringView other) const {
return substr(pos, n).compare(other);
}
int compare(StringView other) const {
int res;
res = memcmp(data_, other.data_, std::min(size_, other.size_));
if (res != 0)
return res;
if (size_ == other.size_)
return res;
return (size_ > other.size_) ? 1 : -1;
}
/* Optimization: If size not equal, string cannot be equal */
bool operator ==(StringView other) const { return size_ == other.size_ && compare(other) == 0; }
bool operator !=(StringView other) const { return !(*this == other); }
/* Accessors */
constexpr bool empty() const { return size_ == 0; }
constexpr const char* data() const { return data_; }
constexpr const char* begin() const { return data_; }
constexpr const char* end() const { return data_ + size_; }
constexpr char operator [](size_t i) const { return data_[i]; }
constexpr size_t size() const { return size_; }
constexpr size_t length() const { return size_; }
};
/**
* \brief Faster comparison for string views (compare size before data)
*
* Still stable, but faster than the normal ordering. */
static inline int StringViewCompareFast(StringView a, StringView b) {
if (a.size() != b.size())
return a.size() - b.size();
return memcmp(a.data(), b.data(), a.size());
}
}
inline bool operator ==(const char *other, APT::StringView that);
inline bool operator ==(const char *other, APT::StringView that) { return that.operator==(other); }
#endif
|
