1// Copyright (c) 2016-2024 Antony Polukhin
2//
3// Distributed under the Boost Software License, Version 1.0. (See accompanying
4// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
5
6#ifndef BOOST_PFR_DETAIL_FUNCTIONAL_HPP
7#define BOOST_PFR_DETAIL_FUNCTIONAL_HPP
8#pragma once
9
10#include <boost/pfr/detail/config.hpp>
11
12#include <functional>
13#include <cstdint>
14
15#include <boost/pfr/detail/sequence_tuple.hpp>
16
17namespace boost { namespace pfr { namespace detail {
18 template <std::size_t I, std::size_t N>
19 struct equal_impl {
20 template <class T, class U>
21 constexpr static bool cmp(const T& v1, const U& v2) noexcept {
22 return ::boost::pfr::detail::sequence_tuple::get<I>(v1) == ::boost::pfr::detail::sequence_tuple::get<I>(v2)
23 && equal_impl<I + 1, N>::cmp(v1, v2);
24 }
25 };
26
27 template <std::size_t N>
28 struct equal_impl<N, N> {
29 template <class T, class U>
30 constexpr static bool cmp(const T&, const U&) noexcept {
31 return T::size_v == U::size_v;
32 }
33 };
34
35 template <std::size_t I, std::size_t N>
36 struct not_equal_impl {
37 template <class T, class U>
38 constexpr static bool cmp(const T& v1, const U& v2) noexcept {
39 return ::boost::pfr::detail::sequence_tuple::get<I>(v1) != ::boost::pfr::detail::sequence_tuple::get<I>(v2)
40 || not_equal_impl<I + 1, N>::cmp(v1, v2);
41 }
42 };
43
44 template <std::size_t N>
45 struct not_equal_impl<N, N> {
46 template <class T, class U>
47 constexpr static bool cmp(const T&, const U&) noexcept {
48 return T::size_v != U::size_v;
49 }
50 };
51
52 template <std::size_t I, std::size_t N>
53 struct less_impl {
54 template <class T, class U>
55 constexpr static bool cmp(const T& v1, const U& v2) noexcept {
56 return sequence_tuple::get<I>(v1) < sequence_tuple::get<I>(v2)
57 || (sequence_tuple::get<I>(v1) == sequence_tuple::get<I>(v2) && less_impl<I + 1, N>::cmp(v1, v2));
58 }
59 };
60
61 template <std::size_t N>
62 struct less_impl<N, N> {
63 template <class T, class U>
64 constexpr static bool cmp(const T&, const U&) noexcept {
65 return T::size_v < U::size_v;
66 }
67 };
68
69 template <std::size_t I, std::size_t N>
70 struct less_equal_impl {
71 template <class T, class U>
72 constexpr static bool cmp(const T& v1, const U& v2) noexcept {
73 return sequence_tuple::get<I>(v1) < sequence_tuple::get<I>(v2)
74 || (sequence_tuple::get<I>(v1) == sequence_tuple::get<I>(v2) && less_equal_impl<I + 1, N>::cmp(v1, v2));
75 }
76 };
77
78 template <std::size_t N>
79 struct less_equal_impl<N, N> {
80 template <class T, class U>
81 constexpr static bool cmp(const T&, const U&) noexcept {
82 return T::size_v <= U::size_v;
83 }
84 };
85
86 template <std::size_t I, std::size_t N>
87 struct greater_impl {
88 template <class T, class U>
89 constexpr static bool cmp(const T& v1, const U& v2) noexcept {
90 return sequence_tuple::get<I>(v1) > sequence_tuple::get<I>(v2)
91 || (sequence_tuple::get<I>(v1) == sequence_tuple::get<I>(v2) && greater_impl<I + 1, N>::cmp(v1, v2));
92 }
93 };
94
95 template <std::size_t N>
96 struct greater_impl<N, N> {
97 template <class T, class U>
98 constexpr static bool cmp(const T&, const U&) noexcept {
99 return T::size_v > U::size_v;
100 }
101 };
102
103 template <std::size_t I, std::size_t N>
104 struct greater_equal_impl {
105 template <class T, class U>
106 constexpr static bool cmp(const T& v1, const U& v2) noexcept {
107 return sequence_tuple::get<I>(v1) > sequence_tuple::get<I>(v2)
108 || (sequence_tuple::get<I>(v1) == sequence_tuple::get<I>(v2) && greater_equal_impl<I + 1, N>::cmp(v1, v2));
109 }
110 };
111
112 template <std::size_t N>
113 struct greater_equal_impl<N, N> {
114 template <class T, class U>
115 constexpr static bool cmp(const T&, const U&) noexcept {
116 return T::size_v >= U::size_v;
117 }
118 };
119
120 // Hash combine functions copied from Boost.ContainerHash
121 // https://github.com/boostorg/container_hash/blob/171c012d4723c5e93cc7cffe42919afdf8b27dfa/include/boost/container_hash/hash.hpp#L311
122 // that is based on Peter Dimov's proposal
123 // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
124 // issue 6.18.
125 //
126 // This also contains public domain code from MurmurHash. From the
127 // MurmurHash header:
128 //
129 // MurmurHash3 was written by Austin Appleby, and is placed in the public
130 // domain. The author hereby disclaims copyright to this source code.
131 template <typename SizeT>
132 constexpr void hash_combine(SizeT& seed, SizeT value) noexcept {
133 seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
134 }
135
136 constexpr auto rotl(std::uint32_t x, std::uint32_t r) noexcept {
137 return (x << r) | (x >> (32 - r));
138 }
139
140 constexpr void hash_combine(std::uint32_t& h1, std::uint32_t k1) noexcept {
141 const std::uint32_t c1 = 0xcc9e2d51;
142 const std::uint32_t c2 = 0x1b873593;
143
144 k1 *= c1;
145 k1 = detail::rotl(x: k1,r: 15);
146 k1 *= c2;
147
148 h1 ^= k1;
149 h1 = detail::rotl(x: h1,r: 13);
150 h1 = h1*5+0xe6546b64;
151 }
152
153#if defined(INT64_MIN) && defined(UINT64_MAX)
154 constexpr void hash_combine(std::uint64_t& h, std::uint64_t k) noexcept {
155 const std::uint64_t m = 0xc6a4a7935bd1e995ULL;
156 const int r = 47;
157
158 k *= m;
159 k ^= k >> r;
160 k *= m;
161
162 h ^= k;
163 h *= m;
164
165 // Completely arbitrary number, to prevent 0's
166 // from hashing to 0.
167 h += 0xe6546b64;
168 }
169#endif
170
171 template <typename T>
172 auto compute_hash(const T& value, long /*priority*/)
173 -> decltype(std::hash<T>()(value))
174 {
175 return std::hash<T>()(value);
176 }
177
178 template <typename T>
179 std::size_t compute_hash(const T& /*value*/, int /*priority*/) {
180 static_assert(sizeof(T) && false, "====================> Boost.PFR: std::hash not specialized for type T");
181 return 0;
182 }
183
184 template <std::size_t I, std::size_t N>
185 struct hash_impl {
186 template <class T>
187 constexpr static std::size_t compute(const T& val) noexcept {
188 std::size_t h = detail::compute_hash( ::boost::pfr::detail::sequence_tuple::get<I>(val), 1L );
189 detail::hash_combine(h, hash_impl<I + 1, N>::compute(val) );
190 return h;
191 }
192 };
193
194 template <std::size_t N>
195 struct hash_impl<N, N> {
196 template <class T>
197 constexpr static std::size_t compute(const T&) noexcept {
198 return 0;
199 }
200 };
201
202///////////////////// Define min_element and to avoid inclusion of <algorithm>
203 constexpr std::size_t min_size(std::size_t x, std::size_t y) noexcept {
204 return x < y ? x : y;
205 }
206
207 template <template <std::size_t, std::size_t> class Visitor, class T, class U>
208 constexpr bool binary_visit(const T& x, const U& y) {
209 constexpr std::size_t fields_count_lhs = detail::fields_count<std::remove_reference_t<T>>();
210 constexpr std::size_t fields_count_rhs = detail::fields_count<std::remove_reference_t<U>>();
211 constexpr std::size_t fields_count_min = detail::min_size(x: fields_count_lhs, y: fields_count_rhs);
212 typedef Visitor<0, fields_count_min> visitor_t;
213
214#if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE
215 return visitor_t::cmp(detail::tie_as_tuple(x), detail::tie_as_tuple(y));
216#else
217 bool result = true;
218 ::boost::pfr::detail::for_each_field_dispatcher(
219 x,
220 [&result, &y](const auto& lhs) {
221 constexpr std::size_t fields_count_rhs_ = detail::fields_count<std::remove_reference_t<U>>();
222 ::boost::pfr::detail::for_each_field_dispatcher(
223 y,
224 [&result, &lhs](const auto& rhs) {
225 result = visitor_t::cmp(lhs, rhs);
226 },
227 detail::make_index_sequence<fields_count_rhs_>{}
228 );
229 },
230 detail::make_index_sequence<fields_count_lhs>{}
231 );
232
233 return result;
234#endif
235 }
236
237}}} // namespace boost::pfr::detail
238
239#endif // BOOST_PFR_DETAIL_FUNCTIONAL_HPP
240

source code of boost/libs/pfr/include/boost/pfr/detail/functional.hpp