Skip to content

Commit aa6840e

Browse files
p12ticp12tic
committed
Headers: Implement <variant>
1 parent 8550dad commit aa6840e

File tree

3 files changed

+247
-0
lines changed

3 files changed

+247
-0
lines changed

‎headers/detail/cppreference_unspecified‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -23,9 +23,11 @@ namespace std {
2323
#if CPPREFERENCE_STDVER >= 2011
2424
using CPPREFERENCE_UNSPECIFIED_TYPE = int;
2525
constexpr int CPPREFERENCE_UNSPECIFIED_TYPE_VALUE = 0;
26+
using CPPREFERENCE_SIMPLIFIED_TYPE = int;
2627
#else
2728
typedef int CPPREFERENCE_UNSPECIFIED_TYPE;
2829
static const int CPPREFERENCE_UNSPECIFIED_TYPE_VALUE = 0;
30+
typedef int CPPREFERENCE_SIMPLIFIED_TYPE;
2931
#endif
3032

3133
} // namespace std

‎headers/utility‎

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -93,6 +93,23 @@ struct piecewise_construct_t { };
9393
constexpr piecewise_construct_t piecewise_construct;
9494
#endif
9595

96+
#if CPPREFERENCE_STDVER >= 2017
97+
struct in_place_t {};
98+
inline constexpr in_place_t in_place;
99+
100+
template<class T>
101+
struct in_place_type_t{};
102+
103+
template<class T>
104+
inline constexpr in_place_type_t<T> in_place_type;
105+
106+
template<size_t I>
107+
struct in_place_index_t;
108+
109+
template<size_t I>
110+
inline constexpr in_place_index_t<I> in_place_index;
111+
#endif
112+
96113
template<class ... Args> class tuple;
97114

98115
template <

‎headers/variant‎

