---

Git.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: ACMM:DramaHtml/filter.m4,v 3.24 03-Nov-2009 09:07:29+11 tjf $"
 *
 * History:
 *     10-Nov-2004 - TJF - Original Version.
 */



#ifndef GITINC
#define GITINC
/*
 *  Copyright (c) Anglo-Australian Telescope Board, 1995.
 *   Not to be used for commercial purposes without AATB permission.
 *  
 *     @(#) $Id: ACMM:DramaGit/Git.h,v 3.49 17-Sep-2009 14:08:18+10 tjf $
 *
 *      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)
 *


 */
#ifdef GIT_MODULE
#define DNOCONST 0
#endif
/*
 *  Include file for Git module
 */

#include "DitsTypes.h"      /* For DitsActionHandlerType and  drama.h */
#include "sds.h"            /* For SdsIdType    */
#include "DitsSys.h"
#include "dul.h"            /*  */
#ifdef __cplusplus
extern "C" {
#endif
/*
 *  Simulation levels, taken from GIT_SPEC. Note GIT_SIM_NONE should be zero.
 */
typedef enum { GIT_SIM_NONE=0, GIT_SIM_BASIC, GIT_SIM_COMMANDS,
               GIT_SIM_STATUS, GIT_SIM_FULL } GitSimulationType;

typedef enum { GIT_MON_START, GIT_MON_FORWARD, GIT_MON_ADD, 
                GIT_MON_DELETE, GIT_MON_CANCEL } GitMonitorMsgType;

typedef struct { 
    const char * GitTrue; 
    const char * GitFalse;
} GitLogStrType;


#define GIT_M_SIM_BASIC 1
#define GIT_M_SIM_COMMANDS 2
#define GIT_M_SIM_STATUS 4

#define GIT_M_ARG_UPPER 1
#define GIT_M_ARG_LOWER 2
#define GIT_M_ARG_KEEPERR 4
#define GIT_M_ARG_ABBREV 8
#define GIT_M_ARG_LASTBIT 0x10

#define GIT_ARG_LMAX 10

#ifdef DPROTOTYPES_OK
    DPUBLIC DVOID GitActivate (
                    DCONSTV SdsIdType parsysid, 
                    StatusType *status);
    DPUBLIC     int GitSimulation (
                        DCONSTV char * DCONSTR exName, 
                        DCONSTV int levels, 
                        GitSimulationType * DCONSTR simulation,
                        float * DCONSTR timebase,
                        StatusType * DCONSTR status);

    DPUBLIC DVOID GitParEnvGetS(
                    DCONSTV char * DCONSTR pName,
                    DCONSTV char * DCONSTR eName,
                    DCONSTV char * DCONSTR badVal,
                    DCONSTV char * DCONSTR defVal,
                    DCONSTV int    actValLen,
                    char * DCONSTR actVal,
                    StatusType * DCONSTR status);
    DPUBLIC int GitEnvGetS(
                    DCONSTV char * name, 
                    DCONSTV int valLen, 
                    char *val, 
                    StatusType *status);
    DPUBLIC DVOID GitArgGetS ( 
                DCONSTV SdsIdType id, 
                DCONSTV char * name, 
                DCONSTV int position,
                DCONSTV char *values[], 
                DCONSTV char *defVal, 
                DCONSTV int flags,
                DCONSTV int actValLen , 
                char * actValue, 
                int *index,
                StatusType * status);
    DPUBLIC DVOID GitArgGetI ( 
                    DCONSTV SdsIdType id, 
                    DCONSTV char *name, 
                    DCONSTV int position,
                    DCONSTV long int range[], 
                    DCONSTV long int defVal, 
                    DCONSTV int flags,
                    long int * actValue, 
                    StatusType *status);

    DPUBLIC DVOID GitArgGetD ( 
                    DCONSTV SdsIdType id, 
                    DCONSTV char *name, 
                    DCONSTV int position,
                    DCONSTV double range[], 
                    DCONSTV double defVal, 
                    DCONSTV int flags,
                    double * actValue, 
                    StatusType *status);

    DPUBLIC DVOID GitArgGetL (
                        DCONSTV SdsIdType id,
                        DCONSTV char *name, 
                        DCONSTV int position,
                        DCONSTV GitLogStrType strings[], 
                        DCONSTV long int defVal, 
                        DCONSTV int flags,
                        long int * actValue, 
                        StatusType *status);

    DPUBLIC DVOID GitArgNamePos ( 
                    DCONSTV SdsIdType id, 
                    DCONSTV char *name, 
                    DCONSTV int position,
                    SdsIdType *argid,
                    StatusType *status);
    DPUBLIC DVOID  GitPathGetInit(
                    DCONSTV  char * DCONSTV name, 
                    int MessageBytes,
                    int MaxMessages,
                    int ReplyBytes,
                    int MaxReplies,
                    int timeout,
                    DitsActionRoutineType handler,
                    DVOIDP client_data,
                    StatusType *status);
    DPUBLIC DVOID GitPathGetComp(
                    DitsPathType *path,
                    DVOIDP * client_data,
                    StatusType *status);


    DPUBLIC DVOID GitTpiInit (StatusType *status);
    DPUBLIC DVOID GitTpiPut (
                        DCONSTV int key, 
                        DVOIDP item, 
                        StatusType *status);
    DPUBLIC DVOID GitTpiGet (
                        DCONSTV int key, 
                        DVOIDP * item, 
                        StatusType *status);
    DPUBLIC DVOID GitTpiDelete (
                        DCONSTV int key, 
                        StatusType *status);

    DPUBLIC DVOID GitArgGetStruct ( 
                DCONSTV SdsIdType id, 
                DCONSTV char *name, 
                DCONSTV int position,
                DCONSTV char *defVal, 
                int  actNameLen,
                char * actName,
                SdsIdType * actValue, 
                StatusType *status);

    DPUBLIC DVOID GitPutDelay(
                    double delay,
                    StatusType *status);
    DPUBLIC DVOID GitPutDelayPar(
                    DCONSTV char * parameter,
                    StatusType *status);
                    
                    
    DPUBLIC DVOID GitTimer(StatusType *status); 
    DPUBLIC DVOID GitTimerArgExtract(DVOIDP ClientData, const SdsIdType InArg, 
                                       SdsIdType * DCONSTR OutArg,
                                       StatusType * DCONSTR status);
            

    typedef DVOID (*GitMonitorStartedType)(int id,
                                        DVOIDP client_data,
                                        StatusType *status);
    typedef DVOID (*GitMonitorChangedType)(
                                        char * name,
                                        SdsCodeType type,
                                        DVOIDP value,
                                        DVOIDP client_data,
                                        StatusType *status);
    typedef DVOID (*GitMonitorResponseType)(
                                        DVOIDP client_data,
                                        StatusType *status);

    typedef DVOID (*GitTimerArgRoutineType)(
                                DVOIDP ClientData,
                                SdsIdType InArg, SdsIdType *OutArg,
                                StatusType *status);

#else
    DPUBLIC DVOID GitActivate ();
    DPUBLIC int GitSimulation ();
    DPUBLIC DVOID GitParEnvGetS();
    DPUBLIC int GitEnvGetS();
    DPUBLIC DVOID GitArgGetS ();
    DPUBLIC DVOID GitArgGetI ();
    DPUBLIC DVOID GitArgGetD ();
    DPUBLIC DVOID GitArgGetD ();
    DPUBLIC DVOID GitArgGetL ();
    DPUBLIC DVOID GitArgNamePos ();
    DPUBLIC DVOID  GitPathGetInit();
    DPUBLIC DVOID GitPathGetComp();
    DPUBLIC DVOID GitTpiInit ();
    DPUBLIC DVOID GitTpiAdd ();
    DPUBLIC DVOID GitTpiGet ();
    DPUBLIC DVOID GitTpiPut ();
    DPUBLIC DVOID GitTpiDelete ();
    DPUBLIC DVOID GitArgGetStruct();
    DPUBLIC DVOID GitPutDelay();
    DPUBLIC DVOID GitPutDelayPar();
    DPUBLIC DVOID GitTimer(StatusType *status);             
    DPUBLIC DVOID GitTimerArgExtract();

    typedef DVOID (*GitMonitorStartedType)();
    typedef DVOID (*GitMonitorChangedType)();
    typedef DVOID (*GitMonitorResponseType)();
    typedef DVOID (*GitTimerArgRoutineType)();

#endif

/*
 *  Can only define these prototypes in gitmonitor.c if stdarg.h is available.
 */

#if (!defined(GITMONITORC) || defined(DSTDARG_OK))  && defined(DPROTOTYPES_OK)
    DPUBLIC DVOID GitMonitorStart(
                    DitsPathType                path,
                    GitMonitorStartedType       Started,
                    GitMonitorChangedType       Changed,
                    GitMonitorResponseType      Completed,
                    GitMonitorResponseType      Unexpected,
                    DVOIDP                      client_data,
                    int                         count,
                    StatusType *status, ...);
     DPUBLIC DVOID GitMonitorStartF(
                    DitsPathType                path,
                    int                         Flags,
                    GitMonitorStartedType       Started,
                    GitMonitorChangedType       Changed,
                    GitMonitorResponseType      Completed,
                    GitMonitorResponseType      Unexpected,
                    DVOIDP                      client_data,
                    int                         count,
                    StatusType *status, ...);
    DPUBLIC DVOID GitMonitorForward(
                    DitsPathType                path,
                    DCONSTV char *              task,
                    DCONSTV char *              action,
                    GitMonitorStartedType       Started,
                    GitMonitorResponseType      Completed,
                    GitMonitorResponseType      Unexpected,
                    DVOIDP                      client_data,
                    int                         count,
                    StatusType *status, ...);

    DPUBLIC DVOID GitMonitorMessage(
                    int                         id,
                    DitsPathType                path,
                    GitMonitorMsgType           type,
                    int                         count,
                    DitsTransIdType           * transid,
                    StatusType *status,...);

#elif !defined(GITMONITORC)
    DPUBLIC DVOID GitMonitorStart();
    DPUBLIC DVOID GitMonitorStartF();
    DPUBLIC DVOID GitMonitorForward();
    DPUBLIC DVOID GitMonitorChange();
#endif


/*
 * Structures used by GitTimer.
 */
typedef struct {
        char ActionName[DITS_C_NAMELEN];
        GitTimerArgRoutineType ArgCreateRoutine;
        DVOIDP ClientData;
        SdsIdType Arg;                  /* Argument for this action */
        
        /* Info private to GitTimer follows */
        DitsGsokMessageType _Message;   /* Message to send */
        } GitTimerDetailsType;

typedef struct {
        char TaskName[DITS_C_NAMELEN];  /* Task involved */
        int  SeqCount;                  /* Number of elements in Sequence */
        GitTimerDetailsType *SequenceDetails; /* Sequence definitons */
        DitsPathInfoType Buffers;       /* Message buffer sizes */
        /* Info private to GitTimer follows */
        int  _Current;                  /* Current in sequence */
        long  _Count;                   /* Number of repeats to do */
        int  _Done;                     /* Number of repeats done; */
        DitsPathType _Path;             /* Path to task involved */
        IMP_AbsTime _StartTime;         /* Start time           */
        } GitTimerType;


#ifdef __cplusplus
} /* extern "C" */
/*
 * C++ only section
 *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
 *
 * Here is a C++ interface to Git.  
 *
 * First, A Class which defines flags used in the rest of this module.
 */
