Initial PSTL commit
[lldb.git] / pstl / include / pstl / internal / execution_defs.h
1 // -*- C++ -*-
2 //===-- execution_defs.h --------------------------------------------------===//
3 //
4 //                     The LLVM Compiler Infrastructure
5 //
6 // This file is dual licensed under the MIT and the University of Illinois Open
7 // Source Licenses. See LICENSE.TXT for details.
8 //
9 //===----------------------------------------------------------------------===//
10
11 #ifndef __PSTL_execution_policy_defs_H
12 #define __PSTL_execution_policy_defs_H
13
14 #include <type_traits>
15
16 namespace __pstl
17 {
18 namespace execution
19 {
20 inline namespace v1
21 {
22
23 // 2.4, Sequential execution policy
24 class sequenced_policy
25 {
26   public:
27     // For internal use only
28     static constexpr std::false_type
29     __allow_unsequenced()
30     {
31         return std::false_type{};
32     }
33     static constexpr std::false_type
34     __allow_vector()
35     {
36         return std::false_type{};
37     }
38     static constexpr std::false_type
39     __allow_parallel()
40     {
41         return std::false_type{};
42     }
43 };
44
45 #if __PSTL_USE_PAR_POLICIES
46 // 2.5, Parallel execution policy
47 class parallel_policy
48 {
49   public:
50     // For internal use only
51     static constexpr std::false_type
52     __allow_unsequenced()
53     {
54         return std::false_type{};
55     }
56     static constexpr std::false_type
57     __allow_vector()
58     {
59         return std::false_type{};
60     }
61     static constexpr std::true_type
62     __allow_parallel()
63     {
64         return std::true_type{};
65     }
66 };
67
68 // 2.6, Parallel+Vector execution policy
69 class parallel_unsequenced_policy
70 {
71   public:
72     // For internal use only
73     static constexpr std::true_type
74     __allow_unsequenced()
75     {
76         return std::true_type{};
77     }
78     static constexpr std::true_type
79     __allow_vector()
80     {
81         return std::true_type{};
82     }
83     static constexpr std::true_type
84     __allow_parallel()
85     {
86         return std::true_type{};
87     }
88 };
89 #endif
90
91 class unsequenced_policy
92 {
93   public:
94     // For internal use only
95     static constexpr std::true_type
96     __allow_unsequenced()
97     {
98         return std::true_type{};
99     }
100     static constexpr std::true_type
101     __allow_vector()
102     {
103         return std::true_type{};
104     }
105     static constexpr std::false_type
106     __allow_parallel()
107     {
108         return std::false_type{};
109     }
110 };
111
112 // 2.8, Execution policy objects
113 constexpr sequenced_policy seq{};
114 #if __PSTL_USE_PAR_POLICIES
115 constexpr parallel_policy par{};
116 constexpr parallel_unsequenced_policy par_unseq{};
117 #endif
118 constexpr unsequenced_policy unseq{};
119
120 // 2.3, Execution policy type trait
121 template <class T>
122 struct is_execution_policy : std::false_type
123 {
124 };
125
126 template <>
127 struct is_execution_policy<sequenced_policy> : std::true_type
128 {
129 };
130 #if __PSTL_USE_PAR_POLICIES
131 template <>
132 struct is_execution_policy<parallel_policy> : std::true_type
133 {
134 };
135 template <>
136 struct is_execution_policy<parallel_unsequenced_policy> : std::true_type
137 {
138 };
139 #endif
140 template <>
141 struct is_execution_policy<unsequenced_policy> : std::true_type
142 {
143 };
144
145 #if __PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT
146 template <class T>
147 constexpr bool is_execution_policy_v = is_execution_policy<T>::value;
148 #endif
149
150 } // namespace v1
151 } // namespace execution
152
153 namespace internal
154 {
155 template <class ExecPolicy, class T>
156 using enable_if_execution_policy =
157     typename std::enable_if<__pstl::execution::is_execution_policy<typename std::decay<ExecPolicy>::type>::value,
158                             T>::type;
159 } // namespace internal
160
161 } // namespace __pstl
162
163 #endif /* __PSTL_execution_policy_defs_H */