Skip to content

Commit b915124

Browse files
jasnelljasnell
committedDec 3, 2024
src: use spaceship operator in SocketAddress
PR-URL: nodejs#56059 Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com> Reviewed-By: Tobias Nießen <tniessen@tnie.de>
1 parent 3b6da7c commit b915124

File tree

4 files changed

+49
-76
lines changed

4 files changed

+49
-76
lines changed
 

‎src/node_sockaddr-inl.h

+3-16
Original file line numberDiff line numberDiff line change
@@ -172,22 +172,9 @@ bool SocketAddress::operator!=(const SocketAddress& other) const {
172172
return !(*this == other);
173173
}
174174

175-
bool SocketAddress::operator<(const SocketAddress& other) const {
176-
return compare(other) == CompareResult::LESS_THAN;
177-
}
178-
179-
bool SocketAddress::operator>(const SocketAddress& other) const {
180-
return compare(other) == CompareResult::GREATER_THAN;
181-
}
182-
183-
bool SocketAddress::operator<=(const SocketAddress& other) const {
184-
CompareResult c = compare(other);
185-
return c == CompareResult::NOT_COMPARABLE ? false :
186-
c <= CompareResult::SAME;
187-
}
188-
189-
bool SocketAddress::operator>=(const SocketAddress& other) const {
190-
return compare(other) >= CompareResult::SAME;
175+
std::partial_ordering SocketAddress::operator<=>(
176+
const SocketAddress& other) const {
177+
return compare(other);
191178
}
192179

193180
template <typename T>

‎src/node_sockaddr.cc

+30-35
Original file line numberDiff line numberDiff line change
@@ -154,9 +154,8 @@ bool is_match_ipv4_ipv6(
154154
sizeof(uint32_t)) == 0;
155155
}
156156

