dcppmonitor.h

Go to the documentation of this file.

/*
 * 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 dcppmonitor_h
#define dcppmonitor_h
/*                            d c p p m o n i t o r
  
 * Module name:
      dcppmonitor.h
  
 * Function:
        A class that which used DcppTask to support parameter monitoring.
  
 * Description:
        This class provides a wrap around to parameter monitoring operations.
        It uses a DcppTask object previously constructed by the user and 
        on which a GetPath operation  must have been completed.
        
        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 documentation (see DramaHtml/Makefile,
        DramaHtml/doxygen.config and DramaHtml/filter.m4 for detials)
  
 * Language:
      C++
  
 * Support: Tony Farrell, AAO
  
 * Copyright (c) Anglo-Australian Telescope Board, 1995.
   Not to be used for commercial purposes without AATB permission.
  
 *     @(#) $Id$
  
 * History:
      12-Oct-1995 - TJF - Original version. Extracted from dcpp.h.
      10-Sep-1997 - TJF - Add IsInitial(), IsStarting() and IsActive().
      09-Dec-1997 - TJF - Declare class with DPUBLICCLASS to allow
                          export from WIN32 DLL.
      16-Mar-2006 - TJF - monId should be INT32 - to avoid compiler warnings
                          with the new SDS Arg calls.
  
 */
#include "dcpptask.h"
/*
 * This file now uses DOXYGEN comments - the following is placed into the
 * index page.  note that the @file block says to include the typedefs,
 * functions etc from this file into the documentation.
 */
 
typedef void (*DcppMonChangedRoutine)
                (const char *name, SdsCodeType type, DcppVoidPnt value,  
                 DcppVoidPnt ClientData, StatusType * status);
 
DPUBLICCLASS DcppMonitor {
     private:
        DcppTask *task;
        DcppMonChangedRoutine changedHandler;
        DcppHandlerRoutine    completedHandler;
        DcppHandlerRoutine    startHandler;
        DcppVoidPnt           clientData;
        enum StateEnum { INIT, WAIT_ID, ACTIVE } state;
        INT32 monId;
 
 
        const char *StateString(StateEnum state) const;
        static DcppHandlerRet CompHandler(DcppVoidPnt ClientData,
                                     StatusType * status);
        static DcppHandlerRet StartedHandler(DcppVoidPnt ClientData,
                                     StatusType *status);
        static DcppHandlerRet TrigHandler(DcppVoidPnt ClientData,
                                     StatusType * status);
 
 
        /* kept for link time compatiblity only - should not be invoked
           any more.  Use DcppVarArgsToSds() for all code.
        */
        void FormatArg(int count, 
                            Arg& ArgId,
                            StatusType * status,
                            va_list args);
 
 
 
/*
 *      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.
 *
 *      Also disallow the default constructor.
 */
        DcppMonitor& operator=(const DcppMonitor&);
        DcppMonitor(const DcppMonitor&);
        DcppMonitor();
 
 
 
 
    public:
        DcppMonitor(DcppTask * Task) { task = Task; state = INIT; };
        
        DcppTask * Task() const { return task; };
 
        void Monitor(
                const DcppMonChangedRoutine ChangedHandler,
                const DcppHandlerRoutine    CompletedHandler,
                const DcppVoidPnt             ClientData,
                const bool SendCurrent,
                const int count, StatusType * const status, ...);
        void MonitorForget(
                const DcppMonChangedRoutine ChangedHandler,
                const DcppHandlerRoutine    CompletedHandler,
                const DcppVoidPnt             ClientData,
                const bool SendCurrent,
                const int count, StatusType * const status, ...);
        void Forward(
                const char * const MTask, 
                const char * const Action,
                const DcppHandlerRoutine    CompletedHandler,
                const DcppVoidPnt             ClientData,
                const bool SendCurrent,
                const int count, StatusType * const status, ...);
        void Forward(
                const char * const MTask, 
                const char * const Action,
                const DcppHandlerRoutine    StartedHandler,
                const DcppHandlerRoutine    CompletedHandler,
                const DcppVoidPnt             ClientData,
                const bool SendCurrent,
                const int count, StatusType * const status, ...);
        void ForwardForget(
                const char * const MTask, 
                const char * const Action,
                const DcppHandlerRoutine    CompletedHandler,
                const DcppVoidPnt             ClientData,
                const bool SendCurrent,
                const int count, StatusType * const status, ...);
        void ForwardStartForget(
                const char * const MTask, 
                const char * const Action,
                const DcppHandlerRoutine    StartHandler,
                const DcppHandlerRoutine    CompletedHandler,
                const DcppVoidPnt             ClientData,
                const bool SendCurrent,
                const int count, StatusType * const status, ...);
 
        void Add (
                  const char * const name, 
                  StatusType * const status,
                  const DcppHandlerRoutine   SuccessHandler = 0,
                  const DcppHandlerRoutine   ErrorHandler   = 0,
                  const DcppVoidPnt ClientData = 0) const ;
        void Delete (
                  const char * const name, 
                  StatusType * const status,
                  const DcppHandlerRoutine   SuccessHandler = 0,
                  const DcppHandlerRoutine   ErrorHandler   = 0,
                  const DcppVoidPnt ClientData = 0) const ;
        
        void Cancel (
                  StatusType * const status,
                  const DcppHandlerRoutine   SuccessHandler = 0,
                  const DcppHandlerRoutine   ErrorHandler   = 0,
                  const DcppVoidPnt ClientData = 0) const ;
 
        bool IsInitial() {
               return (state == INIT);
        }
        bool IsStarting() {
               return (state == WAIT_ID);
        }
        bool IsActive() {
               return (state == ACTIVE);
        }
        void Reset() {
            state = INIT;
        }
};
 
#endif