Lines changed: 228 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,228 @@
1+
/* Copyright (C) 2019 Povilas Kanapickas <povilas@radix.lt>
2+
3+
This file is part of cppreference-doc
4+
5+
This work is licensed under the Creative Commons Attribution-ShareAlike 3.0
6+
Unported License. To view a copy of this license, visit
7+
http://creativecommons.org/licenses/by-sa/3.0/ or send a letter to Creative
8+
Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
9+
10+
Permission is granted to copy, distribute and/or modify this document
11+
under the terms of the GNU Free Documentation License, Version 1.3 or
12+
any later version published by the Free Software Foundation; with no
13+
Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
14+
*/
15+
16+
#ifndef CPPREFERENCE_VARIANT_H
17+
#define CPPREFERENCE_VARIANT_H
18+
19+
#if CPPREFERENCE_STDVER >= 2017
20+
21+
#include <exception> // exception
22+
#include <functional> // hash
23+
#include <utility> // in_place_type_t, ...
24+
#include <type_traits>
25+
#include <detail/cppreference_unspecified>
26+
27+
namespace std {
28+
29+
inline constexpr std::size_t variant_npos = static_cast<size_t>(-1);
30+
31+
struct monostate {};
32+
33+
class bad_variant_access : public exception {
34+
public:
35+
bad_variant_access();
36+
~bad_variant_access() override;
37+
const char * what() const override;
38+
};
39+
40+
template<class... Types>
41+
class variant; // forward declaration
42+
43+
template<size_t I, class T>
44+
struct variant_alternative; // undefined
45+
46+
template<size_t I, class... Types>
47+
struct variant_alternative<I, variant<Types...>> {
48+
using type = CPPREFERENCE_SIMPLIFIED_TYPE;
49+
};
50+
51+
template<size_t I, class... Types>
52+
struct variant_alternative<I, const variant<Types...>> {
53+
using type = CPPREFERENCE_SIMPLIFIED_TYPE;
54+
};
55+
56+
template<size_t I, class... Types>
57+
struct variant_alternative<I, volatile variant<Types...>> {
58+
using type = CPPREFERENCE_SIMPLIFIED_TYPE;
59+
};
60+
61+
template<size_t I, class... Types>
62+
struct variant_alternative<I, const volatile variant<Types...>> {
63+
using type = CPPREFERENCE_SIMPLIFIED_TYPE;
64+
};
65+
66+
template <size_t I, class T>
67+
using variant_alternative_t = typename variant_alternative<I, T>::type;
68+
69+
70+
template<class... Types>
71+
class variant {
72+
public:
73+
constexpr variant();
74+
75+
constexpr variant(const variant& other);
76+
77+
constexpr variant(variant&& other);
78+
79+
template<class T>
80+
constexpr variant(T&& t);
81+
82+
template<class T, class... Args>
83+
constexpr explicit variant(in_place_type_t<T>, Args&&... args);
84+
85+
template<class T, class U, class... Args>
86+
87+
constexpr explicit variant(in_place_type_t<T>,
88+
initializer_list<U> il, Args&&... args);
89+
90+
template<size_t I, class... Args>
91+
constexpr explicit variant(in_place_index_t<I>, Args&&... args);
92+
93+
template<size_t I, class U, class... Args>
94+
constexpr explicit variant(in_place_index_t<I>,
95+
initializer_list<U> il, Args&&... args);
96+
97+
~variant();
98+
99+
constexpr variant& operator=(const variant& rhs);
100+
101+
constexpr variant& operator=(variant&& rhs);
102+
103+
template<class T>
104+
variant& operator=(T&& t);
105+
106+
constexpr size_t index() const;
107+
108+
constexpr bool valueless_by_exception() const;
109+
110+
template <class T, class... Args>
111+
T& emplace(Args&&... args);
112+
113+
template <class T, class U, class... Args>
114+
T& emplace(initializer_list<U> il, Args&&... args);
115+
116+
template <size_t I, class... Args>
117+
variant_alternative_t<I, variant>& emplace(Args&&... args);
118+
119+
template <size_t I, class U, class... Args>
120+
variant_alternative_t<I, variant>&
121+
emplace(initializer_list<U> il, Args&&... args);
122+
123+
void swap(variant& rhs);
124+
};
125+
126+
template<class... Types>
127+
constexpr bool operator==(const variant<Types...>& v, const variant<Types...>& w);
128+
129+
template<class... Types>
130+
constexpr bool operator!=(const variant<Types...>& v, const variant<Types...>& w);
131+
132+
template<class... Types>
133+
constexpr bool operator<(const variant<Types...>& v, const variant<Types...>& w);
134+
135+
template<class... Types>
136+
constexpr bool operator>(const variant<Types...>& v, const variant<Types...>& w);
137+
138+
template<class... Types>
139+
constexpr bool operator<=(const variant<Types...>& v, const variant<Types...>& w);
140+
141+
template<class... Types>
142+
constexpr bool operator>=(const variant<Types...>& v, const variant<Types...>& w);
143+
144+
template <class... Types>
145+
void swap(variant<Types...>& lhs, variant<Types...>& rhs);
146+
147+
template<class Visitor, class... Variants>
148+
constexpr CPPREFERENCE_SIMPLIFIED_TYPE visit(Visitor&& vis, Variants&&... vars);
149+
150+
template <class R, class Visitor, class... Variants>
151+
constexpr R visit(Visitor&&, Variants&&...);
152+
153+
template <class T, class... Types>
154+
constexpr bool holds_alternative(const variant<Types...>& v);
155+
156+
template<size_t I, class... Types>
157+
constexpr variant_alternative_t<I, variant<Types...>>&
158+
get(variant<Types...>& v);
159+
160+
template<size_t I, class... Types>
161+
constexpr variant_alternative_t<I, variant<Types...>>&&
162+
get(variant<Types...>&& v);
163+
164+
template<size_t I, class... Types>
165+
constexpr const variant_alternative_t<I, variant<Types...>>&
166+
get(const variant<Types...>& v);
167+
168+
template<size_t I, class... Types>
169+
constexpr const variant_alternative_t<I, variant<Types...>>&
170+
get(const variant<Types...>&& v);
171+
172+
template<class T, class... Types>
173+
constexpr T& get(variant<Types...>& v);
174+
175+
template<class T, class... Types>
176+
constexpr T&& get(variant<Types...>&& v);
177+
178+
template<class T, class... Types>
179+
constexpr const T& get(const variant<Types...>& v);
180+
181+
template<class T, class... Types>
182+
constexpr const T&& get(const variant<Types...>&& v);
183+
184+
template <size_t I, class... Types>
185+
186+
constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>>
187+
get_if(variant<Types...>* pv);
188+
189+
template <size_t I, class... Types>
190+
constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
191+
get_if(const variant<Types...>* pv);
192+
193+
template <class T, class... Types>
194+
constexpr add_pointer_t<T> get_if(variant<Types...>* pv);
195+
template <class T, class... Types>
196+
constexpr add_pointer_t<const T> get_if(const variant<Types...>* pv);
197+
198+
template<class T>
199+
struct variant_size; // undefined
200+
201+
template<class... Types>
202+
struct variant_size<variant<Types...>> :
203+
integral_constant<size_t, sizeof...(Types)> {
204+
};
205+
206+
template<class... Types>
207+
struct variant_size<const variant<Types...>> :
208+
integral_constant<size_t, sizeof...(Types)> {
209+
};
210+
211+
template<class... Types>
212+
struct variant_size<volatile variant<Types...>> :
213+
integral_constant<size_t, sizeof...(Types)> {
214+
};
215+
216+
template<class... Types>
217+
struct variant_size<const volatile variant<Types...>> :
218+
integral_constant<size_t, sizeof...(Types)> {
219+
};
220+
221+
222+
template <class... Types>
223+
struct hash<variant<Types...>> {};
224+
225+
} // namespace std
226+
227+
#endif // CPPREFERENCE_STDVER >= 2017
228+
#endif // CPPREFERENCE_VARIANT_H

0 commit comments

Comments
 (0)