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

- Fixed code to follow function naming conventions a bit more 

git-svn-id: svn://svn.gna.org/svn/sgpemv2/trunk@306 3ecf2c5c-341e-0410-92b4-d18e462d057c
This commit is contained in:
tchernobog 2006-02-09 19:33:35 +00:00
parent e8b28cc2ec
commit 68a0cef9d9
22 changed files with 427 additions and 407 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/backend/history.cc
View File

@ -26,10 +26,10 @@ using namespace memory;
//History::instance; //static object
History History::_instance(10); //dummy parameter
History::History(int) //private constructor. The parameter is discarded
:_total_time_elapsed(0)
{
}
{}
History&
@ -39,18 +39,18 @@ History::getInstance()
}
/**
/*
Returns a pointer to a copy of the SchedulableStatus object relative to this instant.
It can be NULL if time is out of range or if the SimulationStatus object relative to
this instant has no running entities.
*/
smart_ptr<const SchedulableStatus>
History::getScheduledAt (int time)
History::get_scheduled_at(int time)
{
if (time >= _total_time_elapsed || time < 0) //out of range
return smart_ptr<const SchedulableStatus>(NULL);
return getSimulationStatusAt(time)->getRunning();
return get_simulation_status_at(time)->get_running();
}
/**
@ -58,24 +58,24 @@ History::getScheduledAt (int time)
if time is out of range.
*/
smart_ptr<const SimulationStatus>
History::getSimulationStatusAt (int time)
History::get_simulation_status_at(int time)
{
if (time >= _total_time_elapsed || time < 0) //out of range
return smart_ptr<const SimulationStatus>(NULL);
int trascorso = 0;
for(vector<Slice>::iterator i=_slices.begin(); i < _slices.end(); i++)
if (time < trascorso + i->getDuration()) //FOUND!!
return smart_ptr<const SimulationStatus>(new SimulationStatus(i->getSimulationStatus()));
if (time < trascorso + i->get_duration()) //FOUND!!
return smart_ptr<const SimulationStatus>(new SimulationStatus(i->get_simulation_status()));
else //Go on...
trascorso += i->getDuration();
trascorso += i->get_duration();
//never reached
return smart_ptr<const SimulationStatus>(NULL);
}
int
History::getCurrentTime()
History::get_current_time()
{
return _total_time_elapsed;
}
@ -85,9 +85,9 @@ History::getCurrentTime()
Calls the method notify() in quality of ObservedSubject, updating all observers.
*/
void
History::enqueueSlice (SimulationStatus status)
History::enqueue_slice(SimulationStatus status)
{
if (_slices.size() == 0){
if(_slices.size() == 0){
_slices.push_back(Slice(0, 1, status));
_total_time_elapsed = 1;
notify();
@ -96,13 +96,13 @@ History::enqueueSlice (SimulationStatus status)
//check the last slice
Slice& last = _slices[_slices.size()-1];
if (last.getSimulationStatus() == status) //increments the duration by ONE unit
if (last.get_simulation_status() == status) //increments the duration by ONE unit
{
last.setDuration(last.getDuration()+1);
last.set_duration(last.get_duration()+1);
}
else //insert a new slice CONTIGUOUS to the last one
{
_slices.push_back(Slice(last.getStartedAt() + last.getDuration(), 1, status));
_slices.push_back(Slice(last.get_started_at() + last.get_duration(), 1, status));
}
_total_time_elapsed++; //one instant is passed...
notify();
@ -112,7 +112,7 @@ History::enqueueSlice (SimulationStatus status)
Removes all the informations about the simulation following the specified instant.
*/
void
History::truncateAt (int instant)
History::truncate_at(int instant)
{
//reach the instant
vector<Slice>::iterator i = _slices.begin();

16
src/backend/history.hh
View File

@ -35,7 +35,7 @@
namespace sgpem
{
/** \brief Manages the history of the simulation
/** \brief Manages the history of the simulation
Manages the history of the simulation from the instant 0 to the current time,
i.e. permits to know the state of each schedulable object inside this time interval.
@ -44,17 +44,17 @@ namespace sgpem
In a future iteration it will be possible to revert the entire simulation to a state
present in the history ("undo operation")
*/
*/
class History;
class SG_DLLEXPORT History : public ObservedSubject {
public:
memory::smart_ptr<const sgpem::SchedulableStatus> getScheduledAt (int time);
memory::smart_ptr<const sgpem::SimulationStatus> getSimulationStatusAt (int time);
int getCurrentTime();
void enqueueSlice (sgpem::SimulationStatus status);
void truncateAt (int instant);
memory::smart_ptr<const sgpem::SchedulableStatus> get_scheduled_at(int time);
memory::smart_ptr<const sgpem::SimulationStatus> get_simulation_status_at(int time);
int get_current_time();
void enqueue_slice(sgpem::SimulationStatus status);
void truncate_at(int instant);
static History& getInstance();
@ -65,7 +65,7 @@ namespace sgpem
std::vector<sgpem::Slice> _slices;
};
}
}//~ namespace sgpem
#endif //HISTORY_H

3
src/backend/observedSubject.hh
View File

@ -48,7 +48,8 @@ namespace sgpem
private:
std::vector<Observer*> _attached;
};
}
} //~ namespace sgpem
#endif

