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

118
src/backend/history.cc
View File

@ -23,104 +23,104 @@ using namespace std;
using namespace sgpem; using namespace sgpem;
using namespace memory; using namespace memory;
//History::instance; //static object //History::instance; //static object
History History::_instance(10); //dummy parameter History History::_instance(10); //dummy parameter
History::History(int) //private constructor. The parameter is discarded
:_total_time_elapsed(0) History::History(int) //private constructor. The parameter is discarded
{ :_total_time_elapsed(0)
} {}
History& History&
History::getInstance() History::getInstance()
{ {
return _instance; return _instance;
} }
/** /*
Returns a pointer to a copy of the SchedulableStatus object relative to this instant. 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 It can be NULL if time is out of range or if the SimulationStatus object relative to
this instant has no running entities. this instant has no running entities.
*/ */
smart_ptr<const SchedulableStatus> smart_ptr<const SchedulableStatus>
History::getScheduledAt (int time) History::get_scheduled_at(int time)
{ {
if (time >= _total_time_elapsed || time < 0) //out of range if (time >= _total_time_elapsed || time < 0) //out of range
return smart_ptr<const SchedulableStatus>(NULL); return smart_ptr<const SchedulableStatus>(NULL);
return getSimulationStatusAt(time)->getRunning(); return get_simulation_status_at(time)->get_running();
} }
/** /**
Returns a pointer to a copy of the SimulationStatus object relative to this instant or NULL Returns a pointer to a copy of the SimulationStatus object relative to this instant or NULL
if time is out of range. if time is out of range.
*/ */
smart_ptr<const SimulationStatus> 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 if (time >= _total_time_elapsed || time < 0) //out of range
return smart_ptr<const SimulationStatus>(NULL); return smart_ptr<const SimulationStatus>(NULL);
int trascorso = 0; int trascorso = 0;
for(vector<Slice>::iterator i=_slices.begin(); i < _slices.end(); i++) for(vector<Slice>::iterator i=_slices.begin(); i < _slices.end(); i++)
if (time < trascorso + i->getDuration()) //FOUND!! if (time < trascorso + i->get_duration()) //FOUND!!
return smart_ptr<const SimulationStatus>(new SimulationStatus(i->getSimulationStatus())); return smart_ptr<const SimulationStatus>(new SimulationStatus(i->get_simulation_status()));
else //Go on... else //Go on...
trascorso += i->getDuration(); trascorso += i->get_duration();
//never reached //never reached
return smart_ptr<const SimulationStatus>(NULL); return smart_ptr<const SimulationStatus>(NULL);
} }
int int
History::getCurrentTime() History::get_current_time()
{ {
return _total_time_elapsed; return _total_time_elapsed;
} }
/** /**
Appends to the history a SimulationStatus creating a Slice with duration of 1 instant. Appends to the history a SimulationStatus creating a Slice with duration of 1 instant.
Calls the method notify() in quality of ObservedSubject, updating all observers. Calls the method notify() in quality of ObservedSubject, updating all observers.
*/ */
void 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)); _slices.push_back(Slice(0, 1, status));
_total_time_elapsed = 1; _total_time_elapsed = 1;
notify(); notify();
return; return;
} }
//check the last slice //check the last slice
Slice& last = _slices[_slices.size()-1]; 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 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... _total_time_elapsed++; //one instant is passed...
notify(); notify();
} }
/** /**
Removes all the informations about the simulation following the specified instant. Removes all the informations about the simulation following the specified instant.
*/ */
void void
History::truncateAt (int instant) History::truncate_at(int instant)
{ {
//reach the instant //reach the instant
vector<Slice>::iterator i = _slices.begin(); vector<Slice>::iterator i = _slices.begin();
for (int k=0; k < instant; k++) for (int k=0; k < instant; k++)
i++; i++;
//replaces the current vector with the "trimmed" one. //replaces the current vector with the "trimmed" one.
_slices = vector<Slice>(_slices.begin(),i); _slices = vector<Slice>(_slices.begin(),i);
_total_time_elapsed = instant; _total_time_elapsed = instant;
} }

