1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9// UNSUPPORTED: c++03, c++11, c++14, c++17
10
11// template<class T>
12// concept regular = see below;
13
14#include <concepts>
15
16#include <deque>
17#include <forward_list>
18#include <list>
19#include <map>
20#include <memory>
21#include <optional>
22#include <stdexcept>
23#include <tuple>
24#include <unordered_map>
25#include <vector>
26
27#include "type_classification/moveconstructible.h"
28#include "type_classification/semiregular.h"
29
30static_assert(std::regular<int>);
31static_assert(std::regular<float>);
32static_assert(std::regular<double>);
33static_assert(std::regular<long double>);
34static_assert(std::regular<int volatile>);
35static_assert(std::regular<void*>);
36static_assert(std::regular<int*>);
37static_assert(std::regular<int const*>);
38static_assert(std::regular<int volatile*>);
39static_assert(std::regular<int volatile const*>);
40static_assert(std::regular<int (*)()>);
41
42struct S {};
43static_assert(!std::regular<S>);
44static_assert(std::regular<int S::*>);
45static_assert(std::regular<int (S::*)()>);
46static_assert(std::regular<int (S::*)() noexcept>);
47static_assert(std::regular<int (S::*)() &>);
48static_assert(std::regular<int (S::*)() & noexcept>);
49static_assert(std::regular<int (S::*)() &&>);
50static_assert(std::regular<int (S::*)() && noexcept>);
51static_assert(std::regular<int (S::*)() const>);
52static_assert(std::regular<int (S::*)() const noexcept>);
53static_assert(std::regular<int (S::*)() const&>);
54static_assert(std::regular<int (S::*)() const & noexcept>);
55static_assert(std::regular<int (S::*)() const&&>);
56static_assert(std::regular<int (S::*)() const && noexcept>);
57static_assert(std::regular<int (S::*)() volatile>);
58static_assert(std::regular<int (S::*)() volatile noexcept>);
59static_assert(std::regular<int (S::*)() volatile&>);
60static_assert(std::regular<int (S::*)() volatile & noexcept>);
61static_assert(std::regular<int (S::*)() volatile&&>);
62static_assert(std::regular<int (S::*)() volatile && noexcept>);
63static_assert(std::regular<int (S::*)() const volatile>);
64static_assert(std::regular<int (S::*)() const volatile noexcept>);
65static_assert(std::regular<int (S::*)() const volatile&>);
66static_assert(std::regular<int (S::*)() const volatile & noexcept>);
67static_assert(std::regular<int (S::*)() const volatile&&>);
68static_assert(std::regular<int (S::*)() const volatile && noexcept>);
69
70union U {};
71static_assert(!std::regular<U>);
72static_assert(std::regular<int U::*>);
73static_assert(std::regular<int (U::*)()>);
74static_assert(std::regular<int (U::*)() noexcept>);
75static_assert(std::regular<int (U::*)() &>);
76static_assert(std::regular<int (U::*)() & noexcept>);
77static_assert(std::regular<int (U::*)() &&>);
78static_assert(std::regular<int (U::*)() && noexcept>);
79static_assert(std::regular<int (U::*)() const>);
80static_assert(std::regular<int (U::*)() const noexcept>);
81static_assert(std::regular<int (U::*)() const&>);
82static_assert(std::regular<int (U::*)() const & noexcept>);
83static_assert(std::regular<int (U::*)() const&&>);
84static_assert(std::regular<int (U::*)() const && noexcept>);
85static_assert(std::regular<int (U::*)() volatile>);
86static_assert(std::regular<int (U::*)() volatile noexcept>);
87static_assert(std::regular<int (U::*)() volatile&>);
88static_assert(std::regular<int (U::*)() volatile & noexcept>);
89static_assert(std::regular<int (U::*)() volatile&&>);
90static_assert(std::regular<int (U::*)() volatile && noexcept>);
91static_assert(std::regular<int (U::*)() const volatile>);
92static_assert(std::regular<int (U::*)() const volatile noexcept>);
93static_assert(std::regular<int (U::*)() const volatile&>);
94static_assert(std::regular<int (U::*)() const volatile & noexcept>);
95static_assert(std::regular<int (U::*)() const volatile&&>);
96static_assert(std::regular<int (U::*)() const volatile && noexcept>);
97
98static_assert(std::regular<std::vector<int> >);
99static_assert(std::regular<std::deque<int> >);
100static_assert(std::regular<std::forward_list<int> >);
101static_assert(std::regular<std::list<int> >);
102static_assert(std::regular<std::shared_ptr<std::unique_ptr<int> > >);
103static_assert(std::regular<std::optional<std::vector<int> > >);
104static_assert(std::regular<std::vector<int> >);
105static_assert(std::regular<std::vector<std::unique_ptr<int> > >);
106static_assert(std::semiregular<std::in_place_t> &&
107 !std::regular<std::in_place_t>);
108
109static_assert(!std::regular<has_volatile_member>);
110static_assert(!std::regular<has_array_member>);
111
112// Not objects
113static_assert(!std::regular<void>);
114static_assert(!std::regular<int&>);
115static_assert(!std::regular<int const&>);
116static_assert(!std::regular<int volatile&>);
117static_assert(!std::regular<int const volatile&>);
118static_assert(!std::regular<int&&>);
119static_assert(!std::regular<int const&&>);
120static_assert(!std::regular<int volatile&&>);
121static_assert(!std::regular<int const volatile&&>);
122static_assert(!std::regular<int()>);
123static_assert(!std::regular<int (&)()>);
124static_assert(!std::regular<int[5]>);
125
126// not copyable
127static_assert(!std::regular<std::unique_ptr<int> >);
128static_assert(!std::regular<int const>);
129static_assert(!std::regular<int const volatile>);
130static_assert(!std::regular<volatile_copy_assignment volatile>);
131static_assert(!std::regular<no_copy_constructor>);
132static_assert(!std::regular<no_copy_assignment>);
133static_assert(!std::regular<no_copy_assignment_mutable>);
134static_assert(!std::regular<derived_from_noncopyable>);
135static_assert(!std::regular<has_noncopyable>);
136static_assert(!std::regular<has_const_member>);
137static_assert(!std::regular<has_cv_member>);
138static_assert(!std::regular<has_lvalue_reference_member>);
139static_assert(!std::regular<has_rvalue_reference_member>);
140static_assert(!std::regular<has_function_ref_member>);
141static_assert(!std::regular<deleted_assignment_from_const_rvalue>);
142
143// not default_initializable
144static_assert(!std::regular<std::runtime_error>);
145static_assert(
146 !std::regular<std::tuple<std::runtime_error, std::overflow_error> >);
147static_assert(!std::regular<std::nullopt_t>);
148static_assert(!std::regular<no_copy_constructor>);
149static_assert(!std::regular<no_copy_assignment>);
150static_assert(std::is_copy_assignable_v<no_copy_assignment_mutable> &&
151 !std::regular<no_copy_assignment_mutable>);
152static_assert(!std::regular<derived_from_noncopyable>);
153static_assert(!std::regular<has_noncopyable>);
154
155static_assert(!std::regular<derived_from_non_default_initializable>);
156static_assert(!std::regular<has_non_default_initializable>);
157
158// not equality_comparable
159static_assert(!std::regular<const_copy_assignment const>);
160static_assert(!std::regular<cv_copy_assignment const volatile>);
161
162struct is_equality_comparable {
163 bool operator==(is_equality_comparable const&) const = default;
164};
165static_assert(std::regular<is_equality_comparable>);
166

source code of libcxx/test/std/concepts/concepts.object/regular.compile.pass.cpp