commandLineRemoteController.h

Go to the documentation of this file.

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

#pragma once

#include <vlutil/vlUtil.h>
#include "vrlinkNetworkInterface/vrlinkVrfRemoteController.h"

// This class provides a command line interface for controlling VR-Forces over 
// the network with the remote controller class.

// Enumeration used as a return value for commands in the DtCommandLineRemoteController, anything less than 1 is a failure of some sort
enum DtCommandStatus { DtCommandStatusNotEnoughArguments = -2, DtCommandStatusIncorrectPointFormat = -1, DtCommandStatusFailure = 0, DtCommandStatusSuccess = 1 };


class DtCommandLineRemoteController
{
public:
  
  // constructor
  DtCommandLineRemoteController(makVrf::DtVrlinkVrfRemoteController* controller);

  // destructor
  virtual ~DtCommandLineRemoteController();

  // Process entered text
  void readStdin();

  // Set/Get time to quit
  virtual void setTimeToQuit(bool yesNo);
  virtual bool timeToQuit() const;

  // Get remote vrf controller pointer
  virtual makVrf::DtVrlinkVrfRemoteController* controller() const;

  // Returns true if the given string vector has greater than or equal to the number of arguments required for current step
  static const bool hasEnoughArguments(const int minNumberOfArguments, const std::vector<std::string>& args);

public:

   // Functions for calling the corresponding methods on DtVrfRemoteController.

   // Called in response to "create waypoint"
   virtual DtCommandStatus createWaypoint(const std::vector<std::string>& args);

   // Called in response to "create route"
   virtual DtCommandStatus createRoute(const std::vector<std::string>& args);

   // Called in response to "create tank"
   virtual DtCommandStatus createTank(const std::vector<std::string>& args);

   // Called in response to "print weather"
   virtual DtCommandStatus printEnv(const std::vector<std::string>& args);

   // Called in response to "create aggregate"
   virtual DtCommandStatus createAggregate(const std::vector<std::string>& args);

   // Called in response to "create aerodrome"
   virtual DtCommandStatus createAerodrome(const std::vector<std::string>& args);

   // Called in response to "set plan"
   virtual DtCommandStatus setPlan(const std::vector<std::string>& args);

   // Called in response to "set label"
   virtual DtCommandStatus setLabel(const std::vector<std::string>& args);

   // Called in response to "set systemEnabled"
   virtual DtCommandStatus setSystemEnabled(const std::vector<std::string>& args);

   // Called in response to "set location"
   virtual DtCommandStatus setLocation(const std::vector<std::string>& args);

   // Called in response to "set fuel"
   virtual DtCommandStatus setFuel(const std::vector<std::string>& args);

   // Called in response to "set target"
   virtual DtCommandStatus setTarget(const std::vector<std::string>& args);

   // Called in response to "set restore"
   virtual DtCommandStatus setRestore(const std::vector<std::string>& args);

   // Called in response to "task patrolRoute"
   virtual DtCommandStatus patrolRoute(const std::vector<std::string>& args);

   // Called in response to "task moveToPoint"
   virtual DtCommandStatus moveToPoint(const std::vector<std::string>& args);

   // Called in response to "task follow"
   virtual DtCommandStatus follow(const std::vector<std::string>& args);

   // Called in response to "task wait"
   virtual DtCommandStatus wait(const std::vector<std::string>& args);

   // Called as helper function for bigRoutCommand
   virtual void bigRoute(int iPoints);

   // Called as helper for listSnapshotsCommand
   virtual void listSnapshots();

   // Called as helper for printCommand
   virtual void printSimulationStatus(DtSimulationStatus);

public:

   //-------------------------------------------------------
   // Text callback functions
   //-------------------------------------------------------