36
src/backend/history.hh
View File

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

22
src/backend/observedSubject.cc
View File

@ -28,36 +28,36 @@ ObservedSubject::~ObservedSubject()
} }
/** /**
Calls update() in each Observer Calls update() in each Observer
*/ */
void void
ObservedSubject::notify() ObservedSubject::notify()
{ {
for(vector<Observer*>::iterator i = _attached.begin(); i < _attached.end(); i++) for(vector<Observer*>::iterator i = _attached.begin(); i < _attached.end(); i++)
(*i)->update(); (*i)->update();
} }
/** /**
Attachs an Observer to this ObservedSubject. Attachs an Observer to this ObservedSubject.
*/ */
void void
ObservedSubject::attach(Observer* o) ObservedSubject::attach(Observer* o)
{ {
_attached.push_back(o); _attached.push_back(o);
} }
/** /**
Detachs the observer from this ObservedSubject. Detachs the observer from this ObservedSubject.
*/ */
bool bool
ObservedSubject::detach(Observer* o) ObservedSubject::detach(Observer* o)
{ {
vector<Observer*>::iterator i = find(_attached.begin(), _attached.end(), o); vector<Observer*>::iterator i = find(_attached.begin(), _attached.end(), o);
if (i == _attached.end()) if (i == _attached.end())
return false; return false;
_attached.erase(i); // FOUND and POPPED _attached.erase(i); // FOUND and POPPED
return true; return true;
} }

33
src/backend/observedSubject.hh
View File

@ -30,25 +30,26 @@
namespace sgpem namespace sgpem
{ {
/** /**
Abstract class which represents an observed entity who calls Update() in all Observer objects. Abstract class which represents an observed entity who calls Update() in all Observer objects.
See "Observer Pattern" for more information. See "Observer Pattern" for more information.
*/ */
class ObservedSubject; class ObservedSubject;
class SG_DLLEXPORT ObservedSubject class SG_DLLEXPORT ObservedSubject
{ {
public: public:
virtual ~ObservedSubject() =0; virtual ~ObservedSubject() =0;
void notify(); void notify();
void attach(sgpem::Observer*); void attach(sgpem::Observer*);
bool detach(sgpem::Observer*); bool detach(sgpem::Observer*);
private: private:
std::vector<Observer*> _attached; std::vector<Observer*> _attached;
}; };
}
} //~ namespace sgpem
#endif #endif

6
src/backend/process.cc
View File

@ -23,7 +23,7 @@ using namespace sgpem;
Process::Process(const Glib::ustring& name, const unsigned int& arrival, const unsigned int& total, const int& priority) Process::Process(const Glib::ustring& name, const unsigned int& arrival, const unsigned int& total, const int& priority)
: Schedulable(name, arrival, total, priority) : Schedulable(name, arrival, total, priority)
{ {
} }
@ -32,7 +32,7 @@ Process::~Process()
} }
Glib::ustring Glib::ustring
Process::getType() const Process::get_type() const
{ {
return "Process"; return "Process";
} }

20
src/backend/process.hh
View File

@ -29,22 +29,22 @@
namespace sgpem namespace sgpem
{ {
class Process; class Process;
/** \brief Represents a program in execution. /** \brief Represents a program in execution.
It IS a Schedulable object. It IS a Schedulable object.
*/ */
class SG_DLLEXPORT Process : public Schedulable class SG_DLLEXPORT Process : public Schedulable
{ {
public: public:
Process(const Glib::ustring& name, const unsigned int& arrival, const unsigned int& total, const int& priority); Process(const Glib::ustring& name, const unsigned int& arrival, const unsigned int& total, const int& priority);
~Process(); ~Process();
Glib::ustring getType() const; Glib::ustring get_type() const;
private: private:
}; };
} }

18
src/backend/schedulable.cc
View File

