threadmonitor.hh

Go to the documentation of this file.

#ifndef _DRAMA2_THREADMONITOR_INC
#define _DRAMA2_THREADMONITOR_INC
/*
 * History:
     08-May-2014 - TJF - Original version
     05-Mar-2015 - TJF - Revamp to support canceling.
     23-Oct-2018 - TJF - Add new Monitor constructor which takes a vector
                           of strings. (As you can initialize a vector
                           from an initialize list, but if you already
                           have a vector, you can't initialize it with
                           a vector.)
 
 * The above ID is for Doxygen, this one has the format ACMM is looking for.
 * "@(#) $Id$"
 */
#include "drama/messagehandler.hh"
#include "drama/thread.hh"
#include "drama/path.hh"
#include "Sdp.h"
#include <vector>
#include <string>
namespace drama { 
 
    namespace thread {
        class Monitor;
        class MonitorMessageHandler : public MessageEventHandler {
        private :
            Monitor &_theMonitor;
            
        public:
            MonitorMessageHandler(Monitor &theMon) : _theMonitor(theMon) {}
            void TriggerReceived(thread::ProcessInfo messInfo,
                                 StatusType status, const sds::IdPtr &arg) override final;
    
            virtual bool KickReceived(thread::ProcessInfo messInfo,
                                      const sds::IdPtr &arg) override;
 
        }; // class MonitorMessageHandler
 
 
        class Monitor {
        private:
            /*
             * Pointer to the DRAMA task we are part of.
             */
            std::weak_ptr<Task> _theTask;
 
            Path *_thePath = nullptr;
            thread::TMessHandler *_action = nullptr;
            
            std::vector <std::string> _params;// Parameters being monitored.
            int _monId;                       // The monitor ID
            bool _running;                    // Are we running (may be starting)
 
            bool _canceling;                  // Are we canceling
            std::future<void> _cancelFuture;  // Future used for cancel.
 
            /*
             * Send the message to cancel the monitor.  Executed
             * as a thread by the Cancel() method.
             */
            void SendCancel();
 
 
        public:
 
            Monitor(std::weak_ptr<Task> theTask, 
                    std::initializer_list<std::string> pars): 
                _theTask(theTask), 
                _thePath(nullptr), _action(nullptr),
                _params{pars}, _monId(-1), _running(false),_canceling(false) {
                
            }
 
            Monitor(std::weak_ptr<Task> theTask, 
                    std::vector<std::string> pars): 
                _theTask(theTask), 
                _thePath(nullptr), _action(nullptr),
                _params{pars}, _monId(-1), _running(false),_canceling(false) {
                
            }
 
            template <typename EventProcType = MonitorMessageHandler>
            void Run(Path *thePath, thread::TMessHandler *action) {
 
                static_assert(
                    std::is_base_of<MonitorMessageHandler, 
                    EventProcType>(), 
                    "EventProcType must be a sub-class of drama::thread::MonitorMessageHandler");
 
 
 
                EventProcType handler(*this);
 
 
                Run(thePath, action, &handler);
            }
 
            
            void Run(Path *thePath, 
                     thread::TMessHandler *action, 
                     MonitorMessageHandler *evtProcessor);
 
 
            Monitor& operator=(const Monitor &rhs) = delete;
            Monitor(const Monitor &source) = delete;
 
 
            /* Invoked by a helper class when a monitor is started.
             *
             * Not intended for use by user code.
             */
            void _StartedEvent(const sds::IdPtr &arg);
 
            /* Invoked by a helper class when a monitor is started.
             *
             * Not intended for use by user code.
             */
            void _ChangedEvent(const sds::IdPtr &arg);
 
            void Cancel();
 
            virtual ~Monitor() {}
 
            bool IsRunning() const {
                return _running;
            }
            bool IsCancelling() const {
                return _canceling;
            }
            int GetMonitorId() const {
                return _monId;
            }
 
        protected:
            virtual void ParameterChanged(const sds::IdPtr &arg) = 0;
 
 
            virtual std::shared_ptr<Task>  GetTask() const {
                return std::shared_ptr<Task>(_theTask);
            }
 
        }; // class Monitor
 
        class MonitorToParam : public Monitor {
            using Monitor::Monitor;  // Inherit constructor.
        public:
            virtual ~MonitorToParam();
 
            virtual std::string Transform(const std::string &in);
 
        protected:
            virtual void ParameterChanged(const sds::IdPtr &arg) override final;
 
        }; // class MonitorToParam
 
 
 
        class MonitorByType : public Monitor {
            using Monitor::Monitor;  // Inherit constructor.
        private:
            // See below for details.
            enum class RtnSupType { checkNeeded, yes, viaString, no  };
 
            /*
             * We have a scheme for fallback from integer/unsigned integer/real
             * to string.  These enums are used to determine if we use that
             * fallback.  On the first parameter update of each time, a check
             * is needed to confirm we have a user implemented routine.  If not,
             * then we will use the string routine, if it exists, converting the
             * value to a string.
             */
            RtnSupType _intRoutineSupported  = RtnSupType::checkNeeded;
            RtnSupType _uintRoutineSupported = RtnSupType::checkNeeded;
            RtnSupType _realRoutineSupported = RtnSupType::checkNeeded;
 
            /*
             * Implementation methods.
             */
            void DoIntParam(const std::string &name, const sds::IdPtr &arg);
            void DoUintParam(const std::string &name, const sds::IdPtr &arg);
            void DoRealParam(const std::string &name, const sds::IdPtr &arg);
 
        public:
            virtual ~MonitorByType();
 
        protected:
            virtual void ParameterChanged(const sds::IdPtr &arg) override final;
 
            virtual void ParamChanged(const std::string &name, long value);
 
            virtual void ParamChanged(const std::string &name, unsigned long value);
 
            virtual void ParamChanged(const std::string &name, double value);
 
            virtual void ParamChanged(const std::string &name, const std::string & value);
            virtual void ParamChanged(const std::string &name, const sds::IdPtr &value);
 
        }; // class MonitorByType
 
 
        
    } // namespace thread
} // namespace drama
 
#endif