157-
SocketAddress::CompareResult compare_ipv4(
158-
const SocketAddress& one,
159-
const SocketAddress& two) {
157+
std::partial_ordering compare_ipv4(const SocketAddress& one,
158+
const SocketAddress& two) {
160159
const sockaddr_in* one_in =
161160
reinterpret_cast<const sockaddr_in*>(one.data());
162161
const sockaddr_in* two_in =
@@ -165,31 +164,29 @@ SocketAddress::CompareResult compare_ipv4(
165164
const uint32_t s_addr_two = ntohl(two_in->sin_addr.s_addr);
166165

167166
if (s_addr_one < s_addr_two)
168-
return SocketAddress::CompareResult::LESS_THAN;
167+
return std::partial_ordering::less;
169168
else if (s_addr_one == s_addr_two)
170-
return SocketAddress::CompareResult::SAME;
169+
return std::partial_ordering::equivalent;
171170
else
172-
return SocketAddress::CompareResult::GREATER_THAN;
171+
return std::partial_ordering::greater;
173172
}
174173

175-
SocketAddress::CompareResult compare_ipv6(
176-
const SocketAddress& one,
177-
const SocketAddress& two) {
174+
std::partial_ordering compare_ipv6(const SocketAddress& one,
175+
const SocketAddress& two) {
178176
const sockaddr_in6* one_in =
179177
reinterpret_cast<const sockaddr_in6*>(one.data());
180178
const sockaddr_in6* two_in =
181179
reinterpret_cast<const sockaddr_in6*>(two.data());
182180
int ret = memcmp(&one_in->sin6_addr, &two_in->sin6_addr, 16);
183181
if (ret < 0)
184-
return SocketAddress::CompareResult::LESS_THAN;
182+
return std::partial_ordering::less;
185183
else if (ret > 0)
186-
return SocketAddress::CompareResult::GREATER_THAN;
187-
return SocketAddress::CompareResult::SAME;
184+
return std::partial_ordering::greater;
185+
return std::partial_ordering::equivalent;
188186
}
189187

190-
SocketAddress::CompareResult compare_ipv4_ipv6(
191-
const SocketAddress& ipv4,
192-
const SocketAddress& ipv6) {
188+
std::partial_ordering compare_ipv4_ipv6(const SocketAddress& ipv4,
189+
const SocketAddress& ipv6) {
193190
const sockaddr_in* ipv4_in =
194191
reinterpret_cast<const sockaddr_in*>(ipv4.data());
195192
const sockaddr_in6 * ipv6_in =
@@ -199,18 +196,18 @@ SocketAddress::CompareResult compare_ipv4_ipv6(
199196
reinterpret_cast<const uint8_t*>(&ipv6_in->sin6_addr);
200197

201198
if (memcmp(ptr, mask, sizeof(mask)) != 0)
202-
return SocketAddress::CompareResult::NOT_COMPARABLE;
199+
return std::partial_ordering::unordered;
203200

204201
int ret = memcmp(
205202
&ipv4_in->sin_addr,
206203
ptr + sizeof(mask),
207204
sizeof(uint32_t));
208205

209206
if (ret < 0)
210-
return SocketAddress::CompareResult::LESS_THAN;
207+
return std::partial_ordering::less;
211208
else if (ret > 0)
212-
return SocketAddress::CompareResult::GREATER_THAN;
213-
return SocketAddress::CompareResult::SAME;
209+
return std::partial_ordering::greater;
210+
return std::partial_ordering::equivalent;
214211
}
215212

216213
bool in_network_ipv4(
@@ -235,7 +232,7 @@ bool in_network_ipv6(
235232
// Special case, if prefix == 128, then just do a
236233
// straight comparison.
237234
if (prefix == 128)
238-
return compare_ipv6(ip, net) == SocketAddress::CompareResult::SAME;
235+
return compare_ipv6(ip, net) == std::partial_ordering::equivalent;
239236

240237
uint8_t r = prefix % 8;
241238
int len = (prefix - r) / 8;
@@ -263,7 +260,7 @@ bool in_network_ipv4_ipv6(
263260
int prefix) {
264261

265262
if (prefix == 128)
266-
return compare_ipv4_ipv6(ip, net) == SocketAddress::CompareResult::SAME;
263+
return compare_ipv4_ipv6(ip, net) == std::partial_ordering::equivalent;
267264

268265
uint8_t r = prefix % 8;
269266
int len = (prefix - r) / 8;
@@ -293,7 +290,7 @@ bool in_network_ipv6_ipv4(
293290
const SocketAddress& net,
294291
int prefix) {
295292
if (prefix == 32)
296-
return compare_ipv4_ipv6(net, ip) == SocketAddress::CompareResult::SAME;
293+
return compare_ipv4_ipv6(net, ip) == std::partial_ordering::equivalent;
297294

298295
uint32_t m = ((1ull << prefix) - 1) << (32 - prefix);
299296

@@ -337,8 +334,7 @@ bool SocketAddress::is_match(const SocketAddress& other) const {
337334
return false;
338335
}
339336

340-
SocketAddress::CompareResult SocketAddress::compare(
341-
const SocketAddress& other) const {
337+
std::partial_ordering SocketAddress::compare(const SocketAddress& other) const {
342338
switch (family()) {
343339
case AF_INET:
344340
switch (other.family()) {
@@ -349,24 +345,23 @@ SocketAddress::CompareResult SocketAddress::compare(
349345
case AF_INET6:
350346
switch (other.family()) {
351347
case AF_INET: {
352-
CompareResult c = compare_ipv4_ipv6(other, *this);
353-
switch (c) {
354-
case SocketAddress::CompareResult::NOT_COMPARABLE:
355-
// Fall through
356-
case SocketAddress::CompareResult::SAME:
357-
return c;
358-
case SocketAddress::CompareResult::GREATER_THAN:
359-
return SocketAddress::CompareResult::LESS_THAN;
360-
case SocketAddress::CompareResult::LESS_THAN:
361-
return SocketAddress::CompareResult::GREATER_THAN;
348+
auto c = compare_ipv4_ipv6(other, *this);
349+
if (c == std::partial_ordering::unordered) {
350+
return std::partial_ordering::unordered;
351+
} else if (c == std::partial_ordering::equivalent) {
352+
return std::partial_ordering::equivalent;
353+
} else if (c == std::partial_ordering::less) {
354+
return std::partial_ordering::greater;
355+
} else if (c == std::partial_ordering::greater) {
356+
return std::partial_ordering::less;
362357
}
363358
break;
364359
}
365360
case AF_INET6: return compare_ipv6(*this, other);
366361
}
367362
break;
368363
}
369-
return SocketAddress::CompareResult::NOT_COMPARABLE;
364+
return std::partial_ordering::unordered;
370365
}
371366

372367
bool SocketAddress::is_in_network(

‎src/node_sockaddr.h

+4-13
Original file line numberDiff line numberDiff line change
@@ -11,9 +11,10 @@
1111
#include "uv.h"
1212
#include "v8.h"
1313

14+
#include <compare>
15+
#include <list>
1416
#include <memory>
1517
#include <string>
16-
#include <list>
1718
#include <unordered_map>
1819

1920
namespace node {
@@ -22,24 +23,14 @@ class Environment;
2223

2324
class SocketAddress : public MemoryRetainer {
2425
public:
25-
enum class CompareResult {
26-
NOT_COMPARABLE = -2,
27-
LESS_THAN,
28-
SAME,
29-
GREATER_THAN
30-
};
31-
3226
struct Hash {
3327
size_t operator()(const SocketAddress& addr) const;
3428
};
3529

3630
inline bool operator==(const SocketAddress& other) const;
3731
inline bool operator!=(const SocketAddress& other) const;
3832

39-
inline bool operator<(const SocketAddress& other) const;
40-
inline bool operator>(const SocketAddress& other) const;
41-
inline bool operator<=(const SocketAddress& other) const;
42-
inline bool operator>=(const SocketAddress& other) const;
33+
inline std::partial_ordering operator<=>(const SocketAddress& other) const;
4334

4435
inline static bool is_numeric_host(const char* hostname);
4536
inline static bool is_numeric_host(const char* hostname, int family);
@@ -102,7 +93,7 @@ class SocketAddress : public MemoryRetainer {
10293
bool is_match(const SocketAddress& other) const;
10394

10495
// Compares this SocketAddress to the given other SocketAddress.
105-
CompareResult compare(const SocketAddress& other) const;
96+
std::partial_ordering compare(const SocketAddress& other) const;
10697

10798
// Returns true if this SocketAddress is within the subnet
10899
// identified by the given network address and CIDR prefix.

‎test/cctest/test_sockaddr.cc

+12-12
Original file line numberDiff line numberDiff line change
@@ -145,19 +145,19 @@ TEST(SocketAddress, Comparison) {
145145
SocketAddress addr5(reinterpret_cast<const sockaddr*>(&storage[4]));
146146
SocketAddress addr6(reinterpret_cast<const sockaddr*>(&storage[5]));
147147

148-
CHECK_EQ(addr1.compare(addr1), SocketAddress::CompareResult::SAME);
149-
CHECK_EQ(addr1.compare(addr2), SocketAddress::CompareResult::LESS_THAN);
150-
CHECK_EQ(addr2.compare(addr1), SocketAddress::CompareResult::GREATER_THAN);
148+
CHECK_EQ(addr1.compare(addr1), std::partial_ordering::equivalent);
149+
CHECK_EQ(addr1.compare(addr2), std::partial_ordering::less);
150+
CHECK_EQ(addr2.compare(addr1), std::partial_ordering::greater);
151151
CHECK(addr1 <= addr1);
152152
CHECK(addr1 < addr2);
153153
CHECK(addr1 <= addr2);
154154
CHECK(addr2 >= addr2);
155155
CHECK(addr2 > addr1);
156156
CHECK(addr2 >= addr1);
157157

158-
CHECK_EQ(addr3.compare(addr3), SocketAddress::CompareResult::SAME);
159-
CHECK_EQ(addr3.compare(addr4), SocketAddress::CompareResult::LESS_THAN);
160-
CHECK_EQ(addr4.compare(addr3), SocketAddress::CompareResult::GREATER_THAN);
158+
CHECK_EQ(addr3.compare(addr3), std::partial_ordering::equivalent);
159+
CHECK_EQ(addr3.compare(addr4), std::partial_ordering::less);
160+
CHECK_EQ(addr4.compare(addr3), std::partial_ordering::greater);
161161
CHECK(addr3 <= addr3);
162162
CHECK(addr3 < addr4);
163163
CHECK(addr3 <= addr4);
@@ -166,8 +166,8 @@ TEST(SocketAddress, Comparison) {
166166
CHECK(addr4 >= addr3);
167167

168168
// Not comparable
169-
CHECK_EQ(addr1.compare(addr3), SocketAddress::CompareResult::NOT_COMPARABLE);
170-
CHECK_EQ(addr3.compare(addr1), SocketAddress::CompareResult::NOT_COMPARABLE);
169+
CHECK_EQ(addr1.compare(addr3), std::partial_ordering::unordered);
170+
CHECK_EQ(addr3.compare(addr1), std::partial_ordering::unordered);
171171
CHECK(!(addr1 < addr3));
172172
CHECK(!(addr1 > addr3));
173173
CHECK(!(addr1 >= addr3));
@@ -178,10 +178,10 @@ TEST(SocketAddress, Comparison) {
178178
CHECK(!(addr3 <= addr1));
179179

180180
// Comparable
181-
CHECK_EQ(addr1.compare(addr5), SocketAddress::CompareResult::SAME);
182-
CHECK_EQ(addr2.compare(addr6), SocketAddress::CompareResult::SAME);
183-
CHECK_EQ(addr1.compare(addr6), SocketAddress::CompareResult::LESS_THAN);
184-
CHECK_EQ(addr6.compare(addr1), SocketAddress::CompareResult::GREATER_THAN);
181+
CHECK_EQ(addr1.compare(addr5), std::partial_ordering::equivalent);
182+
CHECK_EQ(addr2.compare(addr6), std::partial_ordering::equivalent);
183+
CHECK_EQ(addr1.compare(addr6), std::partial_ordering::less);
184+
CHECK_EQ(addr6.compare(addr1), std::partial_ordering::greater);
185185
CHECK(addr1 <= addr5);
186186
CHECK(addr1 <= addr6);
187187
CHECK(addr1 < addr6);

0 commit comments

Comments
 (0)