- added console interpreter

- added string_utils

git-svn-id: svn://svn.gna.org/svn/sgpemv2/trunk@342 3ecf2c5c-341e-0410-92b4-d18e462d057c

src/Makefile.am

@@ -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

src/backend/Makefile.am

@@ -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

src/backend/policy.hh

@@ -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

src/backend/string_utils.cc

@@ -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;
+}
+

src/backend/string_utils.hh

@@ -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

src/graphical_simulation.hh

@@ -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

src/graphical_terminal_io.cc

@@ -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;
+}

src/graphical_terminal_io.hh

@@ -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;

src/io_manager.hh

@@ -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
+

src/main.cc

@@ -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********************************";  

src/standard_io.cc

@@ -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;
 }

src/standard_io.hh

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

src/start_gui.cc

@@ -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);
 }

src/start_gui.hh

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

src/text_simulation.cc

@@ -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);			
+	}	
+}

src/text_simulation.hh

@@ -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>);
 	};
   
 }