gittask.h

/*
 * Name: filter.m4
 *
 * Description:
 *     DOXYGEN Input file filter for DRAMA source files.
 *
 *     This file must be complatible with both Solaris and GNU m4.  All
 *     unused macros are deleted and this comment must end up as a C/C++
 *     compatible comment which is not picked up by DOXYGEN.
 * 
 * Synopsis:
 *    DCF(func)  => Produces a link to a DRAMA C source file func.html 
 *                   in ../routines.
 *     DDL(link,text) => Produce a link to ../link.html, specified link text.
 *
 * Language: m4 macro. 
 *
 * Author: Tony Farrell, AAO.
 *
 * "@(#) $Id$"
 *
 * History:
 *     10-Nov-2004 - TJF - Original Version.
 */
 
 
 
#ifndef GITTASKINC
#define GITTASKINC
 
/*                              g i t t a s k
 
 * Module name:
      gittask.h
 
 * Function:
      Include file for the gittask.C module
 
 * Description:
        gittask.C/gittask.h implement a C++ class derived from
        DcppTask.  See gittask.C for details.
      
        This file now uses DOXYGEN comments to generate the C++ web pages.
        m4 macros of the form @htmlonly <a href="../routines/function.html">function()</a>@endhtmlonly are used in the comments
        to refer to DRAMA C function documention (see DramaHtml/Makefile,
        DramaHtml/doxygen.config and DramaHtml/filter.m4 for detials)
 
 * Language:
      C
 
 * Support: Tony Farrell, AAO
 
 * History:
      16-Dec-2003 - TJF - Original Version.
      16-Jan-2004 - TJF - Remove GitTask::isActive variable and
                          revamp list stuff.  Remove status argument from
                          SetSimulation(), Support user override of version
                          stuff, Get remove net start stuff working,
      09-Nov-2004 - TJF - In cases where some arguments were not used, put
                          the name back in (e.g. "StatusType *") such that
                          doxygen does not complain, and then use the
                          argument such that the compiler does not complain.
      30-May-2006 - TJF - The self path constructor now takes an enum as
                          the argument to ensure a char * is not converted
                          to a bool triggering this constructor.
 
 *   @(#) $Id$
 
 */
 
#include "dcpptask.h"
#include "Git.h"
#include "DitsMsgOut.h"
 
#include <string>
 
class GitResetType : public GitEnum {
     private:
        /* Enum possibilities */
        enum resetEnum { Soft=0, Full, Hard, Recover, Invalid };
        /* value contains the actual value, lookupTable the list of strings.*/
        resetEnum value;
        static const char * const lookupTable[];
        
        /* Return lookup table address.  Used by GitEnum::Get */
        const char  * const * Lookup() {
                return lookupTable;
        };
        /* Set the value, Use by GitEnum::Get */
        void SetValue(const unsigned int i) {
            if (i >= Invalid) 
                value = Invalid;
            else
                value = (resetEnum)i;               
        }
        /* Conversion operator - given enum, return an int */
        operator int() const {
                return ((int)(value));
        };
        
    public:
        GitResetType(const SdsId &Id,
                     const char * const Name,
                     int Position,
                     StatusType * status,
                     const int Flags=Git::Upper|Git::Abbrev|Git::KeepErr) {
            // Just get the value using GitEnum.
            GitEnum::Get(Id, Name, Position, status, "SOFT", Flags);
        }
                     
        GitResetType() {
                value = Soft;
        };
 
        void Get(const SdsId &Id,
                 const char * const Name,
                 int Position,
                 StatusType * status,
                 const int Flags=Git::Upper|Git::Abbrev|Git::KeepErr) {
            // Just get the value using GitEnum.
            GitEnum::Get(Id, Name, Position, status, "SOFT", Flags);
        }
        
        void SetRecover() {
                value = Recover;
        };
       void SetSoft() {
            value = Soft;
        }
        void SetHard() {
            value = Hard;
        }
        void SetFull() {
            value = Full;
        }
        bool IsSoft() const { return (value == Soft); };
        bool IsFull() const { return (value == Full); };
        bool IsHard() const { return (value == Hard);  };
        bool IsRecover() const { return (value == Recover); };
        bool IsInvalid() const { return (value == Invalid); };
 
        operator const char*() const {
                return lookupTable[value];
        };
                
};
/*
 * Forward declaration - since we need this in GitTaskRepsonseHandler.
 */