@ -23,10 +23,10 @@ using namespace sgpem;
Schedulable::Schedulable(const Glib::ustring& name, Schedulable::Schedulable(const Glib::ustring& name,
const unsigned int& arrival, const unsigned int& arrival,
const unsigned int& total, const unsigned int& total,
const int& priority): const int& priority):
_name(name), _arrival_time(arrival), _total_time(total), _priority(priority) _name(name), _arrival_time(arrival), _total_time(total), _priority(priority)
{} {}
@ -35,27 +35,27 @@ Schedulable::~Schedulable()
unsigned int unsigned int
Schedulable::getArrivalTime() const Schedulable::get_arrival_time() const
{ {
return _arrival_time; return _arrival_time;
} }
unsigned int unsigned int
Schedulable::getTotalCPUTime() const Schedulable::get_total_cpu_time() const
{ {
return _total_time; return _total_time;
} }
int int
Schedulable::getPriority() const Schedulable::get_priority() const
{ {
return _priority; return _priority;
} }
Glib::ustring Glib::ustring
Schedulable::getName() const Schedulable::get_name() const
{ {
return _name; return _name;
} }

14
src/backend/schedulable.hh
View File

@ -39,18 +39,18 @@ namespace sgpem
class SG_DLLEXPORT Schedulable class SG_DLLEXPORT Schedulable
{ {
public: public:
Schedulable(const Glib::ustring& name, const unsigned int& arrival, const unsigned int& total, const int& priority); Schedulable(const Glib::ustring& name, const unsigned int& arrival, const unsigned int& total, const int& priority);
virtual ~Schedulable() = 0; virtual ~Schedulable() = 0;
virtual unsigned int getArrivalTime() const; virtual unsigned int get_arrival_time() const;
unsigned int getTotalCPUTime() const; unsigned int get_total_cpu_time() const;
int getPriority() const; int get_priority() const;
Glib::ustring getName() const; Glib::ustring get_name() const;
virtual Glib::ustring getType() const =0; virtual Glib::ustring get_type() const = 0;
private: private:
Glib::ustring _name; Glib::ustring _name;
unsigned int _arrival_time; unsigned int _arrival_time;
unsigned int _total_time; unsigned int _total_time;
int _priority; int _priority;

38
src/backend/schedulableStatus.cc
View File

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

68
src/backend/schedulableStatus.hh
View File

@ -27,47 +27,47 @@
namespace sgpem namespace sgpem
{ {
class SchedulableStatus; class SchedulableStatus;
/** \brief Desribes the state of a schedulable entity in a particular moment of the simulation /** \brief Desribes the state of a schedulable entity in a particular moment of the simulation
This class desribes the state of a schedulable entity in a particular moment of the simulation. This class desribes the state of a schedulable entity in a particular moment of the simulation.
Stores part of informations deeded by Scheduler to manage processes and other ones. Stores part of informations deeded by Scheduler to manage processes and other ones.
Objects SchedulableStatus are created by Scheduler and destroyed by SimulationStatus if they are linked to it Objects SchedulableStatus are created by Scheduler and destroyed by SimulationStatus if they are linked to it
or by Scheduler. or by Scheduler.
*/ */
class SG_DLLEXPORT SchedulableStatus class SG_DLLEXPORT SchedulableStatus
{ {
public: public:
enum state enum state
{ {
state_running, state_running,
state_ready, state_ready,
state_blocked, state_blocked,
state_future, state_future,
state_terminated state_terminated
}; };
SchedulableStatus(const Schedulable& obj); SchedulableStatus(const Schedulable& obj);
//SchedulableStatus(const SchedulableStatus& obj); //copy constructor //SchedulableStatus(const SchedulableStatus& obj); //copy constructor
bool operator==(const SchedulableStatus&) const; bool operator==(const SchedulableStatus&) const;
int getCpuTimeLeft() const; int get_cpu_time_left() const;
void giveCpuTime(const int& time); void give_cpu_time(const int& time);
void setLastScheduled(const int& time); void set_last_scheduled(const int& time);
int getLastScheduled() const; int get_last_scheduled() const;
state getState() const; state get_state() const;
void setState(state s); void set_state(state s);
const Schedulable* getSchedulable() const; const Schedulable* get_schedulable() const;
private: private:
const Schedulable* _ref; const Schedulable* _ref;
int _last; int _last;
int _timeLeft; int _time_left;
state _myState; state _my_state;
}; };
} }

77
src/backend/simulationStatus.cc
View File

@ -23,74 +23,73 @@ using namespace sgpem;
using namespace std; using namespace std;
using namespace memory; using namespace memory;
/** \brief Creates the SimulationStatus object with no SchedulableStatus object /** \brief Creates the SimulationStatus object with no SchedulableStatus object
*/ */
SimulationStatus::SimulationStatus() SimulationStatus::SimulationStatus()
{ {
} }
SimulationStatus::SimulationStatus(const SimulationStatus& dx) SimulationStatus::SimulationStatus(const SimulationStatus& dx)
:_set(dx._set) :_set(dx._set)
{ {
} }
/** \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. Adds a SchedulableStatus which represents a running Schedulable object.
Note that a copy of SchedulableStatus will be created Note that a copy of SchedulableStatus will be created
*/ */
void void
SimulationStatus::setRunning(SchedulableStatus entity) SimulationStatus::set_running(SchedulableStatus entity)
{ {
if (entity.getState() != SchedulableStatus::state_running) if (entity.get_state() != SchedulableStatus::state_running)
entity.setState(SchedulableStatus::state_running); entity.set_state(SchedulableStatus::state_running);
_set.push_back(entity); _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 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 one running schedulable object. If no running schedulable object is found will be returned
the NULL pointer. the NULL pointer.
*/ */
smart_ptr<SchedulableStatus> smart_ptr<SchedulableStatus>
SimulationStatus::getRunning() SimulationStatus::get_running()
{ {
for (list<SchedulableStatus>::iterator f=_set.begin(); f != _set.end(); f++) 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>(new SchedulableStatus(*f));
} }
return smart_ptr<SchedulableStatus>(NULL); return smart_ptr<SchedulableStatus>(NULL);
} }
smart_ptr<const SchedulableStatus> smart_ptr<const SchedulableStatus>
SimulationStatus::getRunning() const SimulationStatus::get_running() const
{ {
for (list<SchedulableStatus>::const_iterator f=_set.begin(); f != _set.end(); f++) 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>(new SchedulableStatus(*f));
} }
return smart_ptr<const SchedulableStatus>(NULL); //NOT FOUND RUNNING ENTITIES return smart_ptr<const SchedulableStatus>(NULL); //NOT FOUND RUNNING ENTITIES
} }
/** /**
\brief Returns TRUE if the two objects have the same SchedulableStatus objects \brief Returns TRUE if the two objects have the same SchedulableStatus objects
*/ */
bool bool
SimulationStatus::operator==(const SimulationStatus& dx) const SimulationStatus::operator==(const SimulationStatus& dx) const
{ {
if (_set.size() != dx._set.size()) if (_set.size() != dx._set.size())
return false; return false;
//check if dx has ALL and ONLY the elements holded by _set with no order importance //check if dx has ALL and ONLY the elements holded by _set with no order importance
for(list<SchedulableStatus>::const_iterator f=_set.begin(); f != _set.end(); f++) for(list<SchedulableStatus>::const_iterator f=_set.begin(); f != _set.end(); f++)
if (find(dx._set.begin(), dx._set.end(), *f) == dx._set.end()) //element NOT found!! if (find(dx._set.begin(), dx._set.end(), *f) == dx._set.end()) //element NOT found!!
return false; return false;
return true;
return true;
} }

