just kidding shared_mutexes are c++17

interface/src/raypick/LaserPointerManager.cpp

@@ -15,7 +15,7 @@ QUuid LaserPointerManager::createLaserPointer(const QVariantMap& rayProps, const
     const bool faceAvatar, const bool centerEndY, const bool lockEnd, const bool enabled) {
     std::shared_ptr<LaserPointer> laserPointer = std::make_shared<LaserPointer>(rayProps, renderStates, defaultRenderStates, faceAvatar, centerEndY, lockEnd, enabled);
     if (!laserPointer->getRayUID().isNull()) {
-        WriteLock lock(_addLock);
+        QWriteLocker lock(&_addLock);
         QUuid id = QUuid::createUuid();
         _laserPointersToAdd.push(std::pair<QUuid, std::shared_ptr<LaserPointer>>(id, laserPointer));
         return id;
@@ -24,46 +24,46 @@ QUuid LaserPointerManager::createLaserPointer(const QVariantMap& rayProps, const
 }
 
 void LaserPointerManager::removeLaserPointer(const QUuid uid) {
-    WriteLock lock(_removeLock);
+    QWriteLocker lock(&_removeLock);
     _laserPointersToRemove.push(uid);
 }
 
 void LaserPointerManager::enableLaserPointer(const QUuid uid) {
-    ReadLock lock(_containsLock);
+    QReadLocker lock(&_containsLock);
     if (_laserPointers.contains(uid)) {
-        WriteLock laserLock(*_laserPointerLocks[uid]);
+        QWriteLocker laserLock(_laserPointerLocks[uid].get());
         _laserPointers[uid]->enable();
     }
 }
 
 void LaserPointerManager::disableLaserPointer(const QUuid uid) {
-    ReadLock lock(_containsLock);
+    QReadLocker lock(&_containsLock);
     if (_laserPointers.contains(uid)) {
-        WriteLock laserLock(*_laserPointerLocks[uid]);
+        QWriteLocker laserLock(_laserPointerLocks[uid].get());
         _laserPointers[uid]->disable();
     }
 }
 
 void LaserPointerManager::setRenderState(QUuid uid, const std::string& renderState) {
-    ReadLock lock(_containsLock);
+    QReadLocker lock(&_containsLock);
     if (_laserPointers.contains(uid)) {
-        WriteLock laserLock(*_laserPointerLocks[uid]);
+        QWriteLocker laserLock(_laserPointerLocks[uid].get());
         _laserPointers[uid]->setRenderState(renderState);
     }
 }
 
 void LaserPointerManager::editRenderState(QUuid uid, const std::string& state, const QVariant& startProps, const QVariant& pathProps, const QVariant& endProps) {
-    ReadLock lock(_containsLock);
+    QReadLocker lock(&_containsLock);
     if (_laserPointers.contains(uid)) {
-        WriteLock laserLock(*_laserPointerLocks[uid]);
+        QWriteLocker laserLock(_laserPointerLocks[uid].get());
         _laserPointers[uid]->editRenderState(state, startProps, pathProps, endProps);
     }
 }
 
 const RayPickResult LaserPointerManager::getPrevRayPickResult(const QUuid uid) {
-    ReadLock lock(_containsLock);
+    QReadLocker lock(&_containsLock);
     if (_laserPointers.contains(uid)) {
-        ReadLock laserLock(*_laserPointerLocks[uid]);
+        QReadLocker laserLock(_laserPointerLocks[uid].get());
         return _laserPointers[uid]->getPrevRayPickResult();
     }
     return RayPickResult();
@@ -72,23 +72,23 @@ const RayPickResult LaserPointerManager::getPrevRayPickResult(const QUuid uid) {
 void LaserPointerManager::update() {
     for (QUuid& uid : _laserPointers.keys()) {
         // This only needs to be a read lock because update won't change any of the properties that can be modified from scripts
-        ReadLock laserLock(*_laserPointerLocks[uid]);
+        QReadLocker laserLock(_laserPointerLocks[uid].get());
         _laserPointers[uid]->update();
     }
 
-    WriteLock containsLock(_containsLock);
+    QWriteLocker containsLock(&_containsLock);
     {
-        WriteLock lock(_addLock);
+        QWriteLocker lock(&_addLock);
         while (!_laserPointersToAdd.empty()) {
             std::pair<QUuid, std::shared_ptr<LaserPointer>> laserPointerToAdd = _laserPointersToAdd.front();
             _laserPointersToAdd.pop();
             _laserPointers[laserPointerToAdd.first] = laserPointerToAdd.second;
-            _laserPointerLocks[laserPointerToAdd.first] = std::make_shared<std::shared_mutex>();
+            _laserPointerLocks[laserPointerToAdd.first] = std::make_shared<QReadWriteLock>();
         }
     }
 
     {
-        WriteLock lock(_removeLock);
+        QWriteLocker lock(&_removeLock);
         while (!_laserPointersToRemove.empty()) {
             QUuid uid = _laserPointersToRemove.front();
             _laserPointersToRemove.pop();
@@ -99,57 +99,57 @@ void LaserPointerManager::update() {
 }
 
 void LaserPointerManager::setIgnoreEntities(QUuid uid, const QScriptValue& ignoreEntities) {
-    ReadLock lock(_containsLock);
+    QReadLocker lock(&_containsLock);
     if (_laserPointers.contains(uid)) {
-        WriteLock laserLock(*_laserPointerLocks[uid]);
+        QWriteLocker laserLock(_laserPointerLocks[uid].get());
         _laserPointers[uid]->setIgnoreEntities(ignoreEntities);
     }
 }
 
 void LaserPointerManager::setIncludeEntities(QUuid uid, const QScriptValue& includeEntities) {
-    ReadLock lock(_containsLock);
+    QReadLocker lock(&_containsLock);
     if (_laserPointers.contains(uid)) {
-        WriteLock laserLock(*_laserPointerLocks[uid]);
+        QWriteLocker laserLock(_laserPointerLocks[uid].get());
         _laserPointers[uid]->setIncludeEntities(includeEntities);
     }
 }
 
 void LaserPointerManager::setIgnoreOverlays(QUuid uid, const QScriptValue& ignoreOverlays) {
-    ReadLock lock(_containsLock);
+    QReadLocker lock(&_containsLock);
     if (_laserPointers.contains(uid)) {
-        WriteLock laserLock(*_laserPointerLocks[uid]);
+        QWriteLocker laserLock(_laserPointerLocks[uid].get());
         _laserPointers[uid]->setIgnoreOverlays(ignoreOverlays);
     }
 }
 
 void LaserPointerManager::setIncludeOverlays(QUuid uid, const QScriptValue& includeOverlays) {
-    ReadLock lock(_containsLock);
+    QReadLocker lock(&_containsLock);
     if (_laserPointers.contains(uid)) {
-        WriteLock laserLock(*_laserPointerLocks[uid]);
+        QWriteLocker laserLock(_laserPointerLocks[uid].get());
         _laserPointers[uid]->setIncludeOverlays(includeOverlays);
     }
 }
 
 void LaserPointerManager::setIgnoreAvatars(QUuid uid, const QScriptValue& ignoreAvatars) {
-    ReadLock lock(_containsLock);
+    QReadLocker lock(&_containsLock);
     if (_laserPointers.contains(uid)) {
-        WriteLock laserLock(*_laserPointerLocks[uid]);
+        QWriteLocker laserLock(_laserPointerLocks[uid].get());
         _laserPointers[uid]->setIgnoreAvatars(ignoreAvatars);
     }
 }
 
 void LaserPointerManager::setIncludeAvatars(QUuid uid, const QScriptValue& includeAvatars) {
-    ReadLock lock(_containsLock);
+    QReadLocker lock(&_containsLock);
     if (_laserPointers.contains(uid)) {
-        WriteLock laserLock(*_laserPointerLocks[uid]);
+        QWriteLocker laserLock(_laserPointerLocks[uid].get());
         _laserPointers[uid]->setIncludeAvatars(includeAvatars);
     }
 }
 
 void LaserPointerManager::setLockEndUUID(QUuid uid, QUuid objectID, const bool isOverlay) {
-    ReadLock lock(_containsLock);
+    QReadLocker lock(&_containsLock);
     if (_laserPointers.contains(uid)) {
-        WriteLock laserLock(*_laserPointerLocks[uid]);
+        QWriteLocker laserLock(_laserPointerLocks[uid].get());
         _laserPointers[uid]->setLockEndUUID(objectID, isOverlay);
     }
 }

interface/src/raypick/LaserPointerManager.h

@@ -12,8 +12,8 @@
 #define hifi_LaserPointerManager_h
 
 #include <memory>
-#include <shared_mutex>
 #include <glm/glm.hpp>
+#include <QReadWriteLock>
 
 #include "LaserPointer.h"
 
@@ -44,15 +44,12 @@ public:
 
 private:
     QHash<QUuid, std::shared_ptr<LaserPointer>> _laserPointers;
-    QHash<QUuid, std::shared_ptr<std::shared_mutex>> _laserPointerLocks;
+    QHash<QUuid, std::shared_ptr<QReadWriteLock>> _laserPointerLocks;
-    std::shared_mutex _addLock;
+    QReadWriteLock _addLock;
     std::queue<std::pair<QUuid, std::shared_ptr<LaserPointer>>> _laserPointersToAdd;
-    std::shared_mutex _removeLock;
+    QReadWriteLock _removeLock;
     std::queue<QUuid> _laserPointersToRemove;
-    std::shared_mutex _containsLock;
+    QReadWriteLock _containsLock;
-
-    typedef std::lock_guard<std::shared_mutex> WriteLock;
-    typedef std::shared_lock<std::shared_mutex> ReadLock;
 
 };
 

interface/src/raypick/RayPickManager.cpp

@@ -111,7 +111,7 @@ void RayPickManager::update() {
             }
         }
 
-        WriteLock lock(*_rayPickLocks[uid]);
+        QWriteLocker lock(_rayPickLocks[uid].get());
         if (rayPick->getMaxDistance() == 0.0f || (rayPick->getMaxDistance() > 0.0f && res.distance < rayPick->getMaxDistance())) {
             rayPick->setRayPickResult(res);
         } else {
@@ -119,19 +119,19 @@ void RayPickManager::update() {
         }
     }
 
-    WriteLock containsLock(_containsLock);
+    QWriteLocker containsLock(&_containsLock);
     {
-        WriteLock lock(_addLock);
+        QWriteLocker lock(&_addLock);
         while (!_rayPicksToAdd.empty()) {
             std::pair<QUuid, std::shared_ptr<RayPick>> rayPickToAdd = _rayPicksToAdd.front();
             _rayPicksToAdd.pop();
             _rayPicks[rayPickToAdd.first] = rayPickToAdd.second;
-            _rayPickLocks[rayPickToAdd.first] = std::make_shared<std::shared_mutex>();
+            _rayPickLocks[rayPickToAdd.first] = std::make_shared<QReadWriteLock>();
         }
     }
 
     {
-        WriteLock lock(_removeLock);
+        QWriteLocker lock(&_removeLock);
         while (!_rayPicksToRemove.empty()) {
             QUuid uid = _rayPicksToRemove.front();
             _rayPicksToRemove.pop();
@@ -172,12 +172,12 @@ QUuid RayPickManager::createRayPick(const QVariantMap& rayProps) {
                 dirOffset = vec3FromVariant(rayProps["dirOffset"]);
             }
 
-            WriteLock lock(_addLock);
+            QWriteLocker lock(&_addLock);
             QUuid id = QUuid::createUuid();
             _rayPicksToAdd.push(std::pair<QUuid, std::shared_ptr<RayPick>>(id, std::make_shared<JointRayPick>(jointName, posOffset, dirOffset, filter, maxDistance, enabled)));
             return id;
         } else {
-            WriteLock lock(_addLock);
+            QWriteLocker lock(&_addLock);
             QUuid id = QUuid::createUuid();
             _rayPicksToAdd.push(std::pair<QUuid, std::shared_ptr<RayPick>>(id, std::make_shared<MouseRayPick>(filter, maxDistance, enabled)));
             return id;
@@ -190,7 +190,7 @@ QUuid RayPickManager::createRayPick(const QVariantMap& rayProps) {
             direction = vec3FromVariant(rayProps["direction"]);
         }
 
-        WriteLock lock(_addLock);
+        QWriteLocker lock(&_addLock);
         QUuid id = QUuid::createUuid();
         _rayPicksToAdd.push(std::pair<QUuid, std::shared_ptr<RayPick>>(id, std::make_shared<StaticRayPick>(position, direction, filter, maxDistance, enabled)));
         return id;
@@ -200,28 +200,28 @@ QUuid RayPickManager::createRayPick(const QVariantMap& rayProps) {
 }
 
 void RayPickManager::removeRayPick(const QUuid uid) {
-    WriteLock lock(_removeLock);
+    QWriteLocker lock(&_removeLock);
     _rayPicksToRemove.push(uid);
 }
 
 void RayPickManager::enableRayPick(const QUuid uid) {
-    ReadLock containsLock(_containsLock);
+    QReadLocker containsLock(&_containsLock);
     if (_rayPicks.contains(uid)) {
-        WriteLock rayPickLock(*_rayPickLocks[uid]);
+        QWriteLocker rayPickLock(_rayPickLocks[uid].get());
         _rayPicks[uid]->enable();
     }
 }
 
 void RayPickManager::disableRayPick(const QUuid uid) {
-    ReadLock containsLock(_containsLock);
+    QReadLocker containsLock(&_containsLock);
     if (_rayPicks.contains(uid)) {
-        WriteLock rayPickLock(*_rayPickLocks[uid]);
+        QWriteLocker rayPickLock(_rayPickLocks[uid].get());
         _rayPicks[uid]->disable();
     }
 }
 
 const PickRay RayPickManager::getPickRay(const QUuid uid) {
-    ReadLock containsLock(_containsLock);
+    QReadLocker containsLock(&_containsLock);
     if (_rayPicks.contains(uid)) {
         bool valid;
         PickRay pickRay = _rayPicks[uid]->getPickRay(valid);
@@ -233,58 +233,58 @@ const PickRay RayPickManager::getPickRay(const QUuid uid) {
 }
 
 const RayPickResult RayPickManager::getPrevRayPickResult(const QUuid uid) {
-    ReadLock containsLock(_containsLock);
+    QReadLocker containsLock(&_containsLock);
     if (_rayPicks.contains(uid)) {
-        ReadLock lock(*_rayPickLocks[uid]);
+        QReadLocker lock(_rayPickLocks[uid].get());
         return _rayPicks[uid]->getPrevRayPickResult();
     }
     return RayPickResult();
 }
 
 void RayPickManager::setIgnoreEntities(QUuid uid, const QScriptValue& ignoreEntities) {
-    ReadLock containsLock(_containsLock);
+    QReadLocker containsLock(&_containsLock);
     if (_rayPicks.contains(uid)) {
-        WriteLock lock(*_rayPickLocks[uid]);
+        QWriteLocker lock(_rayPickLocks[uid].get());
         _rayPicks[uid]->setIgnoreEntities(ignoreEntities);
     }
 }
 
 void RayPickManager::setIncludeEntities(QUuid uid, const QScriptValue& includeEntities) {
-    ReadLock containsLock(_containsLock);
+    QReadLocker containsLock(&_containsLock);
     if (_rayPicks.contains(uid)) {
-        WriteLock lock(*_rayPickLocks[uid]);
+        QWriteLocker lock(_rayPickLocks[uid].get());
         _rayPicks[uid]->setIncludeEntities(includeEntities);
     }
 }
 
 void RayPickManager::setIgnoreOverlays(QUuid uid, const QScriptValue& ignoreOverlays) {
-    ReadLock containsLock(_containsLock);
+    QReadLocker containsLock(&_containsLock);
     if (_rayPicks.contains(uid)) {
-        WriteLock lock(*_rayPickLocks[uid]);
+        QWriteLocker lock(_rayPickLocks[uid].get());
         _rayPicks[uid]->setIgnoreOverlays(ignoreOverlays);
     }
 }
 
 void RayPickManager::setIncludeOverlays(QUuid uid, const QScriptValue& includeOverlays) {
-    ReadLock containsLock(_containsLock);
+    QReadLocker containsLock(&_containsLock);
     if (_rayPicks.contains(uid)) {
-        WriteLock lock(*_rayPickLocks[uid]);
+        QWriteLocker lock(_rayPickLocks[uid].get());
         _rayPicks[uid]->setIncludeOverlays(includeOverlays);
     }
 }
 
 void RayPickManager::setIgnoreAvatars(QUuid uid, const QScriptValue& ignoreAvatars) {
-    ReadLock containsLock(_containsLock);
+    QReadLocker containsLock(&_containsLock);
     if (_rayPicks.contains(uid)) {
-        WriteLock lock(*_rayPickLocks[uid]);
+        QWriteLocker lock(_rayPickLocks[uid].get());
         _rayPicks[uid]->setIgnoreAvatars(ignoreAvatars);
     }
 }
 
 void RayPickManager::setIncludeAvatars(QUuid uid, const QScriptValue& includeAvatars) {
-    ReadLock containsLock(_containsLock);
+    QReadLocker containsLock(&_containsLock);
     if (_rayPicks.contains(uid)) {
-        WriteLock lock(*_rayPickLocks[uid]);
+        QWriteLocker lock(_rayPickLocks[uid].get());
         _rayPicks[uid]->setIncludeAvatars(includeAvatars);
     }
 }

interface/src/raypick/RayPickManager.h

@@ -14,8 +14,8 @@
 #include "RayPick.h"
 
 #include <memory>
-#include <shared_mutex>
 #include <QtCore/QObject>
+#include <QReadWriteLock>
 
 #include "RegisteredMetaTypes.h"
 #include "DependencyManager.h"
@@ -63,12 +63,12 @@ public slots:
 
 private:
     QHash<QUuid, std::shared_ptr<RayPick>> _rayPicks;
-    QHash<QUuid, std::shared_ptr<std::shared_mutex>> _rayPickLocks;
+    QHash<QUuid, std::shared_ptr<QReadWriteLock>> _rayPickLocks;
-    std::shared_mutex _addLock;
+    QReadWriteLock _addLock;
     std::queue<std::pair<QUuid, std::shared_ptr<RayPick>>> _rayPicksToAdd;
-    std::shared_mutex _removeLock;
+    QReadWriteLock _removeLock;
     std::queue<QUuid> _rayPicksToRemove;
-    std::shared_mutex _containsLock;
+    QReadWriteLock _containsLock;
 
     typedef QHash<QPair<glm::vec3, glm::vec3>, std::unordered_map<RayPickFilter::Flags, RayPickResult>> RayPickCache;
 
@@ -91,9 +91,6 @@ private:
     unsigned int INTERSECTED_AVATAR() { return IntersectionType::AVATAR; }
     unsigned int INTERSECTED_HUD() { return IntersectionType::HUD; }
 
-    typedef std::lock_guard<std::shared_mutex> WriteLock;
-    typedef std::shared_lock<std::shared_mutex> ReadLock;
-
 };
 
 #endif // hifi_RayPickManager_h