- Reorder pyloader plugin a little so that sources go in a separate

directory


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

plugins/pyloader/src/sgpem.i

@@ -0,0 +1,195 @@
+%module sgpem
+%{
+#include "policy.hh"
+#include "policy_parameters.hh"
+#include "schedulable.hh"
+#include "schedulable_queue.hh"
+#include "schedulable_status.hh"
+#include "scheduler.hh"
+%}
+
+/* NOTE : passing Unicode strings to C++ methods calling them 
+ * from Python results in a SIGSEGV. You've been warned!
+ * (Investigate if this can be fixed, else please report it in 
+ * the sgpem user manual)
+ */
+
+/** Due to the relatively new support for namespaces in SWIG,
+ * make sure to include the full visibility signature when
+ * returning / passing parameters from / to functions with
+ * objects different to the one you're declaring.
+ */
+
+namespace std {
+    class exception {
+    public:
+	virtual const char* what() const throw();
+    private:
+	exception();
+    };
+
+    class runtime_error : public std::exception {
+    public:
+	virtual const char* what() const throw();
+    private:
+	runtime_error();
+    };
+}
+
+namespace sgpem {
+
+    class Policy {
+    public:
+	virtual ~Policy() = 0;
+	sgpem::PolicyParameters& get_parameters();
+    };
+
+    // --------------------------------------------
+    class PolicyParametersException : public std::runtime_error {
+    public:
+	PolicyParametersException(char* msg);
+	%rename (__str__) what;
+	virtual const char* 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(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(name, lower_bound, upper_bound,
+					 required, default_value); 
+		}
+	    
+	    void register_string(const char* name, 
+				 const bool& required, 
+				 const char* default_value = "")
+		{ 
+		    self->register_string(name, required, 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(name, value); }
+	    bool set_float(const char* name, const float& value)
+		{ return self->set_float(name, value); }
+	    bool set_string(const char* name, const char* value)
+		{ return self->set_string(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(name); }
+	    float get_float(const char* name) const 
+		{ return self->get_float(name); }
+	    const char* get_string(const char* name) const
+		{ return self->get_string(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 Schedulable::get_name() const;
+	%extend {
+	    const char* get_name() const 
+	      { return self->get_name().c_str(); }
+	}
+    }; //~ class Schedulable
+
+
+    // --------------------------------------------
+    class SchedulableQueue 
+    {
+    public:
+	unsigned int size() const;
+	const sgpem::SchedulableStatus* get_item_at(const unsigned int&) const;
+	void swap(unsigned int positionA, unsigned int positionB) throw();
+	
+    private:
+	// Avoid instantiation and copy
+	SchedulableQueue();
+	SchedulableQueue(const SchedulableQueue&);
+	SchedulableQueue& operator=(const SchedulableQueue&);
+	~SchedulableQueue();
+    }; //~ class Schedulable
+
+    // ---------------------------------------------
+    class SchedulableStatus
+    {
+    public:
+	enum state
+	{
+	    state_running    = 1<<0,
+	    state_ready      = 1<<1,
+	    state_blocked    = 1<<2,
+	    state_future     = 1<<3,
+	    state_terminated = 1<<4
+	};
+	
+	SchedulableStatus(const SchedulableStatus& obj);
+
+	int         get_cpu_time_left() const;
+	int         get_last_scheduled() const;
+	state       get_state() const;
+	const       sgpem::Schedulable* get_schedulable() const;
+    };
+
+    // ---------------------------------------------
+    class Scheduler {
+    public:
+        sgpem::Policy&             get_policy();
+	static sgpem::Scheduler&   get_instance();
+	sgpem::SchedulableQueue*    get_ready_queue();
+    private:
+	Scheduler();
+	~Scheduler();
+    };
+
+} //~ namespace sgpem