36
src/backend/simulationStatus.hh
View File

@ -29,30 +29,32 @@
namespace sgpem namespace sgpem
{ {
class SimulationStatus; class SimulationStatus;
/** \brief Keeps informatios about the configuration of the simulation /** \brief Keeps informatios about the configuration of the simulation
Keeps informatios about the configuration of the simulation: which process is Keeps informatios about the configuration of the simulation: which process is
running and other infos (since M02+) running and other infos (since M02+)
*/ */
class SG_DLLEXPORT SimulationStatus class SG_DLLEXPORT SimulationStatus
{ {
public: public:
SimulationStatus(); SimulationStatus();
SimulationStatus(const SimulationStatus&); SimulationStatus(const SimulationStatus&);
bool operator==(const SimulationStatus&) const; 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);
private: //this method isn't const because it returns a pointer which CAN alter the object!
//I used a list instead of a vector because this one could reallocate the internal elements memory::smart_ptr<SchedulableStatus> get_running();
//making pointers returned by getRunning() point to nothing! SEGMENTATION-FAULT :-O memory::smart_ptr<const SchedulableStatus> get_running() const;
std::list<SchedulableStatus> _set; void set_running(SchedulableStatus);
};
private:
//I used a list instead of a vector because this one could reallocate the internal elements
//making pointers returned by getRunning() point to nothing! SEGMENTATION-FAULT :-O
std::list<SchedulableStatus> _set;
};
} }

