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
|
/*
* This source code is released into the public domain.
*/
module;
#include <cstdlib>
#include <string>
#include <ucl.h>
module nihil.ucl;
namespace nihil::ucl {
string::string(ref_t, ::ucl_object_t const *uobj)
: object(nihil::ucl::ref, uobj)
{
if (type() != ucl_type)
throw type_mismatch(ucl_type, type());
}
string::string(noref_t, ::ucl_object_t *uobj)
: object(noref, uobj)
{
if (type() != ucl_type)
throw type_mismatch(ucl_type, type());
}
string::string()
: string(std::string_view(""))
{}
string::string(std::string_view value)
: object(nihil::ucl::ref,
::ucl_object_fromstring_common(
value.data(), value.size(),
UCL_STRING_RAW))
{
if (_object == nullptr)
throw error("failed to create UCL object");
}
auto string::value(this string const &self) -> contained_type
{
char const *dptr{};
std::size_t dlen;
auto const *uobj = self.get_ucl_object();
if (::ucl_object_tolstring_safe(uobj, &dptr, &dlen))
return {dptr, dlen};
// This should never fail.
std::abort();
}
auto string::size(this string const &self) -> size_type
{
return self.value().size();
}
auto string::empty(this string const &self) -> bool
{
return self.size() == 0;
}
auto string::data(this string const &self) -> pointer
{
char const *dptr{};
auto const *uobj = self.get_ucl_object();
if (::ucl_object_tostring_safe(uobj, &dptr))
return dptr;
// This should never fail.
std::abort();
}
auto string::begin(this string const &self) -> iterator
{
return self.data();
}
auto string::end(this string const &self) -> iterator
{
return self.data() + self.size();
}
auto operator== (string const &a, string const &b)
-> bool
{
return a.value() == b.value();
}
auto operator<=> (string const &a, string const &b)
-> std::strong_ordering
{
return a.value() <=> b.value();
}
/*
* For convenience, allow comparison with C++ strings without having to
* construct a temporary UCL object.
*/
auto operator==(string const &lhs, std::string_view rhs) -> bool
{
return lhs.value() == rhs;
}
auto operator<=>(string const &lhs, std::string_view rhs)
-> std::strong_ordering
{
return lhs.value() <=> rhs;
}
auto operator==(string const &lhs, std::string const &rhs) -> bool
{
return lhs == std::string_view(rhs);
}
auto operator<=>(string const &lhs, std::string const &rhs)
-> std::strong_ordering
{
return lhs <=> std::string_view(rhs);
}
auto operator==(string const &lhs, char const *rhs) -> bool
{
return lhs == std::string_view(rhs);
}
auto operator<=>(string const &lhs, char const *rhs)
-> std::strong_ordering
{
return lhs <=> std::string_view(rhs);
}
} // namespace nihil::ucl
|
