DRAMA C++ Intro   Class Hierarchy   Alphabetical List of types   List of Classes   File List   Class Member Index   File Members Index   Related Pages  

gittask.h
1 /*
2  * Name: filter.m4
3  *
4  * Description:
5  * DOXYGEN Input file filter for DRAMA source files.
6  *
7  * This file must be complatible with both Solaris and GNU m4. All
8  * unused macros are deleted and this comment must end up as a C/C++
9  * compatible comment which is not picked up by DOXYGEN.
10  *
11  * Synopsis:
12  * DCF(func) => Produces a link to a DRAMA C source file func.html
13  * in ../routines.
14  * DDL(link,text) => Produce a link to ../link.html, specified link text.
15  *
16  * Language: m4 macro.
17  *
18  * Author: Tony Farrell, AAO.
19  *
20  * "@(#) $Id: ACMM:DramaHtml/filter.m4,v 3.29+ 02-May-2014 10:40:01+10 tjf $"
21  *
22  * History:
23  * 10-Nov-2004 - TJF - Original Version.
24  */
25 
26 
27 
28 #ifndef GITTASKINC
29 #define GITTASKINC
30 
31 /* g i t t a s k
32 
33  * Module name:
34  gittask.h
35 
36  * Function:
37  Include file for the gittask.C module
38 
39  * Description:
40  gittask.C/gittask.h implement a C++ class derived from
41  DcppTask. See gittask.C for details.
42 
43  This file now uses DOXYGEN comments to generate the C++ web pages.
44  m4 macros of the form @htmlonly <a href="../routines/function.html">function()</a>@endhtmlonly are used in the comments
45  to refer to DRAMA C function documention (see DramaHtml/Makefile,
46  DramaHtml/doxygen.config and DramaHtml/filter.m4 for detials)
47 
48  * Language:
49  C
50 
51  * Support: Tony Farrell, AAO
52 
53  * History:
54  16-Dec-2003 - TJF - Original Version.
55  16-Jan-2004 - TJF - Remove GitTask::isActive variable and
56  revamp list stuff. Remove status argument from
57  SetSimulation(), Support user override of version
58  stuff, Get remove net start stuff working,
59  09-Nov-2004 - TJF - In cases where some arguments were not used, put
60  the name back in (e.g. "StatusType *") such that
61  doxygen does not complain, and then use the
62  argument such that the compiler does not complain.
63  30-May-2006 - TJF - The self path constructor now takes an enum as
64  the argument to ensure a char * is not converted
65  to a bool triggering this constructor.
66 
67  * @(#) $Id: ACMM:DramaGit/gittask.h,v 3.71 24-Mar-2015 09:39:07+11 tjf $
68 
69  */
70 
71 #include "dcpptask.h"
72 #include "Git.h"
73 #include "DitsMsgOut.h"
74 
75 #include <string>
76 
95 class GitResetType : public GitEnum {
96  private:
97  /* Enum possibilities */
98  enum resetEnum { Soft=0, Full, Hard, Recover, Invalid };
99  /* value contains the actual value, lookupTable the list of strings.*/
100  resetEnum value;
101  static const char * const lookupTable[];
102 
103  /* Return lookup table address. Used by GitEnum::Get */
104  const char * const * Lookup() {
105  return lookupTable;
106  };
107  /* Set the value, Use by GitEnum::Get */
108  void SetValue(const unsigned int i) {
109  if (i >= Invalid)
110  value = Invalid;
111  else
112  value = (resetEnum)i;
113  }
114  /* Conversion operator - given enum, return an int */
115  operator int() const {
116  return ((int)(value));
117  };
118 
119  public:
136  GitResetType(const SdsId &Id,
137  const char * const Name,
138  int Position,
139  StatusType * status,
140  const int Flags=Git::Upper|Git::Abbrev|Git::KeepErr) {
141  // Just get the value using GitEnum.
142  GitEnum::Get(Id, Name, Position, status, "SOFT", Flags);
143  }
144 
149  value = Soft;
150  };
151 
152  void Get(const SdsId &Id,
153  const char * const Name,
154  int Position,
155  StatusType * status,
156  const int Flags=Git::Upper|Git::Abbrev|Git::KeepErr) {
157  // Just get the value using GitEnum.
158  GitEnum::Get(Id, Name, Position, status, "SOFT", Flags);
159  }
160 
163  void SetRecover() {
164  value = Recover;
165  };
168  void SetSoft() {
169  value = Soft;
170  }
173  void SetHard() {
174  value = Hard;
175  }
178  void SetFull() {
179  value = Full;
180  }
183  bool IsSoft() const { return (value == Soft); };
186  bool IsFull() const { return (value == Full); };
189  bool IsHard() const { return (value == Hard); };
192  bool IsRecover() const { return (value == Recover); };
195  bool IsInvalid() const { return (value == Invalid); };
196 
199  operator const char*() const {
200  return lookupTable[value];
201  };
202 
203 };
204 /*
205  * Forward declaration - since we need this in GitTaskRepsonseHandler.
206  */
207 class GitTask;
208 
216  public:
220 
235  virtual DcppHandlerRet CompleteOk(GitTask * /*task*/,StatusType *status) {
236  if (*status != STATUS__OK) return DcppFinished;
237  //task = 0; /* Shut up compiler */
238  return DcppFinished;
239  }
258  StatusType *status) {
259  if (*status == STATUS__OK)
260  *status = DitsGetEntStatus();
261  //task= 0; /* Shut up compliler */
262  return DcppFinished;
263  }
278  virtual DcppHandlerRet Triggered(GitTask * /*task*/, StatusType *status) {
279  if (*status != STATUS__OK) return DcppFinished;
280  //task = 0;
281  return DcppFinished;
282  }
283 
287 
288 };
289 
290 /*
291  * This class is a helper class used by GitTask to help manage
292  * the GitTaskResponseHandler class objects.
293  */
295  private:
296  bool deleteHandler; /* Should the handler be deleted */
297  GitTaskResponseHandler *handler; /* Handler address */
298  GitTask *task; /* Task this is part of */
299  public:
301  deleteHandler(false), handler(0), task(t) {}
302 
303  /*
304  * Set up a new handler routine. If responseHandler is null, then a new
305  * handler is allocated. If freeRepsonse is true, then the handler
306  * will be deleted after we have finished with it. Note that if
307  * responseHandler is null, then freeResponse will also be set true.
308  */
309  void SetNew(GitTaskResponseHandler *responseHandler,
310  bool freeResponse,
311  StatusType *status);
312 
313  /*
314  * Invoke the response handler's CompleteOk() method, delete the handler
315  * if needed and return the result.
316  */
317  DcppHandlerRet InvokeCompleteOK(StatusType *status);
318  /*
319  * Invoke the response handler's CompleteWithError() method, delete the handler
320  * if needed and return the result.
321  */
322 
323  DcppHandlerRet InvokeCompleteError(StatusType *status);
324 
325 
326  /*
327  * Invoke the handler's Trigger() method.
328  */
329  DcppHandlerRet InvokeTriggered(StatusType *status);
330  /*
331  * Tidy up the handler
332  */
333  void Tidy();
334 };
335 
336 
398 class GitTask : public DcppTask {
399  friend class GitTaskActiveList;
400  friend class GitTaskActiveListIterator;
401  friend class GitTaskKnownList;
402  friend class GitTaskKnownListIterator;
403 
404  private:
405  GitTask *nextKnown; /* For putting tasks in the list of */
406  /* known tasks */
407  /* Note, can only be put in one list*/
408  GitTask *nextActive; /* For putting tasks in a list of */
409  /* active tasks */
410  /* Note, can only be put in one list*/
411 
412 
413  GitTask___ResponseManager initialiseResponse;
414  GitTask___ResponseManager exitResponse;
415  GitTask___ResponseManager pollResponse;
416 /*
417  * Internal routines.
418  *
419  * static routines are normally used as callbacks.
420  *
421  * This bunch all used by Initialise.
422  */
423  static DcppHandlerRet HandlePathSuccess(
424  DcppVoidPnt ClientData,
425  StatusType *status);
426  static DcppHandlerRet HandlePathError(
427  DcppVoidPnt ClientData,
428  StatusType *status);
429  static DcppHandlerRet HandleVerGetSuccess(
430  DcppVoidPnt ClientData,
431  StatusType *status);
432  static DcppHandlerRet HandleVerGetError(
433  DcppVoidPnt ClientData,
434  StatusType *status);
435 
436  static DcppHandlerRet HandleInitParGetSuccess(
437  DcppVoidPnt ClientData,
438  StatusType *status);
439  static DcppHandlerRet HandleInitParGetError(
440  DcppVoidPnt ClientData,
441  StatusType *status);
442  static DcppHandlerRet HandleInitParGetErs(
443  DcppVoidPnt ClientData,
444  StatusType *status);
445 
446 
447 
448 /*
449  * Exit handlers
450  */
451  static DcppHandlerRet HandleExitSuccess(
452  DcppVoidPnt ClientData,
453  StatusType *status);
454  static DcppHandlerRet HandleExitError(
455  DcppVoidPnt ClientData,
456  StatusType *status);
457 
458 /*
459  * Poll handlers
460  */
461  static DcppHandlerRet HandlePollSuccess(
462  DcppVoidPnt ClientData,
463  StatusType *status);
464  static DcppHandlerRet HandlePollError(
465  DcppVoidPnt ClientData,
466  StatusType *status);
467  static DcppHandlerRet HandlePollTrigger(
468  DcppVoidPnt ClientData,
469  StatusType *status);
470  static DcppHandlerRet HandlePollKickSuccess(
471  DcppVoidPnt ClientData,
472  StatusType *status);
473  static DcppHandlerRet HandlePollKickError(
474  DcppVoidPnt ClientData,
475  StatusType *status);
476 
482  virtual void DeActivate() {
483  nextActive = 0;
484  };
485 /*
486  * Prevent Assignment and copying of this type by redefining the
487  * assignment and copy operators to be private.
488  * This ensures we can't get multiple threads controlling the one
489  * task unless done intentionally by the caller.
490  */
491  GitTask& operator=(const GitTask&);
492  GitTask(const GitTask&);
493 
494 
495 /*
496  * The internal routines below and data associated with them are
497  * available to inheriting classes.
498  */
499  protected:
500 
501 
502  static const int PollRetry = 5;
504 /*
505  * In a way, we probably should not have variables here, just routines,
506  * but these things are commonly used by inheriters to re-implement
507  * basic functions.
508  */
509  int pollDont;
512  std::string simulationLevel;
513  std::string simulationArg;
514  float timeBase;
516  bool havePath;
517  bool failed;
519  bool amExiting;
521  bool resetting;
522  bool firstTime;
524  std::string verDate;
525  std::string verNum;
526  std::string taskDescr;
547  virtual DcppHandlerRet SendSimulate(StatusType *status);
548 
569  virtual DcppHandlerRet GetVersionInfo(StatusType *status);
570 
594  virtual DcppHandlerRet GetInitialisedPar(StatusType *status);
595 
596 
607  virtual DcppHandlerRet HandleVerComp(StatusType *status);
608 
620  virtual DcppHandlerRet HandleInitParGetComp(bool initialised,
621  StatusType *status);
622 
642  virtual DcppHandlerRet SendInitialise(StatusType * status);
643 
660  virtual DcppHandlerRet NoNetOnRemote(StatusType *status) {
661  if (*status != STATUS__OK) return DcppFinished;
662  return DcppFinished;
663  }
664 
665 
677  virtual void SetInfo(const Arg &info, StatusType *status);
678 
687  virtual void SetInitial(StatusType *status) {
688  if (*status != STATUS__OK) return;
689  havePath = false;
690  }
697  virtual void SetPathWait(StatusType *status) {
698  if (*status != STATUS__OK) return;
699  }
706  virtual void SetInitialising(StatusType *status) {
707  if (*status != STATUS__OK) return;
708  }
715  virtual void SetResetting(StatusType *status){
716  if (*status != STATUS__OK) return;
717  resetting = true;
718  }
725  virtual void SetIdle(StatusType *status) {
726  if (*status != STATUS__OK) return;
727  }
734  virtual void SetExiting(StatusType *status) {
735  if (*status != STATUS__OK) return;
736  amExiting = true;
737  }
740  virtual void SetFailed() {
741  failed = true;
742  }
745  virtual void SetDied() {
746  failed = true;
747  }
748 
749  /* * *
750  * Here we have methods which are not intended for overriding, unless
751  * the underlying routine is also invoked.
752  *
753  *
754  * These are invoked when the SIMULATE_LEVEL command
755  * completes.
756  */
770  DcppVoidPnt ClientData,
771  StatusType *status);
772 
786  DcppVoidPnt ClientData,
787  StatusType *status);
788  /*
789  * Invoked when INITIALISE/RESET completes.
790  */
805  DcppVoidPnt ClientData,
806  StatusType *status);
807 
822  DcppVoidPnt ClientData,
823  StatusType *status);
824 
825 
835  virtual DcppHandlerRet RemoteNetStarted(StatusType *status);
845  virtual DcppHandlerRet RemoteNetStartErr(StatusType *status);
846 
862  virtual bool RecoveryNeeded();
863 
864  public:
870  enum SelfPathType { SelfPath };
886  GitTask(const std::string & name,
887  const std::string &node = "",
888  const std::string &file = "");
889 
903  GitTask(SelfPathType /*self*/) :
904  DcppTask(true),
905  nextKnown(0),
906  nextActive(0),
907  initialiseResponse(this),
908  exitResponse(this),
909  pollResponse(this),
910  pollDont(0),
911  pollCancelling(false),
912  simulationLevel("NONE"),
913  timeBase(1),
914  havePath(false),
915  failed(false),
916  amExiting(false),
917  resetting(false),
918  firstTime(true)
919  {
920  resetMode.SetRecover();
921  StatusType ignore = STATUS__OK;
922  SetInitial(&ignore);
923  //self = SelfPath; // Just to shut up noisey compilers
924  };
925 
945  virtual void SetSimulation(const std::string &value,
946  const float TimeBase,
947  const std::string &string,
948  StatusType *status);
949 
950 
958  virtual void SetResetMode(GitResetType & mode,
959  StatusType *status) {
960  if (*status == STATUS__OK)
961  resetMode = mode;
962  }
963 
1004  virtual DcppHandlerRet Initialise(
1005  StatusType *status,
1006  GitTaskResponseHandler *responseHandler = 0,
1007  bool freeResponse = false);
1008 
1009 
1045  virtual DcppHandlerRet Poll(
1046  StatusType *status,
1047  GitTaskResponseHandler *responseHandler = 0,
1048  bool freeResponse = false);
1049 
1050 
1082  virtual DcppHandlerRet Exit(
1083  StatusType *status,
1084  GitTaskResponseHandler *responseHandler = 0,
1085  bool freeResponse = false);
1086 
1087 
1094  virtual void Report(StatusType * status);
1095 
1098  virtual int IsActive() const {
1099  return (nextActive != 0);
1100  };
1101 
1104  virtual ~GitTask() { }
1105 
1106 
1107 };
1108 
1109 
1110 
1133  friend class GitTaskActiveListIterator;
1134  private :
1135  GitTask *head;
1136 
1137  static GitTask * const ListEnd; /* Indicate the end of the list */
1138 
1139 /*
1140  * Prevent Assignment and copying of this type by redefining the
1141  * assignment and copy operators to be private.
1142  */
1143  GitTaskActiveList& operator=(const GitTaskActiveList&);
1145 
1146  /*
1147  * Since we ony have one of these, the constructor is made
1148  * private and the object declared statically in the theList() function.
1149  */
1150  GitTaskActiveList() { head = ListEnd; };
1157  static GitTaskActiveList * theList();
1158  public:
1159 
1160 
1165  static void ReInit();
1166 
1174  static void Insert(GitTask * t);
1175 
1176 };
1177 
1199  friend class GitTaskKnownListIterator;
1200  private :
1201  GitTask *head;
1202 
1203  static GitTask * const ListEnd; /* Indicate the end of the list */
1204 /*
1205  * Prevent Assignment and copying of this type by redefining the
1206  * assignment and copy operators to be private.
1207  */
1208  GitTaskKnownList& operator=(const GitTaskKnownList&);
1210 
1211  /*
1212  * Since we ony have one of these, the constructor is made
1213  * private and the object declared statically in the theList() function.
1214  */
1215  GitTaskKnownList() : head(ListEnd) { };
1222  static GitTaskKnownList * theList();
1223 
1224 
1225  public:
1226 
1235  static void Insert(GitTask * t);
1236 
1237 };
1238 
1248  private:
1249  GitTask * ptr;
1250  GitTask * head;
1251 
1252  public:
1256  head = ptr = GitTaskActiveList::theList()->head; };
1257 
1263  GitTask * p;
1264  p = (ptr != GitTaskActiveList::ListEnd)? ptr : 0;
1265  ptr = (ptr != GitTaskActiveList::ListEnd) ? ptr->nextActive : GitTaskActiveList::ListEnd;
1266  return (p);
1267  };
1270  void reset() {
1271  ptr = head;
1272  };
1273 };
1284  private:
1285  GitTask * ptr;
1286  GitTask * head;
1287 
1288  public:
1292  head = ptr = GitTaskKnownList::theList()->head; };
1293 
1294 
1300  GitTask * p;
1301  p = (ptr != GitTaskKnownList::ListEnd)? ptr : 0;
1302  ptr = (ptr != GitTaskKnownList::ListEnd) ? ptr->nextKnown : GitTaskKnownList::ListEnd;
1303  return (p);
1304  };
1307  void reset() { /* Reset iterator */
1308  ptr = head;
1309  };
1310 };
1311 
1312 
1313 #endif
virtual DcppHandlerRet Triggered(GitTask *, StatusType *status)
Method invoked on reception of a trigger message.
Definition: gittask.h:278
virtual void Report(StatusType *status)
Dump details using MsgOut.
virtual DcppHandlerRet GetVersionInfo(StatusType *status)
Send the parameter get message which fetchs the version details.
std::string simulationArg
Extra simulation level argument.
Definition: gittask.h:513
bool pollCancelling
Polling is being cancelled.
Definition: gittask.h:510
bool IsFull() const
Return true if the rest type if Full.
Definition: gittask.h:186
virtual void SetFailed()
Indicate an operation has failed.
Definition: gittask.h:740
Keep error status on return.
Definition: Git.h:366
bool IsInvalid() const
Return true if there is no valid reset type.
Definition: gittask.h:195
GitTaskKnownListIterator()
Construct a new iterator for the known task list.
Definition: gittask.h:1291
void SetSoft()
Set the reset type to Soft.
Definition: gittask.h:168
An Iterator for the list of known tasks.
Definition: gittask.h:1283
SelfPathType
Use to ensure the constructor knows it is constructing a self path.
Definition: gittask.h:870
GitResetType(const SdsId &Id, const char *const Name, int Position, StatusType *status, const int Flags=Git::Upper|Git::Abbrev|Git::KeepErr)
Construct a GitReset type from an action argument.
Definition: gittask.h:136
static const int PollRetry
How many times to try poll.
Definition: gittask.h:502
virtual void SetExiting(StatusType *status)
Indicate the task is exiting.
Definition: gittask.h:734
virtual DcppHandlerRet HandleVerComp(StatusType *status)
Continue on after fetch version information.
void reset()
Reset the iterator to point to the head of the list again.
Definition: gittask.h:1307
virtual void SetResetting(StatusType *status)
Indicate we are Restting the task.
Definition: gittask.h:715
virtual void SetSimulation(const std::string &value, const float TimeBase, const std::string &string, StatusType *status)
Set simulation and timebase.
static DcppHandlerRet HandleSimError(DcppVoidPnt ClientData, StatusType *status)
To be invoked when the SIMULATE_LEVEL action fails.
A Class which provides access to DRAMA's message sending facilities.
Definition: dcpptask.h:132
bool IsRecover() const
Return true if the reset type is Hard.
Definition: gittask.h:192
virtual DcppHandlerRet HandleInitParGetComp(bool initialised, StatusType *status)
Continue on after fetching the INITIALISED parameter value.
virtual DcppHandlerRet Poll(StatusType *status, GitTaskResponseHandler *responseHandler=0, bool freeResponse=false)
Send POLL to the GIT task.
An Iterator for the list of active tasks.
Definition: gittask.h:1247
bool failed
Task has failed in some way and should be reset on Initiailse()
Definition: gittask.h:517
bool amExiting
Set true when the EXIT message is sent.
Definition: gittask.h:519
int pollDont
If > PollRetry, don't poll.
Definition: gittask.h:509
virtual DcppHandlerRet CompleteWithError(GitTask *, StatusType *status)
Method invoked on error completion.
Definition: gittask.h:257
bool resetting
Set true if we are resetting.
Definition: gittask.h:521
virtual DcppHandlerRet SendInitialise(StatusType *status)
Actually send the initialise.
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)
Get the value of the object from an SDS struture.
Definition: Git.h:430
Base object used to handle reponses to the GitTask messages.
Definition: gittask.h:215
Allow abbreviations.
Definition: Git.h:367
virtual DcppHandlerRet SendSimulate(StatusType *status)
Obey the SIMULATE_LEVEL action to the task.
Manage the list of active tasks.
Definition: gittask.h:1132
virtual DcppHandlerRet NoNetOnRemote(StatusType *status)
Invoked when the get path operation finds that there is no network on the remote node.
Definition: gittask.h:660
Have finished, action can complete.
Definition: dcpp.h:77
A C++ Interface to the SDS Arg library.
Definition: arg.h:267
A C++ Interface to the handling SDS structures.
Definition: sds.h:709
GitTask * operator()()
Return the next element on the list.
Definition: gittask.h:1262
bool IsSoft() const
Return true if the reset type if Soft.
Definition: gittask.h:183
void reset()
Reset the iterator to point to the head of the list again.
Definition: gittask.h:1270
static DcppHandlerRet HandleInitSuccess(DcppVoidPnt ClientData, StatusType *status)
To be invoked when the INITIAISE/RESET action completes ok.
void SetRecover()
Set the reset type to Recover.
Definition: gittask.h:163
virtual void SetDied()
Indicate the task has died.
Definition: gittask.h:745
Definition: gittask.h:294
GitResetType()
Construct a reset type object, defaulting to a Soft reset.
Definition: gittask.h:148
virtual bool RecoveryNeeded()
Returns true if recovery is needed.
virtual ~GitTaskResponseHandler()
Destructor.
Definition: gittask.h:286
GitTask(SelfPathType)
Path to self constructor.
Definition: gittask.h:903
A class built on DcppTask which control AAO GIT Tasks.
Definition: gittask.h:398
GitResetType resetMode
Mode of reset.
Definition: gittask.h:511
GitTaskResponseHandler()
Constructor.
Definition: gittask.h:219
static DcppHandlerRet HandleSimSuccess(DcppVoidPnt ClientData, StatusType *status)
To be invoked when the SIMULATE_LEVEL action completes ok.
A class which reads Enumerated values from a SDS argument structures.
Definition: Git.h:389
GitTask * operator()()
Return the next element on the list.
Definition: gittask.h:1299
virtual void SetInitialising(StatusType *status)
Indicate we are Initialising the task.
Definition: gittask.h:706
virtual void SetPathWait(StatusType *status)
Indicate we are waiting for a path to the task.
Definition: gittask.h:697
virtual void SetInfo(const Arg &info, StatusType *status)
Set the version information for the sub-tasks.
static DcppHandlerRet HandleInitError(DcppVoidPnt ClientData, StatusType *status)
To be invoked when the INITIAISE/RESET action fails.
virtual DcppHandlerRet CompleteOk(GitTask *, StatusType *status)
Method invoked on successfull completion.
Definition: gittask.h:235
A list of the currently known GIT tasks.
Definition: gittask.h:1198
void * DcppVoidPnt
A pointer to void.
Definition: dcpp.h:59
virtual int IsActive() const
Returns true if the task is active (on active list)
Definition: gittask.h:1098
void SetHard()
Set the reset type to Hard.
Definition: gittask.h:173
bool IsHard() const
Return true if the reset type is Hard.
Definition: gittask.h:189
virtual ~GitTask()
Destructor.
Definition: gittask.h:1104
static void Insert(GitTask *t)
Put a task onto the active list.
virtual DcppHandlerRet GetInitialisedPar(StatusType *status)
Send the parameter get message which fetchs the INITIALISED parameter.
static void ReInit()
Reinitialise the list.
GitTaskActiveListIterator()
Construct a new iterator for the active task list.
Definition: gittask.h:1255
std::string simulationLevel
Simulate level.
Definition: gittask.h:512
virtual DcppHandlerRet RemoteNetStarted(StatusType *status)
To be invoked when a REMOTE DRAMA network has started.
virtual void SetIdle(StatusType *status)
Indicate the task is idle.
Definition: gittask.h:725
bool havePath
Set true when we have the path.
Definition: gittask.h:516
DcppHandlerRet
Type returns by various routines to indicate what is to happen next.
Definition: dcpp.h:75
virtual DcppHandlerRet Initialise(StatusType *status, GitTaskResponseHandler *responseHandler=0, bool freeResponse=false)
Perform the complete initialisation sequence for a GIT task.
std::string verDate
From ENQ_VER_DATE parameter.
Definition: gittask.h:524
static void Insert(GitTask *t)
Put a task onto the known list.
Convert strings to upper case.
Definition: Git.h:364
std::string verNum
From ENQ_VER_NUM parameter.
Definition: gittask.h:525
A class used to represent the type of RESET operation.
Definition: gittask.h:95
bool firstTime
Set true for first init attempt.
Definition: gittask.h:522
float timeBase
Timebase for simulation.
Definition: gittask.h:514
virtual void SetResetMode(GitResetType &mode, StatusType *status)
Set the reset mode.
Definition: gittask.h:958
virtual DcppHandlerRet Exit(StatusType *status, GitTaskResponseHandler *responseHandler=0, bool freeResponse=false)
Cause a GIT task to exit.
virtual void SetInitial(StatusType *status)
Set task to its Initial state.
Definition: gittask.h:687
std::string taskDescr
From ENQ_DEV_DESCR parameter.
Definition: gittask.h:526
void SetFull()
Set the reset type to Full.
Definition: gittask.h:178
virtual DcppHandlerRet RemoteNetStartErr(StatusType *status)
To be invoked when a REMOTE DRAMA network start has failed.

Click here for the DRAMA home page and here for the AAO home page.

For more information, contact tjf@aao.gov.au 

Generated on Mon Feb 22 2016 13:58:31 for AAO DRAMA C++ Interfaces by doxygen 1.8.10