---

dcpptask.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 dcpptask_h
#define dcpptask_h
/*                               d c p p t a s k
  
 * Module name:
      dcpptask.h
  
 * Function:
        A C++ class that provides access to the DRAMA messaging facilities,
  
 * Description:
        An object of this class provides an interface allowing you to send
        messages to other DRAMA tasks.

        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
  
 * Copyright (c) Anglo-Australian Telescope Board, 1995.
   Not to be used for commercial purposes without AATB permission.
  
 *     @(#) $Id: ACMM:DramaDul/dcpptask.h,v 3.43 17-Sep-2009 14:07:37+10 tjf $
  
 * History:
      12-Oct-1995 - TJF - Original version. Extracted from dcpp.h
      09-Nov-1995 - TJF - Change Dits___MsgType to DitsMsgType
      25-Jun-1997 - TJF - Add the Died() function.
      26-Jun-1997 - TJF - Add constructore to buld SelfPath object.
      09-Dec-1997 - TJF - Declare class with DPUBLICCLASS to allow
                          export from WIN32 DLL.
      02-Feb-1998 - TJF - Declare DiscardResponse static function using
                          DSTATICMEM macro to support WIN32 DLL correctly.
      04-Jun-1998 - TJF - When getting task name for a path which is in
                          SELFINIT state, we get the current task's name.
      23-Nov-1998 - TJF - Obey and Send have new transid argument, allowing
                          us to Kick spawned actions.
      22-Dec-1998 - TJF - Add Bulk Data Send function.
      13-Jan-1998 - TJF - Make message operations Virtual.
      16-Nov-1999 - TJF - HandleBulkTrans now returns void.
                          Add new versions of the Obey routines which
                          have an SdsId * final argument, these wrap
                          up the use of DitsSpawnKickArg.  Also add
                          versions with a "const SdsId *", which wrap up a
                          a call to DitsSpawnKickArgUpdate.
      19-Nov-1999 - TJF - DitsSharedMemInfoType arguments replaced by
                          DcppShared arguments.
      12-Sep-2003 - TJF - Add transaction id argument Forget versions of obey
                          (need to create new versions).  This allows us to
                          Forget a spawned obey but then kick it later.
      17-Sep-2003 - TJF - Use Dits___Log for logging.
      22-Sep-2003 - TJF - Add IsDead(), Initial() and Busy() functions and 
                          provide initial support for NOTIFY state.
      16-Dec-2003 - TJF - Add Delete() function.
      06-Jan-2004 - TJF - DisconHandler destructor must be vitual.
      26-Jan-2004 - TJF - Add GetDitsPath() method.
      06-Jul-2004 - TJF - SetName() now looks for a node name and copies
                          it to the right place rather then to the
                          task name part.
  
   
 */
#include "DitsInteraction.h"
#include "DitsFix.h"
#include "DitsBulk.h"
#include "dcpp.h"