   // Called in response to "list"
   static DtCommandStatus listCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "load"
   static DtCommandStatus loadCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "new"
   static DtCommandStatus newCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "save"
   static DtCommandStatus saveCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "create"
   static DtCommandStatus createCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "print"
   static DtCommandStatus printCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "set"
   static DtCommandStatus setCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "task"
   static DtCommandStatus taskCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "aggregate"
   static DtCommandStatus aggregateCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "delete"
   static DtCommandStatus deleteCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "close"
   static DtCommandStatus closeCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "monitor"
   static DtCommandStatus monitorResourcesCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "unmonitor"
   static DtCommandStatus removeMonitorResourcesCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "rewind"
   static DtCommandStatus rewindCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "run"
   static DtCommandStatus runCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "pause"
   static DtCommandStatus pauseCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "simrun"
   static DtCommandStatus simrunCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "simpause"
   static DtCommandStatus simpauseCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "timemultipler" 
   static DtCommandStatus timemultiplierCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "time" 
   static DtCommandStatus timeCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);
    
   // Called in response to "quit" or "q"
   static DtCommandStatus quitCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "help" or "?" or "h"
   static DtCommandStatus helpCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Helper function called when we want help with a specific command  
   static DtCommandStatus helpCommand(const std::string command, DtCommandLineRemoteController* a);

   // Called in response to "help" or "?" or "h"
   static DtCommandStatus bigRouteCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "listsnapshots"
   static DtCommandStatus listSnapshotsCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);
    
   // Called in response to "takesnapshot"
   static DtCommandStatus takeSnapshotCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "turnonsnapshots"
   static DtCommandStatus turnOnSnapshotsCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "turnoffsnapshots"
   static DtCommandStatus turnOffSnapshotsCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "rollback"
   static DtCommandStatus rollbackToSnapshotCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

   // Called in response to "simulationStatus"
   static DtCommandStatus simulationStatusCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);

#if DtHLA
   // Called in response to "etrfireat"
   static DtCommandStatus etrfireatCommand(const std::vector<std::string>& args, DtCommandLineRemoteController* a);
#endif

   //-------------------------------------------------------
   // DtVrfRemoteController callback functions
   //-------------------------------------------------------

   // Called by DtVrfRemoteController::loadScenario when sim engines are missing
   static bool missingBackends(DtBackendMap* map, const std::set<DtSimulationAddress>& currentBackends, void* usr);

   // Sim engine arrival/departure callbacks
   static void backendAddedCb(const DtSimulationAddress& addr, void* usr);
   static void backendRemovedCb(const DtSimulationAddress& addr, void* usr);

   // Simulation status changed callback
   static void simulationStatusChanged(DtSimulationStatus, void* usr);

   // Sim engine loaded/saved callbacks
   static void backendLoadedCb(const DtSimulationAddress& addr, void* usr);
   static void backendSavedCb(const DtSimulationAddress& addr, 
      DtSaveResult result, void* usr);

   // Scenario loaded/saved callbacks
   static void ScenarioLoadedCb(void* usr);
   static void ScenarioSavedCb(void* usr);

   // VR-Forces object created callback
   static void vrfObjectCreatedCb(
      const DtString& name, const DtEntityIdentifier& id, const DtUUID& uuid, void* usr);

   // Plan callbacks 
   static void printStatement(const DtSimStatement* stmt, int indent = 1);
   static void printBlock(const DtSimBlock* stmt, int indent = 1);
   static void planCb(const DtUUID& name, 
      const std::vector<DtSimStatement*>& statements, bool append, void* usr);
   static void planStmtCb(const DtUUID& id, DtPlanStatus status, void* usr);
   static void planCompleteCb(const DtUUID& id, void* usr);

   // Callback used to process monitor resource responses
   static void ProcessResourceResponse(const makVrfEvents::DtEvent&);

   // Callback for list of current snapshots
   static void scenarioSnapshotResponseCb(DtSimMessage* msg, void* usr);

   void setRemoveListCallback(bool b) { myRemoveListCallback = b; };
  

protected:

   // Present command line interface.
   void prompt();

   // Parse user input, call corresponding function
   void processCommand(const std::string buff);

   // Parse a point received as a string "p1,p2,p3", put those points into a DtVector that is passed 
   // the function as returnVector. 
   // Return true if this was successful, false otherwise.
   const bool parsePoint(const std::string& pointString, DtVector& returnVector);

   // Parse the command
   //
   // Tokenize the string on ' ' and '"', return a vector of arguments
   const std::vector<std::string> parseCommand(const std::string& rawCommand);

protected:

   bool myTimeToQuit;
   makVrf::DtVrlinkVrfRemoteController* myController;
   //DtSelectParam sparam;
   static unsigned int theNextAggregateId;
   static unsigned int theNextSubordinateId;
   bool myRemoveListCallback;
   //DtReflectedEntityList* myEntityList;

private:
   int kbInterest;
};