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$"
 *
 * 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$
 *
 *      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_SIM_ALLLEVELS -1  /* The way this was traditionally done */
 
/*
 * These (through to KEEPVALERR) must be unique mask values  
 * 
 */
#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_M_ARG_KEEPVALERR 0x20 /* NOTE - was diffent (and wrong) value before version 3.78 */
 
#define GIT_ARG_LMAX 20
 
 
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 GitArgNamePos2 ( 
        DCONSTV SdsIdType id, 
        DCONSTV char *name, 
        DCONSTV int position,
        DCONSTV int flags,
        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);
 
 
/*
 *  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_LOWER,    
            KeepErr=GIT_M_ARG_KEEPERR,
            Abbrev = GIT_M_ARG_ABBREV,
            LastBit=GIT_M_ARG_LASTBIT,
            KeepValErr=GIT_M_ARG_KEEPVALERR
        };
};
 
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