class GitTask;
 
class GitTaskResponseHandler {
 public:
    GitTaskResponseHandler() {}
 
    virtual DcppHandlerRet CompleteOk(GitTask * /*task*/,StatusType *status) {
        if (*status != STATUS__OK) return DcppFinished; 
        //task = 0;  /* Shut up compiler */
        return DcppFinished;
    }
    virtual DcppHandlerRet CompleteWithError(GitTask * /*task */, 
                                             StatusType *status) {
        if (*status == STATUS__OK)
            *status = DitsGetEntStatus();
        //task= 0; /* Shut up compliler */
        return DcppFinished;
    }
    virtual DcppHandlerRet Triggered(GitTask * /*task*/, StatusType *status) {
        if (*status != STATUS__OK) return DcppFinished; 
        //task = 0;
        return DcppFinished;
    }
 
    virtual ~GitTaskResponseHandler() {};
 
};
 
/*
 *  This class is a helper class used by GitTask to help manage
 *  the GitTaskResponseHandler class objects.
 */
class GitTask___ResponseManager {
 private:
    bool deleteHandler;              /* Should the handler be deleted */
    GitTaskResponseHandler *handler; /* Handler address */
    GitTask *task;                   /* Task this is part of */
 public:
    GitTask___ResponseManager(GitTask *t) : 
        deleteHandler(false), handler(0), task(t)  {}
    
    /*
     * Set up a new handler routine. If responseHandler is null, then a new
     * handler is allocated.  If freeRepsonse is true, then the handler
     * will be deleted after we have finished with it.  Note that if 
     * responseHandler is null, then freeResponse will also be set true.
     */
    void SetNew(GitTaskResponseHandler *responseHandler,
                bool freeResponse,
                StatusType *status);
 
    /*
     * Invoke the response handler's CompleteOk() method, delete the handler
     * if needed and return the result.
     */
    DcppHandlerRet InvokeCompleteOK(StatusType *status);
    /*
     * Invoke the response handler's CompleteWithError() method, delete the handler
     * if needed and return the result.
     */
 
    DcppHandlerRet InvokeCompleteError(StatusType *status);
    
 
    /*
     * Invoke the handler's Trigger() method.
     */
    DcppHandlerRet InvokeTriggered(StatusType *status);
    /*
     * Tidy up the handler
     */
    void Tidy();
};
 
 
class GitTask : public DcppTask {
        friend class GitTaskActiveList;
        friend class GitTaskActiveListIterator;
        friend class GitTaskKnownList;
        friend class GitTaskKnownListIterator;
 
    private:
        GitTask *nextKnown;             /* For putting tasks in the list of */
                                        /* known tasks                      */
                                        /* Note, can only be put in one list*/
        GitTask *nextActive;            /* For putting tasks in a list of   */
                                        /* active tasks                     */
                                        /* Note, can only be put in one list*/
 
 
        GitTask___ResponseManager initialiseResponse;
        GitTask___ResponseManager exitResponse;
        GitTask___ResponseManager pollResponse;
/*
 *      Internal routines.  
 *
 *      static routines are normally used as callbacks.
 *       
 *      This bunch all used by Initialise.
 */
        static DcppHandlerRet HandlePathSuccess(
                                        DcppVoidPnt ClientData,
                                        StatusType *status);
        static DcppHandlerRet HandlePathError(
                                        DcppVoidPnt ClientData,
                                        StatusType *status);
        static DcppHandlerRet HandleVerGetSuccess(
                                        DcppVoidPnt ClientData,
                                        StatusType *status);
        static DcppHandlerRet HandleVerGetError(
                                        DcppVoidPnt ClientData,
                                        StatusType *status);
 
        static DcppHandlerRet HandleInitParGetSuccess(
                                        DcppVoidPnt ClientData,
                                        StatusType *status);
        static DcppHandlerRet HandleInitParGetError(
                                        DcppVoidPnt ClientData,
                                        StatusType *status);
        static DcppHandlerRet HandleInitParGetErs(
                                        DcppVoidPnt ClientData,
                                        StatusType *status);
 
 
 
/*
 *      Exit handlers
 */
        static DcppHandlerRet HandleExitSuccess(
                                        DcppVoidPnt ClientData,
                                        StatusType *status);
        static DcppHandlerRet HandleExitError(
                                        DcppVoidPnt ClientData,
                                        StatusType *status);
 
/*
 *      Poll handlers
 */
        static DcppHandlerRet HandlePollSuccess(
                                        DcppVoidPnt ClientData,
                                        StatusType *status);
        static DcppHandlerRet HandlePollError(
                                        DcppVoidPnt ClientData,
                                        StatusType *status);
        static DcppHandlerRet HandlePollTrigger(
                                        DcppVoidPnt ClientData,
                                        StatusType *status);
        static DcppHandlerRet HandlePollKickSuccess(
                                        DcppVoidPnt ClientData,
                                        StatusType *status);
        static DcppHandlerRet HandlePollKickError(
                                        DcppVoidPnt ClientData,
                                        StatusType *status);
        
