#include <ProximSimulationThread.hh>

Inheritance diagram for ProximSimulationThread:

Collaboration diagram for ProximSimulationThread:

Public Member Functions
	ProximSimulationThread ()

virtual	~ProximSimulationThread ()

virtual ExitCode	Entry ()

virtual void	handleEvent (int event)

ProximLineReader &	lineReader ()

TracedSimulatorFrontend *	frontend ()

void	initialize (ProximMainFrame *gui)

SimulatorInterpreter *	interpreter ()

void	requestStop ()

void	killSimulation ()

void	finishSimulation ()

bool	isBusy ()

Public Member Functions inherited from Listener
	Listener ()

virtual	~Listener ()

virtual void	handleEvent ()

Private Attributes
SimulatorInterpreterContext *	interpreterContext_
	SimulatorInterpreterContext. ? More...

SimulatorInterpreter *	interpreter_
	SimulatorInterpreter where the user input is passed to. More...

TracedSimulatorFrontend *	simulation_
	Simulator backend. More...

ProximLineReader *	lineReader_
	Linereader used for reading the user input. More...

ProximMainFrame *	gui_
	Proxim main frame where the simulator events are passed to. More...

ProximRuntimeErrorHandler *	runtimeErrorHandler_
	Runtime error handler. More...

Detailed Description

ProximSimulationThread class wraps the simulation backend in a separate worker thread.

The worker thread utilizes ProximLinereader to read commands from the user. Simulator events and input requests are passed to the GUI thread as custom wxEvents (see SimulatorEvent class).

Definition at line 55 of file ProximSimulationThread.hh.

Constructor & Destructor Documentation

◆ ProximSimulationThread()

ProximSimulationThread::ProximSimulationThread ( )

The Constructor.

Definition at line 52 of file ProximSimulationThread.cc.

                                               :
     wxThread(wxTHREAD_JOINABLE),
     simulation_(NULL),
     lineReader_(new ProximLineReader),
     gui_(NULL),
     runtimeErrorHandler_(NULL) {
  
 }

◆ ~ProximSimulationThread()

ProximSimulationThread::~ProximSimulationThread ( )

virtual

The Destructor.

Definition at line 67 of file ProximSimulationThread.cc.

                                                 {
     delete lineReader_;
     delete interpreter_;
  
     if (simulation_ != NULL) {
         delete simulation_;
     }
     if (runtimeErrorHandler_ != NULL) {
         delete runtimeErrorHandler_;
     }
     if (interpreterContext_ != NULL) {
         delete interpreterContext_;
     }
 }

References interpreter_, interpreterContext_, lineReader_, runtimeErrorHandler_, and simulation_.

Member Function Documentation

◆ Entry()

void * ProximSimulationThread::Entry ( )

virtual

Entry point for the simulation thread execution.

The thread waits commands from the line reader, and executes them using the simulator interpreter. Commands are executed until the thread is terminated.

Definition at line 127 of file ProximSimulationThread.cc.

                               {
  
     assert(gui_ != NULL);
  
     while (!TestDestroy()) {
     
         std::string command = "";
  
         command = lineReader_->readLine();
         command = StringTools::trim(command);
  
         if (command == "") {
             continue;
         }
  
         if (command == "quit") {
             // Post an event which tells the gui thread to delete this thread.
             SimulatorEvent eventCmd(
                 SimulatorEvent::EVT_SIMULATOR_TERMINATED);
             wxPostEvent(gui_, eventCmd);
  
             // Wait for the gui thread to call Delete() for this thread.
             while (!TestDestroy()) {
                 Sleep(100);
             }
             return 0;
         }
  
         // Inform GUI about the command being executed.
         SimulatorEvent eventCmd(
             SimulatorEvent::EVT_SIMULATOR_COMMAND, command);
         wxPostEvent(gui_, eventCmd);
  
         interpreter_->interpret(command);
  
         // Inform GUI about the command execution being done.
         SimulatorEvent eventCmdDone(
             SimulatorEvent::EVT_SIMULATOR_COMMAND_DONE, command);
         wxPostEvent(gui_, eventCmdDone);
  
         // If the command resulted in error, inform the GUI about the error.
         if (interpreter_->error()) {
             SimulatorEvent eventError(
                 SimulatorEvent::EVT_SIMULATOR_ERROR,
                 interpreter_->result());
             wxPostEvent(gui_, eventError);
             continue;
         }
  
         // Inform GUI about the simulator interpreter result.
         if (interpreter_->result().size() > 0) {
             SimulatorEvent event(
                 SimulatorEvent::EVT_SIMULATOR_OUTPUT,
                 (interpreter_->result() + "\n"));
             wxPostEvent(gui_, event);
         }
     }
     return 0;
 }

