1 //===- llvm/ADT/ilist_node_options.h - ilist_node Options -------*- C++ -*-===// 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 #ifndef LLVM_ADT_ILIST_NODE_OPTIONS_H 10 #define LLVM_ADT_ILIST_NODE_OPTIONS_H 11 12 #include "llvm/Config/abi-breaking.h" 13 14 #include <type_traits> 15 16 namespace llvm { 17 18 template <bool EnableSentinelTracking> class ilist_node_base; 19 template <bool EnableSentinelTracking> class ilist_base; 20 21 /// Option to choose whether to track sentinels. 22 /// 23 /// This option affects the ABI for the nodes. When not specified explicitly, 24 /// the ABI depends on LLVM_ENABLE_ABI_BREAKING_CHECKS. Specify explicitly to 25 /// enable \a ilist_node::isSentinel(). 26 template <bool EnableSentinelTracking> struct ilist_sentinel_tracking {}; 27 28 /// Option to specify a tag for the node type. 29 /// 30 /// This option allows a single value type to be inserted in multiple lists 31 /// simultaneously. See \a ilist_node for usage examples. 32 template <class Tag> struct ilist_tag {}; 33 34 namespace ilist_detail { 35 36 /// Helper trait for recording whether an option is specified explicitly. 37 template <bool IsExplicit> struct explicitness { 38 static const bool is_explicit = IsExplicit; 39 }; 40 typedef explicitness<true> is_explicit; 41 typedef explicitness<false> is_implicit; 42 43 /// Check whether an option is valid. 44 /// 45 /// The steps for adding and enabling a new ilist option include: 46 /// \li define the option, ilist_foo<Bar>, above; 47 /// \li add new parameters for Bar to \a ilist_detail::node_options; 48 /// \li add an extraction meta-function, ilist_detail::extract_foo; 49 /// \li call extract_foo from \a ilist_detail::compute_node_options and pass it 50 /// into \a ilist_detail::node_options; and 51 /// \li specialize \c is_valid_option<ilist_foo<Bar>> to inherit from \c 52 /// std::true_type to get static assertions passing in \a simple_ilist and \a 53 /// ilist_node. 54 template <class Option> struct is_valid_option : std::false_type {}; 55 56 /// Extract sentinel tracking option. 57 /// 58 /// Look through \p Options for the \a ilist_sentinel_tracking option, with the 59 /// default depending on LLVM_ENABLE_ABI_BREAKING_CHECKS. 60 template <class... Options> struct extract_sentinel_tracking; 61 template <bool EnableSentinelTracking, class... Options> 62 struct extract_sentinel_tracking< 63 ilist_sentinel_tracking<EnableSentinelTracking>, Options...> 64 : std::integral_constant<bool, EnableSentinelTracking>, is_explicit {}; 65 template <class Option1, class... Options> 66 struct extract_sentinel_tracking<Option1, Options...> 67 : extract_sentinel_tracking<Options...> {}; 68 #if LLVM_ENABLE_ABI_BREAKING_CHECKS 69 template <> struct extract_sentinel_tracking<> : std::true_type, is_implicit {}; 70 #else 71 template <> 72 struct extract_sentinel_tracking<> : std::false_type, is_implicit {}; 73 #endif 74 template <bool EnableSentinelTracking> 75 struct is_valid_option<ilist_sentinel_tracking<EnableSentinelTracking>> 76 : std::true_type {}; 77 78 /// Extract custom tag option. 79 /// 80 /// Look through \p Options for the \a ilist_tag option, pulling out the 81 /// custom tag type, using void as a default. 82 template <class... Options> struct extract_tag; 83 template <class Tag, class... Options> 84 struct extract_tag<ilist_tag<Tag>, Options...> { 85 typedef Tag type; 86 }; 87 template <class Option1, class... Options> 88 struct extract_tag<Option1, Options...> : extract_tag<Options...> {}; 89 template <> struct extract_tag<> { typedef void type; }; 90 template <class Tag> struct is_valid_option<ilist_tag<Tag>> : std::true_type {}; 91 92 /// Check whether options are valid. 93 /// 94 /// The conjunction of \a is_valid_option on each individual option. 95 template <class... Options> struct check_options; 96 template <> struct check_options<> : std::true_type {}; 97 template <class Option1, class... Options> 98 struct check_options<Option1, Options...> 99 : std::integral_constant<bool, is_valid_option<Option1>::value && 100 check_options<Options...>::value> {}; 101 102 /// Traits for options for \a ilist_node. 103 /// 104 /// This is usually computed via \a compute_node_options. 105 template <class T, bool EnableSentinelTracking, bool IsSentinelTrackingExplicit, 106 class TagT> 107 struct node_options { 108 typedef T value_type; 109 typedef T *pointer; 110 typedef T &reference; 111 typedef const T *const_pointer; 112 typedef const T &const_reference; 113 114 static const bool enable_sentinel_tracking = EnableSentinelTracking; 115 static const bool is_sentinel_tracking_explicit = IsSentinelTrackingExplicit; 116 typedef TagT tag; 117 typedef ilist_node_base<enable_sentinel_tracking> node_base_type; 118 typedef ilist_base<enable_sentinel_tracking> list_base_type; 119 }; 120 121 template <class T, class... Options> struct compute_node_options { 122 typedef node_options<T, extract_sentinel_tracking<Options...>::value, 123 extract_sentinel_tracking<Options...>::is_explicit, 124 typename extract_tag<Options...>::type> 125 type; 126 }; 127 128 } // end namespace ilist_detail 129 } // end namespace llvm 130 131 #endif // LLVM_ADT_ILIST_NODE_OPTIONS_H 132