Event.h

/*
 *  Copyright (C) 2005-2018 Team Kodi
 *  This file is part of Kodi - https://kodi.tv
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *  See LICENSES/README.md for more information.
 */

#pragma once

#include "threads/Condition.h"

#include <initializer_list>
#include <memory>
#include <mutex>
#include <vector>

// forward declare the CEventGroup
namespace XbmcThreads
{
class CEventGroup;
}

class CEvent
{
  bool manualReset;
  volatile bool signaled;
  unsigned int numWaits = 0;

  CCriticalSection groupListMutex; // lock for the groups list
  std::unique_ptr<std::vector<XbmcThreads::CEventGroup*>> groups;

  XbmcThreads::ConditionVariable actualCv;
  CCriticalSection mutex;

  friend class XbmcThreads::CEventGroup;

  void addGroup(XbmcThreads::CEventGroup* group);
  void removeGroup(XbmcThreads::CEventGroup* group);

  // helper for the two wait methods
  inline bool prepReturn()
  {
    bool ret = signaled;
    if (!manualReset && numWaits == 0)
      signaled = false;
    return ret;
  }

  CEvent(const CEvent&) = delete;
  CEvent& operator=(const CEvent&) = delete;

public:
  inline CEvent(bool manual = false, bool signaled_ = false)
    : manualReset(manual), signaled(signaled_)
  {
  }

  inline void Reset()
  {
    std::unique_lock<CCriticalSection> lock(mutex);
    signaled = false;
  }
  void Set();

  inline bool Signaled()
  {
    std::unique_lock<CCriticalSection> lock(mutex);
    return signaled;
  }

  template<typename Rep, typename Period>
  inline bool Wait(std::chrono::duration<Rep, Period> duration)
  {
    std::unique_lock<CCriticalSection> lock(mutex);
    numWaits++;
    actualCv.wait(mutex, duration, std::bind(&CEvent::Signaled, this));
    numWaits--;
    return prepReturn();
  }

  inline bool Wait()
  {
    std::unique_lock<CCriticalSection> lock(mutex);
    numWaits++;
    actualCv.wait(mutex, std::bind(&CEvent::Signaled, this));
    numWaits--;
    return prepReturn();
  }

  inline int getNumWaits()
  {
    std::unique_lock<CCriticalSection> lock(mutex);
    return numWaits;
  }
};

namespace XbmcThreads
{
class CEventGroup
{
  std::vector<CEvent*> events;
  CEvent* signaled{};
  XbmcThreads::ConditionVariable actualCv;
  CCriticalSection mutex;

  unsigned int numWaits{0};

  // This is ONLY called from CEvent::Set.
  inline void Set(CEvent* child)
  {
    std::unique_lock<CCriticalSection> l(mutex);
    signaled = child;
    actualCv.notifyAll();
  }

  friend class ::CEvent;

  CEventGroup(const CEventGroup&) = delete;
  CEventGroup& operator=(const CEventGroup&) = delete;

public:
  CEventGroup(std::initializer_list<CEvent*> events);

  ~CEventGroup();

  CEvent* wait();

  template<typename Rep, typename Period>
  CEvent* wait(std::chrono::duration<Rep, Period> duration)
  {
    std::unique_lock<CCriticalSection> lock(mutex); // grab CEventGroup::mutex
    numWaits++;

    // ==================================================
    // This block checks to see if any child events are
    // signaled and sets 'signaled' to the first one it
    // finds.
    // ==================================================
    signaled = nullptr;
    for (auto* cur : events)
    {
      std::unique_lock<CCriticalSection> lock2(cur->mutex);
      if (cur->signaled)
        signaled = cur;
    }
    // ==================================================

    if (!signaled)
    {
      // both of these release the CEventGroup::mutex
      if (duration == std::chrono::duration<Rep, Period>::max())
        actualCv.wait(mutex, [this]() { return signaled != nullptr; });
      else
        actualCv.wait(mutex, duration, [this]() { return signaled != nullptr; });
    } // at this point the CEventGroup::mutex is reacquired
    numWaits--;

    // signaled should have been set by a call to CEventGroup::Set
    CEvent* ret = signaled;
    if (numWaits == 0)
    {
      if (signaled)
        // This acquires and releases the CEvent::mutex. This is fine since the
        //  CEventGroup::mutex is already being held
        signaled->Wait(std::chrono::duration<Rep, Period>::zero()); // reset the event if needed
      signaled = nullptr; // clear the signaled if all the waiters are gone
    }
    return ret;
  }

  inline int getNumWaits()
  {
    std::unique_lock<CCriticalSection> lock(mutex);
    return numWaits;
  }
};
} // namespace XbmcThreads