2
src/backend/process.cc
View File

@ -32,7 +32,7 @@ Process::~Process()
}
Glib::ustring
Process::getType() const
Process::get_type() const
{
return "Process";
}

2
src/backend/process.hh
View File

@ -41,7 +41,7 @@ namespace sgpem
Process(const Glib::ustring& name, const unsigned int& arrival, const unsigned int& total, const int& priority);
~Process();
Glib::ustring getType() const;
Glib::ustring get_type() const;
private:
};

8
src/backend/schedulable.cc
View File

@ -35,27 +35,27 @@ Schedulable::~Schedulable()
unsigned int
Schedulable::getArrivalTime() const
Schedulable::get_arrival_time() const
{
return _arrival_time;
}
unsigned int
Schedulable::getTotalCPUTime() const
Schedulable::get_total_cpu_time() const
{
return _total_time;
}
int
Schedulable::getPriority() const
Schedulable::get_priority() const
{
return _priority;
}
Glib::ustring
Schedulable::getName() const
Schedulable::get_name() const
{
return _name;
}

10
src/backend/schedulable.hh
View File

@ -42,11 +42,11 @@ namespace sgpem
Schedulable(const Glib::ustring& name, const unsigned int& arrival, const unsigned int& total, const int& priority);
virtual ~Schedulable() = 0;
virtual unsigned int getArrivalTime() const;
unsigned int getTotalCPUTime() const;
int getPriority() const;
Glib::ustring getName() const;
virtual Glib::ustring getType() const =0;
virtual unsigned int get_arrival_time() const;
unsigned int get_total_cpu_time() const;
int get_priority() const;
Glib::ustring get_name() const;
virtual Glib::ustring get_type() const = 0;
private:
Glib::ustring _name;

32
src/backend/schedulableStatus.cc
View File

@ -22,51 +22,51 @@
using namespace sgpem;
using namespace std;
SchedulableStatus::SchedulableStatus(const Schedulable& obj):
_ref(&obj), _last(-1), _timeLeft(obj.getTotalCPUTime()), _myState(state_future)
SchedulableStatus::SchedulableStatus(const Schedulable& obj)
: _ref(&obj), _last(-1), _time_left(obj.get_total_cpu_time()), _my_state(state_future)
{
}
int
SchedulableStatus::getCpuTimeLeft() const
SchedulableStatus::get_cpu_time_left() const
{
return _timeLeft;
return _time_left;
}
void
SchedulableStatus::giveCpuTime(const int& time)
SchedulableStatus::give_cpu_time(const int& time)
{
_timeLeft -= time;
if (_timeLeft < 0)
_timeLeft = 0;
_time_left -= time;
if (_time_left < 0)
_time_left = 0;
}
void
SchedulableStatus::setLastScheduled(const int& time)
SchedulableStatus::set_last_scheduled(const int& time)
{
_last = time;
}
int
SchedulableStatus::getLastScheduled() const
SchedulableStatus::get_last_scheduled() const
{
return _last;
}
SchedulableStatus::state
SchedulableStatus::getState() const
SchedulableStatus::get_state() const
{
return _myState;
return _my_state;
}
void
SchedulableStatus::setState(state s)
SchedulableStatus::set_state(state s)
{
_myState = s;
_my_state = s;
}
const Schedulable*
SchedulableStatus::getSchedulable() const
SchedulableStatus::get_schedulable() const
{
return _ref;
}
@ -74,7 +74,7 @@ SchedulableStatus::getSchedulable() const
bool
SchedulableStatus::operator==(const SchedulableStatus& dx) const
{
return (_ref==dx._ref)&&(_last==dx._last)&&(_timeLeft==dx._timeLeft)&&(_myState==dx._myState);
return (_ref==dx._ref)&&(_last==dx._last)&&(_time_left==dx._time_left)&&(_my_state==dx._my_state);
}

24
src/backend/schedulableStatus.hh
View File

