semaphore.h

#pragma once
#include "future.h"
 
#include <mutex>
#include <queue>
 
namespace coro {
 
 
class semaphore {
public:
 
 
    semaphore() = default;
    semaphore(unsigned long counter): _counter (counter) {}
 
 
    coro::future<void> acquire() {
        return [&](auto promise) {
            std::lock_guard _(_mx);
            if (_counter) {
                --_counter;
                promise();
            } else {
                _waiting.push(std::move(promise));
            }
        };
    }
 
 
    coro::future<void> operator co_await() {
        return acquire();
    }
 
 
    coro::promise<void>::notify release() {
        coro::promise<void>::notify r;
        std::lock_guard _(_mx);
        if (_waiting.empty()) {
            ++_counter;
        } else {
             r = _waiting.front()();
            _waiting.pop();
        }
        return r;
    }
 
 
 
    long get() {
        std::lock_guard _(_mx);
        if (_counter) return static_cast<long>(_counter);
        return -static_cast<long>(_waiting.size());
    }
 
 
 
    bool try_acquire() {
        std::lock_guard _(_mx);
        if (!_counter) return false;
        --_counter;
        return true;
    }
 
 
protected:
    unsigned long _counter = 0;
    std::mutex _mx;
    std::queue<coro::promise<void> > _waiting;
 
};
 
 
}