Event.h

/***********************************************************************************************************************
*                                                                                                                      *
* glscopeclient                                                                                                        *
*                                                                                                                      *
* Copyright (c) 2012-2022 Andrew D. Zonenberg                                                                          *
* All rights reserved.                                                                                                 *
*                                                                                                                      *
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the     *
* following conditions are met:                                                                                        *
*                                                                                                                      *
*    * Redistributions of source code must retain the above copyright notice, this list of conditions, and the         *
*      following disclaimer.                                                                                           *
*                                                                                                                      *
*    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the       *
*      following disclaimer in the documentation and/or other materials provided with the distribution.                *
*                                                                                                                      *
*    * Neither the name of the author nor the names of any contributors may be used to endorse or promote products     *
*      derived from this software without specific prior written permission.                                           *
*                                                                                                                      *
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED   *
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL *
* THE AUTHORS BE HELD LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES        *
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR       *
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE       *
* POSSIBILITY OF SUCH DAMAGE.                                                                                          *
*                                                                                                                      *
***********************************************************************************************************************/
#ifndef Event_h
#define Event_h
 
class Event
{
public:
    Event()
    { m_ready = false; }
 
    void Signal()
    {
        m_ready = true;
        m_cond.notify_one();
    }
 
    bool SignalIfNotAlreadySignaled()
    {
        //Existing event pending? We did nothing
        if(m_ready.exchange(true) == true)
            return false;
 
        //No event was already pending so we submitted one.
        else
        {
            m_cond.notify_one();
            return true;
        }
    }
 
 
    void SignalExactlyOnce(Event& processedEvent)
    {
        while(true)
        {
            //Existing event pending? Block until it's completed
            if(m_ready.exchange(true) == true)
                processedEvent.Block();
 
            //No event was already pending so we submitted one.
            else
            {
                m_cond.notify_one();
                break;
            }
        }
    }
 
    void Block()
    {
        std::unique_lock<std::mutex> lock(m_mutex);
        m_cond.wait(lock, [&]{ return m_ready.load(); });
        m_ready = false;
    }
 
    bool Peek(bool clearReady = true)
    {
        if(m_ready)
        {
            if(clearReady)
                m_ready = false;
            return true;
        }
 
        return false;
    }
 
    void Clear()
    {
        m_ready = false;
    }
 
protected:
    std::mutex m_mutex;
    std::condition_variable m_cond;
    std::atomic_bool m_ready;
};
 
#endif