platform: let CTimeout return uint32_t instead of uint64_t. fixes compilation warning

[deb_libcec.git] / src / lib / platform / threads / mutex.h

diff --git a/src/lib/platform/threads/mutex.h b/src/lib/platform/threads/mutex.h
index bb4e006e331b373dfacd585eb682e53e5f47f697..4a0c331a1fa6d64cbffa29e8466e25c29aca211a 100644 (file)
--- a/src/lib/platform/threads/mutex.h
+++ b/src/lib/platform/threads/mutex.h
@@ -54,11 +54,13 @@ namespace PLATFORM
     inline PreventCopy &operator=(const PreventCopy &c){ *this = c; return *this; }
   };
 
-  class CCondition;
+  template <typename _Predicate>
+    class CCondition;
 
   class CMutex : public PreventCopy
   {
-    friend class CCondition;
+    template <typename _Predicate>
+      friend class CCondition;
   public:
     inline CMutex(void) :
       m_iLockCount(0)
@@ -223,16 +225,66 @@ namespace PLATFORM
     volatile bool m_bIsLocked;
   };
 
-  class CCondition : public PreventCopy
+  template <typename _Predicate>
+    class CCondition : public PreventCopy
+    {
+    public:
+      inline CCondition(void) {}
+      inline ~CCondition(void)
+      {
+        m_condition.Broadcast();
+      }
+
+      inline void Broadcast(void)
+      {
+        m_condition.Broadcast();
+      }
+
+      inline void Signal(void)
+      {
+        m_condition.Signal();
+      }
+
+      inline bool Wait(CMutex &mutex, _Predicate &predicate)
+      {
+        while(!predicate)
+          m_condition.Wait(mutex.m_mutex);
+        return true;
+      }
+
+      inline bool Wait(CMutex &mutex, _Predicate &predicate, uint32_t iTimeout)
+      {
+        if (iTimeout == 0)
+          return Wait(mutex, predicate);
+
+        bool bReturn(true);
+        if (!predicate)
+        {
+          CTimeout timeout(iTimeout);
+          uint32_t iMsLeft(0);
+          bReturn = false;
+          while (!bReturn)
+          {
+            iMsLeft = timeout.TimeLeft();
+            if ((bReturn = iMsLeft == 0 || predicate) == false)
+              m_condition.Wait(mutex.m_mutex, iMsLeft);
+          }
+        }
+        return bReturn;
+      }
+
+    private:
+      CConditionImpl m_condition;
+    };
+
+  class CEvent
   {
   public:
-    inline CCondition(void) :
-      m_bPredicate(false),
+    CEvent(void) :
+      m_bSignaled(false),
+      m_bBroadcast(false),
       m_iWaitingThreads(0) {}
-    inline ~CCondition(void)
-    {
-      Broadcast();
-    }
+    virtual ~CEvent(void) {}
 
     void Broadcast(void)
     {
@@ -246,57 +298,53 @@ namespace PLATFORM
       m_condition.Signal();
     }
 
-    bool Wait(CMutex &mutex, uint32_t iTimeout = 0)
+    bool Wait(void)
     {
-      {
-        CLockObject lock(m_mutex);
-        ++m_iWaitingThreads;
-      }
+      CLockObject lock(m_mutex);
+      ++m_iWaitingThreads;
 
-      if (iTimeout > 0)
-      {
-        CTimeout timeout(iTimeout);
-        while (!m_bPredicate && timeout.TimeLeft() > 0)
-          m_condition.Wait(mutex.m_mutex, timeout.TimeLeft());
-      }
-      else
-      {
-        while (!m_bPredicate)
-          m_condition.Wait(mutex.m_mutex, 0);
-      }
+      bool bReturn = m_condition.Wait(m_mutex, m_bSignaled);
+      return ResetAndReturn() && bReturn;
+    }
+
+    bool Wait(uint32_t iTimeout)
+    {
+      if (iTimeout == 0)
+        return Wait();
 
-      return ResetAndReturn();
+      CLockObject lock(m_mutex);
+      ++m_iWaitingThreads;
+      bool bReturn = m_condition.Wait(m_mutex, m_bSignaled, iTimeout);
+      return ResetAndReturn() && bReturn;
     }
 
     static void Sleep(uint32_t iTimeout)
     {
-      CCondition w;
-      CMutex m;
-      CLockObject lock(m);
-      w.Wait(m, iTimeout);
+      CEvent event;
+      event.Wait(iTimeout);
     }
 
   private:
     void Set(bool bBroadcast = false)
     {
       CLockObject lock(m_mutex);
-      m_bPredicate = true;
+      m_bSignaled  = true;
       m_bBroadcast = bBroadcast;
     }
 
     bool ResetAndReturn(void)
     {
       CLockObject lock(m_mutex);
-      bool bReturn(m_bPredicate);
+      bool bReturn(m_bSignaled);
       if (bReturn && (--m_iWaitingThreads == 0 || !m_bBroadcast))
-        m_bPredicate = false;
+        m_bSignaled = false;
       return bReturn;
     }
 
-    CMutex         m_mutex;
-    CConditionImpl m_condition;
-    volatile bool  m_bPredicate;
-    volatile bool  m_bBroadcast;
-    unsigned int   m_iWaitingThreads;
+    volatile bool              m_bSignaled;
+    CCondition<volatile bool&> m_condition;
+    CMutex                     m_mutex;
+    volatile bool              m_bBroadcast;
+    unsigned int               m_iWaitingThreads;
   };
 }