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