Expose getPointedThing to Lua

[oweals/minetest.git] / src / util / thread.h

diff --git a/src/util/thread.h b/src/util/thread.h
index eda9c0ca2021193fe1ebdb912aabbea221311ac9..201d09a08c1110249dd2fbb389f704e843c07916 100644 (file)
--- a/src/util/thread.h
+++ b/src/util/thread.h
@@ -21,51 +21,43 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #define UTIL_THREAD_HEADER
 
 #include "../irrlichttypes.h"
-#include "../jthread/jthread.h"
-#include "../jthread/jmutex.h"
-#include "../jthread/jmutexautolock.h"
+#include "../threading/thread.h"
+#include "../threading/mutex_auto_lock.h"
 #include "porting.h"
+#include "log.h"
+#include "container.h"
 
 template<typename T>
 class MutexedVariable
 {
 public:
-       MutexedVariable(T value):
+       MutexedVariable(const T &value):
                m_value(value)
-       {
-       }
+       {}
 
        T get()
        {
-               JMutexAutoLock lock(m_mutex);
+               MutexAutoLock lock(m_mutex);
                return m_value;
        }
 
-       void set(T value)
+       void set(const T &value)
        {
-               JMutexAutoLock lock(m_mutex);
+               MutexAutoLock lock(m_mutex);
                m_value = value;
        }
-       
-       // You'll want to grab this in a SharedPtr
-       JMutexAutoLock * getLock()
-       {
-               return new JMutexAutoLock(m_mutex);
-       }
-       
+
        // You pretty surely want to grab the lock when accessing this
        T m_value;
-
 private:
-       JMutex m_mutex;
+       std::mutex m_mutex;
 };
 
 /*
        A single worker thread - multiple client threads queue framework.
 */
 template<typename Key, typename T, typename Caller, typename CallerData>
