matteo/sgpemv2
matteo
/
sgpemv2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

- added console interpreter 

- added string_utils

git-svn-id: svn://svn.gna.org/svn/sgpemv2/trunk@342 3ecf2c5c-341e-0410-92b4-d18e462d057c
This commit is contained in:
fpaparel 2006-02-17 22:19:25 +00:00
parent 8cb6b81c38
commit 759dfdad25
16 changed files with 670 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
src/Makefile.am
View File

@ -18,7 +18,7 @@
# along with SGPEMv2; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
SUBDIRS = backend builtin-policies testsuite
SUBDIRS = backend builtin-policies pyloader testsuite
#additional rules:
%_wrap.cc : %.i
@ -39,12 +39,15 @@ sgpemv2_CPPFLAGS = -I@top_srcdir@ \
-DLOCALEDIR="\"$(localedir)\"" \
$(CAIRO_CFLAGS) \
$(GTKMM_CFLAGS) \
$(PYTHON_CPPFLAGS)
$(PYTHON_CPPFLAGS) \
$(GTHREAD_CFLAGS)
sgpemv2_LDFLAGS = -L@builddir@/backend \
-L@builddir@/pyloader \
$(LT_LDFLAGS)
sgpemv2_LDADD = -lbackend \
sgpemv2_LDADD = -lbackend -lpyloader \
$(CAIRO_LIBS) \
$(GTKMM_LIBS)
$(GTKMM_LIBS) \
$(GTHREAD_LIBS)
# Please keep this in sorted order:
sgpemv2_SOURCES = \
@ -55,7 +58,8 @@ sgpemv2_SOURCES = \
parse_opts.cc \
simulation.cc \
standard_io.cc \
start_gui.cc
start_gui.cc \
text_simulation.cc
noinst_HEADERS = \
graphical_terminal_io.hh \
@ -66,4 +70,5 @@ noinst_HEADERS = \
parse_opts.hh \
simulation.hh \
standard_io.hh \
start_gui.hh
start_gui.hh \
text_simulation.hh

6
src/backend/Makefile.am
View File

@ -57,7 +57,8 @@ libbackend_la_SOURCES = \
schedulable_list.cc \
schedulable_status.cc \
scheduler.cc \
slice.cc
slice.cc \
string_utils.cc
noinst_HEADERS = \
history.hh \
@ -70,4 +71,5 @@ noinst_HEADERS = \
schedulable_list.hh \
schedulable_status.hh \
scheduler.hh \
slice.hh
slice.hh \
string_utils.hh

45
src/backend/policy.hh
View File

@ -30,35 +30,36 @@
namespace sgpem
{
class Policy;
class Policy;
/** \brief
e' una Strategy che rappresenta un algoritmo di scheduling che implementa una politica
di scheduling.
*/
class SG_DLLEXPORT Policy
{
public:
virtual ~Policy();
/** \brief
e' una Strategy che rappresenta un algoritmo di scheduling che implementa una politica
di scheduling.
*/
class SG_DLLEXPORT Policy
{
public:
virtual ~Policy();
virtual void configure() = 0;
virtual void sort_queue(sgpem::Scheduler::event) const = 0;
int get_id() const;
virtual Glib::ustring get_description() const = 0;
virtual bool is_pre_emptive() const = 0;
virtual int get_time_slice() const = 0;
virtual void set_time_slice(const int&) = 0;
virtual void configure() = 0;
virtual void sort_queue(sgpem::Scheduler::event) const = 0;
int get_id() const;
virtual Glib::ustring get_description() const = 0;
virtual bool is_pre_emptive() const = 0;
virtual int get_time_slice() const = 0;
virtual void set_time_slice(const int&) = 0;
const PolicyParameters& get_parameters() const;
const PolicyParameters& get_parameters() const;
private:
PolicyParameters _parameters;
int _id;
};
private:
PolicyParameters _parameters;
int _id;
};
}//~ namespace sgpem
#endif
#endif

96
src/backend/string_utils.cc Normal file
View File