        virtual void DeActivate() {
            nextActive = 0;
        };
/*
 *      Prevent Assignment and copying of this type by redefining the
 *      assignment and copy operators to be private.
 *      This ensures we can't get multiple threads controlling the one
 *      task unless done intentionally by the caller.
 */
        GitTask& operator=(const GitTask&);
        GitTask(const GitTask&);
 
 
/*
 *     The internal routines below and data associated with them are
 *      available to inheriting classes.
 */
    protected:
 
 
        static const int PollRetry = 5; 
/*
 *      In a way, we probably should not have variables here, just routines,
 *      but these things are commonly used by inheriters to re-implement
 *      basic functions.
 */
        int pollDont;                   
        bool pollCancelling;            
        GitResetType resetMode;         
        std::string simulationLevel;   
        std::string simulationArg;     
        float timeBase;                 
        bool havePath;                 
        bool failed;                   
        bool amExiting;                
        bool resetting;               
        bool firstTime;               
        std::string verDate;           
        std::string verNum;            
        std::string taskDescr;         
        virtual DcppHandlerRet SendSimulate(StatusType *status);
 
        virtual DcppHandlerRet GetVersionInfo(StatusType *status);
        
        virtual DcppHandlerRet GetInitialisedPar(StatusType *status);
        
 
        virtual DcppHandlerRet HandleVerComp(StatusType *status);
 
        virtual DcppHandlerRet HandleInitParGetComp(bool initialised, 
                                                    StatusType *status);
 
        virtual DcppHandlerRet SendInitialise(StatusType * status);
 
        virtual DcppHandlerRet NoNetOnRemote(StatusType *status) {
            if (*status != STATUS__OK) return DcppFinished; 
            return DcppFinished;
        }
 
 
        virtual void SetInfo(const Arg &info, StatusType *status);
 
        virtual void SetInitial(StatusType *status) {
            if (*status != STATUS__OK) return; 
            havePath = false;
        }
        virtual void SetPathWait(StatusType *status) { 
            if (*status != STATUS__OK) return; 
        }
        virtual void SetInitialising(StatusType *status) {
            if (*status != STATUS__OK) return; 
        }
        virtual void SetResetting(StatusType *status){ 
            if (*status != STATUS__OK) return; 
            resetting = true; 
        }
        virtual void SetIdle(StatusType *status) { 
            if (*status != STATUS__OK) return; 
        }
        virtual void SetExiting(StatusType *status) { 
            if (*status != STATUS__OK) return; 
            amExiting = true;
        }
        virtual void SetFailed() {
            failed = true;
        }
        virtual void SetDied() {
            failed = true;
        }
 
        /* * * 
         * Here we have methods which are not intended for overriding, unless
         * the underlying routine is also invoked.
         *
         *
         * These are invoked when the SIMULATE_LEVEL command 
         * completes.
         */
        static DcppHandlerRet HandleSimSuccess(
                                        DcppVoidPnt ClientData,
                                        StatusType *status);
 
        static DcppHandlerRet HandleSimError(
                                        DcppVoidPnt ClientData,
                                        StatusType *status);
        /*
         * Invoked when INITIALISE/RESET completes.
         */
        static DcppHandlerRet HandleInitSuccess(
                                        DcppVoidPnt ClientData,
                                        StatusType *status);
 
        static DcppHandlerRet HandleInitError(
                                        DcppVoidPnt ClientData,
                                        StatusType *status);
 
 
        virtual DcppHandlerRet RemoteNetStarted(StatusType *status);
        virtual DcppHandlerRet RemoteNetStartErr(StatusType *status);
 
        virtual bool RecoveryNeeded();
 
