LLVM  10.0.0svn
ilist_node_options.h
Go to the documentation of this file.
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 };
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>
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;
119 };
120 
121 template <class T, class... Options> struct compute_node_options {
122  typedef node_options<T, extract_sentinel_tracking<Options...>::value,
124  typename extract_tag<Options...>::type>
126 };
127 
128 } // end namespace ilist_detail
129 } // end namespace llvm
130 
131 #endif // LLVM_ADT_ILIST_NODE_OPTIONS_H
Check whether an option is valid.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
explicitness< false > is_implicit
node_options< T, extract_sentinel_tracking< Options... >::value, extract_sentinel_tracking< Options... >::is_explicit, typename extract_tag< Options... >::type > type
explicitness< true > is_explicit
Extract sentinel tracking option.
Base class for ilist nodes.
Option to choose whether to track sentinels.
ilist_node_base< enable_sentinel_tracking > node_base_type
Check whether options are valid.
Option to specify a tag for the node type.
ilist_base< enable_sentinel_tracking > list_base_type
Helper trait for recording whether an option is specified explicitly.
Implementations of list algorithms using ilist_node_base.
Definition: ilist_base.h:18
Extract custom tag option.
Traits for options for ilist_node.