@ -0,0 +1,96 @@
// src/backend/string_utils.cc - Copyright 2005, 2006, University
// of Padova, dept. of Pure and Applied
// Mathematics
//
// This file is part of SGPEMv2.
//
// This is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// SGPEMv2 is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with SGPEMv2; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#include "string_utils.hh"
using Glib::ustring;
/**
\brief A function that converts a Unicode string to an integer value
The string can contain ONLY digits and the "minus" character.
\returns TRUE if the string is well formatted
\returns FALSE otherwise
*/
bool
string_to_int(const ustring& str, int& num)
{
static const ustring allvalid = "0123456789-";
static const ustring digits = "0123456789";
// the string can't be empty
if (str.length() == 0 || (str.length() == 1 && str[0] == '-'))
return false;
//checks if the string contains only digits
if (str.find_first_not_of(allvalid) < str.length())
return false;
if (str.substr(1).find_first_not_of(digits) < str.length()-1)
return false;
num=0;
int multiplier = 1, val;
int start; //the position of the biggest digit
if (str[0] == '-')
start = 1;
else
start = 0;
for (int pos = str.length() - 1; pos >= start ; pos--)
{
val = str[pos] - 48; //the INTEGER value of the digit
num += val*multiplier;
multiplier *= 10;
}
//if there is the minus then multiply for -1
if (start == 1)
num *= -1;
return true;
}
/**
\brief A function that converts an integer value to an Unicode string
*/
void
int_to_string(const int& num, ustring& str)
{
if (num == 0)
{
str = '0';
return;
}
str = "";
int val = num;
bool negative = (val < 0)? true : false;
if (negative) val *= -1;
while (true)
{
str = char(val % 10 + 48) + str;
if (val > 1 && val / 10 != 0)
val /= 10;
else
break;
}
if (negative)
str = '-' + str;
}

33
src/backend/string_utils.hh Normal file
View File

@ -0,0 +1,33 @@
// src/backend/string_utils.hh - Copyright 2005, 2006, University
// of Padova, dept. of Pure and Applied
// Mathematics
//
// This file is part of SGPEMv2.
//
// This is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// SGPEMv2 is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with SGPEMv2; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#ifndef STRING_UTILS_HH
#define STRING_UTILS_HH 1
#include "config.h"
#include "glibmm/ustring.h"
bool SG_DLLEXPORT string_to_int(const Glib::ustring&, int&);
void SG_DLLEXPORT int_to_string(const int&, Glib::ustring&);
#endif

62
src/graphical_simulation.hh Normal file
View File

@ -0,0 +1,62 @@
// src/graphical_simulation.hh - Copyright 2005, 2006, University
// of Padova, dept. of Pure and Applied
// Mathematics
//
// This file is part of SGPEMv2.
//
// This is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// SGPEMv2 is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with SGPEMv2; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#ifndef GRAPHICAL_SIMULATION_HH
#define GRAPHICAL_SIMULATION_HH 1
#include "config.h"
#include "gettext.h"
#include <gtkmm/box.h>
#include <gtkmm/window.h>
#include <glibmm/ustring.h>
#include "simulation.hh"
#include "text_simulation.hh"
#include "io_manager.hh"
#include "graphical_terminal_io.hh"
namespace sgpem {
class GraphicalSimulation;
/** \brief This class represent the MAIN PROGRAM WINDOW
*
* ... long desc ... */
class GraphicalTerminalIO : public IOManager, public Gtk::Window
{
public:
GraphicalTerminalIO();
virtual ~GraphicalTerminalIO();
virtual uint write_buffer(const Glib::ustring& buffer);
virtual Glib::ustring read_command();
virtual bool is_full_duplex();
private:
Gtk::TextView _text_output;
mutable Gtk::Entry _text_input;
};
}
#endif

11
src/graphical_terminal_io.cc
View File

@ -81,8 +81,13 @@ GraphicalTerminalIO::read_command()
uint f = command.find_first_not_of(whitespaces);
uint l = command.find_last_not_of(whitespaces);
if(f == ustring::npos)
return 0;
return "";
_text_input.set_text(ustring(""));
return command.substr(f,l);
return command.substr(f,l-f+1);
}
bool
GraphicalTerminalIO::is_full_duplex()
{
return true;
}

