View difference between Paste ID: AwTJ8nkg and 8JBhkA5T

 #include <future>
 #include <mutex>
 #include <unordered_map>
 #include <vector>
 #include <utility>
 #include <algorithm>
 #include <random>
 #include <thread>
 #include <shared_mutex>
 
 using namespace std;
 
 template<typename K, typename V, typename Hash = std::hash<K>>
 class ConcurrentMap {
     struct Key {
         K data;
         size_t hash;
 
         explicit Key(K data) : data(std::move(data)), hash(Hash()(this->data)) {}
 
         bool operator==(const Key &other) const {
             return data == other.data;
         }
     };
 
     struct KeyHasher {
         auto operator()(const Key &value) const {
             return value.hash;
         }
     };
 
     using InnerMapType = std::unordered_map<Key, V, KeyHasher>;
 
     struct SharedMap {
         mutable std::shared_mutex mtx;
         InnerMapType map;
     };
 
 public:
     using MapType = std::unordered_map<K, V, Hash>;
 
     class WriteAccess {
         std::lock_guard<std::shared_mutex> guard;
     public:
         V &ref_to_value;
 
         WriteAccess(InnerMapType &map, Key &key, std::shared_mutex &mtx) : guard(mtx),
                                                                            ref_to_value(map[std::move(key)]) {};
     };
 
     class ReadAccess {
         std::shared_lock<std::shared_mutex> lock;
     public:
         const V &ref_to_value;
 
         ReadAccess(const InnerMapType &map, const Key &key, std::shared_mutex &mtx) : lock(mtx),
                                                                                       ref_to_value(map.at(key)) {};
     };
 
     explicit ConcurrentMap(size_t bucket_count) : data(bucket_count) {}
 
     WriteAccess operator[](const K &key) {
         Key map_key(key);
         auto &[mtx, map] = data[map_key.hash % data.size()];
         return {map, map_key, mtx};
     }
 
     ReadAccess At(const K &key) const {
         const Key map_key(key);
         auto &[mtx, map] = data[map_key.hash % data.size()];
         return {map, map_key, mtx};
     }
 
     bool Has(const K &key) const {
         const Key map_key(key);
         auto &[mtx, map] = data[map_key.hash % data.size()];
         std::shared_lock locker(mtx);
         return map.find(map_key) != map.end();
     }
 
     MapType BuildOrdinaryMap() const {
         MapType to_ret;
         for (auto &[mtx, map] : data) {
             std::shared_lock locker(mtx);
             for (auto &[key, val] : map) {
                 to_ret[key.data] = val;
             }
         }
         return to_ret;
     }
 
 private:
     std::vector<SharedMap> data;
 };