The C and C++ Include Header Files

/usr/include/c++/11/pstl/execution_defs.h


$ cat -n /usr/include/c++/11/pstl/execution_defs.h

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