@ -36,8 +36,8 @@ namespace sgpem
Objects SchedulableStatus are created by Scheduler and destroyed by SimulationStatus if they are linked to it
or by Scheduler.
*/
class SG_DLLEXPORT SchedulableStatus
{
class SG_DLLEXPORT SchedulableStatus
{
public:
enum state
{
@ -53,21 +53,21 @@ class SG_DLLEXPORT SchedulableStatus
//SchedulableStatus(const SchedulableStatus& obj); //copy constructor
bool operator==(const SchedulableStatus&) const;
int getCpuTimeLeft() const;
void giveCpuTime(const int& time);
void setLastScheduled(const int& time);
int getLastScheduled() const;
state getState() const;
void setState(state s);
const Schedulable* getSchedulable() const;
int get_cpu_time_left() const;
void give_cpu_time(const int& time);
void set_last_scheduled(const int& time);
int get_last_scheduled() const;
state get_state() const;
void set_state(state s);
const Schedulable* get_schedulable() const;
private:
const Schedulable* _ref;
int _last;
int _timeLeft;
state _myState;
int _time_left;
state _my_state;
};
};
}

29
src/backend/simulationStatus.cc
View File

@ -23,7 +23,7 @@ using namespace sgpem;
using namespace std;
using namespace memory;
/** \brief Creates the SimulationStatus object with no SchedulableStatus object
/** \brief Creates the SimulationStatus object with no SchedulableStatus object
*/
SimulationStatus::SimulationStatus()
@ -37,49 +37,49 @@ SimulationStatus::SimulationStatus(const SimulationStatus& dx)
/** \brief Adds a SchedulableStatus which represents a running Schedulable object.
/** \brief Adds a SchedulableStatus which represents a running Schedulable object.
Adds a SchedulableStatus which represents a running Schedulable object.
Note that a copy of SchedulableStatus will be created
*/
*/
void
SimulationStatus::setRunning(SchedulableStatus entity)
SimulationStatus::set_running(SchedulableStatus entity)
{
if (entity.getState() != SchedulableStatus::state_running)
entity.setState(SchedulableStatus::state_running);
if (entity.get_state() != SchedulableStatus::state_running)
entity.set_state(SchedulableStatus::state_running);
_set.push_back(entity);
}
/** \brief Looks for a running Schedulable object and returns ist state.
/** \brief Looks for a running Schedulable object and returns ist state.
Looks for a running Schedulable object and returns its state. There can be only
one running schedulable object. If no running schedulable object is found will be returned
the NULL pointer.
*/
*/
smart_ptr<SchedulableStatus>
SimulationStatus::getRunning()
SimulationStatus::get_running()
{
for (list<SchedulableStatus>::iterator f=_set.begin(); f != _set.end(); f++)
if (f->getState() == SchedulableStatus::state_running){ //there can be only ONE running schedulable objext
if (f->get_state() == SchedulableStatus::state_running){ //there can be only ONE running schedulable objext
return smart_ptr<SchedulableStatus>(new SchedulableStatus(*f));
}
return smart_ptr<SchedulableStatus>(NULL);
}
smart_ptr<const SchedulableStatus>
SimulationStatus::getRunning() const
SimulationStatus::get_running() const
{
for (list<SchedulableStatus>::const_iterator f=_set.begin(); f != _set.end(); f++)
if (f->getState() == SchedulableStatus::state_running){ //there can be only ONE running schedulable objext
if (f->get_state() == SchedulableStatus::state_running){ //there can be only ONE running schedulable objext
return smart_ptr<const SchedulableStatus>(new SchedulableStatus(*f));
}
return smart_ptr<const SchedulableStatus>(NULL); //NOT FOUND RUNNING ENTITIES
}
/**
/**
\brief Returns TRUE if the two objects have the same SchedulableStatus objects
*/
*/
bool
SimulationStatus::operator==(const SimulationStatus& dx) const
{
@ -91,6 +91,5 @@ SimulationStatus::operator==(const SimulationStatus& dx) const
if (find(dx._set.begin(), dx._set.end(), *f) == dx._set.end()) //element NOT found!!
return false;
return true;
}

8
src/backend/simulationStatus.hh
View File

@ -44,9 +44,11 @@ namespace sgpem
SimulationStatus(const SimulationStatus&);
bool operator==(const SimulationStatus&) const;
memory::smart_ptr<SchedulableStatus> getRunning(); //this method isn't const because it returns a pointer which CAN alter the object!
memory::smart_ptr<const SchedulableStatus> getRunning() const;
void setRunning(SchedulableStatus);
//this method isn't const because it returns a pointer which CAN alter the object!
memory::smart_ptr<SchedulableStatus> get_running();
memory::smart_ptr<const SchedulableStatus> get_running() const;
void set_running(SchedulableStatus);
private:
//I used a list instead of a vector because this one could reallocate the internal elements

8
src/backend/slice.cc
View File

@ -29,25 +29,25 @@ Slice::Slice(const int& start, const int& duration, const SimulationStatus& stat
}
SimulationStatus&
Slice::getSimulationStatus()
Slice::get_simulation_status()
{
return _ref;
}
int
Slice::getStartedAt() const
Slice::get_started_at() const
{
return _started_at;
}
int
Slice::getDuration() const
Slice::get_duration() const
{
return _duration;
}
void
Slice::setDuration(const int& i)
Slice::set_duration(const int& i)
{
_duration = i;
}

10
src/backend/slice.hh
View File

@ -41,10 +41,10 @@ namespace sgpem
public:
Slice(const int& start, const int& duration, const SimulationStatus& status);
SimulationStatus& getSimulationStatus();
int getStartedAt() const;
int getDuration() const;
void setDuration(const int&);
SimulationStatus& get_simulation_status();
int get_started_at() const;
int get_duration() const;
void set_duration(const int&);
private:
SimulationStatus _ref;
@ -52,6 +52,6 @@ namespace sgpem
int _duration;
};
}
} //~ namespace sgpem
#endif

