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
140
141
142
143
144
145
146
|
// file : butl/utility -*- C++ -*-
// copyright : Copyright (c) 2014-2016 Code Synthesis Ltd
// license : MIT; see accompanying LICENSE file
#ifndef BUTL_UTILITY
#define BUTL_UTILITY
#include <string>
#include <cstddef> // size_t
#include <utility> // forward()
#include <cstring> // strcmp(), strlen()
namespace butl
{
// Convert ASCII character/string case. If there is no upper/lower case
// counterpart, leave the character unchanged. The POSIX locale (also known
// as C locale) must be the current application locale. Otherwise the
// behavior is undefined.
//
// Note that the POSIX locale specifies behaviour on data consisting
// entirely of characters from the portable character set (subset of ASCII
// including 103 non-negative characters and English alphabet letters in
// particular) and the control character set (more about them at
// http://pubs.opengroup.org/onlinepubs/009696899/basedefs/xbd_chap06.html).
//
// Also note that according to the POSIX locale definition the case
// conversion can be applied only to [A-Z] and [a-z] character ranges being
// translated to each other (more about that at
// http://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap07.html#tag_07_02)
//
char ucase (char);
std::string ucase (const char*, std::size_t = std::string::npos);
std::string ucase (const std::string&);
std::string& ucase (std::string&);
void ucase (char*, std::size_t);
char lcase (char);
std::string lcase (const char*, std::size_t = std::string::npos);
std::string lcase (const std::string&);
std::string& lcase (std::string&);
void lcase (char*, std::size_t);
// Compare ASCII characters/strings ignoring case. Behave as if characters
// had been converted to the lower case and then byte-compared. Return a
// negative, zero or positive value if the left hand side is less, equal or
// greater than the right hand side, respectivelly. The POSIX locale (also
// known as C locale) must be the current application locale. Otherwise the
// behavior is undefined.
//
// The optional size argument specifies the maximum number of characters
// to compare.
//
int casecmp (char, char);
int casecmp (const std::string&, const std::string&,
std::size_t = std::string::npos);
int casecmp (const std::string&, const char*,
std::size_t = std::string::npos);
int casecmp (const char*, const char*, std::size_t = std::string::npos);
// Case-insensitive key comparators (i.e., to be used in sets, maps, etc).
//
struct case_compare_string
{
bool operator() (const std::string& x, const std::string& y) const
{
return casecmp (x, y) < 0;
}
};
struct case_compare_c_string
{
bool operator() (const char* x, const char* y) const
{
return casecmp (x, y) < 0;
}
};
bool
alpha (char);
bool
digit (char);
bool
alnum (char);
// Key comparators (i.e., to be used in sets, maps, etc).
//
struct compare_c_string
{
bool operator() (const char* x, const char* y) const
{
return std::strcmp (x, y) < 0;
}
};
struct compare_pointer_target
{
template <typename P>
bool operator() (const P& x, const P& y) const {return *x < *y;}
};
// Combine one or more hash values.
//
inline std::size_t
combine_hash (std::size_t s, std::size_t h)
{
// Magic formula from boost::hash_combine().
//
return s ^ (h + 0x9e3779b9 + (s << 6) + (s >> 2));
}
template <typename... S>
inline std::size_t
combine_hash (std::size_t s, std::size_t h, S... hs)
{
return combine_hash (combine_hash (s, h), hs...);
}
// Support for reverse iteration using range-based for-loop:
//
// for (... : reverse_iterate (x)) ...
//
template <typename T>
class reverse_range
{
T x_;
public:
reverse_range (T&& x): x_ (std::forward<T> (x)) {}
auto begin () const -> decltype (this->x_.rbegin ()) {return x_.rbegin ();}
auto end () const -> decltype (this->x_.rend ()) {return x_.rend ();}
};
template <typename T>
inline reverse_range<T>
reverse_iterate (T&& x) {return reverse_range<T> (std::forward<T> (x));}
}
#include <butl/utility.ixx>
#endif // BUTL_UTILITY
|
