xbmc/threads/Condition.h

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #pragma once
  10
  11 #include "threads/CriticalSection.h"
  12
  13 #include <chrono>
  14 #include <condition_variable>
  15 #include <functional>
  16 #include <mutex>
  17 #include <utility>
  18
  19 namespace XbmcThreads
  20 {
  21
  22   /**
  23    * This is a thin wrapper around std::condition_variable_any. It is subject
  24    *  to "spurious returns"
  25    */
  26   class ConditionVariable
  27   {
  28   private:
  29     std::condition_variable_any cond;
  30     ConditionVariable(const ConditionVariable&) = delete;
  31     ConditionVariable& operator=(const ConditionVariable&) = delete;
  32
  33   public:
  34     ConditionVariable() = default;
  35
  36     inline void wait(CCriticalSection& lock, std::function<bool()> predicate)
  37     {
  38       int count = lock.count;
  39       lock.count = 0;
  40       cond.wait(lock.get_underlying(), std::move(predicate));
  41       lock.count = count;
  42     }
  43
  44     inline void wait(CCriticalSection& lock)
  45     {
  46       int count  = lock.count;
  47       lock.count = 0;
  48       cond.wait(lock.get_underlying());
  49       lock.count = count;
  50     }
  51
  52     template<typename Rep, typename Period>
  53     inline bool wait(CCriticalSection& lock,
  54                      std::chrono::duration<Rep, Period> duration,
  55                      std::function<bool()> predicate)
  56     {
  57       int count = lock.count;
  58       lock.count = 0;
  59       bool ret = cond.wait_for(lock.get_underlying(), duration, predicate);
  60       lock.count = count;
  61       return ret;
  62     }
  63
  64     template<typename Rep, typename Period>
  65     inline bool wait(CCriticalSection& lock, std::chrono::duration<Rep, Period> duration)
  66     {
  67       int count  = lock.count;
  68       lock.count = 0;
  69       std::cv_status res = cond.wait_for(lock.get_underlying(), duration);
  70       lock.count = count;
  71       return res == std::cv_status::no_timeout;
  72     }
  73
  74     inline void wait(std::unique_lock<CCriticalSection>& lock, std::function<bool()> predicate)
  75     {
  76       cond.wait(*lock.mutex(), std::move(predicate));
  77     }
  78
  79     inline void wait(std::unique_lock<CCriticalSection>& lock) { wait(*lock.mutex()); }
  80
  81     template<typename Rep, typename Period>
  82     inline bool wait(std::unique_lock<CCriticalSection>& lock,
  83                      std::chrono::duration<Rep, Period> duration,
  84                      std::function<bool()> predicate)
  85     {
  86       return wait(*lock.mutex(), duration, predicate);
  87     }
  88
  89     template<typename Rep, typename Period>
  90     inline bool wait(std::unique_lock<CCriticalSection>& lock,
  91                      std::chrono::duration<Rep, Period> duration)
  92     {
  93       return wait(*lock.mutex(), duration);
  94     }
  95
  96     inline void notifyAll()
  97     {
  98       cond.notify_all();
  99     }
 100
 101     inline void notify()
 102     {
 103       cond.notify_one();
 104     }
 105   };
 106
 107 }
 108