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

namespace sgpem {

    class Policy {
    public:
	virtual ~Policy() = 0;
	const PolicyParameters& get_parameters() const;
    };

    // --------------------------------------------
    class PolicyParametersException : public std::runtime_error {
    public:
	PolicyParametersException(char* msg);
	%rename (__str__) what();
    }; //~ class PolicyParametersException
  
    // --------------------------------------------
    class PolicyParameters 
    {
    public:
	//methods to CREATE PARAMETERS
	// (rewrapped correctly for SWIG usage)
	%ignore register_int(const Glib::ustring&, const int&,
			     const int&, const bool&, const int&);
	%ignore register_float(const Glib::ustring&, const float&,
			       const float&, const bool&, const float&);
	%ignore register_string(const Glib::ustring&, const bool&, 
				const char*);
	
	%extend {
	    void register_int(const char* name,
			      const int& lower_bound, 
			      const int& upper_bound, 
			      const bool& required, 
			      const int& default_value = 0) 
		{ 
		    self->register_int(Glib::ustring(name), 
				       lower_bound, upper_bound,
				       required, default_value); 
		}

	    void register_float(const char* name,
				const float& lower_bound, 
				const float& upper_bound, 
				const bool& required, 
				const float& default_value = 0.0f)
		{ 
		    self->register_float(Glib::ustring(name), 
					 lower_bound, upper_bound,
					 required, default_value); 
		}
	    
	    void register_string(const char* name, 
				 const bool& required, 
				 const char* default_value = "")
		{ 
		    self->register_string(Glib::ustring(name), 
					  required, 
					  Glib::ustring(default_value));
		}
	}
    
	//methods to SET the VALUE of PARAMETERS
	// (rewrapped correctly for SWIG usage)
	%ignore set_int(const Glib::ustring&, const int&);
	%ignore set_float(const Glib::ustring&, const float&);
	%ignore set_string(const Glib::ustring&, const Glib::ustring&);

	%extend {
	    bool set_int(const char* name, const int& value)
		{ return self->set_int(Glib::ustring(name), value); }
	    bool set_float(const char* name, const float& value)
		{ return self->set_float(Glib::ustring(name), value); }
	    bool set_string(const char* name, const char* value)
		{ return self->set_string(Glib::ustring(name), value); }
	}
	
	//methods to GET the VALUE of PARAMETERS
	// (rewrapped correctly for SWIG usage)
	%ignore get_int(const Glib::ustring&) const;
	%ignore get_float(const Glib::ustring&) const;
	%ignore get_string(const Glib::ustring&) const;

	%extend {
	    int get_int(const char* name) const 
		{ return self->get_int(Glib::ustring(name)); }
	    float get_float(const char* name) const 
		{ return self->get_float(Glib::ustring(name)); }
	    const char* get_string(const char* name) const
		{ return self->get_string(Glib::ustring(name)).c_str(); }
	}

    }; //~ class PolicyParameters
  	
    // --------------------------------------------
    class Schedulable
    {
    public:
	virtual ~Schedulable() = 0;

	virtual unsigned int get_arrival_time()  const;
	int get_priority() const;
	unsigned int get_total_cpu_time() const;
	
	%ignore get_name() const;
	%extend {
	    const char* get_name() const 
		{ return self->get_name().c_str(); }
	}
    }; //~ class Schedulable


    // --------------------------------------------
    class SchedulableList 
    {
    public:
	sgpem::SchedulableStatus* top();
	sgpem::SchedulableStatus* bottom();
	bool insert_at(const uint&, const uint&);
	uint size() const;
	SchedulableStatus* get_item_at(const uint&);
	const SchedulableStatus* get_item_at(const uint&) const;

    private:
	// Avoid instantiation and copy
	SchedulableList();
	SchedulableList(const SchedulableList& );
    }; //~ class Schedulable

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

	SchedulableStatus(const SchedulableStatus& obj);

	int         get_cpu_time_left() const;
	void        give_cpu_time(const int& time);
	int         get_last_scheduled() const;
	state       get_state() const;
	const       Schedulable* get_schedulable() const;
    };

} //~ namespace sgpem