X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Fthreadengine.h;h=59d425481bc142aca3a878e987b9d514b4f835cd;hb=8c2d96013084de950e3a63be4ae6ed626c4093ab;hp=0f729a962e16a1d394583f896c5da7892f03d3b9;hpb=11c08b9aed1792705e5d82b343fae6ce56910338;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/include/threadengine.h b/include/threadengine.h
index 0f729a962..59d425481 100644
--- a/include/threadengine.h
+++ b/include/threadengine.h
@@ -23,46 +23,112 @@
 class InspIRCd;
 class Thread;
 
-
+/** The ThreadEngine class has the responsibility of initialising
+ * Thread derived classes. It does this by creating operating system
+ * level threads which are then associated with the class transparently.
+ * This allows Thread classes to be derived without needing to know how
+ * the OS implements threads. You should ensure that any sections of code
+ * that use threads are threadsafe and do not interact with any other
+ * parts of the code which are NOT known threadsafe!
+ */
 class CoreExport ThreadEngine : public Extensible
 {
  protected:
 
+	 /** Creator instance
+	  */
 	 InspIRCd* ServerInstance;
+	 /** New Thread being created.
+	  */
 	 Thread* NewThread;
 
  public:
 
+	/** Constructor
+	 */
 	ThreadEngine(InspIRCd* Instance);
 
+	/** Destructor
+	 */
 	virtual ~ThreadEngine();
 
+	/** Enable or disable system-wide mutex for threading.
+	 * This MUST be called when you deal with ANYTHING that
+	 * isnt known thread-safe, this INCLUDES STL!
+	 * Remember that if you toggle the mutex you MUST UNSET
+	 * IT LATER otherwise the program will DEADLOCK!
+	 */
 	virtual bool Mutex(bool enable) = 0;
 
+	/** Run the newly created thread
+	 */
 	virtual void Run() = 0;
 
+	/** Create a new thread. This takes an already allocated
+	 * Thread* pointer and initializes it to use this threading
+	 * engine. On failure, this function may throw a CoreException.
+	 */
 	virtual void Create(Thread* thread_to_init) = 0;
 
+	/** This is called by the default destructor of the Thread
+	 * class to ensure that the thread engine which created the thread
+	 * is responsible for destroying it.
+	 */
 	virtual void FreeThread(Thread* thread) = 0;
+
+	virtual const std::string GetName()
+	{
+		return "<pure-virtual>";
+	}
 };
 
+/** Derive from this class to implement your own threaded sections of
+ * code.
+ */
 class CoreExport Thread : public Extensible
 {
+ private:
+	bool ExitFlag;
  public:
 
+	/** Creator thread engine
+	 */
 	ThreadEngine* Creator;
 
-	Thread() : Creator(NULL)
+	/** Set Creator to NULL at this point
+	 */
+	Thread() : ExitFlag(false), Creator(NULL)
 	{
 	}
 
+	/** If this thread has a Creator set, call it to
+	 * free the thread
+	 */
 	virtual ~Thread()
 	{
 		if (Creator)
 			Creator->FreeThread(this);
 	}
 
+	/** Override this method to put your actual
+	 * threaded code here
+	 */
 	virtual void Run() = 0;
+
+	void SetExitFlag()
+	{
+		ExitFlag = true;
+	}
+
+	void ClearExitFlag()
+	{
+		ExitFlag = false;
+	}
+
+	bool GetExitFlag()
+	{
+		return ExitFlag;
+	}
 };