References assert, ScriptInterpreter::error(), SimulatorEvent::EVT_SIMULATOR_COMMAND, SimulatorEvent::EVT_SIMULATOR_COMMAND_DONE, SimulatorEvent::EVT_SIMULATOR_ERROR, SimulatorEvent::EVT_SIMULATOR_OUTPUT, SimulatorEvent::EVT_SIMULATOR_TERMINATED, gui_, TclInterpreter::interpret(), interpreter_, lineReader_, ProximLineReader::readLine(), ScriptInterpreter::result(), and StringTools::trim().

Here is the call graph for this function:

◆ finishSimulation()

void ProximSimulationThread::finishSimulation ( )

Finishes the current simulation.

Definition at line 218 of file ProximSimulationThread.cc.

                                          {
     if (simulation_->isSimulationRunning()) {
         simulation_->prepareToStop(SRE_USER_REQUESTED);
     }
     simulation_->finishSimulation();
 }

References SimulatorFrontend::finishSimulation(), SimulatorFrontend::isSimulationRunning(), SimulatorFrontend::prepareToStop(), simulation_, and SRE_USER_REQUESTED.

Here is the call graph for this function:

◆ frontend()

TracedSimulatorFrontend * ProximSimulationThread::frontend ( )

Returns pointer to the simulator.

Definition at line 307 of file ProximSimulationThread.cc.

                                  {
     return simulation_;
 }

References simulation_.

◆ handleEvent()

void ProximSimulationThread::handleEvent ( int event )

virtual

Handles events from the simulator backend.

The events are passed to the GUI as SimulatorEvents, which is a class derived from the wxEvent class. This way responsibility of the event handling can be passed to the GUI thread.

Reimplemented from Listener.

Definition at line 258 of file ProximSimulationThread.cc.

                                              {
  
     switch (event) {
     case TracedSimulatorFrontend::SIMULATOR_LOADING_MACHINE: {
         SimulatorEvent simEvent(SimulatorEvent::EVT_SIMULATOR_LOADING_MACHINE);
         wxPostEvent(gui_, simEvent);
         return;
     }
     case TracedSimulatorFrontend::SIMULATOR_MACHINE_LOADED: {
         SimulatorEvent simEvent(SimulatorEvent::EVT_SIMULATOR_MACHINE_LOADED);
         wxPostEvent(gui_, simEvent);
         return;
     }
     case TracedSimulatorFrontend::SIMULATOR_LOADING_PROGRAM: {
         SimulatorEvent simEvent(SimulatorEvent::EVT_SIMULATOR_LOADING_PROGRAM);
         wxPostEvent(gui_, simEvent);
         return;
     }
     case TracedSimulatorFrontend::SIMULATOR_PROGRAM_LOADED: {
         SimulatorEvent simEvent(SimulatorEvent::EVT_SIMULATOR_PROGRAM_LOADED);
         wxPostEvent(gui_, simEvent);
         return;
     }
     case TracedSimulatorFrontend::SIMULATOR_START: {
         SimulatorEvent simEvent(SimulatorEvent::EVT_SIMULATOR_START);
         wxPostEvent(gui_, simEvent);
         return;
     }
     case TracedSimulatorFrontend::SIMULATOR_STOP: {
         SimulatorEvent simEvent(SimulatorEvent::EVT_SIMULATOR_STOP);
         wxPostEvent(gui_, simEvent);
         return;
     }
     case TracedSimulatorFrontend::SIMULATOR_RUN: {
         SimulatorEvent simEvent(SimulatorEvent::EVT_SIMULATOR_RUN);
         wxPostEvent(gui_, simEvent);
         return;
     }
     case TracedSimulatorFrontend::SIMULATOR_RESET: {
         gui_->reset();
         return;
     }
     };
 }

References SimulatorEvent::EVT_SIMULATOR_LOADING_MACHINE, SimulatorEvent::EVT_SIMULATOR_LOADING_PROGRAM, SimulatorEvent::EVT_SIMULATOR_MACHINE_LOADED, SimulatorEvent::EVT_SIMULATOR_PROGRAM_LOADED, SimulatorEvent::EVT_SIMULATOR_RUN, SimulatorEvent::EVT_SIMULATOR_START, SimulatorEvent::EVT_SIMULATOR_STOP, gui_, ProximMainFrame::reset(), TracedSimulatorFrontend::SIMULATOR_LOADING_MACHINE, TracedSimulatorFrontend::SIMULATOR_LOADING_PROGRAM, TracedSimulatorFrontend::SIMULATOR_MACHINE_LOADED, TracedSimulatorFrontend::SIMULATOR_PROGRAM_LOADED, TracedSimulatorFrontend::SIMULATOR_RESET, TracedSimulatorFrontend::SIMULATOR_RUN, TracedSimulatorFrontend::SIMULATOR_START, and TracedSimulatorFrontend::SIMULATOR_STOP.

