be_process_posixthreadmanager.h

Go to the documentation of this file.

/*
 * This software was developed at the National Institute of Standards and
 * Technology (NIST) by employees of the Federal Government in the course
 * of their official duties. Pursuant to title 17 Section 105 of the
 * United States Code, this software is not subject to copyright protection
 * and is in the public domain. NIST assumes no responsibility whatsoever for
 * its use by other parties, and makes no guarantees, expressed or implied,
 * about its quality, reliability, or any other characteristic.
 */
 
#ifndef __BE_PROCESS_POSIXTHREADMANAGER_H__
#define __BE_PROCESS_POSIXTHREADMANAGER_H__
 
#include <pthread.h>
 
#include <be_process_manager.h>
#include <be_process_workercontroller.h>
 
namespace BiometricEvaluation
{
        namespace Process
        {
                /* Forward declaration */
                class POSIXThreadWorkerController;
                
                class POSIXThreadManager : public Manager
                {
                public:
                        POSIXThreadManager();
                                                    
                        std::shared_ptr<WorkerController>
                        addWorker(
                            std::shared_ptr<Worker> worker);
 
                        void
                        startWorkers(
                            bool wait = true,
                            bool communicate = false);
 
                        void
                        startWorker(
                            std::shared_ptr<WorkerController> worker,
                            bool wait = true,
                            bool communicate = false);
 
                        void
                        stopWorker(
                            std::shared_ptr<WorkerController> workerController);
 
                        void
                        waitForWorkerExit();
 
                        ~POSIXThreadManager();
 
                private:
                        void
                        _wait();
                };
                
                class POSIXThreadWorkerController : public WorkerController
                {
                public:
                        void
                        reset();
 
                        bool
                        isWorking()
                            const;
 
                        bool
                        everWorked()
                            const;
                        
                        ~POSIXThreadWorkerController();
                        
                protected:
                
                private:
                        POSIXThreadWorkerController(
                            std::shared_ptr<Worker> worker);
                            
                        void
                        start(
                            bool communicate = false);
 
                        void
                        stop();
 
                        static void *
                        workerMainWrapper(
                            void *_this);
 
                        /*
                         * Friends.
                         * XXX We just need addWorker(), startWorkers(), and
                         * XXX _wait() to be friended, but you cannot friend
                         * XXX a private function (_wait()).
                         * TODO Eliminate _wait() from WorkerController?
                         */
                        friend class POSIXThreadManager;
 
                        pthread_t _thread;
 
                        bool _working;
 
                        bool _hasWorked;
                };
        }
}
 
#endif /* __BE_PROCESS_POSIXTHREADMANAGER_H__ */