A lot of fixes.

GitOrigin-RevId: c7c16991da51e09a685537a444385852e8e93af4

1 files changed, 31 insertions, 28 deletions

diff --git a/tdutils/td/utils/DecTree.h b/tdutils/td/utils/DecTree.h
index 9a73e5f29..b44f7a0c1 100644
--- a/tdutils/td/utils/DecTree.h
+++ b/tdutils/td/utils/DecTree.h
@@ -6,17 +6,17 @@
 //
 #pragma once
 
+#include "td/utils/int_types.h"
+#include "td/utils/Random.h"
+
+#include <functional>
 #include <memory>
 #include <utility>
 
-#include "int_types.h"
-#include "Random.h"
-
 namespace td {
 
 template <typename KeyType, typename ValueType, typename Compare = std::less<KeyType>>
 class DecTree {
- private:
   struct Node {
     std::unique_ptr<Node> left_;
     std::unique_ptr<Node> right_;
@@ -35,15 +35,16 @@ class DecTree {
       }
     }
 
-    Node(KeyType key, ValueType value, uint32 y) : key_(std::move(key)), value_(std::move(value)), y_(y) {
-      size_ = 1;
+    Node(KeyType key, ValueType value, uint32 y) : size_(1), key_(std::move(key)), value_(std::move(value)), y_(y) {
     }
   };
   std::unique_ptr<Node> root_;
-  std::unique_ptr<Node> create_node(KeyType key, ValueType value, uint32 y) {
+
+  static std::unique_ptr<Node> create_node(KeyType key, ValueType value, uint32 y) {
     return std::make_unique<Node>(std::move(key), std::move(value), y);
   }
-  std::unique_ptr<Node> insert_node(std::unique_ptr<Node> Tree, KeyType key, ValueType value, uint32 y) {
+
+  static std::unique_ptr<Node> insert_node(std::unique_ptr<Node> Tree, KeyType key, ValueType value, uint32 y) {
     if (Tree == nullptr) {
       return create_node(std::move(key), std::move(value), y);
     }
@@ -63,9 +64,10 @@ class DecTree {
       // ?? assert
     }
     Tree->relax();
-    return std::move(Tree);
+    return Tree;
   }
-  std::unique_ptr<Node> remove_node(std::unique_ptr<Node> Tree, KeyType &key) {
+
+  static std::unique_ptr<Node> remove_node(std::unique_ptr<Node> Tree, const KeyType &key) {
     if (Tree == nullptr) {
       // ?? assert
       return nullptr;
@@ -80,10 +82,10 @@ class DecTree {
     if (Tree != nullptr) {
       Tree->relax();
     }
-    return std::move(Tree);
+    return Tree;
   }
 
-  ValueType *get_node(std::unique_ptr<Node> &Tree, KeyType &key) {
+  static ValueType *get_node(std::unique_ptr<Node> &Tree, const KeyType &key) {
     if (Tree == nullptr) {
       return nullptr;
     }
@@ -95,7 +97,8 @@ class DecTree {
       return &Tree->value_;
     }
   }
-  ValueType *get_node_by_idx(std::unique_ptr<Node> &Tree, size_t idx) {
+
+  static ValueType *get_node_by_idx(std::unique_ptr<Node> &Tree, size_t idx) {
     CHECK(Tree != nullptr);
     auto s = (Tree->left_ != nullptr) ? Tree->left_->size_ : 0;
     if (idx < s) {
@@ -106,46 +109,46 @@ class DecTree {
       return get_node_by_idx(Tree->right_, idx - s - 1);
     }
   }
-  std::pair<std::unique_ptr<Node>, std::unique_ptr<Node>> split_node(std::unique_ptr<Node> Tree, KeyType &key) {
+
+  static std::pair<std::unique_ptr<Node>, std::unique_ptr<Node>> split_node(std::unique_ptr<Node> Tree,
+                                                                            const KeyType &key) {
     if (Tree == nullptr) {
-      return std::pair<std::unique_ptr<Node>, std::unique_ptr<Node>>(nullptr, nullptr);
+      return {nullptr, nullptr};
     }
     if (Compare()(key, Tree->key_)) {
       auto P = split_node(std::move(Tree->left_), key);
       Tree->left_ = std::move(P.second);
       Tree->relax();
       P.second = std::move(Tree);
-      return std::move(P);
+      return P;
     } else {
       auto P = split_node(std::move(Tree->right_), key);
       Tree->right_ = std::move(P.first);
       Tree->relax();
       P.first = std::move(Tree);
-      return std::move(P);
+      return P;
     }
   }
-  std::unique_ptr<Node> merge_node(std::unique_ptr<Node> left, std::unique_ptr<Node> right) {
+
+  static std::unique_ptr<Node> merge_node(std::unique_ptr<Node> left, std::unique_ptr<Node> right) {
     if (left == nullptr) {
-      return std::move(right);
+      return right;
     }
     if (right == nullptr) {
-      return std::move(left);
+      return left;
     }
     if (left->y_ < right->y_) {
       right->left_ = merge_node(std::move(left), std::move(right->left_));
       right->relax();
-      return std::move(right);
+      return right;
     } else {
       left->right_ = merge_node(std::move(left->right_), std::move(right));
       left->relax();
-      return std::move(left);
+      return left;
     }
   }
 
  public:
-  DecTree() {
-  }
-
   size_t size() const {
     if (root_ == nullptr) {
       return 0;
@@ -156,10 +159,10 @@ class DecTree {
   void insert(KeyType key, ValueType value) {
     root_ = insert_node(std::move(root_), std::move(key), std::move(value), td::Random::fast_uint32());
   }
-  void remove(KeyType &key) {
+  void remove(const KeyType &key) {
     root_ = remove_node(std::move(root_), key);
   }
-  ValueType *get(KeyType &key) {
+  ValueType *get(const KeyType &key) {
     return get_node(root_, key);
   }
   ValueType *get_random() {
@@ -169,7 +172,7 @@ class DecTree {
       return get_node_by_idx(root_, td::Random::fast_uint32() % size());
     }
   }
-  bool exists(KeyType &key) {
+  bool exists(const KeyType &key) const {
     return get_node(root_, key) != nullptr;
   }
 };