1 files changed, 58 insertions, 30 deletions

diff --git a/core/os/rw_lock.h b/core/os/rw_lock.h
index 1190102a83..560ec57a5f 100644
--- a/core/os/rw_lock.h
+++ b/core/os/rw_lock.h
@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md).   */
 /*                                                                       */
 /* Permission is hereby granted, free of charge, to any person obtaining */
 /* a copy of this software and associated documentation files (the       */
@@ -33,55 +33,83 @@
 
 #include "core/error/error_list.h"
 
+#if !defined(NO_THREADS)
+
+#include <shared_mutex>
+
 class RWLock {
-protected:
-	static RWLock *(*create_func)();
+	mutable std::shared_timed_mutex mutex;
 
 public:
-	virtual void read_lock() = 0; ///< Lock the rwlock, block if locked by someone else
-	virtual void read_unlock() = 0; ///< Unlock the rwlock, let other threads continue
-	virtual Error read_try_lock() = 0; ///< Attempt to lock the rwlock, OK on success, ERROR means it can't lock.
+	// Lock the rwlock, block if locked by someone else
+	void read_lock() const {
+		mutex.lock_shared();
+	}
 
-	virtual void write_lock() = 0; ///< Lock the rwlock, block if locked by someone else
-	virtual void write_unlock() = 0; ///< Unlock the rwlock, let other thwrites continue
-	virtual Error write_try_lock() = 0; ///< Attempt to lock the rwlock, OK on success, ERROR means it can't lock.
+	// Unlock the rwlock, let other threads continue
+	void read_unlock() const {
+		mutex.unlock_shared();
+	}
 
-	static RWLock *create(); ///< Create a rwlock
+	// Attempt to lock the rwlock, OK on success, ERR_BUSY means it can't lock.
+	Error read_try_lock() const {
+		return mutex.try_lock_shared() ? OK : ERR_BUSY;
+	}
+
+	// Lock the rwlock, block if locked by someone else
+	void write_lock() {
+		mutex.lock();
+	}
+
+	// Unlock the rwlock, let other thwrites continue
+	void write_unlock() {
+		mutex.unlock();
+	}
 
-	virtual ~RWLock() {}
+	// Attempt to lock the rwlock, OK on success, ERR_BUSY means it can't lock.
+	Error write_try_lock() {
+		return mutex.try_lock() ? OK : ERR_BUSY;
+	}
+};
+
+#else
+
+class RWLock {
+public:
+	void read_lock() const {}
+	void read_unlock() const {}
+	Error read_try_lock() const { return OK; }
+
+	void write_lock() {}
+	void write_unlock() {}
+	Error write_try_lock() { return OK; }
 };
 
+#endif
+
 class RWLockRead {
-	RWLock *lock;
+	const RWLock &lock;
 
 public:
-	RWLockRead(const RWLock *p_lock) {
-		lock = const_cast<RWLock *>(p_lock);
-		if (lock) {
-			lock->read_lock();
-		}
+	RWLockRead(const RWLock &p_lock) :
+			lock(p_lock) {
+		lock.read_lock();
 	}
 	~RWLockRead() {
-		if (lock) {
-			lock->read_unlock();
-		}
+		lock.read_unlock();
 	}
 };
 
 class RWLockWrite {
-	RWLock *lock;
+	RWLock &lock;
 
 public:
-	RWLockWrite(RWLock *p_lock) {
-		lock = p_lock;
-		if (lock) {
-			lock->write_lock();
-		}
+	RWLockWrite(RWLock &p_lock) :
+			lock(p_lock) {
+		lock.write_lock();
 	}
 	~RWLockWrite() {
-		if (lock) {
-			lock->write_unlock();
-		}
+		lock.write_unlock();
 	}
 };