From d2fcf4f863a2a34859a1e50769f97911f9c0b835 Mon Sep 17 00:00:00 2001
From: EntireTwix <willkatz.dev@gmail.com>
Date: Fri, 2 Apr 2021 23:55:31 -0700
Subject: [PATCH] :racehorse: made add/del user based on shared lock system for
 Save()

---
 include/bank.hpp | 23 +++++++++++------------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/include/bank.hpp b/include/bank.hpp
index ea4f24b..c31c06c 100644
--- a/include/bank.hpp
+++ b/include/bank.hpp
@@ -15,14 +15,14 @@ private:
         std::mutex>
         users;
 
-    std::mutex size_users;
+    std::shared_mutex size_lock;
 
 public:
     std::string admin_pass;
 
     bool AddUser(const std::string &name, std::string &&init_pass)
     {
-        std::unique_lock<std::mutex> lock{size_users};
+        std::shared_lock<std::shared_mutex> lock{size_lock};
         return users.try_emplace_l(
             name, [](User &) {}, std::forward<std::string &&>(init_pass));
     }
@@ -31,7 +31,7 @@ public:
         bool state = (admin_pass == attempt);
         if (state)
         {
-            std::unique_lock<std::mutex> lock{size_users};
+            std::shared_lock<std::shared_mutex> lock{size_lock};
             state = users.try_emplace_l(
                 name, [](User &) {}, init_bal, std::forward<std::string &&>(init_pass));
         }
@@ -40,12 +40,10 @@ public:
 
     bool DelUser(const std::string &name, const std::string &attempt)
     {
-        std::unique_lock<std::mutex> lock{size_users};
         return users.erase_if(name, [&attempt](const User &u) { return (attempt == u.password); });
     }
     bool AdminDelUser(const std::string &name, const std::string &attempt)
     {
-        std::unique_lock<std::mutex> lock{size_users};
         return users.erase_if(name, [this, &attempt](const User &) { return (admin_pass == attempt); });
     }
 
@@ -95,15 +93,16 @@ public:
 
         std::ofstream user_save("users.json");
         Json::Value temp;
-        //this gets access to the parallel map with the size being constant
-        std::unique_lock<std::mutex> lock{size_users};
-        for (const auto &u : users)
+
         {
-            //this gets read access to prevent writes
-            users.if_contains(u.first, [&temp, &u](const User &u_val) {
-                temp[u.first] = u_val.Serialize();
-            })
+            std::unique_lock<std::shared_mutex> lock{size_lock}; //grabbing it from any busy add/del opperations
+            for (const auto &u : users)
+            {
+                temp[u.first] = u.second.Serialize();
+            }
+            std::cout << "dropped unique lock\n";
         }
+
         writer->write(temp, &user_save);
         user_save.close();
     }