Drop old semaphore implementation

- Removed platform-specific implementations.
- Now all semaphores are in-object, unless they need to be conditionally created.
- Similarly to `Mutex`, provided a dummy implementation for when `NO_THREADS` is defined.
- Similarly to `Mutex`, methods are made `const` for easy use in such contexts.
- Language bindings updated: `wait()` and `post()` are now `void`.
- Language bindings updated: `try_wait()` added.

Bonus:
- Rewritten the `#ifdef` in `mutex.h` to meet the code style.

1 files changed, 15 insertions, 16 deletions

diff --git a/core/os/semaphore.h b/core/os/semaphore.h
index f16a15a6db..6f194d4887 100644
--- a/core/os/semaphore.h
+++ b/core/os/semaphore.h
@@ -34,30 +34,32 @@
 #include "core/error_list.h"
 #include "core/typedefs.h"
 
+#if !defined(NO_THREADS)
+
 #include <condition_variable>
 #include <mutex>
 
 class Semaphore {
 private:
-	std::mutex mutex_;
-	std::condition_variable condition_;
-	unsigned long count_ = 0; // Initialized as locked.
+	mutable std::mutex mutex_;
+	mutable std::condition_variable condition_;
+	mutable unsigned long count_ = 0; // Initialized as locked.
 
 public:
-	_ALWAYS_INLINE_ void post() {
+	_ALWAYS_INLINE_ void post() const {
 		std::lock_guard<decltype(mutex_)> lock(mutex_);
 		++count_;
 		condition_.notify_one();
 	}
 
-	_ALWAYS_INLINE_ void wait() {
+	_ALWAYS_INLINE_ void wait() const {
 		std::unique_lock<decltype(mutex_)> lock(mutex_);
 		while (!count_) // Handle spurious wake-ups.
 			condition_.wait(lock);
 		--count_;
 	}
 
-	_ALWAYS_INLINE_ bool try_wait() {
+	_ALWAYS_INLINE_ bool try_wait() const {
 		std::lock_guard<decltype(mutex_)> lock(mutex_);
 		if (count_) {
 			--count_;
@@ -67,18 +69,15 @@ public:
 	}
 };
 
-class SemaphoreOld {
-protected:
-	static SemaphoreOld *(*create_func)();
+#else
 
+class Semaphore {
 public:
-	virtual Error wait() = 0; ///< wait until semaphore has positive value, then decrement and pass
-	virtual Error post() = 0; ///< unlock the semaphore, incrementing the    value
-	virtual int get() const = 0; ///< get semaphore value
-
-	static SemaphoreOld *create(); ///< Create a mutex
-
-	virtual ~SemaphoreOld();
+	_ALWAYS_INLINE_ void post() const {}
+	_ALWAYS_INLINE_ void wait() const {}
+	_ALWAYS_INLINE_ bool try_wait() const { return true; }
 };
 
 #endif
+
+#endif