28 ThreadBlockerWhileUsed2

No longer used so the code is only recorded here in this web-page.

A specialised version that assumes Wait() is called exactly once, allowing for a more efficient implementation.

class ThreadBlockerWhileUsed2
{
    cxNotCloneable(ThreadBlockerWhileUsed2)
    
public:
    explicit ThreadBlockerWhileUsed2(int count = 0) : count_(count), closed_(false) {}

    ~ThreadBlockerWhileUsed2()
    {
        cxAssert(closed_);
        cxAssert(count_ == 0);
    }

    int operator++() 
    {
        std::lock_guard<std::mutex> lock(mutex_);
        ++count_;
        return count_;
    }

    int operator--()
    {
        std::lock_guard<std::mutex> lock(mutex_);
        cxAssert(count_ > 0);
        if (--count_ == 0 && closed_)
        {
            cv_.notify_one();
        }
        return count_;
    }

    // Postfix
    int operator++(int) { return operator++()-1; }
    int operator--(int) { return operator--()+1; }

    void Wait()
    {
        std::unique_lock<std::mutex> lock(mutex_);
        cxAssert(!closed_);
        closed_ = true;
        cv_.wait(lock,[this]{return count_ == 0;});
    }
private:
    std::mutex mutex_;
    std::condition_variable cv_;  // condition = (count_ == 0 && closed_)
    int count_;
    bool closed_;
};