%module sgpem
%{
#include "policy_parameters.hh"
#include "schedulable.hh"
#include "schedulable_list.hh"
#include "schedulable_status.hh"
%}

namespace sgpem {

  // --------------------------------------------
  class PolicyParametersException : public std::runtime_error {
  public:
    PolicyParametersException(char* msg): std::runtime_error(msg);
  }; //~ class PolicyParametersException
  
  // --------------------------------------------
  class PolicyParameters 
  {
  public:
    template<typename T>
      class Parameter;
    
    //methods to CREATE PARAMETERS
    void register_int(Glib::ustring name,
		      const int& lower_bound, 
		      const int& upper_bound, 
		      const bool& required, 
		      const int& default_value = 0);

    void register_float(Glib::ustring name,
			const float& lower_bound, 
			const float& upper_bound, 
			const bool& required, 
			const float& default_value = 0.0f);

    void register_string(Glib::ustring name, 
			 const bool& required, 
			 const Glib::ustring& default_value = "");
    
    void clear();
    
    //methods to RETRIEVE CREATED PARAMETERS
    std::map<Glib::ustring, Parameter<int> > get_registered_int_parameters() const;
    std::map<Glib::ustring, Parameter<float> > get_registered_float_parameters() const;
    std::map<Glib::ustring, Parameter<Glib::ustring> > get_registered_string_parameters() const;
    
    //methods to SET the VALUE of PARAMETERS
    bool set_int(Glib::ustring name, const int& value);
    bool set_float(Glib::ustring name, const float& value);
    bool set_string(Glib::ustring name, const Glib::ustring& value);
    
    //methods to GET the VALUE of PARAMETERS
    int	get_int(Glib::ustring name) const;
    float get_float(Glib::ustring name) const;
    Glib::ustring get_string(Glib::ustring name) const;
  }; //~ class PolicyParameters
  
  // --------------------------------------------
  template<typename T>
  class PolicyParameters::Parameter
  {
  public:
    Parameter(Glib::ustring name, 
	      const T& value, 
	      const T& lower_bound, 
	      const T& upper_bound, 
	      const bool& required,  
	      const T& default_value = 0);

    Glib::ustring get_name() const;
    T get_lower_bound() const;
    T get_upper_bound() const;
    bool is_required() const;
    T get_default() const;
    T get_value() const;
    void set_value(const T&);
  }; //~ class PolicyParameters::Parameter<>
	
  // --------------------------------------------
  class Schedulable
  {
  public:
    Schedulable(const Glib::ustring& name, 
		const unsigned int& arrival, 
		const unsigned int& total, 
		const int& priority);	
    virtual ~Schedulable() = 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;
  }; //~ class Schedulable


  // --------------------------------------------
  class SchedulableList 
  {
  public:
    SchedulableList();
		
    bool operator==(const SchedulableList&) const;
    bool has_same_objects(const SchedulableList& dx) const;
    sgpem::SchedulableStatus* top();
    sgpem::SchedulableStatus* bottom();
    void add_at_bottom(const sgpem::SchedulableStatus&);
    void add_at_top(const sgpem::SchedulableStatus&);
    memory::smart_ptr<sgpem::SchedulableStatus> remove(const uint& position);
    bool insert_at(const uint&, const uint&);
    uint size() const;
    SchedulableStatus* get_item_at(const uint&);
    const SchedulableStatus* get_item_at(const uint&) const;
    void  clear();
  }; //~ class Schedulable

	
  // ---------------------------------------------
  class SchedulableStatus
  {
  public:
    enum state
      {
	state_running,
	state_ready,
	state_blocked,
	state_future,
	state_terminated
      };

    SchedulableStatus(const Schedulable& obj);
    bool operator==(const SchedulableStatus&) 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;
  };

} //~ namespace sgpem