currentTasksAdminContent.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2015 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/


#pragma once

#include "vrftasks/adminContent.h"
#include <vlutil/vlString.h>
#include "vrftasks/vrftasksDefines.h"
#include <list>
#include <vector>
#include <vrfutil/vrfBufferSerialize.h>
#include <vrftasks/vrfObjectMessageTypeTemplate.h>

class DtSimTask;
class DtSetDataRequest;

struct DT_DLL_vrftasks DtCurrentTaskData
{
   DtCurrentTaskData() {task = 0;}
   DtCurrentTaskData(const DtCurrentTaskData& orig) :
   task(orig.task), subtasks(orig.subtasks), status(orig.status), conflictingTaskIds(orig.conflictingTaskIds),
   controller(orig.controller), taskId(orig.taskId) {};

   DtSimTask* task;
   int taskId;
   DtString controller;

   std::list<DtCurrentTaskData> subtasks;

   int status;

   std::vector<DtSimTaskMessageType> conflictingTaskIds;
};

struct DT_DLL_vrftasks DtCurrentScriptedSetData
{
   DtCurrentScriptedSetData() {set = 0;}
   DtCurrentScriptedSetData(const DtCurrentScriptedSetData& orig) :
   set(orig.set), controller(orig.controller), setId(orig.setId) {};

   DtSetDataRequest* set;
   int setId;
   DtString controller;
};

DT_DLL_vrftasks int getSize(const DtCurrentTaskData&  val);

DT_DLL_vrftasks char *encode(const DtCurrentTaskData& val, char *buffer);

DT_DLL_vrftasks const char *decode(DtCurrentTaskData& val, const char *buffer);


DT_DLL_vrftasks int getSize(const DtCurrentScriptedSetData&  val);

DT_DLL_vrftasks char *encode(const DtCurrentScriptedSetData& val, char *buffer);

DT_DLL_vrftasks const char *decode(DtCurrentScriptedSetData& val, const char *buffer);


class DT_DLL_vrftasks DtCurrentTasksAdminContent : public DtAdminContent
{
public:
   typedef std::list<DtCurrentTaskData> DtTaskList;
   typedef std::list<DtCurrentScriptedSetData> DtScriptedSetList;

   DtCurrentTasksAdminContent();

   DtCurrentTasksAdminContent(const DtCurrentTasksAdminContent & orig);

   const DtCurrentTasksAdminContent & operator=(const 
      DtCurrentTasksAdminContent & orig);

   virtual ~DtCurrentTasksAdminContent() override;

   static DtAdminContent* create();

   virtual bool init() override;

   virtual const DtAdminContentMessageType& type() const override;

   virtual void addTaskToList(const DtSimTask* task, const std::vector<DtSimTaskMessageType>& conflictingTaskTypes, int taskId,
      int status, const DtString& controller);

   virtual void addScriptedSetToList(const DtSetDataRequest* set, int taskId,
      const DtString& controller);

   virtual void addSubtask(const DtSimTask* task, int subtaskId, int spawningTaskId, int status, const DtString& controller,
      bool addIfNoParent = false);

   virtual void clearTaskList();

   virtual void clearScriptedSetsList();

   virtual const DtTaskList& taskList() const;

   virtual const DtScriptedSetList& scriptedSetList() const;

   virtual bool testTaskForConflict(const DtSimTaskMessageType& taskType) const;

   virtual DtAdminContent * clone() const override;

   virtual DtString stringRep() const override;

   virtual int netRepSize() const override;

   virtual bool setFromNet(const char* contentBuffer, unsigned contentSize) override;

   virtual bool setToNet() override;

   virtual void resolveUnparentedSubtasks();

   virtual void clearUnparentedSubtasks();

protected:
   virtual void addUnparentedSubtask(const DtSimTask* task, int subtaskId, int spawningTaskId, int status, const DtString& controller);

   void clearTaskList(DtTaskList& taskList);

   virtual void clearAllTasks();

   void copyTaskList(const DtTaskList& taskList, DtTaskList& into);

   void copyScriptedSetList(const DtScriptedSetList& taskList, DtScriptedSetList& into);

   virtual DtString printTasksToString(const DtTaskList& tasks) const;
   virtual DtString printSetsToString(const DtScriptedSetList& tasks) const;

   virtual void addTaskWithStatus(DtTaskList& list, const DtSimTask* task, int status, const std::vector<DtSimTaskMessageType>& conflictingTaskTypes,
      int taskId, const DtString& controller);

protected:
   DtTaskList myTaskList;
   DtScriptedSetList myScriptedSetList;

   typedef std::map<int, DtCurrentTaskData*> InternalTaskMap;
   InternalTaskMap myInternalTaskMap;

   struct UnparentedSubtask
   {
      DtSimTask* task;
      int parentId;
      int subtaskId;
      int status;
      DtString controller;
   };

   typedef std::vector<UnparentedSubtask> UnparentedSubtasks;
   UnparentedSubtasks myUnparentedSubtasks;
};