Make AccessGuard use a shared_mutex instead (#2702)

This allows `accessConst` to use a shared lock instead of a unique lock

src/common/ChannelChatters.cpp

@@ -11,7 +11,7 @@ ChannelChatters::ChannelChatters(Channel &channel)
 {
 }
 
-AccessGuard<const UsernameSet> ChannelChatters::accessChatters() const
+SharedAccessGuard<const UsernameSet> ChannelChatters::accessChatters() const
 {
     return this->chatters_.accessConst();
 }

src/common/ChannelChatters.hpp

@@ -15,7 +15,7 @@ public:
     ChannelChatters(Channel &channel);
     virtual ~ChannelChatters() = default;  // add vtable
 
-    AccessGuard<const UsernameSet> accessChatters() const;
+    SharedAccessGuard<const UsernameSet> accessChatters() const;
 
     void addRecentChatter(const QString &user);
     void addJoinedUser(const QString &user);

src/common/UniqueAccess.hpp

@@ -1,39 +1,33 @@
 #pragma once
 
 #include <mutex>
+#include <shared_mutex>
 #include <type_traits>
 
 namespace chatterino {
 
-template <typename T>
+template <typename T, typename LockType = std::unique_lock<std::shared_mutex>>
 class AccessGuard
 {
 public:
-    AccessGuard(T &element, std::mutex &mutex)
+    AccessGuard(T &element, std::shared_mutex &mutex)
         : element_(&element)
-        , mutex_(&mutex)
+        , lock_(mutex)
     {
-        this->mutex_->lock();
     }
 
-    AccessGuard(AccessGuard<T> &&other)
+    AccessGuard(AccessGuard<T, LockType> &&other)
         : element_(other.element_)
-        , mutex_(other.mutex_)
+        , lock_(std::move(other.lock_))
     {
-        other.isValid_ = false;
     }
 
-    AccessGuard<T> &operator=(AccessGuard<T> &&other)
+    AccessGuard<T, LockType> &operator=(AccessGuard<T, LockType> &&other)
     {
-        other.isValid_ = false;
         this->element_ = other.element_;
-        this->mutex_ = other.element_;
-    }
+        this->lock_ = std::move(other.lock_);
 
-    ~AccessGuard()
-    {
-        if (this->isValid_)
-            this->mutex_->unlock();
+        return *this;
     }
 
     T *operator->() const
@@ -48,10 +42,13 @@ public:
 
 private:
     T *element_{};
-    std::mutex *mutex_{};
-    bool isValid_{true};
+    LockType lock_;
 };
 
+template <typename T>
+using SharedAccessGuard =
+    AccessGuard<const T, std::shared_lock<std::shared_mutex>>;
+
 template <typename T>
 class UniqueAccess
 {
@@ -90,14 +87,14 @@ public:
 
     template <typename X = T,
               typename = std::enable_if_t<!std::is_const<X>::value>>
-    AccessGuard<const X> accessConst() const
+    SharedAccessGuard<const X> accessConst() const
     {
-        return AccessGuard<const T>(this->element_, this->mutex_);
+        return SharedAccessGuard<const T>(this->element_, this->mutex_);
     }
 
 private:
     mutable T element_;
-    mutable std::mutex mutex_;
+    mutable std::shared_mutex mutex_;
 };
 
 }  // namespace chatterino

src/providers/twitch/TwitchAccount.cpp

@@ -176,12 +176,14 @@ void TwitchAccount::checkFollow(const QString targetUserID,
                               [] {});
 }
 
-AccessGuard<const std::set<TwitchUser>> TwitchAccount::accessBlocks() const
+SharedAccessGuard<const std::set<TwitchUser>> TwitchAccount::accessBlocks()
+    const
 {
     return this->ignores_.accessConst();
 }
 
-AccessGuard<const std::set<QString>> TwitchAccount::accessBlockedUserIds() const
+SharedAccessGuard<const std::set<QString>> TwitchAccount::accessBlockedUserIds()
+    const
 {
     return this->ignoresUserIds_.accessConst();
 }
@@ -345,7 +347,7 @@ void TwitchAccount::loadUserstateEmotes(QStringList emoteSetKeys)
         });
 }
 
-AccessGuard<const TwitchAccount::TwitchAccountEmoteData>
+SharedAccessGuard<const TwitchAccount::TwitchAccountEmoteData>
     TwitchAccount::accessEmotes() const
 {
     return this->emotes_.accessConst();

src/providers/twitch/TwitchAccount.hpp

@@ -106,12 +106,12 @@ public:
     void checkFollow(const QString targetUserID,
                      std::function<void(FollowResult)> onFinished);
 
-    AccessGuard<const std::set<QString>> accessBlockedUserIds() const;
-    AccessGuard<const std::set<TwitchUser>> accessBlocks() const;
+    SharedAccessGuard<const std::set<QString>> accessBlockedUserIds() const;
+    SharedAccessGuard<const std::set<TwitchUser>> accessBlocks() const;
 
     void loadEmotes();
     void loadUserstateEmotes(QStringList emoteSetKeys);
-    AccessGuard<const TwitchAccountEmoteData> accessEmotes() const;
+    SharedAccessGuard<const TwitchAccountEmoteData> accessEmotes() const;
 
     // Automod actions
     void autoModAllow(const QString msgID);

src/providers/twitch/TwitchChannel.cpp

@@ -454,8 +454,8 @@ void TwitchChannel::setRoomId(const QString &id)
     }
 }
 
-AccessGuard<const TwitchChannel::RoomModes> TwitchChannel::accessRoomModes()
-    const
+SharedAccessGuard<const TwitchChannel::RoomModes>
+    TwitchChannel::accessRoomModes() const
 {
     return this->roomModes_.accessConst();
 }
@@ -472,7 +472,7 @@ bool TwitchChannel::isLive() const
     return this->streamStatus_.access()->live;
 }
 
-AccessGuard<const TwitchChannel::StreamStatus>
+SharedAccessGuard<const TwitchChannel::StreamStatus>
     TwitchChannel::accessStreamStatus() const
 {
     return this->streamStatus_.accessConst();

src/providers/twitch/TwitchChannel.hpp

@@ -83,8 +83,8 @@ public:
     int chatterCount();
     virtual bool isLive() const override;
     QString roomId() const;
-    AccessGuard<const RoomModes> accessRoomModes() const;
-    AccessGuard<const StreamStatus> accessStreamStatus() const;
+    SharedAccessGuard<const RoomModes> accessRoomModes() const;
+    SharedAccessGuard<const StreamStatus> accessStreamStatus() const;
 
     // Emotes
     const TwitchBadges &globalTwitchBadges() const;