#include "arg.h"
 
DPUBLICCLASS Git {
    public:
        enum { 
            Upper=GIT_M_ARG_UPPER,    
            Lower=GIT_M_ARG_UPPER,    
            KeepErr=GIT_M_ARG_KEEPERR,
            Abbrev = GIT_M_ARG_ABBREV,
            LastBit=GIT_M_ARG_LASTBIT 
        };
};

DPUBLICCLASS GitEnum : public Git {
 protected:
    virtual void SetValue(const unsigned int) = 0;
    virtual const char  * const * Lookup() = 0;
 public:
    virtual ~GitEnum() {};
    void Get(const SdsId& Id,
             const char * const Name,
             const int Position,
             StatusType *status,
             const char *Default=0,
             const int Flags = Git::Upper|Git::Abbrev)
        {
            char string[100];
            int index;
            GitArgGetS((SdsIdType)Id,Name,Position,(const char **)Lookup(),
                       Default,
                       Flags,sizeof(string),string,&index,status);
            SetValue(index);   
        };
    
};
DPUBLICCLASS GitBool : public Git {
 private:
    bool value;
    static const GitLogStrType lookupTable[];
 protected:
    virtual const GitLogStrType * Lookup() {
                return lookupTable;
    }
 public:
    GitBool() {
        value = false;
    }
    GitBool (   /*Constructor with automatic Get        */
        const SdsId& Id,
        const char * const Name,
        const int Position,
        StatusType * const status,
        const bool  Default = false,
        const int Flags = (Git::Upper|Git::Abbrev))
        {
            value = false;
            Get(Id,Name,Position,status,Default,Flags);
        }
    virtual ~GitBool() {};      /* Destructor for inheritors */
    virtual void Get(           /* Get value from Sds structure */
        const SdsId& Id,
        const char * const Name,
        const int Position,
        StatusType * const status,
        const bool  Default = false,
        const int Flags = (Git::Upper|Git::Abbrev))
        {
            long int actValue;
            GitArgGetL((SdsIdType)Id,Name,Position,Lookup(),Default,
                       Flags,&actValue,status);
            value = actValue ? true : false;                    
        };
    operator int() const {
        return ((int)(value));
    };
    operator bool() const {
        return value;
    };
                        
};
DPUBLICCLASS GitReal : public Git {
 private:
    double value;

 protected:
    virtual const double * Range() { return 0; };
 public:
    GitReal(const double def = 0.0) {   /* Basic constructor    */
                value = def;
    }
    GitReal (   /*Constructor with automatic Get        */
        const SdsId& Id,
        const char * const Name,
        const int Position,
        StatusType * const status,
        const double  Default = 0.0,
        const int Flags = 0)
        {
                value = 0.0;
                Get(Id,Name,Position,status,Default,Flags);
        }
    virtual ~GitReal() {};      /* Destructor for inheritors */
    virtual void Get(           /* Get value from Sds structure */
                        const SdsId& Id,
                        const char * const Name,
                        const int Position,
                        StatusType * const status,
                        const double  Default = 0.0,
                        const int Flags = 0)
        {
            GitArgGetD((SdsIdType)Id,Name,Position,Range(),Default,
                       Flags,&value,status);
        };
    operator double() const {
        return (value);
    };
    operator float() const {
        return (value);
    };
                        
};

DPUBLICCLASS GitInt : public Git {
 private:
    long int value;

 protected:
    virtual const long int * Range() { return 0; };
 public:
    GitInt(const long int def = 0) {    /* Basic constructor    */
                value = def;
    }
    GitInt (    /*Constructor with automatic Get        */
        const SdsId& Id,
        const char * const Name,
        const int Position,
        StatusType * const status,
        const long int Default = 0,
        const int Flags = 0)
        {
            value = 0;
            Get(Id,Name,Position,status,Default,Flags);
        }
    virtual ~GitInt() {};       /* Destructor for inheritors */
    virtual void Get(           /* Get value from Sds structure */
        const SdsId& Id,
        const char * const Name,
        const int Position,
        StatusType * const status,
        const long int Default = 0,
        const int Flags = 0)
        {
            GitArgGetI((SdsIdType)Id,Name,Position,Range(),Default,
                       Flags,&value,status);
        };
    operator long int() const {
                return (value);
    };
                        
};

#endif
#endif

---