Remove less and use std (#658)

* Remove less and use std

Signed-off-by: ortyomka <[email protected]>

Author: ortyomka

core/codec/cbor/cbor_dump.cpp

@@ -29,8 +29,8 @@ namespace fc {
 
   struct LessCborKey {
     bool operator()(const std::string &l, const std::string &r) const {
-      return less(
-          l.size(), r.size(), common::span::cbytes(l), common::span::cbytes(r));
+      return std::forward_as_tuple(l.size(), common::span::cbytes(l))
+             < std::forward_as_tuple(r.size(), common::span::cbytes(r));
     }
   };
 

core/codec/cbor/cbor_encode_stream.cpp

@@ -81,7 +81,8 @@ namespace fc::codec::cbor {
 
   struct LessCborKey {
     bool operator()(BytesIn lhs, BytesIn rhs) const {
-      return less(lhs.size(), rhs.size(), lhs, rhs);
+      return std::forward_as_tuple(lhs.size(), lhs)
+             < std::forward_as_tuple(rhs.size(), rhs);
     }
   };
 

core/common/cmp.hpp

@@ -10,14 +10,3 @@
     return !(l == r);                              \
   }
 #define FC_OPERATOR_NOT_EQUAL(T) FC_OPERATOR_NOT_EQUAL_2(T, T)
-
-namespace fc {
-  inline auto less() {
-    return false;
-  }
-
-  template <typename T, typename... Ts>
-  inline auto less(const T &l, const T &r, const Ts &...ts) {
-    return l < r || (!(r < l) && less(ts...));
-  }
-}  // namespace fc

core/paych/vouchers.cpp

@@ -76,13 +76,13 @@ namespace fc::paych_vouchers {
     if (lane_it == row.lanes.end() || lane_it->lane != voucher.lane) {
       lane_it = row.lanes.emplace(lane_it, LaneVouchers{voucher.lane});
     }
-    const auto voucher_it{
-        std::lower_bound(lane_it->vouchers.begin(),
-                         lane_it->vouchers.end(),
-                         voucher,
-                         [](const SignedVoucher &l, const SignedVoucher &r) {
-                           return less(l.lane, r.lane, l.nonce, r.nonce);
-                         })};
+    const auto voucher_it{std::lower_bound(
+        lane_it->vouchers.begin(),
+        lane_it->vouchers.end(),
+        voucher,
+        [](const SignedVoucher &l, const SignedVoucher &r) {
+          return std::tie(l.lane, l.nonce) < std::tie(r.lane, r.nonce);
+        })};
     const auto found{voucher_it != lane_it->vouchers.end()
                      && voucher_it->lane == voucher.lane
                      && voucher_it->nonce == voucher.nonce};

core/primitives/address/address.cpp

@@ -5,7 +5,6 @@
 
 #include "primitives/address/address.hpp"
 
-#include "common/cmp.hpp"
 #include "common/visitor.hpp"
 #include "crypto/blake2/blake2b160.hpp"
 
@@ -117,7 +116,8 @@ namespace fc::primitives::address {
   }
 
   bool operator<(const Address &lhs, const Address &rhs) {
-    return less(lhs.getProtocol(), rhs.getProtocol(), lhs.data, rhs.data);
+    return std::forward_as_tuple(lhs.getProtocol(), lhs.data)
+           < std::forward_as_tuple(rhs.getProtocol(), rhs.data);
   }
 
 }  // namespace fc::primitives::address

core/primitives/sector/sector.hpp

@@ -6,7 +6,6 @@
 #pragma once
 
 #include "common/blob.hpp"
-#include "common/cmp.hpp"
 #include "common/enum.hpp"
 #include "crypto/randomness/randomness_types.hpp"
 #include "primitives/cid/cid.hpp"
@@ -26,7 +25,7 @@ namespace fc::primitives::sector {
     SectorNumber sector;
   };
   inline bool operator<(const SectorId &lhs, const SectorId &rhs) {
-    return less(lhs.miner, rhs.miner, lhs.sector, rhs.sector);
+    return std::tie(lhs.miner, lhs.sector) < std::tie(rhs.miner, rhs.sector);
   }
   inline bool operator==(const SectorId &lhs, const SectorId &rhs) {
     return lhs.miner == rhs.miner && lhs.sector == rhs.sector;

core/sector_storage/impl/scheduler_impl.hpp

@@ -56,12 +56,9 @@ namespace fc::sector_storage {
   };
 
   inline bool operator<(const TaskRequest &lhs, const TaskRequest &rhs) {
-    return less(rhs.priority,
-                lhs.priority,
-                lhs.task_type,
-                rhs.task_type,
-                lhs.sector.id.sector,
-                rhs.sector.id.sector);
+    // priority is intentionally reversed
+    return std::tie(rhs.priority, lhs.task_type, lhs.sector.id.sector)
+           < std::tie(lhs.priority, rhs.task_type, rhs.sector.id.sector);
   }
 
   class SchedulerImpl : public Scheduler {

core/sector_storage/stores/impl/index_impl.hpp

@@ -28,7 +28,8 @@ namespace fc::sector_storage::stores {
   };
 
   inline bool operator<(const Decl &lhs, const Decl &rhs) {
-    return less(lhs.sector_id, rhs.sector_id, lhs.type, rhs.type);
+    return std::tie(lhs.sector_id, lhs.type)
+           < std::tie(rhs.sector_id, rhs.type);
   }
 
   class SectorIndexImpl : public SectorIndex {

core/sector_storage/worker.hpp

@@ -56,7 +56,7 @@ namespace fc::sector_storage {
   CBOR_TUPLE(CallId, sector, id);
 
   inline bool operator<(const CallId &lhs, const CallId &rhs) {
-    return less(lhs.sector, rhs.sector, lhs.id, rhs.id);
+    return std::tie(lhs.sector, lhs.id) < std::tie(rhs.sector, rhs.id);
   }
 
   inline bool operator==(const CallId &lhs, const CallId &rhs) {

core/storage/mpool/mpool.cpp

@@ -134,17 +134,17 @@ namespace fc::storage::mpool {
   }
 
   bool before(const MsgChain &l, const MsgChain &r) {
-    return less(r.gas_perf, l.gas_perf, r.gas_reward, l.gas_reward);
+    // right and left are intentionally reversed
+    return std::tie(r.gas_perf, r.gas_reward)
+           < std::tie(l.gas_perf, l.gas_reward);
   }
 
   bool beforeEffective(const MsgChain &l, const MsgChain &r) {
     return (l.merged && !r.merged) || (l.gas_perf >= 0 && r.gas_perf < 0)
-           || less(r.eff_perf,
+           || (std::tie(r.eff_perf, r.gas_perf, r.gas_reward) < std::tie(
                    l.eff_perf,
-                   r.gas_perf,
                    l.gas_perf,
-                   r.gas_reward,
-                   l.gas_reward);
+                   l.gas_reward));  // right and left are intentionally reversed
   }
 
   template <typename F>
@@ -729,7 +729,8 @@ namespace fc::storage::mpool {
     }
 
     std::sort(prices.begin(), prices.end(), [](auto &l, auto &r) {
-      return less(r.first, l.first, l.second, r.second);
+      // second is intentionally reversed
+      return std::tie(r.first, l.second) < std::tie(l.first, r.second);
     });
     auto at = static_cast<int64_t>(kBlockGasTarget * blocks / 2);
     TokenAmount premium;