boost/pfr/ops.hpp

0001 // Copyright (c) 2016-2025 Antony Polukhin
0002 //
0003 // Distributed under the Boost Software License, Version 1.0. (See accompanying
0004 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0005
0006 #ifndef BOOST_PFR_OPS_HPP
0007 #define BOOST_PFR_OPS_HPP
0008 #pragma once
0009
0010 #include <boost/pfr/detail/config.hpp>
0011
0012 #include <boost/pfr/detail/detectors.hpp>
0013 #include <boost/pfr/ops_fields.hpp>
0014
0015 /// \file boost/pfr/ops.hpp
0016 /// Contains comparison and hashing functions.
0017 /// If type is comparable using its own operator or its conversion operator, then the types operator is used. Otherwise
0018 /// the operation is done via corresponding function from boost/pfr/ops.hpp header.
0019 ///
0020 /// \b Example:
0021 /// \code
0022 ///     #include <boost/pfr/ops.hpp>
0023 ///     struct comparable_struct {      // No operators defined for that structure
0024 ///         int i; short s; char data[7]; bool bl; int a,b,c,d,e,f;
0025 ///     };
0026 ///     // ...
0027 ///
0028 ///     comparable_struct s1 {0, 1, "Hello", false, 6,7,8,9,10,11};
0029 ///     comparable_struct s2 {0, 1, "Hello", false, 6,7,8,9,10,11111};
0030 ///     assert(boost::pfr::lt(s1, s2));
0031 /// \endcode
0032 ///
0033 /// \podops for other ways to define operators and more details.
0034 ///
0035 /// \b Synopsis:
0036 namespace boost { namespace pfr {
0037
0038 namespace detail {
0039
0040 ///////////////////// Helper typedefs that are used by all the ops
0041     template <template <class, class> class Detector, class T, class U>
0042     using enable_not_comp_base_t = std::enable_if_t<
0043         not_appliable<Detector, T const&, U const&>::value,
0044         bool
0045     >;
0046
0047     template <template <class, class> class Detector, class T, class U>
0048     using enable_comp_base_t = std::enable_if_t<
0049         !not_appliable<Detector, T const&, U const&>::value,
0050         bool
0051     >;
0052 ///////////////////// std::enable_if_t like functions that enable only if types do not support operation
0053
0054     template <class T, class U> using enable_not_eq_comp_t = enable_not_comp_base_t<comp_eq_detector, T, U>;
0055     template <class T, class U> using enable_not_ne_comp_t = enable_not_comp_base_t<comp_ne_detector, T, U>;
0056     template <class T, class U> using enable_not_lt_comp_t = enable_not_comp_base_t<comp_lt_detector, T, U>;
0057     template <class T, class U> using enable_not_le_comp_t = enable_not_comp_base_t<comp_le_detector, T, U>;
0058     template <class T, class U> using enable_not_gt_comp_t = enable_not_comp_base_t<comp_gt_detector, T, U>;
0059     template <class T, class U> using enable_not_ge_comp_t = enable_not_comp_base_t<comp_ge_detector, T, U>;
0060
0061     template <class T> using enable_not_hashable_t = std::enable_if_t<
0062         not_appliable<hash_detector, const T&, const T&>::value,
0063         std::size_t
0064     >;
0065 ///////////////////// std::enable_if_t like functions that enable only if types do support operation
0066
0067     template <class T, class U> using enable_eq_comp_t = enable_comp_base_t<comp_eq_detector, T, U>;
0068     template <class T, class U> using enable_ne_comp_t = enable_comp_base_t<comp_ne_detector, T, U>;
0069     template <class T, class U> using enable_lt_comp_t = enable_comp_base_t<comp_lt_detector, T, U>;
0070     template <class T, class U> using enable_le_comp_t = enable_comp_base_t<comp_le_detector, T, U>;
0071     template <class T, class U> using enable_gt_comp_t = enable_comp_base_t<comp_gt_detector, T, U>;
0072     template <class T, class U> using enable_ge_comp_t = enable_comp_base_t<comp_ge_detector, T, U>;
0073
0074     template <class T> using enable_hashable_t = std::enable_if_t<
0075         !not_appliable<hash_detector, const T&, const T&>::value,
0076         std::size_t
0077     >;
0078 } // namespace detail
0079
0080 BOOST_PFR_BEGIN_MODULE_EXPORT
0081
0082 /// \brief Compares lhs and rhs for equality using their own comparison and conversion operators; if no operators available returns \forcedlink{eq_fields}(lhs, rhs).
0083 ///
0084 /// \returns true if lhs is equal to rhs; false otherwise
0085 template <class T, class U>
0086 constexpr detail::enable_not_eq_comp_t<T, U> eq(const T& lhs, const U& rhs) noexcept {
0087     return boost::pfr::eq_fields(lhs, rhs);
0088 }
0089
0090 /// \overload eq
0091 template <class T, class U>
0092 constexpr detail::enable_eq_comp_t<T, U> eq(const T& lhs, const U& rhs) {
0093     return lhs == rhs;
0094 }
0095
0096
0097 /// \brief Compares lhs and rhs for inequality using their own comparison and conversion operators; if no operators available returns \forcedlink{ne_fields}(lhs, rhs).
0098 ///
0099 /// \returns true if lhs is not equal to rhs; false otherwise
0100 template <class T, class U>
0101 constexpr detail::enable_not_ne_comp_t<T, U> ne(const T& lhs, const U& rhs) noexcept {
0102     return boost::pfr::ne_fields(lhs, rhs);
0103 }
0104
0105 /// \overload ne
0106 template <class T, class U>
0107 constexpr detail::enable_ne_comp_t<T, U> ne(const T& lhs, const U& rhs) {
0108     return lhs != rhs;
0109 }
0110
0111
0112 /// \brief Compares lhs and rhs for less-than using their own comparison and conversion operators; if no operators available returns \forcedlink{lt_fields}(lhs, rhs).
0113 ///
0114 /// \returns true if lhs is less than rhs; false otherwise
0115 template <class T, class U>
0116 constexpr detail::enable_not_lt_comp_t<T, U> lt(const T& lhs, const U& rhs) noexcept {
0117     return boost::pfr::lt_fields(lhs, rhs);
0118 }
0119
0120 /// \overload lt
0121 template <class T, class U>
0122 constexpr detail::enable_lt_comp_t<T, U> lt(const T& lhs, const U& rhs) {
0123     return lhs < rhs;
0124 }
0125
0126
0127 /// \brief Compares lhs and rhs for greater-than using their own comparison and conversion operators; if no operators available returns \forcedlink{lt_fields}(lhs, rhs).
0128 ///
0129 /// \returns true if lhs is greater than rhs; false otherwise
0130 template <class T, class U>
0131 constexpr detail::enable_not_gt_comp_t<T, U> gt(const T& lhs, const U& rhs) noexcept {
0132     return boost::pfr::gt_fields(lhs, rhs);
0133 }
0134
0135 /// \overload gt
0136 template <class T, class U>
0137 constexpr detail::enable_gt_comp_t<T, U> gt(const T& lhs, const U& rhs) {
0138     return lhs > rhs;
0139 }
0140
0141
0142 /// \brief Compares lhs and rhs for less-equal using their own comparison and conversion operators; if no operators available returns \forcedlink{le_fields}(lhs, rhs).
0143 ///
0144 /// \returns true if lhs is less or equal to rhs; false otherwise
0145 template <class T, class U>
0146 constexpr detail::enable_not_le_comp_t<T, U> le(const T& lhs, const U& rhs) noexcept {
0147     return boost::pfr::le_fields(lhs, rhs);
0148 }
0149
0150 /// \overload le
0151 template <class T, class U>
0152 constexpr detail::enable_le_comp_t<T, U> le(const T& lhs, const U& rhs) {
0153     return lhs <= rhs;
0154 }
0155
0156
0157 /// \brief Compares lhs and rhs for greater-equal using their own comparison and conversion operators; if no operators available returns \forcedlink{ge_fields}(lhs, rhs).
0158 ///
0159 /// \returns true if lhs is greater or equal to rhs; false otherwise
0160 template <class T, class U>
0161 constexpr detail::enable_not_ge_comp_t<T, U> ge(const T& lhs, const U& rhs) noexcept {
0162     return boost::pfr::ge_fields(lhs, rhs);
0163 }
0164
0165 /// \overload ge
0166 template <class T, class U>
0167 constexpr detail::enable_ge_comp_t<T, U> ge(const T& lhs, const U& rhs) {
0168     return lhs >= rhs;
0169 }
0170
0171
0172 /// \brief Hashes value using its own std::hash specialization; if no std::hash specialization available returns \forcedlink{hash_fields}(value).
0173 ///
0174 /// \returns std::size_t with hash of the value
0175 template <class T>
0176 constexpr detail::enable_not_hashable_t<T> hash_value(const T& value) noexcept {
0177     return boost::pfr::hash_fields(value);
0178 }
0179
0180 /// \overload hash_value
0181 template <class T>
0182 constexpr detail::enable_hashable_t<T> hash_value(const T& value) {
0183     return std::hash<T>{}(value);
0184 }
0185
0186 BOOST_PFR_END_MODULE_EXPORT
0187
0188 }} // namespace boost::pfr
0189
0190 #endif // BOOST_PFR_OPS_HPP