CID less operator (#42)

Signed-off-by: Alexey-N-Chernyshov <[email protected]>

Author: Alexey-N-Chernyshov

include/libp2p/multi/content_identifier.hpp

@@ -39,6 +39,7 @@ namespace libp2p::multi {
     std::string toPrettyString(const std::string &base);
 
     bool operator==(const ContentIdentifier &c) const;
+    bool operator<(const ContentIdentifier &c) const;
 
     Version version;
     MulticodecType::Code content_type;

include/libp2p/multi/multihash.hpp

@@ -88,6 +88,7 @@ namespace libp2p::multi {
 
     bool operator==(const Multihash &other) const;
     bool operator!=(const Multihash &other) const;
+    bool operator<(const Multihash &other) const;
 
    private:
     /**

src/multi/content_identifier.cpp

@@ -37,4 +37,12 @@ namespace libp2p::multi {
         and content_address == c.content_address;
   }
 
+  bool ContentIdentifier::operator<(const ContentIdentifier &c) const {
+    return version < c.version
+           || (version == c.version
+               && (content_type < c.content_type
+                   || (content_type == c.content_type
+                       && content_address < c.content_address)));
+  }
+
 }  // namespace libp2p::multi

src/multi/multihash.cpp

@@ -112,6 +112,11 @@ namespace libp2p::multi {
     return !(this->operator==(other));
   }
 
+  bool Multihash::operator<(const class libp2p::multi::Multihash &other) const {
+    return this->type_ < other.type_ ||
+        (this->type_ == other.type_ && this->data_ < other.data_);
+  }
+
 }  // namespace libp2p::multi
 
 size_t std::hash<libp2p::multi::Multihash>::operator()(

test/libp2p/multi/cid_test.cpp

@@ -43,6 +43,62 @@ TEST(CidTest, PrettyString) {
                 + libp2p::common::hex_lower(EXAMPLE_MULTIHASH.getHash()));
 }
 
+/**
+ * @given CID of different versions
+ * @when compare CIDs
+ * @then lesser version is always less
+ */
+TEST(CidTest, CompareDifferentVersion) {
+  ContentIdentifier c0_v0(ContentIdentifier::Version::V0, MulticodecType::IDENTITY,
+                          ZERO_MULTIHASH);
+  ContentIdentifier c0_v1(ContentIdentifier::Version::V1, MulticodecType::IDENTITY,
+                       ZERO_MULTIHASH);
+  ASSERT_TRUE(c0_v0 < c0_v1);
+  ASSERT_FALSE(c0_v0 < c0_v0);
+  ASSERT_FALSE(c0_v1 < c0_v1);
+
+  ContentIdentifier c1_v1(ContentIdentifier::Version::V1, MulticodecType::IDENTITY,
+                          ZERO_MULTIHASH);
+  ASSERT_TRUE(c0_v0 < c1_v1);
+
+  ContentIdentifier c2_v0(ContentIdentifier::Version::V0, MulticodecType::SHA1,
+                          ZERO_MULTIHASH);
+  ASSERT_TRUE(c0_v0 < c2_v0);
+  ASSERT_TRUE(c0_v0 < c0_v1);
+}
+
+/**
+ * @given CID of different types
+ * @when compare CIDs
+ * @then lesser type is always less
+ */
+TEST(CidTest, CompareDifferentTypes) {
+  ContentIdentifier c1(ContentIdentifier::Version::V1, MulticodecType::IDENTITY,
+                          ZERO_MULTIHASH);
+  ContentIdentifier c2(ContentIdentifier::Version::V1, MulticodecType::SHA1,
+                          ZERO_MULTIHASH);
+  ASSERT_TRUE(c1 < c2);
+  ASSERT_FALSE(c2 < c1);
+  ASSERT_FALSE(c1 < c1);
+  ASSERT_FALSE(c2 < c2);
+}
+
+/**
+ * @given CID of different hashes
+ * @when compare CIDs
+ * @then lesser hash is always less
+ */
+TEST(CidTest, CompareDifferentHashes) {
+  ContentIdentifier c1(ContentIdentifier::Version::V1, MulticodecType::IDENTITY,
+                       ZERO_MULTIHASH);
+  ContentIdentifier c2(ContentIdentifier::Version::V1, MulticodecType::IDENTITY,
+                       EXAMPLE_MULTIHASH);
+  ASSERT_TRUE(c1 < c2);
+  ASSERT_FALSE(c2 < c1);
+  ASSERT_FALSE(c1 < c1);
+  ASSERT_FALSE(c2 < c2);
+}
+
 class CidEncodeTest
     : public testing::TestWithParam<std::pair<
           ContentIdentifier, libp2p::outcome::result<std::vector<uint8_t>>>> {};

test/libp2p/multi/multihash_test.cpp

@@ -84,3 +84,35 @@ TEST(Multihash, FromToBuffer) {
   ASSERT_FALSE(Multihash::createFromBytes(v))
       << "Length in the header does not equal actual length";
 }
+
+/**
+ * @given blake hash and sha256 hash with same hash
+ * @when compare multihashes
+ * @then sha256 hash is less then blake hash
+ */
+TEST(Multihash, CompareDifferentTypes) {
+  std::vector<uint8_t> hash{2, 3, 4};
+  auto sha256_hash = Multihash::create(HashType::sha256, hash).value();
+  auto blake_hash = Multihash::create(HashType::blake2s128, hash).value();
+  // type sha256 < blake2s128
+  ASSERT_TRUE(sha256_hash < blake_hash);
+  ASSERT_FALSE(blake_hash < sha256_hash);
+  ASSERT_FALSE(sha256_hash < sha256_hash);
+  ASSERT_FALSE(blake_hash < blake_hash);
+}
+
+/**
+ * @given similar hash type and different hashes
+ * @when compare multihashes
+ * @then lesser hash is less
+ */
+TEST(Multihash, CompareDifferentHashes) {
+  std::vector<uint8_t> hash_lesser{2, 3, 4};
+  std::vector<uint8_t> hash{3, 4, 5};
+  auto hash1 = Multihash::create(HashType::sha256, hash_lesser).value();
+  auto hash2 = Multihash::create(HashType::sha256, hash).value();
+  ASSERT_TRUE(hash1 < hash2);
+  ASSERT_FALSE(hash2 < hash1);
+  ASSERT_FALSE(hash1 < hash1);
+  ASSERT_FALSE(hash2 < hash2);
+}