mirror of
https://github.com/scylladb/scylladb.git
synced 2026-04-23 01:50:35 +00:00
f5b05cf981
in C++20, compiler generate operator!=() if the corresponding operator==() is already defined, the language now understands that the comparison is symmetric in the new standard. fortunately, our operator!=() is always equivalent to `! operator==()`, this matches the behavior of the default generated operator!=(). so, in this change, all `operator!=` are removed. in addition to the defaulted operator!=, C++20 also brings to us the defaulted operator==() -- it is able to generated the operator==() if the member-wise lexicographical comparison. under some circumstances, this is exactly what we need. so, in this change, if the operator==() is also implemented as a lexicographical comparison of all memeber variables of the class/struct in question, it is implemented using the default generated one by removing its body and mark the function as `default`. moreover, if the class happen to have other comparison operators which are implemented using lexicographical comparison, the default generated `operator<=>` is used in place of the defaulted `operator==`. sometimes, we fail to mark the operator== with the `const` specifier, in this change, to fulfil the need of C++ standard, and to be more correct, the `const` specifier is added. also, to generate the defaulted operator==, the operand should be `const class_name&`, but it is not always the case, in the class of `version`, we use `version` as the parameter type, to fulfill the need of the C++ standard, the parameter type is changed to `const version&` instead. this does not change the semantic of the comparison operator. and is a more idiomatic way to pass non-trivial struct as function parameters. please note, because in C++20, both operator= and operator<=> are symmetric, some of the operators in `multiprecision` are removed. they are the symmetric form of the another variant. if they were not removed, compiler would, for instance, find ambiguous overloaded operator '=='. this change is a cleanup to modernize the code base with C++20 features. Signed-off-by: Kefu Chai <kefu.chai@scylladb.com> Closes #13687
44 lines
992 B
C++
44 lines
992 B
C++
#pragma once
|
|
#include <absl/container/btree_set.h>
|
|
#include <cstdint>
|
|
#include <ostream>
|
|
#include "schema/schema.hh"
|
|
|
|
class decorated_key_with_hash;
|
|
class mutation_fragment;
|
|
|
|
// Hash of a repair row
|
|
class repair_hash {
|
|
public:
|
|
uint64_t hash = 0;
|
|
repair_hash() = default;
|
|
explicit repair_hash(uint64_t h) : hash(h) {
|
|
}
|
|
void clear() {
|
|
hash = 0;
|
|
}
|
|
void add(const repair_hash& other) {
|
|
hash ^= other.hash;
|
|
}
|
|
std::strong_ordering operator<=>(const repair_hash&) const = default;
|
|
friend std::ostream& operator<<(std::ostream& os, const repair_hash& x) {
|
|
return os << x.hash;
|
|
}
|
|
};
|
|
|
|
using repair_hash_set = absl::btree_set<repair_hash>;
|
|
|
|
class repair_hasher {
|
|
uint64_t _seed;
|
|
schema_ptr _schema;
|
|
public:
|
|
repair_hasher(uint64_t seed, schema_ptr s)
|
|
: _seed(seed)
|
|
, _schema(std::move(s))
|
|
{}
|
|
|
|
repair_hash do_hash_for_mf(const decorated_key_with_hash& dk_with_hash, const mutation_fragment& mf);
|
|
};
|
|
|
|
|