From b3eef5b0b82c20a9f11868ba376f6bb2d94faae4 Mon Sep 17 00:00:00 2001 From: Mike Buland Date: Wed, 3 Oct 2007 09:13:28 +0000 Subject: Nothing about function. I added a bunch of docs and re-arranged a bunch of the existing docs. Taking advantage of some of the cooler extra features of doxygen I've started writing extra how-to pages covering working with sections of the library. Also, I started grouping the classes by function so they show up on the Modules page together, very cute. --- src/ito.h | 63 +++++++++++++++++++++++++++++++++------------------------------ 1 file changed, 33 insertions(+), 30 deletions(-) (limited to 'src/ito.h') diff --git a/src/ito.h b/src/ito.h index c062052..4ed2c8b 100644 --- a/src/ito.h +++ b/src/ito.h @@ -6,11 +6,12 @@ namespace Bu { /** - * Simple thread class. This wraps the basic pthread (posix threads) system in - * an object oriented sort of way. It allows you to create a class with - * standard member variables and callable functions that can be run in it's own - * thread, one per class instance. + * Simple thread class. This wraps the basic pthread (posix threads) + * system in an object oriented sort of way. It allows you to create a + * class with standard member variables and callable functions that can be + * run in it's own thread, one per class instance. *@author Mike Buland + *@ingroup Threading */ class Ito { @@ -27,24 +28,26 @@ namespace Bu /** * Begin thread execution. This will call the overridden run function, - * which will simply execute in it's own thread until the function exits, - * the thread is killed, or the thread is cancelled (optionally). The - * thread started in this manner has access to all of it's class variables, - * but be sure to protect possible multiple-access with ItoMutex objects. - *@returns True if starting the thread was successful. False if something - * went wrong and the thread has not started. + * which will simply execute in it's own thread until the function + * exits, the thread is killed, or the thread is cancelled (optionally). + * The thread started in this manner has access to all of it's class + * variables, but be sure to protect possible multiple-access with + * ItoMutex objects. + * @returns True if starting the thread was successful. False if + * something went wrong and the thread has not started. */ bool start(); /** - * Forcibly kill a thread. This is not generally considered a good thing to - * do, but in those rare cases you need it, it's invaluable. The problem - * with stopping (or killing) a thread is that it stops it the moment you - * call stop, no matter what it's doing. The object oriented approach to - * this will help clean up any class variables that were used, but anything - * not managed as a member variable will probably create a memory leak type - * of situation. Instead of stop, consider using cancel, which can be - * handled by the running thread in a graceful manner. + * Forcibly kill a thread. This is not generally considered a good + * thing to do, but in those rare cases you need it, it's invaluable. + * The problem with stopping (or killing) a thread is that it stops it + * the moment you call stop, no matter what it's doing. The object + * oriented approach to this will help clean up any class variables + * that were used, but anything not managed as a member variable will + * probably create a memory leak type of situation. Instead of stop, + * consider using cancel, which can be handled by the running thread in + * a graceful manner. *@returns True if the thread was stopped, false otherwise. When this * function returns the thread may not have stopped, to ensure that the * thread has really stopped, call join. @@ -52,11 +55,11 @@ namespace Bu bool stop(); /** - * The workhorse of the Ito class. This is the function that will run in - * the thread, when this function exits the thread dies and is cleaned up - * by the system. Make sure to read up on ItoMutex, ItoCondition, and - * cancel to see how to control and protect everything you do in a safe way - * within this function. + * The workhorse of the Ito class. This is the function that will run + * in the thread, when this function exits the thread dies and is + * cleaned up by the system. Make sure to read up on ItoMutex, + * ItoCondition, and cancel to see how to control and protect + * everything you do in a safe way within this function. *@returns I'm not sure right now, but this is the posix standard form. */ virtual void *run()=0; @@ -64,13 +67,13 @@ namespace Bu /** * Join the thread in action. This function performs what is commonly * called a thread join. That is that it effectively makes the calling - * thread an the Ito thread contained in the called object one in the same, - * and pauses the calling thread until the called thread exits. That is, - * when called from, say, your main(), mythread.join() will not return until - * the thread mythread has exited. This is very handy at the end of - * programs to ensure all of your data was cleaned up. - *@returns True if the thread was joined, false if the thread couldn't be - * joined, usually because it isn't running to begin with. + * thread an the Ito thread contained in the called object one in the + * same, and pauses the calling thread until the called thread exits. + * That is, when called from, say, your main(), mythread.join() will + * not return until the thread mythread has exited. This is very handy + * at the end of programs to ensure all of your data was cleaned up. + *@returns True if the thread was joined, false if the thread couldn't + * be joined, usually because it isn't running to begin with. */ bool join(); -- cgit v1.2.3