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