be_process_workercontroller.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_WORKERCONTROLLER_H__
#define __BE_PROCESS_WORKERCONTROLLER_H__
 
#include <memory>
 
#include <be_error_exception.h>
#include <be_memory_autoarray.h>
#include <be_process.h>
#include <be_process_worker.h>
 
namespace BiometricEvaluation
{
        namespace Process
        {
                class WorkerController
                {
                public:
                        WorkerController(
                            std::shared_ptr<Worker> worker);
                            
                        virtual void
                        sendMessageToWorker(
                            const Memory::uint8Array &message);
 
                        virtual void
                        setParameter(
                            const std::string &name, 
                            std::shared_ptr<void> argument);
                            
                        virtual void
                        setParameterFromDouble(
                            const std::string &name, 
                            double argument);
                        
                        virtual void
                        setParameterFromInteger(
                            const std::string &name, 
                            int64_t argument);
                            
                        virtual void
                        setParameterFromString(
                            const std::string &name, 
                            const std::string &argument);
                            
                        virtual void
                        reset();
                        
                        virtual bool
                        isWorking()
                            const = 0;
 
                        virtual bool
                        everWorked()
                            const = 0;
 
                        inline bool
                        finishedWorking()
                            const
                        {
                                return (this->everWorked() &&
                                    !this->isWorking());
                        }
                        
                        std::shared_ptr<Worker>
                        getWorker()
                            const;
 
                        virtual int32_t
                        getExitStatus()
                            const
                            final;
                        
                        virtual ~WorkerController();
 
                protected:
                        std::shared_ptr<Worker> _worker;
                        bool _rvSet;
                        int32_t _rv;
                
                private:
                        virtual void
                        start(
                            bool communicate = false) = 0;
 
                        virtual void
                        stop() = 0;
                };
        }
}
 
#endif /* __BE_PROCESS_WORKERCONTROLLER_H__ */