DPUBLICCLASS DcppTask {

    public:
        class DisconHandler {
          public:
            DisconHandler() {}
            virtual void Disconnected(DcppTask *) = 0;
            virtual ~DisconHandler() {}
        };

    private:
    
        DisconHandler *disconnectHandler;

        /* List element for list of objects of this type */
        struct TaskListElem {
            TaskListElem *next;
            DcppTask *task;
        };
        /* Pointer to global list of task objects */
        static TaskListElem *ObjectList;  

        static bool disconnectEnabled;
        /* Pointer to this task's entry in list   */
        TaskListElem *MyListElem;      

        static bool Log;


        static DitsDisConnectRoutineType origDisconnect;
        static DVOIDP origDisconnectData;


        bool taskLog;
    
                /* The path to the task, if state != INITIAL    */      
        DitsPathType path;
                /* The state of this task object (NOTIFY not yet supported */
        enum StateEnum { INITIAL, SELFINIT, PATHWAIT1, LOADING, 
                PATHWAIT2, ACTIVE, DIED, NOTIFY } state;
                /* Buffer sizes                         */
        DcppBuffers buffers;
                /* Flags to the PathGet operation       */
        int pathflags;
                /* Task priority                        */
        int priority;
                /* Flags to the load command            */
        int loadflags;
                /* Set true to indicate the last GetPath loaded this task */
        bool loaded;
                /* Do we log loads                      */
        bool logLoad;
                /* The name of the task                 */
        char taskname[DITS_C_NAMELEN];
                /* The location of the task             */
        char tasklocation[DcppNodeNameLen];
                /* The file to load the task from       */
        char taskfile[DcppNodeNameLen];
                /* The requested process name           */
        char process[DITS_C_NAMELEN];
                /* Argument to the load command */
        char argument[DcppArgumentLen];
                /* Decode string                */
        char decode[DcppNodeNameLen];

        unsigned stackSize;

/*
 *      Various internal routines.
 */
        void constructorHelper();

        void Disconnected();

        const char *StateString(StateEnum state) const;

        void LogStartMsg(const char *name, DitsMsgType type,
                const SdsId & arg, bool forgotten, StatusType *status) const;
        static void LogArgument(void *client_data, const char *line,
                                        StatusType * status);
       DcppHandlerRet HandlePathWait1( 
                        DcppTransaction * const transaction, 
                        StatusType * const status);
        DcppHandlerRet HandleLoading( 
                        DcppTransaction * const transaction, 
                        StatusType * const status);
        DcppHandlerRet HandlePathWait2( 
                        DcppTransaction * const transaction, 
                        StatusType * const status);

        DcppHandlerRet HandleRejected(
                        DcppTransaction * const transaction, 
                        StatusType * const status);
        DcppHandlerRet HandleCompleted(
                        DcppTransaction * const transaction, 
                        StatusType * const status);
        DcppHandlerRet HandleTrigger( 
                        DcppTransaction * const transaction, 
                        StatusType * const status);
        DcppHandlerRet HandleErs( 
                        DcppTransaction * const transaction, 
                        StatusType * const status);
        DcppHandlerRet HandleMsg( 
                        DcppTransaction * const transaction, 
                        StatusType * const status);
        void HandleBulkTrans( 
                        DcppTransaction * const transaction, 
                        StatusType * const status);
        DcppHandlerRet HandleBulkDone( 
                        DcppTransaction * const transaction, 
                        StatusType * const status);

        DcppHandlerRet Send(
                  const char * const name, 
                  const DitsMsgType Type,
                  const int flags,
                  const SdsId & arg,
                  const DcppHandlerRoutine SuccessHandler,
                  const DcppHandlerRoutine ErrorHandler,
                  const DcppHandlerRoutine TriggerHandler,
                  const DcppHandlerRoutine ErsHandler,
                  const DcppHandlerRoutine MsgHandler,
                  const DcppVoidPnt ClientData,
                  DitsTransIdType * const transid,
                  StatusType * const status);

        DcppHandlerRet Send(
                  const char * const name, 
                  const DitsMsgType Type,
                  const int flags,
                  const DcppShared & SharedMem,
                  const bool sds,
                  const int NotifyBytes,
                  const DcppHandlerRoutine SuccessHandler,
                  const DcppHandlerRoutine ErrorHandler,
                  const DcppHandlerRoutine TriggerHandler,
                  const DcppHandlerRoutine ErsHandler,
                  const DcppHandlerRoutine MsgHandler,
                  const DcppBulkTransRoutine BulkTransHandler,
                  const DcppHandlerRoutine BulkDoneHandler,
                  const DcppVoidPnt ClientData,
                  DitsTransIdType * const transid,
                  StatusType * const status);

        void SendForget(
                  const char * const name, 
                  const DitsMsgType Type,
                  const int flags,
                  const SdsId & arg,
                  const DcppHandlerRoutine SuccessHandler,
                  const DcppHandlerRoutine ErrorHandler,
                  const DcppHandlerRoutine TriggerHandler,
                  const DcppHandlerRoutine ErsHandler,
                  const DcppHandlerRoutine MsgHandler,
                  const DcppVoidPnt ClientData,
                  DitsTransIdType * const transid,
                  StatusType * const status);

        


/*
 *      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.
 */
        DcppTask& operator=(const DcppTask&);
        DcppTask(const DcppTask&);
        DcppTask();


    public:
        DcppTask(const char * const name, 
                 const char * const location = 0, 
                 const char * const file = 0);

        DcppTask(bool self);

        virtual ~DcppTask();  
/*
 *      Static logging enabling routine.  Effects all objects of this type
 */
        static void LoggingOn() { Log = true;}
        static void LoggingOff() { Log = false;}
        void TaskLoggingOn() { taskLog = true;}
        void TaskLoggingOff() { taskLog = false;}
        void Report(StatusType *status) const;
/*
 *      Inquiries
 */
        bool GetPathLoaded() const { return (loaded); };
        const char * TaskName()  const { 
            /* If self path and we have not initilaised yet, have to
               return the current task's name */
            if (state == SELFINIT)
                return DitsGetTaskName();
            return (taskname);
        };
        const char * Location()  const { return (tasklocation); };
        const char * GetArgument() const { return (argument); };

/*
 *      Routines to set various load and get path options.
 */
        virtual void SetName(const char * const TaskName) {
            unsigned i;
            /*
             * Copy the task name one character at a time - so that
             * we can look for a node name.
             */
            for (i = 0; (TaskName[i] != 0 && TaskName[i] != '@') ; ++i)
            {
                /*
                 * Bail out if too long,  ensuring we null terminate the 
                 * name (but don't complain - through we probably should)
                 */
                if (i >= sizeof(taskname)-1)
                {
                    taskname[sizeof(taskname)-1] = 0;
                    return;
                }
                taskname[i] = TaskName[i];
            }
            taskname[i] = 0; /* Null terminate the stored name */
            /*
             * If we found the node name.
             */
            if (TaskName[i] == '@')
            {
                unsigned j;
                ++i;       /* Point to first character in node name */
                /*
                 * Now copy the node name in.
                 */
                for (j = 0; TaskName[i] != 0  ; ++i, ++j)
                {
                    if (j >= sizeof(tasklocation)-1)
                    {
                        tasklocation[sizeof(tasklocation)-1] = 0;
                        return;
                    }
                    tasklocation[j] = TaskName[i];
                }
                /*
                 * Null terminate.
                 */
                tasklocation[j] = 0;
            }                         
        };
        virtual void SetLocation(const char * const Location) {
                strncpy(tasklocation,Location,sizeof(tasklocation)); 
                tasklocation[sizeof(tasklocation)-1] = 0;
        };
        virtual void SetFile(const char * const File) {
                strncpy(taskfile,File,sizeof(taskfile)); 
                taskfile[sizeof(taskfile)-1] = 0;
        };
        virtual void SetBuffers(const DcppBuffers & Buffers) {
                this->buffers = Buffers;
        };
        virtual void SetFlowControl() {
                pathflags |= DITS_M_FLOW_CONTROL;
        }
        virtual void SetProcess(const char * const ProcessName) {
                if ((ProcessName) && (strlen(ProcessName) > 0))
                {
                    strncpy(process,ProcessName,sizeof(process)) ;
                    process[sizeof(process)-1] = 0; /* Null terminate */
                    loadflags |= DITS_M_PROC_NAME;
                }
                else
                    loadflags &= ~DITS_M_PROC_NAME;
        };

        virtual void SetStackSize(unsigned bytes) {
            stackSize = bytes;
            if (bytes > 0)
                loadflags |= DITS_M_SET_BYTES;
            else
                loadflags &= ~DITS_M_SET_BYTES;
        };


       virtual void SetArgument(const char * const LoadArg, 
                                bool const Append=false)
       {
                if (Append)
                {
                     int len = sizeof(argument) - strlen(argument) - 1;
                     strncat(argument," ",len);
                     --len;
                    strncat(argument,LoadArg,len);      
                }
                else
                    strncpy(argument,LoadArg,sizeof(argument)) ;

                argument[sizeof(argument)-1] = 0;
       };

        virtual void SetPriority(const int Priority, 
                                 const bool Absolute = false) {
            priority = Priority;
            if (Absolute)
            {
                loadflags &= ~DITS_M_REL_PRIO;
                loadflags |= DITS_M_ABS_PRIO;
            }
            else if (Priority == 0)
            {
                loadflags &= ~(DITS_M_REL_PRIO|DITS_M_ABS_PRIO);
            }
            else
            {
                loadflags &= ~DITS_M_ABS_PRIO;
                loadflags |= DITS_M_REL_PRIO;
            }
        };
/*
        IMP_ARG_SPLIT not yet supported

        virtual void SetDecode(const char * const Decode) {
                if (strlen(Decode) > 0)
                {
                    strncpy(decode,Decode,sizeof(decode)) ;
                    loadflags |= DITS_M_ARG_SPLIT;
                }
                else
                    loadflags &= ~DITS_M_ARG_SPLIT;
        };
*/
        virtual void SetNames(const bool Flag = true) {
            if (Flag)
                loadflags |= DITS_M_NAMES;
            else
                loadflags &= ~DITS_M_NAMES;
        };
        virtual void SetSymbols(const bool Flag = true) {
            if (Flag)
                loadflags |= DITS_M_SYMBOL;
            else
                loadflags &= ~DITS_M_SYMBOL;
        };
        virtual void SetProg(const bool Flag = true) {
            if (Flag)
                loadflags |= DITS_M_PROG;
            else
                loadflags &= ~DITS_M_PROG;
        };
        virtual void LogLoad(const bool Flag = true) {
            logLoad = Flag;
        };

        virtual void ClearState() {
                state = INITIAL;
        };
        virtual bool Active() {
            return ((state == ACTIVE)||(state == SELFINIT));
        }
        virtual bool IsDead() {
            return (state == DIED);
        }
        virtual bool Initial() {
            return ((state == INITIAL)||(state == DIED));
        }
        virtual bool Busy() {
            return ((state == PATHWAIT1) ||
                    (state == PATHWAIT2) ||
                    (state == LOADING)   ||
                    (state == NOTIFY));
        }

        virtual DcppHandlerRet GetPath(
                        StatusType * const status,
                        const DcppHandlerRoutine SuccessHandler=0,
                        const DcppHandlerRoutine ErrorHandler=0,
                        const DcppVoidPnt ClientData=0);

        virtual void Died() {
            path = 0;
            state = DIED;
        }
        virtual void LosePath(StatusType * const status) {
            if ((state != INITIAL)&&(state != SELFINIT)&&
                ( path != 0 )&&(path != DitsGetSelfPath()))
                DitsLosePath(path,status);
            Died();
        }
        virtual void Delete(int force, StatusType * status) {
            int known;
            /* Delete the task, note, we cast away the const as the 
               underlying imp routine is not prototyped correctly */
            DitsDeleteTask((char *)TaskName(), force, &known, status);
            Died();
        }
/*
 *      Various messages
 *
 *      Standard Obey function - optionally return transaction id.
 */
        virtual DcppHandlerRet Obey(const char * const name, 
                  StatusType * const status,
                  const SdsId & arg=SdsNull,
                  const DcppHandlerRoutine SuccessHandler=0,
                  const DcppHandlerRoutine ErrorHandler=0,
                  const DcppHandlerRoutine TriggerHandler=0,
                  const DcppVoidPnt ClientData=0,
                  const DcppHandlerRoutine ErsHandler=0,
                  const DcppHandlerRoutine MsgHandler=0,
                  DitsTransIdType * const transid=0) {
                return(Send(name,DITS_MSG_OBEY,0,arg,SuccessHandler,
                            ErrorHandler,TriggerHandler,ErsHandler,MsgHandler,
                            ClientData,transid,status));
        };
        /* 
         * Version of obey where transaction id Sds id is returned instead of
         *   DitsTransIdType 
         */

        virtual DcppHandlerRet Obey(const char * const name, 
                  StatusType * const status,
                  const SdsId & arg,
                  const DcppHandlerRoutine SuccessHandler,
                  const DcppHandlerRoutine ErrorHandler,
                  const DcppHandlerRoutine TriggerHandler,
                  const DcppVoidPnt ClientData,
                  const DcppHandlerRoutine ErsHandler,
                  const DcppHandlerRoutine MsgHandler,
                  SdsId * const tidArg) {
                DitsTransIdType tid = 0;
                DcppHandlerRet result = Send(
                    name,DITS_MSG_OBEY,0,arg,
                    SuccessHandler,
                    ErrorHandler,TriggerHandler,ErsHandler,MsgHandler,
                    ClientData,&tid,status);
                DcppSpawnKickArg(tid, tidArg, status);
                return result;
        };
        /* Version where transaction id Sds id is returned instead of
           DitsTransIdType.  Since the SdsID argument is const, we can
           distinish one where we want to update an existing item rather
           then create a new item 
           */

        virtual DcppHandlerRet Obey(const char * const name, 
                  StatusType * const status,
                  const SdsId & arg,
                  const DcppHandlerRoutine SuccessHandler,
                  const DcppHandlerRoutine ErrorHandler,
                  const DcppHandlerRoutine TriggerHandler,
                  const DcppVoidPnt ClientData,
                  const DcppHandlerRoutine ErsHandler,
                  const DcppHandlerRoutine MsgHandler,
                  const SdsId * const tidArg) {
                DitsTransIdType tid = 0;
                DcppHandlerRet result = Send(
                    name,DITS_MSG_OBEY,0,arg,
                    SuccessHandler,
                    ErrorHandler,TriggerHandler,ErsHandler,MsgHandler,
                    ClientData,&tid,status);
                DcppSpawnKickArgUpdate(tid, tidArg, status);
                return result;
        };
        virtual DcppHandlerRet Kick(const char * const name, 
                  StatusType * const status,
                  const SdsId & arg=SdsNull,
                  const DcppHandlerRoutine SuccessHandler=0,
                  const DcppHandlerRoutine ErrorHandler=0,
                  const DcppVoidPnt ClientData=0,
                  const DcppHandlerRoutine ErsHandler=0,
                  const DcppHandlerRoutine MsgHandler=0) {
                return(Send(name,DITS_MSG_KICK,0,arg,SuccessHandler,
                            ErrorHandler,0,ErsHandler,MsgHandler,
                            ClientData,0,status));
        };
        /* Bulk data versions of the above */
        virtual DcppHandlerRet Obey(const char * const name, 
                  const DcppShared & SharedMem,
                  const bool sds,
                  const int NotifyBytes,
                  StatusType * const status,
                  const DcppHandlerRoutine SuccessHandler=0,
                  const DcppHandlerRoutine ErrorHandler=0,
                  const DcppBulkTransRoutine BulkTransHandler=0,
                  const DcppHandlerRoutine BulkDoneHandler=0,
                  const DcppHandlerRoutine TriggerHandler=0,
                  const DcppVoidPnt ClientData=0,
                  const DcppHandlerRoutine ErsHandler=0,
                  const DcppHandlerRoutine MsgHandler=0,
                  DitsTransIdType * const transid=0) {
                return(Send(name,DITS_MSG_OBEY,0,
                            SharedMem,sds,NotifyBytes,
                            SuccessHandler, ErrorHandler,TriggerHandler,
                            ErsHandler,MsgHandler,
                            BulkTransHandler, BulkDoneHandler,
                            ClientData,transid,status));
        };
        virtual DcppHandlerRet Obey(const char * const name, 
                  const DcppShared & SharedMem,
                  const bool sds,
                  const int NotifyBytes,
                  StatusType * const status,
                  const DcppHandlerRoutine SuccessHandler,
                  const DcppHandlerRoutine ErrorHandler,
                  const DcppBulkTransRoutine BulkTransHandler,
                  const DcppHandlerRoutine BulkDoneHandler,
                  const DcppHandlerRoutine TriggerHandler,
                  const DcppVoidPnt ClientData,
                  const DcppHandlerRoutine ErsHandler,
                  const DcppHandlerRoutine MsgHandler,
                  SdsId * const tidArg) {

                DitsTransIdType tid = 0;
                DcppHandlerRet result = Send(
                    name,DITS_MSG_OBEY,0,
                    SharedMem,sds,NotifyBytes,
                    SuccessHandler, ErrorHandler,TriggerHandler,
                    ErsHandler,MsgHandler,
                    BulkTransHandler, BulkDoneHandler,
                    ClientData,&tid,status);
                DcppSpawnKickArg(tid, tidArg, status);
                return result;
               
        };
        virtual DcppHandlerRet Obey(const char * const name, 
                  const DcppShared & SharedMem,
                  const bool sds,
                  const int NotifyBytes,
                  StatusType * const status,
                  const DcppHandlerRoutine SuccessHandler,
                  const DcppHandlerRoutine ErrorHandler,
                  const DcppBulkTransRoutine BulkTransHandler,
                  const DcppHandlerRoutine BulkDoneHandler,
                  const DcppHandlerRoutine TriggerHandler,
                  const DcppVoidPnt ClientData,
                  const DcppHandlerRoutine ErsHandler,
                  const DcppHandlerRoutine MsgHandler,
                  const SdsId * const tidArg) {

                DitsTransIdType tid = 0;
                DcppHandlerRet result = Send(
                    name,DITS_MSG_OBEY,0,
                    SharedMem,sds,NotifyBytes,
                    SuccessHandler, ErrorHandler,TriggerHandler,
                    ErsHandler,MsgHandler,
                    BulkTransHandler, BulkDoneHandler,
                    ClientData,&tid,status);
                DcppSpawnKickArgUpdate(tid, tidArg, status);
                return result;
               
        };
        virtual DcppHandlerRet Kick(const char * const name, 
                  const DcppShared & SharedMem,
                  const bool sds,
                  const int NotifyBytes,
                  StatusType * const status,
                  const DcppHandlerRoutine SuccessHandler=0,
                  const DcppHandlerRoutine ErrorHandler=0,
                  const DcppBulkTransRoutine BulkTransHandler=0,
                  const DcppHandlerRoutine BulkDoneHandler=0,
                  const DcppVoidPnt ClientData=0,
                  const DcppHandlerRoutine ErsHandler=0,
                  const DcppHandlerRoutine MsgHandler=0) {
                return(Send(name,DITS_MSG_KICK,0,
                            SharedMem,sds,NotifyBytes,
                            SuccessHandler, ErrorHandler,0,
                            ErsHandler,MsgHandler,
                            BulkTransHandler, BulkDoneHandler,
                            ClientData,0,status));
        };
        virtual DcppHandlerRet Get(const char * const name, 
                  StatusType * const status,
                  const DcppHandlerRoutine SuccessHandler=0,
                  const DcppHandlerRoutine ErrorHandler=0,
                  const DcppVoidPnt ClientData=0,
                  const DcppHandlerRoutine ErsHandler=0) {
                return(Send(name,DITS_MSG_GETPARAM,0,SdsNull,SuccessHandler,
                            ErrorHandler,0,ErsHandler,0,
                            ClientData,0,status));
        };
        virtual DcppHandlerRet MGet(
                  const DcppHandlerRoutine SuccessHandler,
                  const DcppHandlerRoutine ErrorHandler,
                  const DcppVoidPnt ClientData, unsigned count,
                  StatusType * status, ...);

        virtual DcppHandlerRet MGet(
                  const DcppHandlerRoutine SuccessHandler,
                  const DcppHandlerRoutine ErrorHandler,
                  const DcppHandlerRoutine ErsHandler,
                  const DcppVoidPnt ClientData, unsigned count,
                  StatusType * status, ...);

        virtual DcppHandlerRet Set(const char * const name, 
                  StatusType * const status,
                  const SdsId & arg = SdsNull,
                  const DcppHandlerRoutine SuccessHandler=0,
                  const DcppHandlerRoutine ErrorHandler=0,
                  const DcppVoidPnt ClientData=0,
                  const DcppHandlerRoutine ErsHandler=0) {
                return(Send(name,DITS_MSG_SETPARAM,0,arg,SuccessHandler,
                        ErrorHandler,0,ErsHandler,0,
                        ClientData,0,status));
        };
        virtual DcppHandlerRet Control(const char * const name, 
                  StatusType * const status,
                  const SdsId & arg=SdsNull,
                  const DcppHandlerRoutine SuccessHandler=0,
                  const DcppHandlerRoutine ErrorHandler=0,
                  const DcppHandlerRoutine TriggerHandler=0,
                  const DcppVoidPnt ClientData=0,
                  const DcppHandlerRoutine ErsHandler=0) {
                return(Send(name,DITS_MSG_CONTROL,0,arg,SuccessHandler,
                            ErrorHandler,TriggerHandler,ErsHandler,0,
                            ClientData,0,status));
        };
        virtual DcppHandlerRet Monitor(const char *name, 
                  StatusType * const status,
                  const SdsId & arg=SdsNull,
                  const DcppHandlerRoutine SuccessHandler=0,
                  const DcppHandlerRoutine ErrorHandler=0,
                  const DcppHandlerRoutine TriggerHandler=0,
                  const DcppVoidPnt ClientData=0,
                  const bool SendCurrent=false,
                  const DcppHandlerRoutine ErsHandler=0) {
                int flags =  SendCurrent ? DITS_M_SENDCUR : 0;
                return(Send(name,DITS_MSG_MONITOR,flags,arg,SuccessHandler,
                        ErrorHandler,TriggerHandler,ErsHandler,0,
                        ClientData,0,status));
        };
        /* 
         * Forget Versions - Obey and Monitor only
         */
        virtual void ObeyForget(const char * const name, 
                  StatusType * const status,
                  const SdsId & arg=SdsNull,
                  const DcppHandlerRoutine SuccessHandler=0,
                  const DcppHandlerRoutine ErrorHandler=0,
                  const DcppHandlerRoutine TriggerHandler=0,
                  const DcppVoidPnt ClientData=0,
                  const DcppHandlerRoutine ErsHandler=0,
                  const DcppHandlerRoutine MsgHandler=0,
                  DitsTransIdType * const transid=0) {
                SendForget(name,DITS_MSG_OBEY,0,arg,SuccessHandler,
                        ErrorHandler,TriggerHandler,ErsHandler,MsgHandler,
                        ClientData,transid,status);
        };
        virtual void ObeyForget(const char * const name, 
                  StatusType * const status,
                  const SdsId & arg,
                  const DcppHandlerRoutine SuccessHandler,
                  const DcppHandlerRoutine ErrorHandler,
                  const DcppHandlerRoutine TriggerHandler,
                  const DcppVoidPnt ClientData,
                  const DcppHandlerRoutine ErsHandler,
                  const DcppHandlerRoutine MsgHandler,
                  SdsId * const tidArg) {
                DitsTransIdType tid = 0;
                SendForget(name,DITS_MSG_OBEY,0,arg,SuccessHandler,
                        ErrorHandler,TriggerHandler,ErsHandler,MsgHandler,
                        ClientData,&tid,status);
                DcppSpawnKickArg(tid, tidArg, status);
        };
        virtual void ObeyForget(const char * const name, 
                  StatusType * const status,
                  const SdsId & arg,
                  const DcppHandlerRoutine SuccessHandler,
                  const DcppHandlerRoutine ErrorHandler,
                  const DcppHandlerRoutine TriggerHandler,
                  const DcppVoidPnt ClientData,
                  const DcppHandlerRoutine ErsHandler,
                  const DcppHandlerRoutine MsgHandler,
                  const SdsId * const tidArg) {
                DitsTransIdType tid = 0;
                SendForget(name,DITS_MSG_OBEY,0,arg,SuccessHandler,
                        ErrorHandler,TriggerHandler,ErsHandler,MsgHandler,
                        ClientData,&tid,status);
                DcppSpawnKickArgUpdate(tid, tidArg, status);
        };
        virtual void KickForget(const char * const name, 
                  StatusType * const status,
                  const SdsId & arg=SdsNull,
                  const DcppHandlerRoutine SuccessHandler=0,
                  const DcppHandlerRoutine ErrorHandler=0,
                  const DcppVoidPnt ClientData=0,
                  const DcppHandlerRoutine ErsHandler=0,
                  const DcppHandlerRoutine MsgHandler=0) {
                SendForget(name,DITS_MSG_KICK,0,arg,SuccessHandler,
                        ErrorHandler,0,ErsHandler,MsgHandler,
                           ClientData,0,status);
        };
        virtual void MonitorForget(const char *name, 
                  StatusType * const status,
                  const SdsId & arg=SdsNull,
                  const DcppHandlerRoutine SuccessHandler=0,
                  const DcppHandlerRoutine ErrorHandler=0,
                  const DcppHandlerRoutine TriggerHandler=0,
                  const DcppVoidPnt ClientData=0,
                  const bool SendCurrent=false,
                  const DcppHandlerRoutine ErsHandler=0) {
                int flags =  SendCurrent ? DITS_M_SENDCUR : 0;
                SendForget(name,DITS_MSG_MONITOR,flags,arg,SuccessHandler,
                        ErrorHandler,TriggerHandler,ErsHandler,0,
                        ClientData,0,status);
        };

        virtual DisconHandler *PutDisconnectHandler(DisconHandler *p) {
            DisconHandler *old = disconnectHandler;
            disconnectHandler = p;
            return old;
        }

        DcppHandlerRet HandleMessage(DcppTransaction * transaction, 
                        StatusType * status);

        DSTATICMEM DcppHandlerRet DiscardResponse(DcppVoidPnt ClientData,
                        StatusType * status) ;

        virtual void GetDitsPath(DitsPathType *path, StatusType *status);

        static DVOID HandleDisconnected(const char *task,
                                        DitsPathType path,
                                        StatusType *status);
};


#endif

---