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
138
139
|
// Copyright (C) 2011 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#include <numeric>
#include <string.h>
#include <util/strutil.h>
using namespace std;
namespace isc {
namespace util {
namespace str {
// Normalize slashes
void
normalizeSlash(std::string& name) {
if (!name.empty()) {
size_t pos = 0;
while ((pos = name.find('\\', pos)) != std::string::npos) {
name[pos] = '/';
}
}
}
// Trim String
string
trim(const string& instring) {
string retstring = "";
if (!instring.empty()) {
static const char* blanks = " \t\n";
// Search for first non-blank character in the string
size_t first = instring.find_first_not_of(blanks);
if (first != string::npos) {
// String not all blanks, so look for last character
size_t last = instring.find_last_not_of(blanks);
// Extract the trimmed substring
retstring = instring.substr(first, (last - first + 1));
}
}
return (retstring);
}
// Tokenize string. As noted in the header, this is locally written to avoid
// another dependency on a Boost library.
vector<string>
tokens(const std::string& text, const std::string& delim) {
vector<string> result;
// Search for the first non-delimiter character
size_t start = text.find_first_not_of(delim);
while (start != string::npos) {
// Non-delimiter found, look for next delimiter
size_t end = text.find_first_of(delim, start);
if (end != string::npos) {
// Delimiter found, so extract string & search for start of next
// non-delimiter segment.
result.push_back(text.substr(start, (end - start)));
start = text.find_first_not_of(delim, end);
} else {
// End of string found, extract rest of string and flag to exit
result.push_back(text.substr(start));
start = string::npos;
}
}
return (result);
}
// Local function to pass to accumulate() for summing up string lengths.
namespace {
size_t
lengthSum(string::size_type curlen, const string& cur_string) {
return (curlen + cur_string.size());
}
}
// Provide printf-style formatting.
std::string
format(const std::string& format, const std::vector<std::string>& args) {
static const string flag = "%s";
// Initialize return string. To speed things up, we'll reserve an
// appropriate amount of space - current string size, plus length of all
// the argument strings, less two characters for each argument (the %s in
// the format string is being replaced).
string result;
size_t length = accumulate(args.begin(), args.end(), format.size(),
lengthSum) - (args.size() * flag.size());
result.reserve(length);
// Iterate through replacing all tokens
result = format;
size_t tokenpos = 0; // Position of last token replaced
std::vector<std::string>::size_type i = 0; // Index into argument array
while ((i < args.size()) && (tokenpos != string::npos)) {
tokenpos = result.find(flag, tokenpos);
if (tokenpos != string::npos) {
result.replace(tokenpos, flag.size(), args[i++]);
}
}
return (result);
}
std::string
getToken(std::istringstream& iss) {
string token;
iss >> token;
if (iss.bad() || iss.fail()) {
isc_throw(StringTokenError, "could not read token from string");
}
return (token);
}
} // namespace str
} // namespace util
} // namespace isc
|