    public:
        enum SelfPathType { SelfPath };
        GitTask(const std::string & name,
                const std::string &node = "",
                const std::string &file = "");
 
        GitTask(SelfPathType /*self*/) : 
            DcppTask(true),
            nextKnown(0),
            nextActive(0), 
            initialiseResponse(this),
            exitResponse(this),
            pollResponse(this),
            pollDont(0),
            pollCancelling(false),
            simulationLevel("NONE"),
            timeBase(1), 
            havePath(false),
            failed(false),
            amExiting(false),
            resetting(false),
            firstTime(true)
            {
                resetMode.SetRecover();
                StatusType ignore = STATUS__OK;
                SetInitial(&ignore);
                //self = SelfPath;  // Just to shut up noisey compilers 
            };
 
        virtual void SetSimulation(const std::string &value, 
                                   const float TimeBase,
                                   const std::string &string,
                                   StatusType *status);
 
        
        virtual void SetResetMode(GitResetType & mode,
                                  StatusType *status) {
                if (*status == STATUS__OK)
                        resetMode = mode;
        }
 
        virtual DcppHandlerRet Initialise(
            StatusType *status,
            GitTaskResponseHandler *responseHandler = 0,
            bool freeResponse = false);
 
 
        virtual DcppHandlerRet Poll(
            StatusType *status,
            GitTaskResponseHandler *responseHandler = 0,
            bool freeResponse = false);
 
 
        virtual DcppHandlerRet Exit(
            StatusType *status,
            GitTaskResponseHandler *responseHandler = 0,
            bool freeResponse = false);
 
 
        virtual void Report(StatusType * status);
 
        virtual int IsActive() const {
            return (nextActive != 0);
        };
 
        virtual ~GitTask() { }
 
 
};
 
 
 
class GitTaskActiveList {
    friend class GitTaskActiveListIterator;
    private :
        GitTask *head;
 
        static GitTask * const ListEnd;  /* Indicate the end of the list */
 
/*
 *      Prevent Assignment and copying of this type by redefining the
 *      assignment and copy operators to be private.
 */
        GitTaskActiveList& operator=(const GitTaskActiveList&);
        GitTaskActiveList(const GitTaskActiveList&);
 
        /*
         * Since we ony have one of these, the constructor is made
         * private and the object declared statically in the theList() function.
         */
        GitTaskActiveList() { head = ListEnd; };
        static GitTaskActiveList * theList();
    public:
 
        
        static void ReInit();
 
        static void Insert(GitTask * t);
        
};
 
class GitTaskKnownList {
    friend class GitTaskKnownListIterator;
    private :
        GitTask *head;
 
        static GitTask * const ListEnd;  /* Indicate the end of the list */
/*
 *      Prevent Assignment and copying of this type by redefining the
 *      assignment and copy operators to be private.
 */
        GitTaskKnownList& operator=(const GitTaskKnownList&);
        GitTaskKnownList(const GitTaskKnownList&);
 
        /*
         * Since we ony have one of these, the constructor is made
         * private and the object declared statically in the theList() function.
         */
        GitTaskKnownList() : head(ListEnd) {  };
        static GitTaskKnownList * theList();
 
 
    public:    
 
        static void Insert(GitTask * t);
        
};
 
class GitTaskActiveListIterator {
    private:
        GitTask * ptr;
        GitTask * head;
 
    public:
        GitTaskActiveListIterator() { 
            head = ptr = GitTaskActiveList::theList()->head; };
 
        GitTask *operator()() {
            GitTask * p;
            p   = (ptr != GitTaskActiveList::ListEnd)? ptr : 0; 
            ptr = (ptr != GitTaskActiveList::ListEnd) ? ptr->nextActive : GitTaskActiveList::ListEnd;
            return (p);
        };
        void reset() {               
            ptr = head;
        };
};
class GitTaskKnownListIterator {
    private:
        GitTask * ptr;
        GitTask * head;
 
    public:
        GitTaskKnownListIterator() { 
            head = ptr = GitTaskKnownList::theList()->head; };
 
 
        GitTask *operator()() {
            GitTask * p;
            p   = (ptr != GitTaskKnownList::ListEnd)? ptr : 0;  
            ptr = (ptr != GitTaskKnownList::ListEnd) ? ptr->nextKnown : GitTaskKnownList::ListEnd;
            return (p);
        };
        void reset() {                  /* Reset iterator */
            ptr = head;
        };
};
 
 
#endif