Here is the call graph for this function:

◆ initialize()

void ProximSimulationThread::initialize ( ProximMainFrame * gui )

Initializes the thread.

Definition at line 87 of file ProximSimulationThread.cc.

                                                        {
  
     gui_ = gui;
  
     lineReader_->initialize(">");
     simulation_ = new TracedSimulatorFrontend();
  
     interpreterContext_ = new SimulatorInterpreterContext(*simulation_);
     interpreter_ = new SimulatorInterpreter(
         0, NULL, *interpreterContext_, *lineReader_);
  
     simulation_->registerListener(
         TracedSimulatorFrontend::SIMULATOR_LOADING_PROGRAM, this);
     simulation_->registerListener(
         TracedSimulatorFrontend::SIMULATOR_PROGRAM_LOADED, this);
     simulation_->registerListener(
         TracedSimulatorFrontend::SIMULATOR_LOADING_MACHINE, this);
     simulation_->registerListener(
         TracedSimulatorFrontend::SIMULATOR_MACHINE_LOADED, this);
     simulation_->registerListener(
         TracedSimulatorFrontend::SIMULATOR_START, this);
     simulation_->registerListener(
         TracedSimulatorFrontend::SIMULATOR_STOP, this);
     simulation_->registerListener(
         TracedSimulatorFrontend::SIMULATOR_RUN, this);
     simulation_->registerListener(
         TracedSimulatorFrontend::SIMULATOR_RESET, this);
  
     runtimeErrorHandler_ = new ProximRuntimeErrorHandler(*simulation_, *gui_);
 }

Referenced by Proxim::OnInit().

Here is the call graph for this function:

◆ interpreter()

SimulatorInterpreter * ProximSimulationThread::interpreter ( )

Returns reference to the script interpreter of the simulator.

Returns: Simulator script interpreter of the simulator.

Definition at line 244 of file ProximSimulationThread.cc.

                                     {
     return interpreter_;
  
 }

References interpreter_.

Referenced by ProximToolbox::interpreter(), and Proxim::OnInit().

◆ isBusy()

bool ProximSimulationThread::isBusy ( )

Returns true if the thread is busy running the simulation.

Returns: True, if the thread is currently running simulation.

Definition at line 318 of file ProximSimulationThread.cc.

                                {
     if (simulation_->isSimulationRunning()) {
         return true;
     } else {
         return false;
     } 
 }

References SimulatorFrontend::isSimulationRunning(), and simulation_.

Here is the call graph for this function:

◆ killSimulation()

void ProximSimulationThread::killSimulation ( )

Kills the current simulation.

Definition at line 205 of file ProximSimulationThread.cc.

                                        {
     if (simulation_->isSimulationRunning()) {
         simulation_->prepareToStop(SRE_USER_REQUESTED);
     }
     simulation_->killSimulation();
     SimulatorEvent simEvent(SimulatorEvent::EVT_SIMULATOR_STOP);
     wxPostEvent(gui_, simEvent);
 }

References SimulatorEvent::EVT_SIMULATOR_STOP, gui_, SimulatorFrontend::isSimulationRunning(), TracedSimulatorFrontend::killSimulation(), SimulatorFrontend::prepareToStop(), simulation_, and SRE_USER_REQUESTED.

Here is the call graph for this function:

◆ lineReader()

ProximLineReader & ProximSimulationThread::lineReader ( )

Returns reference to the line reader which the thread uses to read user input.

Returns: LineReader used by the simulator.

Definition at line 233 of file ProximSimulationThread.cc.

                                    {
     return *lineReader_;
 }

References lineReader_.

◆ requestStop()

void ProximSimulationThread::requestStop ( )

Requests the simulation backend to stop the simulation.

Definition at line 192 of file ProximSimulationThread.cc.

                                     {
     simulation_->prepareToStop(SRE_USER_REQUESTED);
     if (simulation_->isSimulationStopped()) {
         SimulatorEvent simEvent(SimulatorEvent::EVT_SIMULATOR_STOP);
         wxPostEvent(gui_, simEvent);
     }
 }