Market actor methods (#145)

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

Author: turuslan

core/adt/balance_table.cpp

@@ -14,21 +14,21 @@ OUTCOME_CPP_DEFINE_CATEGORY(fc::adt, BalanceTableError, e) {
 }
 
 namespace fc::adt {
-  outcome::result<TokenAmount> BalanceTable::get(const Key &key) {
-    OUTCOME_TRY(value, tryGet(key));
-    if (value) {
-      return *value;
-    }
-    return 0;
-  }
-
   outcome::result<void> BalanceTable::add(const Key &key, TokenAmount amount) {
     OUTCOME_TRY(value, get(key));
     value += amount;
     OUTCOME_TRY(set(key, value));
     return outcome::success();
   }
 
+  outcome::result<void> BalanceTable::addCreate(const Key &key, TokenAmount amount) {
+    OUTCOME_TRY(value, tryGet(key));
+    if (value) {
+      amount += *value;
+    }
+    return set(key, amount);
+  }
+
   outcome::result<TokenAmount> BalanceTable::subtractWithMin(const Key &key,
                                                              TokenAmount amount,
                                                              TokenAmount min) {

core/adt/balance_table.hpp

@@ -18,10 +18,10 @@ namespace fc::adt {
   struct BalanceTable : public Map<TokenAmount, AddressKeyer> {
     using Map::Map;
 
-    outcome::result<TokenAmount> get(const Key &key);
-
     outcome::result<void> add(const Key &key, TokenAmount amount);
 
+    outcome::result<void> addCreate(const Key &key, TokenAmount amount);
+
     outcome::result<TokenAmount> subtractWithMin(const Key &key,
                                                  TokenAmount amount,
                                                  TokenAmount min);

core/adt/map.hpp

@@ -80,23 +80,23 @@ namespace fc::adt {
 
   /// Cbor encode map
   template <class Stream,
-            typename V,
-            typename K,
+            typename Value,
+            typename Keyer,
             size_t bit_width,
             typename = std::enable_if_t<
                 std::remove_reference_t<Stream>::is_cbor_encoder_stream>>
-  Stream &operator<<(Stream &&s, const Map<V, K, bit_width> &map) {
+  Stream &operator<<(Stream &&s, const Map<Value, Keyer, bit_width> &map) {
     return s << map.hamt.cid();
   }
 
   /// Cbor decode map
   template <class Stream,
-            typename V,
-            typename K,
+            typename Value,
+            typename Keyer,
             size_t bit_width,
             typename = std::enable_if_t<
                 std::remove_reference_t<Stream>::is_cbor_decoder_stream>>
-  Stream &operator>>(Stream &&s, Map<V, K, bit_width> &map) {
+  Stream &operator>>(Stream &&s, Map<Value, Keyer, bit_width> &map) {
     CID root;
     s >> root;
     map.hamt = {nullptr, root, bit_width};

core/primitives/piece/piece.hpp

@@ -75,5 +75,9 @@ namespace fc::primitives::piece {
     CID cid;
   };
 
+  inline bool operator==(const PieceInfo &lhs, const PieceInfo &rhs) {
+    return lhs.size == rhs.size && lhs.cid == rhs.cid;
+  }
+
 };      // namespace fc::primitives::piece
 #endif  // CPP_FILECOIN_PIECE_HPP

core/storage/amt/amt.cpp

@@ -152,9 +152,12 @@ namespace fc::storage::amt {
                                  gsl::span<const uint8_t> value) {
     node.has_bits = true;
     if (height == 0) {
-      return boost::get<Node::Values>(node.items)
-          .insert(std::make_pair(key, value))
-          .second;
+      auto &values = boost::get<Node::Values>(node.items);
+      if (values.insert(std::make_pair(key, value)).second) {
+        return true;
+      }
+      values.at(key) = Value(value);
+      return false;
     }
     auto mask = maskAt(height);
     OUTCOME_TRY(child, loadLink(node, key / mask, true));