10
src/graphicalterminalio.cc
View File

@ -27,15 +27,13 @@
#include <gtkmm/textview.h>
#include <glibmm/ustring.h>
GraphicalTerminalIO::GraphicalTerminalIO()
{
using namespace sgpem;
}
GraphicalTerminalIO::GraphicalTerminalIO()
{}
GraphicalTerminalIO::~GraphicalTerminalIO()
{
}
{}
GraphicalTerminalIO::size_type
GraphicalTerminalIO::write_buffer(const Glib::ustring& buffer)

21
src/graphicalterminalio.hh
View File

@ -31,26 +31,31 @@
#include "iomanager.hh"
// ---------------------------------------------
namespace sgpem {
class GraphicalTerminalIO;
// ---------------------------------------------
// ---------------------------------------------
class GraphicalTerminalIO;
/** \brief
// ---------------------------------------------
/** \brief
*
* ... long desc ... */
class GraphicalTerminalIO : public IOManager, public Gtk::VBox {
class GraphicalTerminalIO : public IOManager, public Gtk::VBox
{
typedef unsigned int size_type;
public:
public:
GraphicalTerminalIO();
virtual ~GraphicalTerminalIO();
virtual size_type write_buffer(const Glib::ustring& buffer);
virtual size_type read_command(Glib::ustring& buffer) const;
private:
private:
Gtk::TextView text_output;
Gtk::Entry text_input;
};
};
}
#endif

19
src/iomanager.hh
View File

@ -26,22 +26,27 @@
#include <glibmm/ustring.h>
// ---------------------------------------------
namespace sgpem {
class IOManager;
// ---------------------------------------------
// ---------------------------------------------
class IOManager;
/** \brief
// ---------------------------------------------
/** \brief
*
* ... long desc ... */
class IOManager {
class IOManager
{
typedef unsigned int size_type;
public:
public:
virtual ~IOManager() {}
virtual size_type write_buffer(const Glib::ustring& buffer) = 0;
virtual size_type read_command(Glib::ustring& buffer) const = 0;
};
};
}
#endif

68
src/main.cc
View File

