- Add first draft of SWIG interface file, and create Python

loadable module. However, please note that:
	- All the methods accepting a Glib::ustring should
	not be exported, instead they should be replaced by wrapper
	functions accepting PyObject*.
	- The same thing applies to every other method accepting
	a ``non built-in'' data type
	- Return types should probably be wrapped, too
	- It may be a good idea to implement wrapper methods 
	that print out the content of a C++ object, 
	so that a Python user can do a simple "print schedStat". 
	This is achieved by adding a "__str__()" method to the 
	class. See the SWIG manual for further infos about
	returning const char* values.


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

src/backend/pyloader/Policy.py

@@ -1,5 +1,5 @@
 
-# from sgpem import SchedulableQueue, PolicyParameters
+from sgpem import SchedulableList, PolicyParameters
 from Abstract import *
 
 class Policy:

src/backend/sgpem.i

@@ -0,0 +1,144 @@
+%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