be_process_manager.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_MANAGER_H__
#define __BE_PROCESS_MANAGER_H__
 
#include <vector>
 
#include <be_error_exception.h>
#include <be_process.h>
#include <be_process_worker.h>
#include <be_process_workercontroller.h>
 
namespace BiometricEvaluation
{
        namespace Process
        {
                class Manager
                {
                public:
                        Manager();
                
                        virtual std::shared_ptr<WorkerController>
                        addWorker(
                            std::shared_ptr<Worker> worker) = 0;
                        
                        virtual uint32_t
                        getNumCompletedWorkers() const;
 
                        virtual uint32_t
                        getNumActiveWorkers() const;
 
                        virtual uint32_t
                        getTotalWorkers()
                            const;
                            
                        virtual void
                        startWorkers(
                            bool wait = true,
                            bool communicate = false) = 0;
 
                        virtual void
                        startWorker(
                            std::shared_ptr<WorkerController> worker,
                            bool wait = true,
                            bool communicate = false) = 0;
 
                        virtual void
                        waitForWorkerExit() = 0;
 
                        virtual void
                        reset();
 
                        virtual void
                        stopWorker(
                            std::shared_ptr<WorkerController> worker) = 0;
 
                        virtual bool
                        waitForMessage(
                            std::shared_ptr<WorkerController> &sender,
                            int *nextFD = nullptr,
                            int numSeconds = -1)
                            const;
                        
                        virtual bool
                        getNextMessage(
                            std::shared_ptr<WorkerController> &sender,
                            Memory::uint8Array &message,
                            int numSeconds = -1) const;
 
                        virtual void
                        broadcastMessage(
                            Memory::uint8Array &message) const;
 
                        virtual ~Manager();
                        
                protected:
                        virtual void
                        _wait() = 0;
                        
                        std::vector<std::shared_ptr<WorkerController>>
                            _workers;
                        
                        std::vector<std::shared_ptr<WorkerController>>
                            _pendingExit;
                        
                private:
                
                };
        }
}
 
 
#endif /* __BE_PROCESS_MANAGER_H__ */