2
src/graphical_terminal_io.hh
View File

@ -52,6 +52,8 @@ namespace sgpem {
virtual uint write_buffer(const Glib::ustring& buffer);
virtual Glib::ustring read_command();
virtual bool is_full_duplex();
private:
Gtk::TextView _text_output;
mutable Gtk::Entry _text_input;

18
src/io_manager.hh
View File

@ -38,11 +38,29 @@ namespace sgpem {
{
public:
virtual ~IOManager() {}
<<<<<<< .mine
/**Writes a string into an output (the console, a text widget, ...)
\returns the number of charaters written
*/
virtual uint write_buffer(const Glib::ustring& buffer) = 0;
/**Reads a command from an interactive input (the console, a text widget, ...)
\returns a trimmed string (without blank spaces, tabs... at the extremities)
*/
virtual Glib::ustring read_command() = 0;
/**Specify whether this IOManger permits to write and read at the same time
*/
virtual bool is_full_duplex() = 0;
=======
virtual uint write_buffer(const Glib::ustring& buffer) = 0;
virtual Glib::ustring read_command() = 0;
>>>>>>> .r341
};
}
#endif

20
src/main.cc
View File

@ -34,9 +34,11 @@
#include "backend/process.hh"
#include "backend/policy.hh"
#include "backend/policy_parameters.hh"
#include "backend/python_policy.hh"
#include "backend/python_policy_manager.hh"
#include "standard_io.hh"
#include "text_simulation.hh"
#include <glibmm/timer.h>
#include <glibmm/ustring.h>
#include <iostream>
@ -57,6 +59,10 @@ main(int argc, char* argv[])
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
// Set up Glib thread support
Glib::thread_init();
/*
// Parses options and prepares vector with
// filenames of documents to be opened
@ -68,12 +74,14 @@ main(int argc, char* argv[])
filenames.insert(filenames.begin(), a_ptr, a_ptr+a_count);
}
*/
//start_gui(argc, argv);
StandardIO io;
io.write_buffer("\nciao!!");
ustring ss = io.read_command();
cout << "\n\n\n" << ss;
TextSimulation text_sim;
//textual IO
smart_ptr<IOManager> io(new StandardIO());
text_sim.add_io_device(io);
//grafical IO
start_gui(argc, argv);
//SMOKE-TEST for backend classes
/* cout << "\n\n********************************";

26
src/standard_io.cc
View File

@ -28,6 +28,7 @@ uint
StandardIO::write_buffer(const ustring& buffer)
{
cout << buffer;
cout.flush();
if (cout.good())
return buffer.length();
else
@ -37,7 +38,26 @@ StandardIO::write_buffer(const ustring& buffer)
ustring
StandardIO::read_command()
{
ustring i;
cin >>i;
return i;
using namespace std;
char p[2000];
cin.getline(p,2000);
ustring command(p);
static const ustring whitespaces = " \r\b\n\t\a";
// are there any other wspaces?
// trimming:
uint f = command.find_first_not_of(whitespaces);
uint l = command.find_last_not_of(whitespaces);
if(f == ustring::npos)
return "";
return command.substr(f,l-f+1);
}
bool
StandardIO::is_full_duplex()
{
return false;
}

1
src/standard_io.hh
View File

@ -43,6 +43,7 @@ namespace sgpem {
uint write_buffer(const Glib::ustring& buffer);
Glib::ustring read_command();
bool is_full_duplex();
};
}

2
src/start_gui.cc
View File

@ -30,6 +30,8 @@ void
start_gui(int argc, char** argv)
{
Gtk::Main gtk_main(argc,argv);
sgpem::GraphicalTerminalIO main_window;
Gtk::Main::run(main_window);
}

2
src/start_gui.hh
View File

@ -23,6 +23,8 @@
#include "config.h"
/** \brief This function starts the whole GUI */
void SG_DLLEXPORT start_gui(int argc, char** argv);

353
src/text_simulation.cc Normal file
View File

@ -0,0 +1,353 @@
// src/backend/text_simulation.cc - Copyright 2005, 2006, University
// of Padova, dept. of Pure and Applied
// Mathematics
//
// This file is part of SGPEMv2.
//
// This is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// SGPEMv2 is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with SGPEMv2; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#include "text_simulation.hh"
using namespace std;
using namespace sgpem;
using namespace memory;
using Glib::Thread;
using Glib::ustring;
TextSimulation::~TextSimulation()
{
}
/**Adds an IO_device and creates a thread which loops the read-parse-execute process
*/
void
TextSimulation::add_io_device(smart_ptr<IOManager> io)
{
_devices.push_back(io);
pair<TextSimulation*, int> p(this, 0);
Thread::create( sigc::bind(&TextSimulation::_io_loop, p), true);
}
void
TextSimulation::parse_command(pair< pair<TextSimulation*, int>, const ustring > p)
{
TextSimulation* obj = p.first.first;
int quale = p.first.second;
ustring str = p.second;
if (str.length() == 0)
return;
//CAPITALIZE alla grguments
str = str.uppercase();
vector<ustring> arguments;
uint f=0;
static const ustring whitespaces = " \r\b\n\t\a";
//fills the vector with parameters
while (true)
{
f = str.find_first_of(whitespaces);
if (f > str.length())
{
//the end of the string
arguments.push_back(str);
break;
}
else
{
//add the token
arguments.push_back(str.substr(0, f));
//trim the initial whitespaces
str = str.substr(f+1);
f = str.find_first_not_of(whitespaces);
str = str.substr(f);
}
}
if (arguments.size() == 0)
return;
bool show_help = false;
int param = 0;
check:
if (arguments[param] == "RUN")
{
if (show_help)
{
obj->_devices[quale]->write_buffer(_(
"\n-- RUN COMMAND --\nStarts the simulation. It can be continuous or step-by-step"
" depending the mode configured with SetMode (default=continuous)"));
return;
}
obj->_devices[quale]->write_buffer("\n\tRUN!!");
}
else if (arguments[param] == "PAUSE")
{
if (show_help)
{
obj->_devices[quale]->write_buffer(_(
"\n-- PAUSE COMMAND --\nPauses the simulation. The next call to RUN will restart it."));
return;
}
obj->_devices[quale]->write_buffer("\n\tPAUSE!!");
}
else if (arguments[param] == "STOP")
{
if (show_help)
{
obj->_devices[quale]->write_buffer(_(
"\n-- STOP COMMAND --\nStops the simulation. The next call to RUN will "
"bring the simulation to the FIRST instant and start it."));
return;
}
obj->_devices[quale]->write_buffer("\n\tSTOP!!");
}
else if (arguments[param] == "RESET")
{
if (show_help)
{
obj->_devices[quale]->write_buffer(_(
"\n-- RESET COMMAND --\nResets the simulation jumping back to the first instant."));
return;
}
obj->_devices[quale]->write_buffer("\n\tRESET!!");
}
else if (arguments[param] == "QUIT")
{
if (show_help)
{
obj->_devices[quale]->write_buffer(_(
"\n-- QUIT COMMAND --\nExits the program."));
return;
}
obj->_devices[quale]->write_buffer(_("\n\n*** Thank you for using SGPEM by Sirius Cybernetics Corporation ***\n\n"));
exit(1);
}
else if (arguments[param] == "HELP")
{
if (show_help)
{
obj->_devices[quale]->write_buffer(_(
"\n-- YOU ARE JOKING ME --\nYou're really too dummy!!!\n"));
exit(1);
}
if (arguments.size() == 1)
{
obj->_devices[quale]->write_buffer( "\nAvaiable commands:\nRUN\nPAUSE\nSTOP\nRESET\nQUIT\nHELP"
"\nGETMODE\nSETMODE\nSETTIMER\nGETTIMER\nJUMPTO\nGETPOLICY"
"\nSETPOLICY\nGETPOLICYATTRIBUTES"
"\n\nHELP followed by a command shows help about it."
"\n ex. HELP RUN shows help about the command RUN");
return;
}
show_help = true;
param = 1;
goto check;
}
else if (arguments[param] == "SETMODE")
{
if (show_help)
{
obj->_devices[quale]->write_buffer(_(
"\n-- SetMode COMMAND --\nPermits to change the mode of the simulation.\n\nSintax: Setmode <param>\n\t<param> can take values:\n"
"\n\t\tCONTINUOUS - when calling RUN the simulation will show an animation using the wait-interval set by SETTIMER\n"
"\n\t\tSTEP - when calling RUN the simulation will show only one step of the animation\n"));
return;
}
if (arguments.size() != 2)
{
obj->_devices[quale]->write_buffer(_("\nERROR: wrong number of parameters."
"\nType HELP SETMODE for the description of the sintax"));
return;
}
if (arguments[1] == "CONTINUOUS")
obj->set_mode(true);
else if (arguments[1] == "STEP")
obj->set_mode(false);
else
obj->_devices[quale]->write_buffer(_("\nERROR: the second parameter can be only CONTINUOUS or STEP"));
}
else if (arguments[param] == "GETMODE")
{
if (show_help)
{
obj->_devices[quale]->write_buffer(_(
"\n-- GetMode COMMAND --\nReturns\n\tCONTINUOUS : if the simulation is shown with an animation"
"\n\tSTEP : if if the simulation is shown step-by-step"));
return;
}
if (obj->get_mode())
obj->_devices[quale]->write_buffer(_("\nCONTINUOUS"));
else
obj->_devices[quale]->write_buffer(_("\nSTEP"));
}
else if (arguments[param] == "SETTIMER")
{
if (show_help)
{
obj->_devices[quale]->write_buffer(_(
"\n-- SetTimer COMMAND --\nPermits to change the interval between a step and the following one during a continuous animation."
"\n\nSintax: SetTimer <param>\n\t<param> must be an integer value > 0 and < 10000.\n"));
return;
}
if (arguments.size() != 2)
{
obj->_devices[quale]->write_buffer(_("\nERROR: wrong number of parameters."
"\nType HELP SETTIMER for the description of the sintax"));
return;
}
int num;
if (string_to_int(arguments[1], num) && num > 0 && num < 10000)
obj->set_timer(num);
else
obj->_devices[quale]->write_buffer(_(
"\nERROR: the second parameter has a wrong value."
"\nType HELP SETTIMER for the description of the sintax"));
}
else if (arguments[param] == "GETTIMER")
{
if (show_help)
{
obj->_devices[quale]->write_buffer(_(
"\n-- GetTimer COMMAND --\nReturns the number of milliseconds the simulation "
"in the continuous mode waits between a step and the following one"));
return;
}
ustring ss;
int_to_string(obj->get_timer(), ss);
obj->_devices[quale]->write_buffer(ss);
}
else if (arguments[param] == "JUMPTO")
{
if (show_help)
{
obj->_devices[quale]->write_buffer(_(
"\n-- JumpTo COMMAND --\nPermits to jump to a desired instant of the simulation."
" All states of the simulation before <param> will be recalculated and printed out."
"\n\nSintax: JumpTo <param>\n\t<param> must be an integer value >= 0"));
return;
}
if (arguments.size() != 2)
{
obj->_devices[quale]->write_buffer(_("\nERROR: wrong number of parameters."
"\nType HELP JUMPTO for the description of the sintax"));
return;
}
int num;
if (string_to_int(arguments[1], num) && num >= 0)
obj->jump_to(num);
else
obj->_devices[quale]->write_buffer(_(
"\nERROR: the second parameter has a wrong value."
"\nType HELP JUMPTO for the description of the sintax"));
}
else if (arguments[param] == "GETPOLICY")
{
if (show_help)
{
obj->_devices[quale]->write_buffer(_(
"\n-- GetPolicy COMMAND --\nReturns the name and the description of the current applied policy."));
return;
}
obj->_devices[quale]->write_buffer(obj->get_policy()->get_description());
}
else if (arguments[param] == "GETPOLICYATTRIBUTES")
{
if (show_help)
{
obj->_devices[quale]->write_buffer(_(
"\n-- GetPolicyAttributes COMMAND --\nReturns the list of attributes of the current applied policy."
"\nThe description of each parameter includes:"
"\n\tthe NAME of the marameter with its type\n\tits current VALUE"
"\n\tits LOWER and UPPER bounds\n\twhether the parameter is REQUIRED"));
return;
}
ustring temp;
const PolicyParameters& param = obj->get_policy()->get_parameters();
map<ustring, PolicyParameters::Parameter<int> > map_i = param.get_registered_int_parameters();
map<ustring, PolicyParameters::Parameter<int> >::iterator i_i = map_i.begin();
for(; i_i != map_i.end(); i_i++)
{
obj->_devices[quale]->write_buffer("\nint\t" + i_i->second.get_name());
int_to_string(i_i->second.get_value(), temp);
obj->_devices[quale]->write_buffer("\tvalue=" + temp);
int_to_string(i_i->second.get_lower_bound(), temp);
obj->_devices[quale]->write_buffer(" lower=" + temp);
int_to_string(i_i->second.get_upper_bound(), temp);
obj->_devices[quale]->write_buffer(" upper=" + temp);
if (i_i->second.is_required())
obj->_devices[quale]->write_buffer(" required=true");
else
obj->_devices[quale]->write_buffer(" required=false");
}
map<ustring, PolicyParameters::Parameter<ustring> > map_s = param.get_registered_string_parameters();
map<ustring, PolicyParameters::Parameter<ustring> >::iterator i_s = map_s.begin();
for(; i_s != map_s.end(); i_s++)
{
obj->_devices[quale]->write_buffer("\nustring\t" + i_s->second.get_name());
obj->_devices[quale]->write_buffer("\tvalue=" + i_s->second.get_value());
if (i_s->second.is_required())
obj->_devices[quale]->write_buffer(" required=true");
else
obj->_devices[quale]->write_buffer(" required=false");
}
}
else
{
obj->_devices[quale]->write_buffer("\nCommand not recognized: ");
obj->_devices[quale]->write_buffer(arguments[param]);
return;
}
}
void
TextSimulation::update()
{
}
void
TextSimulation::_io_loop(pair<TextSimulation* , int > pun)
{
while(true)
{
//reads the command
ustring str;
pun.first->_devices[pun.second]->write_buffer("\nSGPEM=> ");
str = pun.first->_devices[pun.second]->read_command();
pair<pair<TextSimulation*, int>, const ustring> p(pair<TextSimulation*, int>(pun.first, pun.second), str);
if (pun.first->_devices[pun.second]->is_full_duplex())
//if the IOManager can read AND write at the same time then create a new thread
//thath will write to it while going on reading the next command
Thread::create( sigc::bind(&TextSimulation::parse_command, p), true);
else
//no read is possible: only write
pun.first->parse_command(p);
}
}

21
src/text_simulation.hh
View File

@ -22,10 +22,18 @@
#define TEXT_SIMULATION_HH 1
#include "config.h"
#include "gettext.h"
#include "simulation.hh"
#include "io_manager.hh"
#include "templates/smartp.hh"
#include "backend/string_utils.hh"
#include "backend/policy_parameters.hh"
#include <glibmm/thread.h>
#include <glibmm/ustring.h>
#include <utility>
namespace sgpem
@ -35,11 +43,18 @@ namespace sgpem
/**
*/
class SG_DLLEXPORT TextSimulation : public Simulation
class SG_DLLEXPORT TextSimulation : public Simulation, public sigc::trackable
{
public:
public:
~TextSimulation();
static void parse_command(std::pair< std::pair<TextSimulation*, int>, const Glib::ustring >);
void add_io_device(memory::smart_ptr<IOManager>);
void update();
private:
std::vector<memory::smart_ptr<IOManager> > _devices;
static void _io_loop(std::pair<TextSimulation*, int>);
};
}