-class GetResult
-{
+class GetResult {
 public:
        Key key;
        T item;
@@ -73,34 +65,27 @@ public:
 };
 
 template<typename Key, typename T, typename Caller, typename CallerData>
-class ResultQueue: public MutexedQueue< GetResult<Key, T, Caller, CallerData> >
-{
+class ResultQueue : public MutexedQueue<GetResult<Key, T, Caller, CallerData> > {
 };
 
 template<typename Caller, typename Data, typename Key, typename T>
-class CallerInfo
-{
+class CallerInfo {
 public:
        Caller caller;
        Data data;
-       ResultQueue< Key, T, Caller, Data>* dest;
+       ResultQueue<Key, T, Caller, Data> *dest;
 };
 
 template<typename Key, typename T, typename Caller, typename CallerData>
-class GetRequest
-{
+class GetRequest {
 public:
-       GetRequest()
-       {
-       }
-       GetRequest(Key a_key)
-       {
-               key = a_key;
-       }
-       ~GetRequest()
+       GetRequest() {}
+       ~GetRequest() {}
+
+       GetRequest(const Key &a_key): key(a_key)
        {
        }
-       
+
        Key key;
        std::list<CallerInfo<Caller, CallerData, Key, T> > callers;
 };
@@ -113,49 +98,44 @@ public:
  * @param CallerData data passed back to caller
  */
 template<typename Key, typename T, typename Caller, typename CallerData>
-class RequestQueue
-{
+class RequestQueue {
 public:
        bool empty()
        {
                return m_queue.empty();
        }
 
-       void add(Key key, Caller caller, CallerData callerdata,
-                       ResultQueue<Key, T, Caller, CallerData> *dest)
+       void add(const Key &key, Caller caller, CallerData callerdata,
+               ResultQueue<Key, T, Caller, CallerData> *dest)
        {
+               typename std::deque<GetRequest<Key, T, Caller, CallerData> >::iterator i;
+               typename std::list<CallerInfo<Caller, CallerData, Key, T> >::iterator j;
+
                {
-                       JMutexAutoLock lock(m_queue.getMutex());
+                       MutexAutoLock lock(m_queue.getMutex());
 
                        /*
                                If the caller is already on the list, only update CallerData
                        */
-                       for(typename std::deque< GetRequest<Key, T, Caller, CallerData> >::iterator
-                                       i = m_queue.getQueue().begin();
-                                       i != m_queue.getQueue().end(); ++i)
-                       {
+                       for (i = m_queue.getQueue().begin(); i != m_queue.getQueue().end(); ++i) {
                                GetRequest<Key, T, Caller, CallerData> &request = *i;
-
-                               if(request.key == key)
-                               {
-                                       for(typename std::list< CallerInfo<Caller, CallerData, Key, T> >::iterator
-                                                       i = request.callers.begin();
-                                                       i != request.callers.end(); ++i)
-                                       {
-                                               CallerInfo<Caller, CallerData, Key, T> &ca = *i;
-                                               if(ca.caller == caller)
-                                               {
-                                                       ca.data = callerdata;
-                                                       return;
-                                               }
+                               if (request.key != key)
+                                       continue;
+
+                               for (j = request.callers.begin(); j != request.callers.end(); ++j) {
+                                       CallerInfo<Caller, CallerData, Key, T> &ca = *j;
+                                       if (ca.caller == caller) {
+                                               ca.data = callerdata;
+                                               return;
                                        }
-                                       CallerInfo<Caller, CallerData, Key, T> ca;
-                                       ca.caller = caller;
-                                       ca.data = callerdata;
-                                       ca.dest = dest;
-                                       request.callers.push_back(ca);
-                                       return;
                                }
+
+                               CallerInfo<Caller, CallerData, Key, T> ca;
+                               ca.caller = caller;
+                               ca.data = callerdata;
+                               ca.dest = dest;
+                               request.callers.push_back(ca);
+                               return;
                        }
                }
 
@@ -170,7 +150,7 @@ public:
                ca.data = callerdata;
                ca.dest = dest;
                request.callers.push_back(ca);
-               
+
                m_queue.push_back(request);
        }
 
@@ -184,13 +164,11 @@ public:
                return m_queue.pop_frontNoEx();
        }
 
-       void pushResult(GetRequest<Key, T, Caller, CallerData> req,
-                                       T res) {
-
-               for(typename std::list< CallerInfo<Caller, CallerData, Key, T> >::iterator
+       void pushResult(GetRequest<Key, T, Caller, CallerData> req, T res)
+       {
+               for (typename std::list<CallerInfo<Caller, CallerData, Key, T> >::iterator
                                i = req.callers.begin();
-                               i != req.callers.end(); ++i)
-               {
+                               i != req.callers.end(); ++i) {
                        CallerInfo<Caller, CallerData, Key, T> &ca = *i;
 
                        GetResult<Key,T,Caller,CallerData> result;
@@ -205,7 +183,50 @@ public:
        }
 
 private:
-       MutexedQueue< GetRequest<Key, T, Caller, CallerData> > m_queue;
+       MutexedQueue<GetRequest<Key, T, Caller, CallerData> > m_queue;
+};
+
+class UpdateThread : public Thread
+{
+public:
+       UpdateThread(const std::string &name) : Thread(name + "Update") {}
+       ~UpdateThread() {}
+
+       void deferUpdate() { m_update_sem.post(); }
+
+       void stop()
+       {
+               Thread::stop();
+
+               // give us a nudge
+               m_update_sem.post();
+       }
+
+       void *run()
+       {
+               DSTACK(FUNCTION_NAME);
+               BEGIN_DEBUG_EXCEPTION_HANDLER
+
+               while (!stopRequested()) {
+                       m_update_sem.wait();
+                       // Set semaphore to 0
+                       while (m_update_sem.wait(0));
+
+                       if (stopRequested()) break;
+
+                       doUpdate();
+               }
+
+               END_DEBUG_EXCEPTION_HANDLER
+
+               return NULL;
+       }
+
+protected:
+       virtual void doUpdate() = 0;
+
+private:
+       Semaphore m_update_sem;
 };
 
 #endif