gitpath.hh

Go to the documentation of this file.

#ifndef _DRAMA2_GITPATH_INC
#define _DRAMA2_GITPATH_INC
 
/*
 * History:
     17-Mar-2015 - TJF - Original version
     30-Sep-2016 - TJF - Many changes before now.
                         Improve comments.
                         Add ignoreInitParam argument to GetVerInfo().
                         Add GetVerInfo() method.
     20-Nov-2017 - TJF   Add GetSimulation() method.
     21-May-2018 - TJF - Add RemoteNetStart() method to Path class, allows
                          a sub-class to start the remote network.
     28-Oct-2020 - TJF - Support the idea of  the controlled task itself being
                          a control task.  The main difference is that they
                          are sent RESET RECOVER commands when other tasks may
                          not be.  Add  _isControlTask member and 
                          SetIsAControlTask() method.
 
 * The above ID is for Doxygen, this one has the format ACMM is looking for.
 * "@(#) $Id$"
 */
 
#include "drama.hh"
#include "Git.h"
 
namespace drama { 
    namespace git {
 
 
 
        enum ResetEnum { 
            Soft=0,  
            Full,    
            Hard,    
            Recover, 
            Invalid  
        };
        /* Used to relate reset enum string values to the enum value */
        class ResetEnumLookup : public drama::gitarg::EnumLookupClass {
        public:
            unsigned int GetMaxValue() const override final {
                return (int)(Invalid)-1;
            }
            const char  ** GetStringArray() const override final {
                static const char *table[] = { "SOFT", "FULL", "HARD", 
                                               "RECOVER", 0 };
                return table;
            }
        };
        class ResetType : public drama::gitarg::Enum<ResetEnumLookup, ResetEnum>{
            using drama::gitarg::Enum<ResetEnumLookup, ResetEnum>::Enum;
 
        public:
        };
 
        class Path : public drama::Path {
 
        protected:
            /*
             * History says that sub-classes might need these. Really the
             * functionality should be revamped an appropriate access methods
             * provided.
             */
            ResetType _resetMode=ResetEnum::Full;  
            bool _pollDont=false;       
            bool _pollCanceling=false;  
            unsigned _pollMaxAttempts=5;
            std::string _simLevel="NONE";
            std::string _simArg;        
            float _simTimeBase=1;       
            bool  _simSent = false;     
            bool _havePath=false;       
            bool _failed=false;         
            bool _amExiting=false;      
            bool _resetting=false;      
            bool _firstTime=true;       
            bool _initialised=false;    
            bool _isControlTask=false;  
            std::string _verDate;       
            std::string _verNum;        
            std::string _taskDescr;     
            std::string _devType;       
            virtual void DoGetPath(thread::TMessHandler *action);
 
            virtual void SendSimLevel(thread::TMessHandler *action,
                                      const std::string &simLevel,
                                      float timeBase,
                                      const std::string &simArg);
 
            virtual void SendInitialise(thread::TMessHandler *action);
 
            virtual void GetVerInfo(thread::TMessHandler *action,
                                    bool ignoreInitParam/* = false*/);
 
 
            virtual void SendReset(thread::TMessHandler *action, 
                                   ResetType & mode);
 
 
 
            virtual void SendExit(thread::TMessHandler *action);
 
 
 
        public:
            Path(std::weak_ptr<drama::Task> theTask,
                 const std::string &name, 
                 const std::string &host = "", 
                 const std::string &file = "");
            virtual void SetSimulation(const std::string &value, 
                                       const float timeBase=1.0,
                                       const std::string &simArg="");
 
 
            virtual void GetSimulation(bool *beenSet,
                                       std::string *value,
                                       float *timeBase=nullptr,
                                       std::string *simArg=nullptr) const;
 
        
            void SetResetMode(ResetEnum mode) {
                _resetMode = mode;
            }
            ResetEnum GetResetMode() const {
                return _resetMode;
            }
 
            virtual void Initialise(thread::TMessHandler *action,
                                    bool ignoreInitParam = false);
 
            virtual void Poll(thread::TMessHandler *action);
 
            void SetPollMaxAttempts(unsigned int n) {
                _pollMaxAttempts = n;
            }
 
 
            virtual void PollCancel(thread::TMessHandler *action);
 
            virtual void Exit(thread::TMessHandler *action);
            virtual void Report(thread::TMessHandler *action);
 
            virtual ~Path() { }
 
            virtual void SetFailed() {
//fprintf(stderr,"#### SetFailed invoked\n");
                _failed = true;
            }
 
            virtual void GetVerInfo(std::string *verNum,
                                    std::string *verDate=nullptr,
                                    std::string *taskDescr=nullptr,
                                    std::string *devType=nullptr) const ;
 
 
            virtual bool RemoteNetStart(const std::string &node,
                                        thread::TMessHandler *action);
 
 
 
            void SetIsAControlTask() {
                _isControlTask = true;
            }
 
 
            
        }; // class Path
 
    } // namespace git
    
} // namespace drama
 
#endif