8000 Add kind() · Dadie/docopt.cpp@2b40eaa · GitHub
[go: up one dir, main page]
Skip to content

Commit 2b40eaa

Browse files
indianakernickjaredgrubb
indianakernick
authored and
jaredgrubb
committed
Add kind()
1 parent 11912fc commit 2b40eaa

File tree

1 file changed

+65
-64
lines changed

1 file changed

+65
-64
lines changed

‎docopt_value.h

Lines changed: 65 additions & 64 deletions
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,14 @@
1717

1818
namespace docopt {
1919

20+
enum class Kind {
21+
Empty,
22+
Bool,
23+
Long,
24+
String,
25+
StringList
26+
};
27+
2028
/// A generic type to hold the various types that can be produced by docopt.
2129
///
2230
/// This type can be one of: {bool, long, string, vector<string>}, or empty.
@@ -36,15 +44,17 @@ namespace docopt {
3644
value(value&&) noexcept;
3745
value& operator=(value const&);
3846
value& operator=(value&&) noexcept;
47+
48+
Kind kind() const { return mKind; }
3949

4050
// Test if this object has any contents at all
41-
explicit operator bool() const { return kind != Kind::Empty; }
51+
explicit operator bool() const { return mKind != Kind::Empty; }
4252

4353
// Test the type contained by this value object
44-
bool isBool() const { return kind==Kind::Bool; }
45-
bool isString() const { return kind==Kind::String; }
46-
bool isLong() const { return kind==Kind::Long; }
47-
bool isStringList() const { return kind==Kind::StringList; }
54+
bool isBool() const { return mKind==Kind::Bool; }
55+
bool isString() const { return mKind==Kind::String; }
56+
bool isLong() const { return mKind==Kind::Long; }
57+
bool isStringList() const { return mKind==Kind::StringList; }
4858

4959
// Throws std::invalid_argument if the type does not match
5060
bool asBool() const;
@@ -59,14 +69,6 @@ namespace docopt {
5969
friend bool operator!=(value const&, value const&);
6070

6171
private:
62-
enum class Kind {
63-
Empty,
64-
Bool,
65-
Long,
66-
String,
67-
StringList
68-
};
69-
7072
union Variant {
7173
Variant() {}
7274
~Variant() { /* do nothing; will be destroyed by ~value */ }
@@ -89,19 +91,18 @@ namespace docopt {
8991
}
9092

9193
void throwIfNotKind(Kind expected) const {
92-
if (kind == expected)
94+
if (mKind == expected)
9395
return;
9496

9597
std::string error = "Illegal cast to ";
9698
error += kindAsString(expected);
9799
error += "; type is actually ";
98-
error += kindAsString(kind);
100+
error += kindAsString(mKind);
99101
throw std::runtime_error(std::move(error));
100102
}
101103

102-
private:
103-
Kind kind = Kind::Empty;
104-
Variant variant {};
104+
Kind mKind = Kind::Empty;
105+
Variant mVariant {};
105106
};
106107

107108
/// Write out the contents to the ostream
@@ -120,51 +121,51 @@ namespace std {
120121
namespace docopt {
121122
inline
122123
value::value(bool v)
123-
: kind(Kind::Bool)
124+
: mKind(Kind::Bool)
124125
{
125-
variant.boolValue = v;
126+
mVariant.boolValue = v;
126127
}
127128

128129
inline
129130
value::value(long v)
130-
: kind(Kind::Long)
131+
: mKind(Kind::Long)
131132
{
132-
variant.longValue = v;
133+
mVariant.longValue = v;
133134
}
134135

135136
inline
136137
value::value(std::string v)
137-
: kind(Kind::String)
138+
: mKind(Kind::String)
138139
{
139-
new (&variant.strValue) std::string(std::move(v));
140+
new (&mVariant.strValue) std::string(std::move(v));
140141
}
141142

142143
inline
143144
value::value(std::vector<std::string> v)
144-
: kind(Kind::StringList)
145+
: mKind(Kind::StringList)
145146
{
146-
new (&variant.strList) std::vector<std::string>(std::move(v));
147+
new (&mVariant.strList) std::vector<std::string>(std::move(v));
147148
}
148149

149150
inline
150151
value::value(value const& other)
151-
: kind(other.kind)
152+
: mKind(other.mKind)
152153
{
153-
switch (kind) {
154+
switch (mKind) {
154155
case Kind::String:
155-
new (&variant.strValue) std::string(other.variant.strValue);
156+
new (&mVariant.strValue) std::string(other.mVariant.strValue);
156157
break;
157158

158159
case Kind::StringList:
159-
new (&variant.strList) std::vector<std::string>(other.variant.strList);
160+
new (&mVariant.strList) std::vector<std::string>(other.mVariant.strList);
160161
break;
161162

162163
case Kind::Bool:
163-
variant.boolValue = other.variant.boolValue;
164+
mVariant.boolValue = other.mVariant.boolValue;
164165
break;
165166

166167
case Kind::Long:
167-
variant.longValue = other.variant.longValue;
168+
mVariant.longValue = other.mVariant.longValue;
168169
break;
169170

170171
case Kind::Empty:
@@ -175,23 +176,23 @@ namespace docopt {
175176

176177
inline
177178
value::value(value&& other) noexcept
178-
: kind(other.kind)
179+
: mKind(other.mKind)
179180
{
180-
switch (kind) {
181+
switch (mKind) {
181182
case Kind::String:
182-
new (&variant.strValue) std::string(std::move(other.variant.strValue));
183+
new (&mVariant.strValue) std::string(std::move(other.mVariant.strValue));
183184
break;
184185

185186
case Kind::StringList:
186-
new (&variant.strList) std::vector<std::string>(std::move(other.variant.strList));
187+
new (&mVariant.strList) std::vector<std::string>(std::move(other.mVariant.strList));
187188
break;
188189

189190
case Kind::Bool:
190-
variant.boolValue = other.variant.boolValue;
191+
mVariant.boolValue = other.mVariant.boolValue;
191192
break;
192193

193194
case Kind::Long:
194-
variant.longValue = other.variant.longValue;
195+
mVariant.longValue = other.mVariant.longValue;
195196
break;
196197

197198
case Kind::Empty:
@@ -203,13 +204,13 @@ namespace docopt {
203204
inline
204205
value::~value()
205206
{
206-
switch (kind) {
207+
switch (mKind) {
207208
case Kind::String:
208-
variant.strValue.~basic_string();
209+
mVariant.strValue.~basic_string();
209210
break;
210211

211212
case Kind::StringList:
212-
variant.strList.~vector();
213+
mVariant.strList.~vector();
213214
break;
214215

215216
case Kind::Empty:
@@ -243,23 +244,23 @@ namespace docopt {
243244
inline
244245
size_t value::hash() const noexcept
245246
{
246-
switch (kind) {
247+
switch (mKind) {
247248
case Kind::String:
248-
return std::hash<std::string>()(variant.strValue);
249+
return std::hash<std::string>()(mVariant.strValue);
249250

250251
case Kind::StringList: {
251-
size_t seed = std::hash<size_t>()(variant.strList.size());
252-
for(auto const& str : variant.strList) {
252+
size_t seed = std::hash<size_t>()(mVariant.strList.size());
253+
for(auto const& str : mVariant.strList) {
253254
hash_combine(seed, str);
254255
}
255256
return seed;
256257
}
257258

258259
case Kind::Bool:
259-
return std::hash<bool>()(variant.boolValue);
260+
return std::hash<bool>()(mVariant.boolValue);
260261

261262
case Kind::Long:
262-
return std::hash<long>()(variant.longValue);
263+
return std::hash<long>()(mVariant.longValue);
263264

264265
case Kind::Empty:
265266
default:
@@ -271,15 +272,15 @@ namespace docopt {
271272
bool value::asBool() const
272273
{
273274
throwIfNotKind(Kind::Bool);
274-
return variant.boolValue;
275+
return mVariant.boolValue;
275276
}
276277

277278
inline
278279
long value::asLong() const
279280
{
280281
// Attempt to convert a string to a long
281-
if (kind == Kind::String) {
282-
const std::string& str = variant.strValue;
282+
if (mKind == Kind::String) {
283+
const std::string& str = mVariant.strValue;
283284
std::size_t pos;
284285
const long ret = stol(str, &pos); // Throws if it can't convert
285286
if (pos != str.length()) {
@@ -289,43 +290,43 @@ namespace docopt {
289290
return ret;
290291
}
291292
throwIfNotKind(Kind::Long);
292-
return variant.longValue;
293+
return mVariant.longValue;
293294
}
294295

295296
inline
296297
std::string const& value::asString() const
297298
{
298299
throwIfNotKind(Kind::String);
299-
return variant.strValue;
300+
return mVariant.strValue;
300301
}
301302

302303
inline
303304
std::vector<std::string> const& value::asStringList() const
304305
{
305306
throwIfNotKind(Kind::StringList);
306-
return variant.strList;
307+
return mVariant.strList;
307308
}
308309

309310
inline
310311
bool operator==(value const& v1, value const& v2)
311312
{
312-
if (v1.kind != v2.kind)
313+
if (v1.mKind != v2.mKind)
313314
return false;
314315

315-
switch (v1.kind) {
316-
case value::Kind::String:
317-
return v1.variant.strValue==v2.variant.strValue;
316+
switch (v1.mKind) {
317+
case Kind::String:
318+
return v1.mVariant.strValue==v2.mVariant.strValue;
318319

319-
case value::Kind::StringList:
320-
return v1.variant.strList==v2.variant.strList;
320+
case Kind::StringList:
321+
return v1.mVariant.strList==v2.mVariant.strList;
321322

322-
case value::Kind::Bool:
323-
return v1.variant.boolValue==v2.variant.boolValue;
323+
case Kind::Bool:
324+
return v1.mVariant.boolValue==v2.mVariant.boolValue;
324325

325-
case value::Kind::Long:
326-
return v1.variant.longValue==v2.variant.longValue;
326+
case Kind::Long:
327+
return v1.mVariant.longValue==v2.mVariant.longValue;
327328

328-
case value::Kind::Empty:
329+
case Kind::Empty:
329330
default:
330331
return true;
331332
}

0 commit comments

Comments
 (0)
0