@ -37,14 +37,14 @@
#include <string>
#include <vector>
using namespace std;
using namespace sgpem;
using namespace memory;
using namespace std;
using namespace sgpem;
using namespace memory;
int
main(int argc, char* argv[])
{
using namespace sgpem;
// Set up gettext support
setlocale(LC_ALL, "");
@ -61,7 +61,7 @@ main(int argc, char* argv[])
filenames.insert(filenames.begin(), a_ptr, a_ptr+a_count);
}
*/
//start_gui(argc, argv);
//start_gui(argc, argv);
//SMOKE-TEST for backend classes
cout << "\n\n********************************";
@ -73,45 +73,45 @@ main(int argc, char* argv[])
SchedulableStatus ss2(p2);
SchedulableStatus ss3(p3);
SimulationStatus sim1; sim1.setRunning(p1);
SimulationStatus sim2; sim2.setRunning(p2);
SimulationStatus sim3; sim3.setRunning(p3);
SimulationStatus sim1; sim1.set_running(p1);
SimulationStatus sim2; sim2.set_running(p2);
SimulationStatus sim3; sim3.set_running(p3);
History h(History::getInstance());
h.enqueueSlice(sim1);
h.enqueueSlice(sim1);
h.enqueueSlice(sim2);
h.enqueueSlice(sim1);
h.enqueueSlice(sim2);
h.enqueueSlice(sim1);
h.enqueueSlice(sim2);
h.enqueueSlice(sim3);
h.enqueueSlice(sim3);
h.enqueueSlice(sim1);
h.enqueueSlice(sim3);
h.enqueueSlice(sim1);
h.enqueue_slice(sim1);
h.enqueue_slice(sim1);
h.enqueue_slice(sim2);
h.enqueue_slice(sim1);
h.enqueue_slice(sim2);
h.enqueue_slice(sim1);
h.enqueue_slice(sim2);
h.enqueue_slice(sim3);
h.enqueue_slice(sim3);
h.enqueue_slice(sim1);
h.enqueue_slice(sim3);
h.enqueue_slice(sim1);
h.truncateAt(3);
h.truncate_at(3);
smart_ptr<const sgpem::SimulationStatus> quale;
quale = h.getSimulationStatusAt(0);
if (quale) cout << "\n" << quale->getRunning()->getSchedulable()->getName(); else cout << "NO";
quale = h.getSimulationStatusAt(1);
if (quale) cout << "\n" << quale->getRunning()->getSchedulable()->getName(); else cout << "NO";
quale = h.getSimulationStatusAt(2);
if (quale) cout << "\n" << quale->getRunning()->getSchedulable()->getName(); else cout << "NO";
quale = h.get_simulation_status_at(0);
if (quale) cout << "\n" << quale->get_running()->get_schedulable()->get_name(); else cout << "NO";
quale = h.get_simulation_status_at(1);
if (quale) cout << "\n" << quale->get_running()->get_schedulable()->get_name(); else cout << "NO";
quale = h.get_simulation_status_at(2);
if (quale) cout << "\n" << quale->get_running()->get_schedulable()->get_name(); else cout << "NO";
h.truncateAt(2);
h.truncate_at(2);
smart_ptr<const sgpem::SchedulableStatus> quale2;
quale2 = h.getScheduledAt(0);
if (quale2) cout << "\n" << quale2->getSchedulable()->getName(); else cout << "NO";
quale2 = h.getScheduledAt(1);
if (quale2) cout << "\n" << quale2->getSchedulable()->getName(); else cout << "NO";
quale2 = h.getScheduledAt(2);
if (quale2) cout << "\n" << quale2->getSchedulable()->getName(); else cout << "NO";
quale2 = h.get_scheduled_at(0);
if (quale2) cout << "\n" << quale2->get_schedulable()->get_name(); else cout << "NO";
quale2 = h.get_scheduled_at(1);
if (quale2) cout << "\n" << quale2->get_schedulable()->get_name(); else cout << "NO";
quale2 = h.get_scheduled_at(2);
if (quale2) cout << "\n" << quale2->get_schedulable()->get_name(); else cout << "NO";
cout << "\n\n";

2
src/mainwindow.cc
View File

@ -29,6 +29,8 @@
#include <gtkmm/menubar.h>
#include <gtkmm/window.h>
using namespace sgpem;
MainWindow::MainWindow()
{
set_title(PACKAGE_STRING);

25
src/mainwindow.hh
View File

@ -18,31 +18,36 @@
// along with SGPEMv2; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#ifndef GTKGUI_MAINWINDOW_HH
#define GTKGUI_MAINWINDOW_HH 1
#ifndef MAINWINDOW_HH
#define MAINWINDOW_HH 1
#include "config.h"
#include "gettext.h"
#include <gtkmm/window.h>
// ---------------------------------------------
namespace sgpem {
class MainWindow;
// ---------------------------------------------
// ---------------------------------------------
class MainWindow;
/** \brief The main program window
// ---------------------------------------------
/** \brief The main program window
*
* This is the main simulation window displayed
* when the program is run with a GUI */
class MainWindow : public Gtk::Window {
public:
class MainWindow : public Gtk::Window
{
public:
MainWindow();
virtual ~MainWindow();
private:
private:
};
};
} //~ namespace sgpem
#endif

13
src/observer.hh
View File

@ -25,16 +25,19 @@
namespace sgpem
{
/**
Abstract class which represents an observed entity who calls Update() in all Observer objects.
See "Observer Pattern" for more information.
*/
class Observer;
/** \brief An abstract class helping to implemen an Observer Pattern
*
* Abstract class which represents an observed entity which calls
* update() on all Observer objects.
*
* See the "Observer Pattern" for more information.
*/
class SG_DLLEXPORT Observer
{
public:
virtual ~Observer()=0;
virtual ~Observer() = 0;
virtual void update();

2
src/startgui.cc
View File

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