1 files changed, 33 insertions, 9 deletions
diff --git a/includes/TaskMan.h b/includes/TaskMan.h
index d39598f..2b2742d 100644
--- a/includes/TaskMan.h
+++ b/includes/TaskMan.h
@@ -10,16 +10,31 @@
 #include <Async.h>
 #include <Threads.h>
 #include <Exceptions.h>
+#include <Task.h>
 
 namespace gnu = __gnu_cxx;
 
 namespace Balau {
 
-class Task;
 class TaskScheduler;
 
+namespace Events {
+
+class TaskEvent;
+
+};
+
 class TaskMan {
   public:
+    class TaskManThread : public Thread {
+      public:
+          virtual ~TaskManThread();
+        virtual void * proc();
+        void stopMe(int code = 0) { m_taskMan->stopMe(code); }
+      private:
+        TaskMan * m_taskMan;
+    };
+
       TaskMan();
       ~TaskMan();
     int mainLoop();
@@ -27,11 +42,25 @@ class TaskMan {
     struct ev_loop * getLoop() { return m_loop; }
     void signalTask(Task * t);
     static void stop(int code);
-    void stopMe(int code) { m_stopped = true; m_stopCode = code; }
-    static Thread * createThreadedTaskMan();
+    void stopMe(int code = 0);
+    static TaskManThread * createThreadedTaskMan() {
+        TaskManThread * r = new TaskManThread();
+        r->threadStart();
+        return r;
+    }
+    static void stopThreadedTaskMan(TaskManThread * tmt) {
+        tmt->stopMe(0);
+        tmt->join();
+        delete tmt;
+    }
     bool stopped() { return m_stopped; }
+    template<class T>
+    static T * registerTask(T * t, Task * stick = NULL) { TaskMan::iRegisterTask(t, stick, NULL); return t; }
+    template<class T>
+    static T * registerTask(T * t, Events::TaskEvent * event) { TaskMan::iRegisterTask(t, NULL, event); return t; }
+
   private:
-    static void registerTask(Task * t, Task * stick);
+    static void iRegisterTask(Task * t, Task * stick, Events::TaskEvent * event);
     static void registerAsyncOp(AsyncOperation * op);
     void * getStack();
     void freeStack(void * stack);
@@ -51,8 +80,6 @@ class TaskMan {
     friend class Task;
     friend class TaskScheduler;
     template<class T>
-    friend T * createTask(T * t, Task * stick = NULL);
-    template<class T>
     friend T * createAsyncOp(T * op);
     struct taskHasher { size_t operator()(const Task * t) const { return reinterpret_cast<uintptr_t>(t); } };
     typedef gnu::hash_set<Task *, taskHasher> taskHash_t;
@@ -68,9 +95,6 @@ class TaskMan {
 };
 
 template<class T>
-T * createTask(T * t, Task * stick) { TaskMan::registerTask(t, stick); return t; }
-
-template<class T>
 T * createAsyncOp(T * op) { TaskMan::registerAsyncOp(op); return op; }
 
 };