llvm/ADT/ADL.h

0001 //===- llvm/ADT/ADL.h - Argument dependent lookup utilities -----*- C++ -*-===//
0002 //
0003 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
0004 // See https://llvm.org/LICENSE.txt for license information.
0005 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
0006 //
0007 //===----------------------------------------------------------------------===//
0008
0009 #ifndef LLVM_ADT_ADL_H
0010 #define LLVM_ADT_ADL_H
0011
0012 #include <type_traits>
0013 #include <iterator>
0014 #include <utility>
0015
0016 namespace llvm {
0017
0018 // Only used by compiler if both template types are the same.  Useful when
0019 // using SFINAE to test for the existence of member functions.
0020 template <typename T, T> struct SameType;
0021
0022 namespace adl_detail {
0023
0024 using std::begin;
0025
0026 template <typename RangeT>
0027 constexpr auto begin_impl(RangeT &&range)
0028     -> decltype(begin(std::forward<RangeT>(range))) {
0029   return begin(std::forward<RangeT>(range));
0030 }
0031
0032 using std::end;
0033
0034 template <typename RangeT>
0035 constexpr auto end_impl(RangeT &&range)
0036     -> decltype(end(std::forward<RangeT>(range))) {
0037   return end(std::forward<RangeT>(range));
0038 }
0039
0040 using std::rbegin;
0041
0042 template <typename RangeT>
0043 constexpr auto rbegin_impl(RangeT &&range)
0044     -> decltype(rbegin(std::forward<RangeT>(range))) {
0045   return rbegin(std::forward<RangeT>(range));
0046 }
0047
0048 using std::rend;
0049
0050 template <typename RangeT>
0051 constexpr auto rend_impl(RangeT &&range)
0052     -> decltype(rend(std::forward<RangeT>(range))) {
0053   return rend(std::forward<RangeT>(range));
0054 }
0055
0056 using std::swap;
0057
0058 template <typename T>
0059 constexpr void swap_impl(T &&lhs,
0060                          T &&rhs) noexcept(noexcept(swap(std::declval<T>(),
0061                                                          std::declval<T>()))) {
0062   swap(std::forward<T>(lhs), std::forward<T>(rhs));
0063 }
0064
0065 using std::size;
0066
0067 template <typename RangeT>
0068 constexpr auto size_impl(RangeT &&range)
0069     -> decltype(size(std::forward<RangeT>(range))) {
0070   return size(std::forward<RangeT>(range));
0071 }
0072
0073 } // end namespace adl_detail
0074
0075 /// Returns the begin iterator to \p range using `std::begin` and
0076 /// function found through Argument-Dependent Lookup (ADL).
0077 template <typename RangeT>
0078 constexpr auto adl_begin(RangeT &&range)
0079     -> decltype(adl_detail::begin_impl(std::forward<RangeT>(range))) {
0080   return adl_detail::begin_impl(std::forward<RangeT>(range));
0081 }
0082
0083 /// Returns the end iterator to \p range using `std::end` and
0084 /// functions found through Argument-Dependent Lookup (ADL).
0085 template <typename RangeT>
0086 constexpr auto adl_end(RangeT &&range)
0087     -> decltype(adl_detail::end_impl(std::forward<RangeT>(range))) {
0088   return adl_detail::end_impl(std::forward<RangeT>(range));
0089 }
0090
0091 /// Returns the reverse-begin iterator to \p range using `std::rbegin` and
0092 /// function found through Argument-Dependent Lookup (ADL).
0093 template <typename RangeT>
0094 constexpr auto adl_rbegin(RangeT &&range)
0095     -> decltype(adl_detail::rbegin_impl(std::forward<RangeT>(range))) {
0096   return adl_detail::rbegin_impl(std::forward<RangeT>(range));
0097 }
0098
0099 /// Returns the reverse-end iterator to \p range using `std::rend` and
0100 /// functions found through Argument-Dependent Lookup (ADL).
0101 template <typename RangeT>
0102 constexpr auto adl_rend(RangeT &&range)
0103     -> decltype(adl_detail::rend_impl(std::forward<RangeT>(range))) {
0104   return adl_detail::rend_impl(std::forward<RangeT>(range));
0105 }
0106
0107 /// Swaps \p lhs with \p rhs using `std::swap` and functions found through
0108 /// Argument-Dependent Lookup (ADL).
0109 template <typename T>
0110 constexpr void adl_swap(T &&lhs, T &&rhs) noexcept(
0111     noexcept(adl_detail::swap_impl(std::declval<T>(), std::declval<T>()))) {
0112   adl_detail::swap_impl(std::forward<T>(lhs), std::forward<T>(rhs));
0113 }
0114
0115 /// Returns the size of \p range using `std::size` and functions found through
0116 /// Argument-Dependent Lookup (ADL).
0117 template <typename RangeT>
0118 constexpr auto adl_size(RangeT &&range)
0119     -> decltype(adl_detail::size_impl(std::forward<RangeT>(range))) {
0120   return adl_detail::size_impl(std::forward<RangeT>(range));
0121 }
0122
0123 namespace detail {
0124
0125 template <typename RangeT>
0126 using IterOfRange = decltype(adl_begin(std::declval<RangeT &>()));
0127
0128 template <typename RangeT>
0129 using ValueOfRange =
0130     std::remove_reference_t<decltype(*adl_begin(std::declval<RangeT &>()))>;
0131
0132 } // namespace detail
0133 } // namespace llvm
0134
0135 #endif // LLVM_ADT_ADL_H