18
src/backend/slice.cc
View File

@ -24,30 +24,30 @@ using namespace std;
Slice::Slice(const int& start, const int& duration, const SimulationStatus& status) Slice::Slice(const int& start, const int& duration, const SimulationStatus& status)
: _ref(status), _started_at(start), _duration(duration) : _ref(status), _started_at(start), _duration(duration)
{ {
} }
SimulationStatus& SimulationStatus&
Slice::getSimulationStatus() Slice::get_simulation_status()
{ {
return _ref; return _ref;
} }
int int
Slice::getStartedAt() const Slice::get_started_at() const
{ {
return _started_at; return _started_at;
} }
int int
Slice::getDuration() const Slice::get_duration() const
{ {
return _duration; return _duration;
} }
void void
Slice::setDuration(const int& i) Slice::set_duration(const int& i)
{ {
_duration = i; _duration = i;
} }

34
src/backend/slice.hh
View File

@ -27,31 +27,31 @@
namespace sgpem namespace sgpem
{ {
class Slice; class Slice;
/** \brief Represents a slice of time during which some characteristic of the state of the simulation are constant /** \brief Represents a slice of time during which some characteristic of the state of the simulation are constant
Represents a slice of time during which some characteristic of the state of the simulation are constant. Represents a slice of time during which some characteristic of the state of the simulation are constant.
It holds a SimulationStatus object which can be accesse through getSimulationStatus() It holds a SimulationStatus object which can be accesse through getSimulationStatus()
*/ */
class SG_DLLEXPORT Slice class SG_DLLEXPORT Slice
{ {
public: public:
Slice(const int& start, const int& duration, const SimulationStatus& status); Slice(const int& start, const int& duration, const SimulationStatus& status);
SimulationStatus& getSimulationStatus(); SimulationStatus& get_simulation_status();
int getStartedAt() const; int get_started_at() const;
int getDuration() const; int get_duration() const;
void setDuration(const int&); void set_duration(const int&);
private: private:
SimulationStatus _ref; SimulationStatus _ref;
int _started_at; int _started_at;
int _duration; int _duration;
}; };
} } //~ namespace sgpem
#endif #endif

10
src/graphicalterminalio.cc
View File

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

39
src/graphicalterminalio.hh
View File

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

31
src/iomanager.hh
View File

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

90
src/main.cc
View File

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

2
src/mainwindow.cc
View File

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

35
src/mainwindow.hh
View File

@ -18,31 +18,36 @@
// along with SGPEMv2; if not, write to the Free Software // along with SGPEMv2; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#ifndef GTKGUI_MAINWINDOW_HH #ifndef MAINWINDOW_HH
#define GTKGUI_MAINWINDOW_HH 1 #define MAINWINDOW_HH 1
#include "config.h" #include "config.h"
#include "gettext.h" #include "gettext.h"
#include <gtkmm/window.h> #include <gtkmm/window.h>
// --------------------------------------------- namespace sgpem {
class MainWindow; // ---------------------------------------------
// --------------------------------------------- class MainWindow;
/** \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:
MainWindow();
virtual ~MainWindow();
private: /** \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:
MainWindow();
virtual ~MainWindow();
}; private:
};
} //~ namespace sgpem
#endif #endif

27
src/observer.hh
View File

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

2
src/startgui.cc
View File

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