--- /dev/null
+/*
+ * APIInternalFailureException.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Thu Nov 20 15:15:42 2003
+ * Projet : Salome 2
+ *
+ */
+
+#include "Batch_APIInternalFailureException.hxx"
+
+namespace Batch {
+
+}
--- /dev/null
+/*
+ * APIInternalFailureException.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Thu Nov 20 15:15:41 2003
+ * Projet : Salome 2
+ *
+ */
+
+#ifndef _APIINTERNALFAILUREEXCEPTION_H_
+#define _APIINTERNALFAILUREEXCEPTION_H_
+
+
+#include "Batch_GenericException.hxx"
+#include "Batch_GenericException.hxx"
+
+namespace Batch {
+
+ class APIInternalFailureException : public GenericException
+ {
+ public:
+ // Constructeur
+ APIInternalFailureException(string ch = "undefined") : GenericException("APIInternalFailureException", ch) {}
+ };
+
+}
+
+#endif
--- /dev/null
+/*
+ * BatchManager.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <netdb.h>
+//#include "MEDMEM_STRING.hxx"
+#include "Batch_Job.hxx"
+#include "Batch_JobId.hxx"
+#include "Batch_JobInfo.hxx"
+#include "Batch_InvalidArgumentException.hxx"
+#include "Batch_FactBatchManager.hxx"
+#include "Batch_BatchManager.hxx"
+
+namespace Batch {
+
+ // Constructeur
+// BatchManager::BatchManager(string host) throw(InvalidArgumentException) : _hostname(host), jobid_map()
+// {
+// // On verifie que le hostname est correct
+// if (!gethostbyname(_hostname.c_str())) { // hostname unknown from network
+// string msg = "hostname \"";
+// msg += _hostname;
+// msg += "\" unknown from the network";
+// throw InvalidArgumentException(msg.c_str());
+// }
+// }
+ BatchManager::BatchManager(const FactBatchManager * parent, const char * host) throw(InvalidArgumentException) : _hostname(host), jobid_map(), _parent(parent)
+ {
+ // On verifie que le hostname est correct
+ if (!gethostbyname(_hostname.c_str())) { // hostname unknown from network
+ string msg = "hostname \"";
+ msg += _hostname;
+ msg += "\" unknown from the network";
+ throw InvalidArgumentException(msg.c_str());
+ }
+ }
+
+ // Destructeur
+ BatchManager::~BatchManager()
+ {
+ // Nothing to do
+ }
+
+ string BatchManager::__repr__() const
+ {
+ ostringstream oss;
+ oss << "<BatchManager of type '" << (_parent ? _parent->getType() : "unknown (no factory)") << "' connected to server '" << _hostname << "'>";
+ return oss.str();
+ }
+
+ // Recupere le l'identifiant d'un job deja soumis au BatchManager
+// const JobId BatchManager::getJobIdByReference(const string & ref)
+// {
+// return JobId(this, ref);
+// }
+ const JobId BatchManager::getJobIdByReference(const char * ref)
+ {
+ return JobId(this, ref);
+ }
+
+// // Methode pour le controle des jobs : soumet un job au gestionnaire
+// const JobId BatchManager::submitJob(const Job & job)
+// {
+// static int idx = 0;
+// //MEDMEM::STRING sst;
+// ostringstream sst;
+// sst << "Jobid_" << idx++;
+// JobId id(this, sst.str());
+// return id;
+// }
+
+// // Methode pour le controle des jobs : retire un job du gestionnaire
+// void BatchManager::deleteJob(const JobId & jobid)
+// {
+// // Nothing to do
+// }
+
+// // Methode pour le controle des jobs : suspend un job en file d'attente
+// void BatchManager::holdJob(const JobId & jobid)
+// {
+// // Nothing to do
+// }
+
+// // Methode pour le controle des jobs : relache un job suspendu
+// void BatchManager::releaseJob(const JobId & jobid)
+// {
+// // Nothing to do
+// }
+
+// // Methode pour le controle des jobs : modifie un job en file d'attente
+// void BatchManager::alterJob(const JobId & jobid, const Parametre & param, const Environnement & env)
+// {
+// // Nothing to do
+// }
+
+// // Methode pour le controle des jobs : modifie un job en file d'attente
+// void BatchManager::alterJob(const JobId & jobid, const Parametre & param)
+// {
+// // Nothing to do
+// }
+
+// // Methode pour le controle des jobs : modifie un job en file d'attente
+// void BatchManager::alterJob(const JobId & jobid, const Environnement & env)
+// {
+// // Nothing to do
+// }
+
+// // Methode pour le controle des jobs : renvoie l'etat du job
+// JobInfo BatchManager::queryJob(const JobId & jobid)
+// {
+// return JobInfo();
+// }
+
+}
--- /dev/null
+/*
+ * BatchManager.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#ifndef _BATCHMANAGER_H_
+#define _BATCHMANAGER_H_
+
+using namespace std;
+#include <string>
+#include <map>
+#include "Batch_Job.hxx"
+#include "Batch_JobId.hxx"
+#include "Batch_JobInfo.hxx"
+#include "Batch_InvalidArgumentException.hxx"
+
+namespace Batch {
+
+ class Job;
+ class JobId;
+ class JobInfo;
+ class FactBatchManager;
+
+ class BatchManager
+ {
+ public:
+ // Constructeur et destructeur
+ //BatchManager(string host="localhost") throw(InvalidArgumentException); // connexion a la machine host
+ BatchManager(const FactBatchManager * parent, const char * host="localhost") throw(InvalidArgumentException); // connexion a la machine host
+ virtual ~BatchManager();
+ virtual string __repr__() const;
+
+ // Recupere le l'identifiant d'un job deja soumis au BatchManager
+ //virtual const JobId getJobIdByReference(const string & ref);
+ virtual const JobId getJobIdByReference(const char * ref);
+
+ // Methodes pour le controle des jobs : virtuelles pures
+ virtual const JobId submitJob(const Job & job) = 0; // soumet un job au gestionnaire
+ virtual void deleteJob(const JobId & jobid) = 0; // retire un job du gestionnaire
+ virtual void holdJob(const JobId & jobid) = 0; // suspend un job en file d'attente
+ virtual void releaseJob(const JobId & jobid) = 0; // relache un job suspendu
+ virtual void alterJob(const JobId & jobid, const Parametre & param, const Environnement & env) = 0; // modifie un job en file d'attente
+ virtual void alterJob(const JobId & jobid, const Parametre & param) = 0; // modifie un job en file d'attente
+ virtual void alterJob(const JobId & jobid, const Environnement & env) = 0; // modifie un job en file d'attente
+ virtual JobInfo queryJob(const JobId & jobid) = 0; // renvoie l'etat du job
+
+ protected:
+ string _hostname; // serveur ou tourne le BatchManager
+ map< const string, const JobId * > jobid_map; // table des jobs deja soumis
+ const FactBatchManager * _parent;
+
+ private:
+
+ };
+
+}
+
+#endif
--- /dev/null
+/*
+ * BatchManagerCatalog.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2004
+ * Projet : SALOME 2
+ *
+ */
+
+#include <string>
+#include <sstream>
+#include <map>
+#include "Batch_BatchManagerCatalog.hxx"
+#include "Batch_FactBatchManager.hxx"
+
+namespace Batch {
+
+ pthread_mutex_t BatchManagerCatalog::_mutex = PTHREAD_MUTEX_INITIALIZER;
+ map<string, FactBatchManager *> * BatchManagerCatalog::_p_catalog = 0;
+
+ // Constructeur
+ BatchManagerCatalog::BatchManagerCatalog()
+ {
+ // Nothing to do
+ }
+
+ // Destructeur
+ BatchManagerCatalog::~BatchManagerCatalog()
+ {
+ // Nothing to do
+ }
+
+ // Functor
+ FactBatchManager * BatchManagerCatalog::getFactBatchManager(const char * type)
+ {
+ return (* BatchManagerCatalog::_p_catalog)[type];
+ }
+
+ void BatchManagerCatalog::addFactBatchManager(const char * type, FactBatchManager * pFBM)
+ {
+ if (pFBM) { // *** section critique ***
+ pthread_mutex_lock(&_mutex);
+
+ if (! BatchManagerCatalog::_p_catalog) BatchManagerCatalog::_p_catalog = new map<string, FactBatchManager *>;
+ (*BatchManagerCatalog::_p_catalog)[type] = pFBM;
+
+ pthread_mutex_unlock(&_mutex);
+ }
+ }
+
+ FactBatchManager * BatchManagerCatalog::operator() (const char * type) const
+ {
+ return BatchManagerCatalog::getFactBatchManager(type);
+ }
+
+ map<string, FactBatchManager *> * BatchManagerCatalog::dict() const
+ {
+ return _p_catalog;
+ }
+
+ string BatchManagerCatalog::__repr__() const
+ {
+ ostringstream oss;
+ oss << "<BatchManagerCatalog contains {";
+ string sep;
+ for(map<string, FactBatchManager *>::const_iterator it = (*_p_catalog).begin(); it != (*_p_catalog).end(); it++, sep=", ") {
+ oss << sep << "'" << (*it).first << "' : '" << (*it).second->__repr__() << "'";
+ }
+ oss << "}>";
+ return oss.str();
+ }
+
+}
--- /dev/null
+/*
+ * BatchManagerCatalog.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2004
+ * Projet : SALOME 2
+ *
+ */
+
+#ifndef _CATALOG_H_
+#define _CATALOG_H_
+
+using namespace std;
+#include <string>
+#include <map>
+#include <pthread.h>
+
+namespace Batch {
+
+ class FactBatchManager;
+
+ class BatchManagerCatalog
+ {
+ public:
+ // Constructeur
+ BatchManagerCatalog();
+ // Destructeur
+ virtual ~BatchManagerCatalog();
+
+ static FactBatchManager * getFactBatchManager(const char * type);
+ static void addFactBatchManager(const char * type, FactBatchManager * pFBM);
+ virtual FactBatchManager * operator() (const char * type) const;
+
+ virtual map<string, FactBatchManager *> * dict() const;
+ virtual string __repr__() const;
+
+ protected:
+ static map<string, FactBatchManager *> * _p_catalog;
+ static pthread_mutex_t _mutex;
+
+ private:
+
+ };
+
+}
+
+#endif
--- /dev/null
+/*
+ * BatchManager_PBS.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Thu Nov 6 10:17:22 2003
+ * Projet : Salome 2
+ *
+ */
+
+extern "C" {
+#include <pbs_error.h>
+#include <pbs_ifl.h>
+}
+#include <iostream>
+#include <fstream>
+#include <sstream>
+//#include "MEDMEM_STRING.hxx"
+#include "Batch_BatchManager_PBS.hxx"
+
+namespace Batch {
+
+ // Recupere le nom du serveur par defaut
+// string BatchManager_PBS::getDefaultServer() {
+// string server_name = "localhost";
+
+// const char * server_name_path = "@openpbsspooldir@/server_name";
+// ifstream server_name_file(server_name_path);
+// if (server_name_file) {
+// server_name_file >> server_name;
+// server_name_file.close();
+// }
+
+// return server_name;
+// }
+
+ // Constructeur
+// BatchManager_PBS::BatchManager_PBS() throw(InvalidArgumentException,ConnexionFailureException) : BatchManager(BatchManager_PBS::getDefaultServer())
+// {
+// // On se connecte au serveur PBS
+// _connect = pbs_connect(const_cast< char * >(_hostname.c_str()));
+// if (_connect < 0) { // si erreur
+// char * errmsg = pbs_geterrmsg(_connect);
+// string msg = "PBS Server on host \"";
+// msg += _hostname;
+// msg += "\" : ";
+// msg += errmsg ? errmsg : "Reason unknown";
+// throw ConnexionFailureException(msg.c_str());
+// }
+// }
+
+ // Constructeur
+// BatchManager_PBS::BatchManager_PBS(string host) throw(InvalidArgumentException,ConnexionFailureException) : BatchManager(host)
+// {
+// // On se connecte au serveur PBS
+// _connect = pbs_connect(const_cast< char * >(_hostname.c_str()));
+// if (_connect < 0) { // si erreur
+// char * errmsg = pbs_geterrmsg(_connect);
+// string msg = "PBS Server on host \"";
+// msg += _hostname;
+// msg += "\" : ";
+// msg += errmsg ? errmsg : "Reason unknown";
+// throw ConnexionFailureException(msg.c_str());
+// }
+// }
+ BatchManager_PBS::BatchManager_PBS(const FactBatchManager * parent, const char * host) throw(InvalidArgumentException,ConnexionFailureException) : BatchManager(parent, host)
+ {
+ // On se connecte au serveur PBS
+ _connect = pbs_connect(const_cast< char * >(_hostname.c_str()));
+ if (_connect < 0) { // si erreur
+ char * errmsg = pbs_geterrmsg(_connect);
+ string msg = "PBS Server on host \"";
+ msg += _hostname;
+ msg += "\" : ";
+ msg += errmsg ? errmsg : "Reason unknown";
+ throw ConnexionFailureException(msg.c_str());
+ }
+ }
+
+ // Destructeur
+ BatchManager_PBS::~BatchManager_PBS()
+ {
+ // On se deconnecte du serveur PBS
+ int rc = pbs_disconnect(_connect);
+ if (rc < 0) { // si erreur
+ string msg = "PBS Server on host \"";
+ msg += _hostname;
+ msg += "\" : ";
+ msg += pbs_geterrmsg(_connect);
+ throw ConnexionFailureException(msg.c_str());
+ }
+ }
+
+ // Methode pour le controle des jobs : soumet un job au gestionnaire
+ const JobId BatchManager_PBS::submitJob(const Job & job)
+ {
+ Job_PBS jobpbs = job;
+ char * ref = pbs_submit(_connect,
+ jobpbs.getAttributesOP(),
+ jobpbs.getScript(),
+ jobpbs.getDestination(),
+ NULL);
+ if (!ref) { // si erreur
+ char * msg = pbs_geterrmsg(_connect);
+ if (!msg) msg = "unknown";
+ throw APIInternalFailureException(string("PBS submit error. Reason : ") + msg);
+ }
+
+ JobId id(this, string(ref));
+ free(ref);
+ return id;
+ }
+
+ // Methode pour le controle des jobs : retire un job du gestionnaire
+ void BatchManager_PBS::deleteJob(const JobId & jobid)
+ {
+ char * ref = const_cast< char * >(jobid.getReference().c_str());
+ int rc = pbs_deljob(_connect, ref, 0);
+ if (rc) { // si erreur
+ char * msg = pbs_geterrmsg(_connect);
+ if (!msg) msg = "unknown";
+ throw APIInternalFailureException(string("PBS deljob error. Reason : ") + msg);
+ }
+ }
+
+ // Methode pour le controle des jobs : suspend un job en file d'attente
+ void BatchManager_PBS::holdJob(const JobId & jobid)
+ {
+ char * ref = const_cast< char * >(jobid.getReference().c_str());
+ int rc = pbs_holdjob(_connect, ref, USER_HOLD, 0);
+ if (rc) { // si erreur
+ char * msg = pbs_geterrmsg(_connect);
+ if (!msg) msg = "unknown";
+ throw APIInternalFailureException(string("PBS holdjob error. Reason : ") + msg);
+ }
+ }
+
+ // Methode pour le controle des jobs : relache un job suspendu
+ void BatchManager_PBS::releaseJob(const JobId & jobid)
+ {
+ char * ref = const_cast< char * >(jobid.getReference().c_str());
+ int rc = pbs_rlsjob(_connect, ref, USER_HOLD, 0);
+ if (rc) { // si erreur
+ char * msg = pbs_geterrmsg(_connect);
+ if (!msg) msg = "unknown";
+ throw APIInternalFailureException(string("PBS rlsjob error. Reason : ") + msg);
+ }
+ }
+
+
+ // Methode pour le controle des jobs : modifie un job en file d'attente
+ void BatchManager_PBS::alterJob(const JobId & jobid, const Parametre & param, const Environnement & env)
+ {
+ Job job(param, env);
+ Job_PBS jobpbs(job);
+
+ char * ref = const_cast< char * >(jobid.getReference().c_str());
+ int rc = pbs_alterjob(_connect,
+ ref,
+ jobpbs.getAttributes(),
+ NULL);
+ if (rc) { // si erreur
+ char * msg = pbs_geterrmsg(_connect);
+ if (!msg) msg = "unknown";
+ throw APIInternalFailureException(string("PBS alterjob error. Reason : ") + msg);
+ }
+
+ }
+
+ // Methode pour le controle des jobs : modifie un job en file d'attente
+ void BatchManager_PBS::alterJob(const JobId & jobid, const Parametre & param)
+ {
+ alterJob(jobid, param, Environnement());
+ }
+
+ // Methode pour le controle des jobs : modifie un job en file d'attente
+ void BatchManager_PBS::alterJob(const JobId & jobid, const Environnement & env)
+ {
+ alterJob(jobid, Parametre(), env);
+ }
+
+
+
+ // Methode pour le controle des jobs : renvoie l'etat du job
+ JobInfo BatchManager_PBS::queryJob(const JobId & jobid)
+ {
+ char * id = const_cast< char * >(jobid.getReference().c_str());
+ JobInfo_PBS ji = JobInfo_PBS(pbs_statjob(_connect, id, 0, 0), true);
+ return ji;
+ }
+
+
+
+}
--- /dev/null
+/*
+ * BatchManager_PBS.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Thu Nov 6 10:17:22 2003
+ * Projet : Salome 2
+ *
+ */
+
+#ifndef _BATCHMANAGER_PBS_H_
+#define _BATCHMANAGER_PBS_H_
+
+
+#include "Batch_Job.hxx"
+#include "Batch_Job.hxx"
+#include "Batch_JobId.hxx"
+#include "Batch_JobInfo.hxx"
+#include "Batch_JobInfo_PBS.hxx"
+#include "Batch_Job_PBS.hxx"
+#include "Batch_InvalidArgumentException.hxx"
+#include "Batch_ConnexionFailureException.hxx"
+#include "Batch_APIInternalFailureException.hxx"
+#include "Batch_NotYetImplementedException.hxx"
+#include "Batch_BatchManager.hxx"
+
+namespace Batch {
+
+ class Job;
+ class JobId;
+ class JobInfo;
+ class FactBatchManager;
+
+ class BatchManager_PBS : public BatchManager
+ {
+ public:
+ // Constructeur et destructeur
+ //BatchManager_PBS() throw(InvalidArgumentException,ConnexionFailureException); // connexion au serveur par defaut
+ //BatchManager_PBS(string host) throw(InvalidArgumentException,ConnexionFailureException); // connexion a la machine host
+ BatchManager_PBS(const FactBatchManager * parent, const char * host="localhost") throw(InvalidArgumentException,ConnexionFailureException); // connexion a la machine host
+ virtual ~BatchManager_PBS();
+
+ // Recupere le nom du serveur par defaut
+ // static string BatchManager_PBS::getDefaultServer();
+
+ // Methodes pour le controle des jobs
+ virtual const JobId submitJob(const Job & job); // soumet un job au gestionnaire
+ virtual void deleteJob(const JobId & jobid); // retire un job du gestionnaire
+ virtual void holdJob(const JobId & jobid); // suspend un job en file d'attente
+ virtual void releaseJob(const JobId & jobid); // relache un job suspendu
+ virtual void alterJob(const JobId & jobid, const Parametre & param, const Environnement & env); // modifie un job en file d'attente
+ virtual void alterJob(const JobId & jobid, const Parametre & param); // modifie un job en file d'attente
+ virtual void alterJob(const JobId & jobid, const Environnement & env); // modifie un job en file d'attente
+ virtual JobInfo queryJob(const JobId & jobid); // renvoie l'etat du job
+
+ virtual void setParametre(const JobId & jobid, const Parametre & param) { return alterJob(jobid, param); } // modifie un job en file d'attente
+ virtual void setEnvironnement(const JobId & jobid, const Environnement & env) { return alterJob(jobid, env); } // modifie un job en file d'attente
+
+
+ protected:
+ int _connect; // PBS connect id
+
+ private:
+
+#ifdef SWIG
+ public:
+ // Recupere le l'identifiant d'un job deja soumis au BatchManager
+ //virtual const JobId getJobIdByReference(const string & ref) { return BatchManager::getJobIdByReference(ref); }
+ virtual const JobId getJobIdByReference(const char * ref) { return BatchManager::getJobIdByReference(ref); }
+#endif
+
+ };
+
+}
+
+#endif
--- /dev/null
+/*
+ * BoolType.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#include <string>
+#include "Batch_BoolType.hxx"
+
+namespace Batch {
+
+ // Conversion en chaine
+ string BoolType::affiche() const
+ {
+ return _data ? string("true") : string("false");
+ }
+
+ // Operateur d'affectation
+ BoolType & BoolType::operator =(bool b)
+ {
+ _data = b;
+ return *this;
+ }
+
+ // Conversion en bool
+ BoolType::operator bool() const
+ {
+ return this->_data;
+ }
+
+ // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
+ // qu'il faudra detruire ensuite manuellement
+ GenericType * BoolType::clone() const
+ {
+ BoolType * pB = new BoolType(this->_data);
+ assert(pB != 0);
+ return pB;
+ }
+
+}
--- /dev/null
+/*
+ * BoolType.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#ifndef _BOOLTYPE_H_
+#define _BOOLTYPE_H_
+
+using namespace std;
+#include <string>
+#include "Batch_GenericType.hxx"
+
+namespace Batch {
+
+ class BoolType : public GenericType
+ {
+ public:
+ // Constructeur
+ BoolType(const bool b=false) : _data(b) {}
+
+ // Conversion en chaine
+ virtual string affiche() const;
+
+ // Operateur d'affectation
+ virtual BoolType & operator =(bool);
+
+ // Conversion en bool
+ virtual operator bool() const;
+
+ // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
+ // qu'il faudra detruire ensuite manuellement
+ virtual GenericType * clone() const;
+
+ protected:
+ bool _data;
+
+ private:
+
+ };
+
+}
+
+#endif
--- /dev/null
+/*
+ * CharType.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#include <string>
+#include "Batch_CharType.hxx"
+
+namespace Batch {
+
+ // Conversion en chaine
+ string CharType::affiche() const
+ {
+ return string(1, _data);
+ }
+
+ // Operateur d'affectation
+ CharType & CharType::operator =(char c)
+ {
+ _data = c;
+ return *this;
+ }
+
+ // Conversion en char
+ CharType::operator char() const
+ {
+ return this->_data;
+ }
+
+ // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
+ // qu'il faudra detruire ensuite manuellement
+ GenericType * CharType::clone() const
+ {
+ CharType * pC = new CharType(this->_data);
+ assert(pC != 0);
+ return pC;
+ }
+
+}
--- /dev/null
+/*
+ * CharType.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#ifndef _CHARTYPE_H_
+#define _CHARTYPE_H_
+
+using namespace std;
+#include <string>
+#include "Batch_GenericType.hxx"
+
+namespace Batch {
+
+ class CharType : public GenericType
+ {
+ public:
+ // Constructeur
+ CharType(const char c=0) : _data(c) {}
+
+ // Conversion en chaine
+ virtual string affiche() const;
+
+ // Operateur d'affectation
+ virtual CharType & operator =(char);
+
+ // Conversion en char
+ virtual operator char() const;
+
+ // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
+ // qu'il faudra detruire ensuite manuellement
+ virtual GenericType * clone() const;
+
+ protected:
+ char _data;
+
+ private:
+
+ };
+
+}
+
+#endif
+
--- /dev/null
+/*
+ * ConnexionFailureException.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Thu Nov 13 11:24:31 2003
+ * Projet : Salome 2
+ *
+ */
+
+#include "Batch_ConnexionFailureException.hxx"
+
+namespace Batch {
+
+}
--- /dev/null
+/*
+ * ConnexionFailureException.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Thu Nov 13 11:24:31 2003
+ * Projet : Salome 2
+ *
+ */
+
+#ifndef _CONNEXIONFAILUREEXCEPTION_H_
+#define _CONNEXIONFAILUREEXCEPTION_H_
+
+
+#include "Batch_GenericException.hxx"
+
+namespace Batch {
+
+ class ConnexionFailureException : public GenericException
+ {
+ public:
+ // Constructeur
+ ConnexionFailureException(string ch = "undefined") : GenericException("ConnexionFailureException", ch) {}
+
+ };
+
+}
+
+#endif
+
--- /dev/null
+/*
+ * Couple.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Tue Dec 9 15:00:35 2003
+ * Projet : Salome 2
+ *
+ */
+
+#include "Batch_Couple.hxx"
+
+namespace Batch {
+
+ // Operateur d'affectation
+ Couple & Couple::operator =(const Couple & C)
+ {
+ _local = C._local;
+ _remote = C._remote;
+ return *this;
+ }
+
+ // Conversion en chaine
+ string Couple::str() const
+ {
+ string res;
+ res = "Couple(local : ";
+ res += _local;
+ res += ", remote : ";
+ res += _remote;
+ res += ")";
+ return res;
+ }
+
+ // Operateur pour l'affichage sur un stream
+ ostream & operator << (ostream & os, const Couple & cp)
+ {
+ return os << cp.str();
+ }
+
+}
--- /dev/null
+/*
+ * Couple.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Tue Dec 9 15:00:35 2003
+ * Projet : Salome 2
+ *
+ */
+
+#ifndef _COUPLE_H_
+#define _COUPLE_H_
+
+using namespace std;
+#include <string>
+
+namespace Batch {
+
+ class Couple
+ {
+ public:
+ // Constructeur standard
+ Couple(const string & local="", const string & remote="") : _local(local), _remote(remote) {}
+
+ // Constructeur par recopie
+ Couple(const Couple & C) : _local(C._local), _remote(C._remote) {}
+
+ // Operateur pour l'affichage sur un stream
+ friend ostream & operator << (ostream & os, const Couple & cp);
+
+ // Operateur d'affectation
+ virtual Couple & operator =(const Couple &);
+
+ // Conversion en chaine
+ virtual string str() const;
+
+ // Accesseurs
+ virtual string getLocal() const { return _local; }
+ virtual string getRemote() const { return _remote; }
+
+ protected:
+ string _local; // chemin d'acces au fichier local
+ string _remote; // chemin d'acees au fichier distant
+
+ private:
+
+ };
+
+}
+
+#endif
+
--- /dev/null
+/*
+ * CoupleType.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Tue Dec 9 14:51:53 2003
+ * Projet : Salome 2
+ *
+ */
+
+#include "Batch_CoupleType.hxx"
+
+namespace Batch {
+
+ // Conversion en chaine
+ string CoupleType::affiche() const
+ {
+ return _data.str();
+ }
+
+ // Operateur d'affectation
+ CoupleType & CoupleType::operator =(const Couple & C)
+ {
+ _data = C;
+ return *this;
+ }
+
+ // Conversion en char
+ CoupleType::operator Couple() const
+ {
+ return _data;
+ }
+
+ // Conversion en chaine
+ CoupleType::operator string() const
+ {
+ return _data.str();
+ }
+
+ // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
+ // qu'il faudra detruire ensuite manuellement
+ GenericType * CoupleType::clone() const
+ {
+ CoupleType * pC = new CoupleType(this->_data);
+ assert(pC != 0);
+ return pC;
+ }
+
+}
+
--- /dev/null
+/*
+ * CoupleType.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Tue Dec 9 14:51:53 2003
+ * Projet : Salome 2
+ *
+ */
+
+#ifndef _COUPLETYPE_H_
+#define _COUPLETYPE_H_
+
+using namespace std;
+#include <string>
+#include "Batch_GenericType.hxx"
+#include "Batch_Couple.hxx"
+
+namespace Batch {
+
+ class CoupleType : public GenericType
+ {
+ public:
+ // Constructeur
+ CoupleType(const Couple & C) : _data(C) {}
+
+ // Conversion en chaine
+ virtual string affiche() const;
+ virtual operator string() const;
+
+ // Operateur d'affectation
+ virtual CoupleType & operator =(const Couple & C);
+
+ // Conversion en char
+ virtual operator Couple() const;
+
+ // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
+ // qu'il faudra detruire ensuite manuellement
+ virtual GenericType * clone() const;
+
+ protected:
+ Couple _data;
+
+ private:
+
+ };
+
+}
+
+#endif
--- /dev/null
+/*
+ * Date.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Wed Nov 26 14:11:42 2003
+ * Projet : Salome 2
+ *
+ */
+
+#include <cstdio>
+#include <ctime>
+#include "Batch_Date.hxx"
+
+namespace Batch {
+
+ Date::Date(const long l)
+ {
+ struct tm * p_tm = localtime(&l);
+ _day = p_tm->tm_mday;
+ _month = p_tm->tm_mon + 1;
+ _year = p_tm->tm_year + 1900;
+ _hour = p_tm->tm_hour;
+ _min = p_tm->tm_min;
+ _sec = p_tm->tm_sec;
+ }
+
+ Date::Date(const string s)
+ {
+ if ((s == "now") || (s == "Now") || (s == "NOW")) {
+ long l = time(0);
+ struct tm * p_tm = localtime(&l);
+ _day = p_tm->tm_mday;
+ _month = p_tm->tm_mon + 1;
+ _year = p_tm->tm_year + 1900;
+ _hour = p_tm->tm_hour;
+ _min = p_tm->tm_min;
+ _sec = p_tm->tm_sec;
+
+ } else {
+ char c;
+// istringstream ist(s);
+// ist >> _day >> c
+// >> _month >> c
+// >> _year >> c
+// >> _hour >> c
+// >> _min >> c
+// >> _sec;
+ sscanf(s.c_str(), "%ld/%ld/%ld-%ld:%ld:%ld", &_day, &_month, &_year, &_hour, &_min, &_sec);
+ }
+ }
+
+ Date & Date::operator =(long l)
+ {
+ struct tm * p_tm = localtime(&l);
+ _day = p_tm->tm_mday;
+ _month = p_tm->tm_mon + 1;
+ _year = p_tm->tm_year + 1900;
+ _hour = p_tm->tm_hour;
+ _min = p_tm->tm_min;
+ _sec = p_tm->tm_sec;
+
+ return *this;
+ }
+
+ Date & Date::operator +(long l)
+ {
+ *this = epoch() + l;
+ return *this;
+ }
+
+ Date & Date::operator -(long l)
+ {
+ *this = epoch() - l;
+ return *this;
+ }
+
+ Date & Date::operator +=(long l)
+ {
+ *this = epoch() + l;
+ return *this;
+ }
+
+ Date & Date::operator -=(long l)
+ {
+ *this = epoch() - l;
+ return *this;
+ }
+
+ Date & Date::operator =(const string & s)
+ {
+ if ((s == "now") || (s == "Now") || (s == "NOW")) {
+ long l = time(0);
+ struct tm * p_tm = localtime(&l);
+ _day = p_tm->tm_mday;
+ _month = p_tm->tm_mon + 1;
+ _year = p_tm->tm_year + 1900;
+ _hour = p_tm->tm_hour;
+ _min = p_tm->tm_min;
+ _sec = p_tm->tm_sec;
+
+ } else {
+ char c;
+// istringstream ist(s);
+// ist >> _day >> c
+// >> _month >> c
+// >> _year >> c
+// >> _hour >> c
+// >> _min >> c
+// >> _sec;
+ sscanf(s.c_str(), "%ld/%ld/%ld-%ld:%ld:%ld", &_day, &_month, &_year, &_hour, &_min, &_sec);
+ }
+
+ return *this;
+ }
+
+ string Date::str() const
+ {
+ char buf[64];
+ string datestr;
+
+ // _day to char *
+ sprintf(buf, "%02ld", _day);
+ datestr += buf;
+ datestr += "/";
+
+ // _month to char *
+ sprintf(buf, "%02ld", _month);
+ datestr += buf;
+ datestr += "/";
+
+ // _year to char *
+ sprintf(buf, "%04ld", _year);
+ datestr += buf;
+ datestr += "-";
+
+ // _hour to char *
+ sprintf(buf, "%02ld", _hour);
+ datestr += buf;
+ datestr += ":";
+
+ // _min to char *
+ sprintf(buf, "%02ld", _min);
+ datestr += buf;
+ datestr += ":";
+
+ // _sec to char *
+ sprintf(buf, "%02ld", _sec);
+ datestr += buf;
+
+ return datestr;
+ }
+
+ long Date::epoch() const
+ {
+ struct tm T;
+ T.tm_mday = _day;
+ T.tm_mon = _month - 1;
+ T.tm_year = _year - 1900;
+ T.tm_hour = _hour;
+ T.tm_min = _min;
+ T.tm_sec = _sec;
+ return mktime(&T);
+ }
+
+}
+
+
+// COMMENTS
--- /dev/null
+/*
+ * Date.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Wed Nov 26 14:11:42 2003
+ * Projet : Salome 2
+ *
+ */
+
+#ifndef _DATE_H_
+#define _DATE_H_
+
+using namespace std;
+#include <string>
+
+namespace Batch {
+
+ class Date
+ {
+ public:
+ Date(const long l=0);
+ Date(const string s);
+ virtual Date & operator =(long l);
+ virtual Date & operator +(long l);
+ virtual Date & operator -(long l);
+ virtual Date & operator +=(long l);
+ virtual Date & operator -=(long l);
+ virtual Date & operator =(const string & s);
+ virtual string str() const;
+ virtual long epoch() const;
+
+ protected:
+ int _day, _month, _year;
+ int _hour, _min, _sec;
+
+ private:
+
+ };
+
+}
+
+#endif
+
+// COMMENTS
--- /dev/null
+/*
+ * DateType.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Wed Nov 26 11:15:34 2003
+ * Projet : Salome 2
+ *
+ */
+extern "C" {
+#include <time.h>
+}
+#include "Batch_DateType.hxx"
+
+namespace Batch {
+
+ // Conversion en chaine
+ string DateType::affiche() const
+ {
+ return _data.str();
+ }
+
+ // Operateur d'affectation
+ DateType & DateType::operator =(const Date & d)
+ {
+ _data = d;
+ return *this;
+ }
+
+ // Conversion en Date
+ DateType::operator Date() const
+ {
+ return _data;
+ }
+
+ // Conversion en long
+ DateType::operator long() const
+ {
+ return _data.epoch();
+ }
+
+ // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
+ // qu'il faudra detruire ensuite manuellement
+ GenericType * DateType::clone() const
+ {
+ DateType * pD = new DateType(this->_data);
+ assert(pD != 0);
+ return pD;
+ }
+
+}
--- /dev/null
+/*
+ * DateType.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Wed Nov 26 11:15:34 2003
+ * Projet : Salome 2
+ *
+ */
+
+#ifndef _DATETYPE_H_
+#define _DATETYPE_H_
+
+using namespace std;
+#include <string>
+#include "Batch_GenericType.hxx"
+#include "Batch_Date.hxx"
+
+namespace Batch {
+
+ class DateType : public GenericType
+ {
+ public:
+ // Constructeur
+ DateType(const Date & d) : _data(d) {};
+
+ // Conversion en chaine
+ virtual string affiche() const;
+
+ // Operateur d'affectation
+ virtual DateType & operator =(const Date &);
+
+ // Conversion en Date
+ virtual operator Date() const;
+
+ // Conversion en long
+ virtual operator long() const;
+
+ // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
+ // qu'il faudra detruire ensuite manuellement
+ virtual GenericType * clone() const;
+
+ protected:
+ Date _data;
+
+ private:
+ };
+
+}
+
+#endif
+
--- /dev/null
+/*
+ * Environnement.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Thu Oct 16 11:37:47 2003
+ * Projet : Salome 2
+ *
+ */
+
+#include "Batch_Environnement.hxx"
+
+namespace Batch {
+
+
+}
--- /dev/null
+/*
+ * Environnement.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Thu Oct 16 11:37:47 2003
+ * Projet : Salome 2
+ *
+ */
+
+#ifndef _ENVIRONNEMENT_H_
+#define _ENVIRONNEMENT_H_
+
+
+using namespace std;
+#include <string>
+#include <map>
+
+namespace Batch {
+
+ typedef map < string, string > Environnement;
+
+}
+
+#endif
+
--- /dev/null
+/*
+ * FactBatchManager.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2004
+ * Projet : SALOME 2
+ *
+ */
+
+#include <string>
+#include <sstream>
+#include "Batch_BatchManagerCatalog.hxx"
+#include "Batch_FactBatchManager.hxx"
+#include "utilities.h"
+
+namespace Batch {
+
+ // Constructeur
+ FactBatchManager::FactBatchManager(const string & _t) : type(_t)
+ {
+ BatchManagerCatalog::addFactBatchManager(type.c_str(), this);
+ ostringstream msg;
+ msg << "FactBatchManager of type '" << type << "' inserted into catalog";
+ MESSAGE(msg.str().c_str());
+ }
+
+ // Destructeur
+ FactBatchManager::~FactBatchManager()
+ {
+ // Nothing to do
+ }
+
+ // Accesseur
+ string FactBatchManager::getType() const
+ {
+ return type;
+ }
+
+ string FactBatchManager::__repr__() const
+ {
+ ostringstream oss;
+ oss << "<FactBatchManager of type '" << type << "'>";
+ return oss.str();
+ }
+
+}
--- /dev/null
+/*
+ * FactBatchManager.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2004
+ * Projet : SALOME 2
+ *
+ */
+
+#ifndef _FACTBATCHMANAGER_H_
+#define _FACTBATCHMANAGER_H_
+
+using namespace std;
+#include <string>
+#include <map>
+
+namespace Batch {
+
+ class BatchManager;
+
+ class FactBatchManager
+ {
+ public:
+ // Constructeur et destructeur
+ FactBatchManager(const string & type);
+ virtual ~FactBatchManager();
+
+ virtual BatchManager * operator() (const char * hostname) const = 0;
+ string getType() const;
+ string __repr__() const;
+
+ protected:
+ string type;
+
+ private:
+
+ };
+
+}
+
+#endif
--- /dev/null
+/*
+ * FactBatchManager_PBS.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2004
+ * Projet : SALOME 2
+ *
+ */
+
+#include <string>
+#include "Batch_BatchManager_PBS.hxx"
+#include "Batch_FactBatchManager_PBS.hxx"
+#include "utilities.h"
+
+namespace Batch {
+
+ static FactBatchManager_PBS sFBM_PBS;
+
+ // Constructeur
+ FactBatchManager_PBS::FactBatchManager_PBS() : FactBatchManager("PBS")
+ {
+ // Nothing to do
+ }
+
+ // Destructeur
+ FactBatchManager_PBS::~FactBatchManager_PBS()
+ {
+ // Nothing to do
+ }
+
+ // Functor
+ BatchManager_PBS * FactBatchManager_PBS::operator() (const char * hostname) const
+ {
+ MESSAGE("Building new BatchManager_PBS on host '" << hostname << "'");
+ return new BatchManager_PBS(this, hostname);
+ }
+
+
+}
--- /dev/null
+/*
+ * FactBatchManager_PBS.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2004
+ * Projet : SALOME 2
+ *
+ */
+
+#ifndef _FACTBATCHMANAGER_PBS_H_
+#define _FACTBATCHMANAGER_PBS_H_
+
+using namespace std;
+#include <string>
+#include <map>
+#include "Batch_FactBatchManager.hxx"
+
+namespace Batch {
+
+ class BatchManager_PBS;
+
+ class FactBatchManager_PBS : public FactBatchManager
+ {
+ public:
+ // Constructeur et destructeur
+ FactBatchManager_PBS();
+ virtual ~FactBatchManager_PBS();
+
+ virtual BatchManager_PBS * operator() (const char * hostname) const;
+
+ protected:
+
+ private:
+
+ };
+
+}
+
+#endif
--- /dev/null
+/*
+ * GenericException.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Wed Nov 26 10:15:57 2003
+ * Projet : Salome 2
+ *
+ */
+
+#include "Batch_GenericException.hxx"
+
+namespace Batch {
+
+}
--- /dev/null
+/*
+ * GenericException.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Wed Nov 26 10:15:56 2003
+ * Projet : Salome 2
+ *
+ */
+
+#ifndef _GENERICEXCEPTION_H_
+#define _GENERICEXCEPTION_H_
+
+
+using namespace std;
+#include <string>
+
+namespace Batch {
+
+ class GenericException
+ {
+ public:
+ const string type; // la nature de l'exception
+ const string message; // la raison de l'exception
+
+ // Constructeur
+ GenericException(const string tp = "GenericException", const string ch = "undefined") : type(tp), message(ch) {}
+ };
+
+}
+
+#endif
--- /dev/null
+/*
+ * GenericType.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+
+#include <iostream>
+#include <string>
+#include "Batch_GenericType.hxx"
+
+namespace Batch {
+
+ // nombre total d'objet GenericType et al.
+ int GenericType::_nb = 0;
+
+ // Operateur pour l'affichage sur un stream
+ ostream & operator << (ostream & os, const GenericType & obj)
+ {
+ return os << obj.affiche();
+ }
+
+ // Conversion en chaine
+ string GenericType::affiche() const
+ {
+ return string("(GenericType : si ce message apparait, vous devez avoir un probleme)");
+ }
+
+ // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
+ // qu'il faudra detruire ensuite manuellement
+ GenericType * GenericType::clone() const
+ {
+ GenericType * pG = new GenericType;
+ assert(pG != 0);
+ return pG;
+ }
+
+}
+
--- /dev/null
+/*
+ * GenericType.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#ifndef _GENERICTYPE_H_
+#define _GENERICTYPE_H_
+
+
+using namespace std;
+#include <iostream>
+#include <string>
+
+namespace Batch {
+
+ class GenericType
+ {
+ public:
+ // Constructeur et destructeur
+ GenericType() { _nb++; }
+ virtual ~GenericType() { _nb--; }
+
+ // Operateur pour l'affichage sur un stream
+ friend ostream & operator << (ostream & os, const GenericType & obj);
+
+ // Conversion en chaine
+ virtual string affiche() const;
+
+ // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
+ // qu'il faudra detruire ensuite manuellement
+ virtual GenericType * clone() const;
+
+ // Retourne le nombre d'objets GenericType et al.
+ static int getNb() { return _nb; }
+
+ protected:
+
+ private:
+ static int _nb; // nombre total d'objets GenericType et al.
+
+ };
+
+}
+
+#endif
+
--- /dev/null
+/*
+ * IntType.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#include <string>
+#include <sstream>
+//#include "MEDMEM_STRING.hxx"
+#include "Batch_IntType.hxx"
+
+
+namespace Batch {
+
+ // Conversion en chaine
+ string IntType::affiche() const
+ {
+ //MEDMEM::STRING sst;
+ ostringstream sst;
+ sst << _data;
+ return sst.str();
+ }
+
+ // Operateur d'affectation
+ IntType & IntType::operator =(int i)
+ {
+ _data = i;
+ return *this;
+ }
+
+ // Conversion en int
+ IntType::operator int() const
+ {
+ return this->_data;
+ }
+
+ // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
+ // qu'il faudra detruire ensuite manuellement
+ GenericType * IntType::clone() const
+ {
+ IntType * pI = new IntType(this->_data);
+ assert(pI != 0);
+ return pI;
+ }
+
+}
--- /dev/null
+/*
+ * IntType.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#ifndef _INTTYPE_H_
+#define _INTTYPE_H_
+
+using namespace std;
+#include <string>
+#include "Batch_GenericType.hxx"
+
+namespace Batch {
+
+ class IntType : public GenericType
+ {
+ public:
+ // Constructeur
+ IntType(const int i=0) : _data(i) {}
+
+ // Conversion en chaine
+ virtual string affiche() const;
+
+ // Operateur d'affectation
+ virtual IntType & operator =(int);
+
+ // Conversion en int
+ virtual operator int() const;
+
+ // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
+ // qu'il faudra detruire ensuite manuellement
+ virtual GenericType * clone() const;
+
+ protected:
+ int _data;
+
+ private:
+
+ };
+
+}
+
+#endif
--- /dev/null
+/*
+ * InvalidArgumentException.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Thu Oct 16 16:18:00 2003
+ * Projet : Salome 2
+ *
+ */
+
+#include "Batch_InvalidArgumentException.hxx"
+
+namespace Batch {
+
+}
--- /dev/null
+/*
+ * InvalidArgumentException.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Thu Oct 16 16:18:00 2003
+ * Projet : Salome 2
+ *
+ */
+
+#ifndef _INVALIDARGUMENTEXCEPTION_H_
+#define _INVALIDARGUMENTEXCEPTION_H_
+
+
+#include "Batch_GenericException.hxx"
+#include "Batch_GenericException.hxx"
+
+namespace Batch {
+
+ class InvalidArgumentException : public GenericException
+ {
+ public:
+ // Constructeur
+ InvalidArgumentException(string ch = "undefined") : GenericException("InvalidArgumentException", ch) {}
+ };
+
+}
+
+#endif
+
--- /dev/null
+/*
+ * InvalidKeyException.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Wed Oct 15 10:39:51 2003
+ * Projet : Salome 2
+ *
+ */
+
+#include "Batch_InvalidKeyException.hxx"
+
+namespace Batch {
+
+}
+
--- /dev/null
+/*
+ * InvalidKeyException.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Wed Oct 15 10:39:51 2003
+ * Projet : Salome 2
+ *
+ */
+
+#ifndef _INVALIDKEYEXCEPTION_H_
+#define _INVALIDKEYEXCEPTION_H_
+
+
+#include "Batch_GenericException.hxx"
+#include "Batch_GenericException.hxx"
+
+namespace Batch {
+
+ class InvalidKeyException : public GenericException
+ {
+ public:
+ // Constructeur
+ InvalidKeyException(string ch = "undefined") : GenericException("InvalidKeyException", ch) {}
+
+ protected:
+
+ private:
+
+ };
+
+}
+
+#endif
+
--- /dev/null
+/*
+ * Job.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#include "Batch_Job.hxx"
+#include "Batch_Parametre.hxx"
+#include <sstream>
+//#include "MEDMEM_STRING.hxx"
+
+namespace Batch {
+
+ // Constructeur
+ Job::Job() : _param(), _env()
+ {
+ // Nothing to do
+ }
+
+
+ // Constructeur
+ Job::Job(Parametre param) : _param(param), _env()
+ {
+ // Nothing to do
+ }
+
+
+ // Constructeur
+ Job::Job(Environnement env) : _param(), _env(env)
+ {
+ // Nothing to do
+ }
+
+
+ // Constructeur
+ Job::Job(Parametre param, Environnement env) : _param(param), _env(env)
+ {
+ // Nothing to do
+ }
+
+ // Operateur pour l'affichage sur un stream
+ ostream & operator <<(ostream & os, const Job & job)
+ {
+ return os << job.__str__();
+ }
+
+ // Accesseur
+ Parametre Job::getParametre() const
+ {
+ return _param;
+ }
+
+ // Accesseur
+ void Job::setParametre(const Parametre & param)
+ {
+ _param = param;
+ }
+
+ // Accesseur
+ Environnement Job::getEnvironnement() const
+ {
+ return _env;
+ }
+
+ // Accesseur
+ void Job::setEnvironnement(const Environnement & env)
+ {
+ _env = env;
+ }
+
+
+ // Methode pour l'interfacage avec Python (SWIG) : affichage en Python
+ string Job::__str__() const {
+ //MEDMEM::STRING str;
+ ostringstream str;
+ str << "<Job (" << this << ") :" << endl;
+ str << " Parametre :" << endl;
+ Parametre::const_iterator itp;
+ for(itp=_param.begin(); itp!=_param.end(); itp++) {
+ str << " * " << (*itp).first << " : " << (*itp).second << endl;
+ }
+ str << " Environnement :" << endl;
+ Environnement::const_iterator ite;
+ for(ite=_env.begin(); ite!=_env.end(); ite++) {
+ str << " * " << (*ite).first << " : " << (*ite).second << endl;
+ }
+ str << " >";
+ return str.str();
+ }
+
+
+}
--- /dev/null
+/*
+ * Job.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#ifndef _JOB_H_
+#define _JOB_H_
+
+
+#include "Batch_Parametre.hxx"
+#include "Batch_Environnement.hxx"
+
+namespace Batch {
+
+ class Job
+ {
+ public:
+ // Constructeurs et destructeur
+ Job();
+ Job(Parametre param);
+ Job(Environnement env);
+ Job(Parametre param, Environnement env);
+ virtual ~Job() {}
+
+ // Operateur pour l'affichage sur un stream
+ friend ostream & operator <<(ostream & os, const Job & job);
+
+ // Accesseurs
+ Parametre getParametre() const;
+ void setParametre(const Parametre &);
+
+ // Accesseurs
+ Environnement getEnvironnement() const;
+ void setEnvironnement(const Environnement &);
+
+ // Methodes pour l'interfacage avec Python (SWIG)
+ // TODO : supprimer ces methodes et transferer leur definitions dans SWIG
+ string __str__() const; // SWIG : affichage en Python
+ string __repr__() const { return __str__(); }; // SWIG : affichage en Python
+
+ protected:
+ Parametre _param; // table des parametres batch du job
+ Environnement _env; // table des variables d'environnement
+
+ private:
+
+ };
+
+}
+
+#endif
--- /dev/null
+/*
+ * JobId.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#include "Batch_JobId.hxx"
+#include "Batch_BatchManager.hxx"
+#include <sstream>
+//#include "MEDMEM_STRING.hxx"
+
+namespace Batch {
+
+ // Constructeur standard
+ JobId::JobId() : _p_batchmanager(), _reference("undefined")
+ {
+ // Nothing to do
+ }
+
+ // Constructeur avec le pointeur sur le BatchManager associe et avec une reference
+ JobId::JobId(BatchManager * _p_bm, string ref) : _p_batchmanager(_p_bm), _reference(ref)
+ {
+ // Nothing to do
+ }
+
+ // Destructeur
+ JobId::~JobId()
+ {
+ // Nothing to do
+ }
+
+ // Operateur d'affectation entre objets
+ JobId & JobId::operator =(const JobId & jobid)
+ {
+ _p_batchmanager = jobid._p_batchmanager;
+ _reference = jobid._reference;
+
+ return *this;
+ }
+
+ // Constructeur par recopie
+ JobId::JobId(const JobId & jobid) : _p_batchmanager(jobid._p_batchmanager), _reference(jobid._reference)
+ {
+ // Nothing to do
+ }
+
+ // Accesseur pour la reference interne
+ string JobId::getReference() const
+ {
+ return _reference;
+ }
+
+ // Methode pour le controle du job : retire le job du gestionnaire
+ void JobId::deleteJob() const
+ {
+ assert(_p_batchmanager != 0);
+ _p_batchmanager->deleteJob(*this);
+ }
+
+ // Methode pour le controle du job : suspend le job en file d'attente
+ void JobId::holdJob() const
+ {
+ assert(_p_batchmanager != 0);
+ _p_batchmanager->holdJob(*this);
+ }
+
+ // Methode pour le controle du job : relache le job suspendu
+ void JobId::releaseJob() const
+ {
+ assert(_p_batchmanager != 0);
+ _p_batchmanager->releaseJob(*this);
+ }
+
+ // Methode pour le controle du job : modifie le job en file d'attente
+ void JobId::alterJob(const Parametre & param, const Environnement & env) const
+ {
+ assert(_p_batchmanager != 0);
+ _p_batchmanager->alterJob(*this, param, env);
+ }
+
+ // Methode pour le controle du job : modifie le job en file d'attente
+ void JobId::alterJob(const Parametre & param) const
+ {
+ assert(_p_batchmanager != 0);
+ _p_batchmanager->alterJob(*this, param);
+ }
+
+ // Methode pour le controle du job : modifie le job en file d'attente
+ void JobId::alterJob(const Environnement & env) const
+ {
+ assert(_p_batchmanager != 0);
+ _p_batchmanager->alterJob(*this, env);
+ }
+
+ // Methode pour le controle du job : renvoie l'etat du job
+ JobInfo JobId::queryJob() const
+ {
+ assert(_p_batchmanager != 0);
+ return _p_batchmanager->queryJob(*this);
+ }
+
+
+ // Methode pour l'interfacage avec Python (SWIG) : affichage en Python
+ string JobId::__str__() const {
+ //MEDMEM::STRING str;
+ ostringstream str;
+ str << "<JobId (" << this << ") : referenced '" << _reference << "'>";
+ return str.str();
+ }
+
+}
--- /dev/null
+/*
+ * JobId.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#ifndef _JOBID_H_
+#define _JOBID_H_
+
+
+#include "Batch_JobInfo.hxx"
+#include "Batch_BatchManager.hxx"
+
+namespace Batch {
+
+ class BatchManager;
+
+ class JobId
+ {
+ friend class BatchManager;
+
+ public:
+ // Constructeur standard et destructeur
+ JobId();
+ virtual ~JobId();
+
+ // Constructeur avec le pointeur sur le BatchManager associe et avec une reference
+ JobId(BatchManager *, string ref);
+
+ // Operateur d'affectation entre objets
+ virtual JobId & operator =(const JobId &);
+
+ // Constructeur par recopie
+ JobId(const JobId &);
+
+ // Accesseur pour la reference interne
+ virtual string getReference() const;
+
+ // Methodes pour le controle du job
+ virtual void deleteJob() const; // retire un job du gestionnaire
+ virtual void holdJob() const; // suspend un job en file d'attente
+ virtual void releaseJob() const; // relache un job suspendu
+ virtual void alterJob(const Parametre & param, const Environnement & env) const; // modifie un job en file d'attente
+ virtual void alterJob(const Parametre & param) const; // modifie un job en file d'attente
+ virtual void alterJob(const Environnement & env) const; // modifie un job en file d'attente
+ virtual void setParametre(const Parametre & param) { return alterJob(param); } // modifie un job en file d'attente
+ virtual void setEnvironnement(const Environnement & env) { return alterJob(env); } // modifie un job en file d'attente
+ virtual Batch::JobInfo queryJob() const; // renvoie l'etat du job
+
+ // Methodes pour l'interfacage avec Python (SWIG)
+ // TODO : supprimer ces methodes et transferer leur definitions dans SWIG
+ string __str__() const; // SWIG : affichage en Python
+ string __repr__() const { return __str__(); }; // SWIG : affichage en Python
+
+ protected:
+ BatchManager * _p_batchmanager; // pointeur sur le BatchManager qui controle le job
+ string _reference; // reference du job au sein du BatchManager
+
+ private:
+
+ };
+
+}
+
+#endif
--- /dev/null
+/*
+ * JobInfo.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Thu Nov 6 10:05:30 2003
+ * Projet : Salome 2
+ *
+ */
+
+#include <iostream>
+#include <string>
+#include <sstream>
+//#include "MEDMEM_STRING.hxx"
+#include "Batch_JobInfo.hxx"
+
+namespace Batch {
+
+ // Destructeur
+ JobInfo::~JobInfo()
+ {
+ // Nothing to do
+ }
+
+
+ // Operateur pour l'affichage sur un stream
+ ostream & operator <<(ostream & os, const JobInfo & ji)
+ {
+ return os << ji.__str__();
+ }
+
+
+ // Methodes pour l'interfacage avec Python (SWIG) : affichage en Python
+ string JobInfo::__str__() const
+ {
+ //MEDMEM::STRING sst;
+ ostringstream sst;
+ sst << "<JobInfo (" << this << ") :" << endl;
+ sst << " ID = " <<_param[ID] << endl;
+
+ sst << " + Parametre :" << endl;
+ Parametre::const_iterator itp;
+ for(itp=_param.begin(); itp!=_param.end(); itp++) {
+ if ( (*itp).first != ID ) {
+ sst << " * " << (*itp).first << " = " << (*itp).second << endl;
+ }
+ }
+
+ sst << " + Environnement :" << endl;
+ Environnement::const_iterator ite;
+ for(ite=_env.begin(); ite!=_env.end(); ite++) {
+ sst << " * " << (*ite).first << " = " << (*ite).second << endl;
+ }
+
+ sst << " >";
+
+ return sst.str();
+ }
+
+ // Accesseur
+ Parametre JobInfo::getParametre() const
+ {
+ return _param;
+ }
+
+ // Accesseur
+ Environnement JobInfo::getEnvironnement() const
+ {
+ return _env;
+ }
+
+
+}
--- /dev/null
+/*
+ * JobInfo.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Thu Nov 6 10:05:30 2003
+ * Projet : Salome 2
+ *
+ */
+
+#ifndef _JOBINFO_H_
+#define _JOBINFO_H_
+
+using namespace std;
+#include <iostream>
+#include <string>
+#include "Batch_Parametre.hxx"
+#include "Batch_Environnement.hxx"
+
+namespace Batch {
+
+ class JobInfo
+ {
+ public:
+ // Constructeur standard et destructeur
+ JobInfo() : _param(), _env() {};
+ virtual ~JobInfo();
+
+ // Constructeur par recopie
+ JobInfo(const JobInfo & jinfo) : _param(jinfo._param), _env(jinfo._env) {};
+
+ // Operateur pour l'affichage sur un stream
+ friend ostream & operator <<(ostream & os, const JobInfo & ji);
+
+ // Accesseurs
+ virtual Parametre getParametre() const;
+ virtual Environnement getEnvironnement() const;
+
+ // Methodes pour l'interfacage avec Python (SWIG)
+ // TODO : supprimer ces methodes et transferer leur definitions dans SWIG
+ string __str__() const; // SWIG : affichage en Python
+ string __repr__() const { return __str__(); }; // SWIG : affichage en Python
+
+ protected:
+ Parametre _param; // parametres du job
+ Environnement _env; // variables d'environnement du job
+
+ private:
+
+ };
+
+}
+
+#endif
--- /dev/null
+/*
+ * JobInfo_PBS.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Fri Nov 21 09:42:06 2003
+ * Projet : Salome 2
+ *
+ */
+
+#include <cstdio>
+#include <sstream>
+//#include "MEDMEM_STRING.hxx"
+#include "Batch_Parametre.hxx"
+#include "Batch_Environnement.hxx"
+#include "Batch_RunTimeException.hxx"
+#include "Batch_JobInfo_PBS.hxx"
+
+namespace Batch {
+
+ // Constructeurs
+ JobInfo_PBS::JobInfo_PBS(struct batch_status * list, bool tobedeleted) : JobInfo()
+ {
+ // On ne considere que le premier element de la liste
+ // Si tout est OK, la liste ne devrait contenir qu'un element
+ // Sinon on leve une exception.
+ struct batch_status * p_job = list;
+ int i;
+ for(i=0; p_job; p_job = p_job->next) i++;
+ if (i == 0) throw RunTimeException("Liste vide (le job est absent de la file)");
+ if (i > 1) {
+ //MEDMEM::STRING sst;
+ ostringstream sst;
+ sst << "JobInfo_PBS::JobInfo_PBS(struct batch_status * list, bool tobedeleted) : la liste contient "
+ << i << " elements" << " (1 seul requis)" << endl;
+ throw RunTimeException(sst.str());
+ }
+ p_job = list;
+
+ // On remplit les membres _param et _env
+
+ if (p_job->name && strlen(p_job->name)) _param[ID] = p_job->name;
+ if (p_job->text && strlen(p_job->text)) _param[TEXT] = p_job->text;
+
+ for(struct attrl * p_attr = p_job->attribs; p_attr; p_attr = p_attr->next) {
+
+ string name, res, value;
+ if (p_attr->name && strlen(p_attr->name)) name = p_attr->name;
+ if (p_attr->resource && strlen(p_attr->resource)) res = p_attr->resource;
+ if (p_attr->value && strlen(p_attr->value)) value = p_attr->value;
+
+ if (name == ATTR_N) {
+ _param[NAME] = value;
+
+ } else if (name == ATTR_owner) {
+ _param[USER] = value;
+
+ } else if (name == ATTR_state) {
+ _param[STATE] = value;
+
+ } else if (name == ATTR_queue) {
+ _param[QUEUE] = value;
+
+ } else if (name == ATTR_A) {
+ _param[ACCOUNT] = value;
+
+ } else if (name == ATTR_M) {
+ _param[MAIL] = value;
+
+ } else if (name == ATTR_c) {
+ if (!strcmp(value.c_str(), CHECKPOINT_UNSPECIFIED)) _param[CHECKPOINT] = 1L;
+ else _param[CHECKPOINT] = 0L;
+
+ } else if (name == ATTR_h) {
+ if (!strcmp(value.c_str(), NO_HOLD)) _param[HOLD] = 0L;
+ else _param[HOLD] = 1L;
+
+ } else if (name == ATTR_ctime) {
+ _param[CREATIONTIME] = atol(value.c_str());
+
+ } else if (name == ATTR_etime) {
+ _param[ELIGIBLETIME] = atol(value.c_str());
+
+ } else if (name == ATTR_mtime) {
+ _param[MODIFICATIONTIME] = atol(value.c_str());
+
+ } else if (name == ATTR_qtime) {
+ _param[QUEUEDTIME] = atol(value.c_str());
+
+ } else if (name == ATTR_exechost) {
+ _param[EXECUTIONHOST] = value;
+
+ } else if (name == ATTR_session) {
+ _param[PID] = atol(value.c_str());
+
+ } else if (name == ATTR_euser) {
+ _param[EUSER] = value;
+
+ } else if (name == ATTR_egroup) {
+ _param[EGROUP] = value;
+
+ } else if (name == ATTR_l) {
+ if (res == "cput") {
+ _param[MAXCPUTIME] = HMStoLong(value);
+
+ } else if (res == "walltime") {
+ _param[MAXWALLTIME] = HMStoLong(value);
+
+ }
+
+ } else if (name == ATTR_used) {
+ if (res == "cput") {
+ _param[USEDCPUTIME] = HMStoLong(value);
+
+ } else if (res == "walltime") {
+ _param[USEDWALLTIME] = HMStoLong(value);
+
+ }
+
+ } else if (name == ATTR_v) {
+ int deb = 0;
+ int pos = 0;
+ bool ok = true;
+
+ while (ok) {
+ pos = value.find(",", deb);
+ string sub = value.substr(deb, pos-deb);
+ deb = pos + 1;
+ if (pos < 0) ok = false;
+
+ int eq = sub.find("=");
+ _env[sub.substr(0, eq)] = sub.substr(eq+1);
+ }
+
+ }
+ }
+
+
+ if (tobedeleted) pbs_statfree(list);
+ }
+
+ // Destructeur
+ JobInfo_PBS::~JobInfo_PBS()
+ {
+ // Nothing to do
+ }
+
+ // Convertit une date HH:MM:SS en secondes
+ long JobInfo_PBS::HMStoLong(const string & s)
+ {
+ long hour, min, sec;
+
+ sscanf( s.c_str(), "%ld:%ld:%ld", &hour, &min, &sec);
+ return ( ( ( hour * 60L ) + min ) * 60L ) + sec;
+ }
+
+ // Methode pour l'interfacage avec Python (SWIG) : affichage en Python
+ string JobInfo_PBS::__str__() const
+ {
+ //MEDMEM::STRING sst;
+ ostringstream sst;
+ sst << "<JobInfo_PBS (" << this << ") :" << endl;
+ sst << " ID = " <<_param[ID] << endl;
+
+ sst << " + Parametre :" << endl;
+ Parametre::const_iterator itp;
+ for(itp=_param.begin(); itp!=_param.end(); itp++) {
+ if ( (*itp).first != ID ) {
+ sst << " * " << (*itp).first << " = " << (*itp).second << endl;
+ }
+ }
+ return sst.str();
+ }
+
+
+}
--- /dev/null
+/*
+ * JobInfo_PBS.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Fri Nov 21 09:42:05 2003
+ * Projet : Salome 2
+ *
+ */
+
+#ifndef _JOBINFO_PBS_H_
+#define _JOBINFO_PBS_H_
+
+extern "C" {
+
+#include <pbs_error.h>
+#include <pbs_ifl.h>
+}
+#include <string>
+#include "Batch_RunTimeException.hxx"
+#include "Batch_JobInfo.hxx"
+
+namespace Batch {
+
+ class JobInfo_PBS : public JobInfo
+ {
+ public:
+ // Constructeurs et destructeur
+ JobInfo_PBS() : JobInfo() {};
+ JobInfo_PBS(struct batch_status * stat_list, bool tobedeleted = false);
+ virtual ~JobInfo_PBS();
+
+ // Constructeur par recopie
+ JobInfo_PBS(const JobInfo_PBS & jinfo) : JobInfo(jinfo) {};
+
+ // Methodes pour l'interfacage avec Python (SWIG)
+ // TODO : supprimer ces methodes et transferer leur definitions dans SWIG
+ string __str__() const; // SWIG : affichage en Python
+ string __repr__() const { return __str__(); }; // SWIG : affichage en Python
+
+ protected:
+
+ private:
+ // Convertit une date HH:MM:SS en secondes
+ long HMStoLong(const string &);
+
+ };
+
+}
+
+#endif
--- /dev/null
+/*
+ * Job_PBS.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Fri Nov 14 11:00:39 2003
+ * Projet : Salome 2
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "Batch_Job_PBS.hxx"
+
+namespace Batch {
+
+ // Ajoute un element (name,resource,value) a la liste chainee d'attributs + operateur
+ void Job_PBS::setResourceAttributeOP(struct attropl ** attr_list, const char * attr_name, const char * attr_resource, const char * attr_value)
+ {
+ // L'element (name,resource,value) existe-t-il deja ? si oui ptr != 0
+ struct attropl * ptr = findResourceAttributeOP(*attr_list, attr_name, attr_resource);
+
+ if (!ptr) { // L'element n'existe pas, il faut le creer
+ if (ptr = lastAttributeOP(*attr_list)) { // la liste n'est pas vide
+ ptr->next = new struct attropl;
+ ptr = ptr->next;
+ ptr->next = 0;
+
+ } else { // la liste est completement vide
+ ptr = *attr_list = new struct attropl;
+ ptr->next = 0;
+ }
+
+ // On remplit les champs (name,resource,value)
+ ptr->name = new char[strlen(attr_name) + 1];
+ strncpy(ptr->name, attr_name, strlen(attr_name));
+ ptr->name[strlen(attr_name)] = 0;
+
+ ptr->resource = new char[strlen(attr_resource) + 1];
+ strncpy(ptr->resource, attr_resource, strlen(attr_resource));
+ ptr->resource[strlen(attr_resource)] = 0;
+
+ ptr->value = new char[strlen(attr_value) + 1];
+ strncpy(ptr->value, attr_value, strlen(attr_value));
+ ptr->value[strlen(attr_value)] = 0;
+
+ } else { // L'attribut existe, on change sa valeur
+ delete[] ptr->value; // On efface la valeur precedente
+ ptr->value = new char[strlen(attr_value) + 1];
+ strncpy(ptr->value, attr_value, strlen(attr_value));
+ ptr->value[strlen(attr_value)] = 0;
+
+ }
+ }
+
+
+ // Recherche un element (name,resource,value) dans la liste chainee d'attributs + operateur
+ struct attropl * Job_PBS::findResourceAttributeOP(struct attropl * attr_list, const char * attr_name, const char * attr_resource)
+ {
+ // On parcoure la liste chainee pour trouver l'element dont les champs name et resource coincident
+ struct attropl * ptr = attr_list;
+ while (ptr) {
+ if (!strcmp(ptr->name, attr_name) && !strcmp(ptr->resource, attr_resource)) break;
+ ptr = ptr->next;
+ }
+ return ptr;
+ }
+
+
+ // Recherche le dernier element de la liste chainee d'attributs + operateur
+ struct attropl * Job_PBS::lastAttributeOP(struct attropl * attr_list)
+ {
+ struct attropl * ptr = attr_list;
+ while (ptr && ptr->next) {
+ ptr = ptr->next;
+ }
+ return ptr;
+ }
+
+
+ // Convertit un objet Parametre en liste chainee d'attributs + operateur
+ struct attropl * Job_PBS::ParametreToAttributeOPList(struct attropl ** _p_attr_list, Parametre & P)
+ {
+ Parametre::iterator it;
+ string st_second;
+ for(it=P.begin(); it!=P.end(); it++) {
+ if ( (*it).first == ACCOUNT ) {
+ st_second = (*it).second.str();
+ setResourceAttributeOP(_p_attr_list, ATTR_A, "", st_second.c_str());
+
+
+ } else if ( (*it).first == CHECKPOINT ) {
+ setResourceAttributeOP(_p_attr_list, ATTR_c, "", "u");
+
+
+ } else if ( (*it).first == CKPTINTERVAL ) {
+ // Not significant
+
+ } else if ( (*it).first == EXECUTABLE ) {
+ // Already done
+
+ } else if ( (*it).first == HOLD ) {
+ if (static_cast< long >((*it).second))
+ setResourceAttributeOP(_p_attr_list, ATTR_h, "", USER_HOLD);
+ else
+ setResourceAttributeOP(_p_attr_list, ATTR_h, "", NO_HOLD);
+
+ } else if ( (*it).first == INFILE ) {
+ Versatile V = (*it).second;
+ Versatile::iterator Vit;
+
+ string sep = "";
+ string stagein;
+
+ for(Vit=V.begin(); Vit!=V.end(); Vit++, sep=",") {
+ CoupleType cpt = *static_cast< CoupleType * >(*Vit);
+ Couple cp = cpt;
+ string local = cp.getLocal();
+ string remote = cp.getRemote();
+
+ // ATTENTION : les notions de fichier "local" ou "remote" sont inverses de celle de PBS qui a un point de vue serveur et non pas utilisateur
+ stagein += sep + remote + "@" + local;
+ }
+
+ if (stagein.size())
+ setResourceAttributeOP(_p_attr_list, ATTR_stagein, "", stagein.c_str());
+
+
+ } else if ( (*it).first == MAIL ) {
+ st_second = (*it).second.str();
+ setResourceAttributeOP(_p_attr_list, ATTR_M, "", st_second.c_str());
+
+ } else if ( (*it).first == MAXCPUTIME ) {
+ char attr_value[32];
+ long secondes = (*it).second;
+ long heures = secondes / 3600L;
+ long minutes = (secondes - 3600L * heures) / 60L;
+ secondes = secondes % 60L;
+ sprintf(attr_value, "%02ld:%02ld:%02ld", heures, minutes, secondes);
+
+ setResourceAttributeOP(_p_attr_list, ATTR_l, "cput", attr_value);
+
+
+ } else if ( (*it).first == MAXDISKSIZE ) {
+
+ } else if ( (*it).first == MAXRAMSIZE ) {
+
+ } else if ( (*it).first == MAXWALLTIME ) {
+ char attr_value[32];
+ long secondes = (*it).second;
+ long heures = secondes / 3600L;
+ long minutes = (secondes - 3600L * heures) / 60L;
+ secondes = secondes % 60L;
+ sprintf(attr_value, "%02ld:%02ld:%02ld", heures, minutes, secondes);
+
+ setResourceAttributeOP(_p_attr_list, ATTR_l, "walltime", attr_value);
+
+
+ } else if ( (*it).first == NAME ) {
+ st_second = (*it).second.str();
+ setResourceAttributeOP(_p_attr_list, ATTR_N, "", st_second.c_str());
+
+
+ } else if ( (*it).first == OUTFILE ) {
+ Versatile V = (*it).second;
+ Versatile::iterator Vit;
+
+ string sep = "";
+ string stageout;
+
+ for(Vit=V.begin(); Vit!=V.end(); Vit++, sep=",") {
+ CoupleType cpt = *static_cast< CoupleType * >(*Vit);
+ Couple cp = cpt;
+ string local = cp.getLocal();
+ string remote = cp.getRemote();
+
+ if (remote == "stdout")
+ setResourceAttributeOP(_p_attr_list, ATTR_o, "", local.c_str());
+
+ else if (remote == "stderr")
+ setResourceAttributeOP(_p_attr_list, ATTR_e, "", local.c_str());
+
+ else
+ // ATTENTION : les notions de fichier "local" ou "remote" sont inverses de celle de PBS qui a un point de vue serveur et non pas utilisateur
+ stageout += sep + remote + "@" + local;
+ }
+
+ if (stageout.size())
+ setResourceAttributeOP(_p_attr_list, ATTR_stageout, "", stageout.c_str());
+
+ } else if ( (*it).first == QUEUE ) {
+ // Already done
+
+ } else if ( (*it).first == STARTDATE ) {
+
+ } else if ( (*it).first == TMPDIR ) {
+
+ } else if ( (*it).first == USER ) {
+ st_second = (*it).second.str();
+ setResourceAttributeOP(_p_attr_list, ATTR_u, "", st_second.c_str());
+
+ }
+ }
+ return *_p_attr_list;
+ }
+
+
+ // Convertit un objet Environnement en liste chainee d'attributs + operateur
+ struct attropl * Job_PBS::EnvironnementToAttributeOPList(struct attropl ** _p_attr_list, Environnement & E)
+ {
+ Environnement::iterator it;
+ for(it=E.begin(); it!=E.end(); it++) {
+ setResourceAttributeOP(_p_attr_list, ATTR_v, (*it).first.c_str(), ( (*it).first + "=" + (*it).second ).c_str());
+ }
+ return *_p_attr_list;
+ }
+
+
+ // Ajoute les variables d'environnement presentes dans tout job PBS
+ void Job_PBS::addPBSEnvironnement(Environnement & E)
+ {
+ char * c;
+
+ c = getenv("HOME");
+ if (c) E["PBS_O_HOME"] = c;
+
+ c = getenv("LANG");
+ if (c) E["PBS_O_LANG"] = c;
+
+ c = getenv("LOGNAME");
+ if (c) E["PBS_O_LOGNAME"] = c;
+
+ c = getenv("PATH");
+ if (c) E["PBS_O_PATH"] = c;
+
+ c = getenv("LD_LIBRARY_PATH");
+ if (c) E["PBS_O_LD_LIBRARY_PATH"] = c;
+
+ c = getenv("MAIL");
+ if (c) E["PBS_O_MAIL"] = c;
+
+ c = getenv("SHELL");
+ if (c) E["PBS_O_SHELL"] = c;
+
+ c = getenv("TZ");
+ if (c) E["PBS_O_TZ"] = c;
+
+ /* Recuperation du working directory */
+ size_t size = 256;
+ char * buf = 0;
+ char * rc = 0;
+ do {
+ if (buf) delete[] buf;
+ buf = new char[size];
+ rc = getcwd(buf, size);
+ size += size;
+ } while (!rc);
+ E["PBS_O_WORKDIR"] = buf;
+ delete[] buf;
+ }
+
+
+ // Ajoute un element (name,resource,value) a la liste chainee d'attributs
+ void Job_PBS::setResourceAttribute(struct attrl ** attr_list, const char * attr_name, const char * attr_resource, const char * attr_value)
+ {
+ // L'element (name,resource,value) existe-t-il deja ? si oui ptr != 0
+ struct attrl * ptr = findResourceAttribute(*attr_list, attr_name, attr_resource);
+
+ if (!ptr) { // L'attribut n'existe pas, il faut le creer
+ if (ptr = lastAttribute(*attr_list)) { // la liste n'est pas vide
+ ptr->next = new struct attrl;
+ ptr = ptr->next;
+ ptr->next = 0;
+
+ } else { // la liste est completement vide
+ ptr = *attr_list = new struct attrl;
+ ptr->next = 0;
+ }
+
+ // On remplit les champs (name,resource,value)
+ ptr->name = new char[strlen(attr_name) + 1];
+ strncpy(ptr->name, attr_name, strlen(attr_name));
+ ptr->name[strlen(attr_name)] = 0;
+
+ ptr->resource = new char[strlen(attr_resource) + 1];
+ strncpy(ptr->resource, attr_resource, strlen(attr_resource));
+ ptr->resource[strlen(attr_resource)] = 0;
+
+ ptr->value = new char[strlen(attr_value) + 1];
+ strncpy(ptr->value, attr_value, strlen(attr_value));
+ ptr->value[strlen(attr_value)] = 0;
+
+ } else { // L'attribut existe, on change sa valeur
+ delete[] ptr->value; // On efface la valeur precedente
+ ptr->value = new char[strlen(attr_value) + 1];
+ strncpy(ptr->value, attr_value, strlen(attr_value));
+ ptr->value[strlen(attr_value)] = 0;
+
+ }
+ }
+
+ // Recherche un element (name,resource,value) dans la liste chainee d'attributs
+ struct attrl * Job_PBS::findResourceAttribute(struct attrl * attr_list, const char * attr_name, const char * attr_resource)
+ {
+ // On parcoure la liste chainee pour trouver l'element dont les champs name et resource coincident
+ struct attrl * ptr = attr_list;
+ while (ptr) {
+ if (!strcmp(ptr->name, attr_name) && !strcmp(ptr->resource, attr_resource)) break;
+ ptr = ptr->next;
+ }
+ return ptr;
+ }
+
+
+ // Recherche le dernier element de la liste chainee d'attributs
+ struct attrl * Job_PBS::lastAttribute(struct attrl * attr_list)
+ {
+ struct attrl * ptr = attr_list;
+ while (ptr && ptr->next) {
+ ptr = ptr->next;
+ }
+ return ptr;
+ }
+
+
+ // Constructeur
+ Job_PBS::Job_PBS(const Job & job) : _p_attropl(0), _p_attrl(0), _script(0), _destination(0)
+ {
+ Parametre P = job.getParametre();
+ Parametre::iterator it;
+
+ // On extrait de l'objet Parametre le champ EXECUTABLE qui deviendra le script PBS
+ if ( (it=P.find(EXECUTABLE)) != P.end()) {
+ Versatile V = (*it).second;
+ string st_exe = V.str();
+ const char * exe = st_exe.c_str();
+ int lg = strlen(exe);
+ _script = new char[lg + 1];
+ for (int ii=0; ii<lg+1; ii++) _script[ii] = 0;
+ strcpy(_script, exe);
+ _script[lg] = 0;
+
+ } else {
+ _script = new char[1];
+ _script[0] = 0;
+ }
+
+ // On extrait de l'objet Parametre le champ QUEUE qui deviendra la destination
+ if ( (it=P.find(QUEUE)) != P.end()) {
+ Versatile V = (*it).second;
+ string st_dest = V.str();
+ const char * dest = st_dest.c_str();
+ _destination = new char[strlen(dest) + 2 + 1];
+ _destination[0] = 0;
+ strcat(_destination, dest);
+ _destination[strlen(dest)] = 0;
+ } else {
+ _destination = new char[1];
+ _destination[0] = 0;
+ }
+
+ // On convertit les objets Parametre et Environnement en liste chainee d'attributs + operateur
+ Environnement E = job.getEnvironnement();
+ addPBSEnvironnement(E);
+
+ _p_attropl = ParametreToAttributeOPList(&_p_attropl, P);
+ _p_attropl = EnvironnementToAttributeOPList(&_p_attropl, E);
+
+ }
+
+
+ // Destructeur
+ Job_PBS::~Job_PBS()
+ {
+ // On detruit la liste chainee d'attributs + operateur
+ struct attropl * current_p_attropl = _p_attropl;
+ while (current_p_attropl) {
+ struct attropl * next = current_p_attropl->next;
+ delete[] current_p_attropl->name;
+ delete[] current_p_attropl->resource;
+ delete[] current_p_attropl->value;
+ delete current_p_attropl;
+ current_p_attropl = next;
+ }
+
+ // On detruit la liste chainee d'attributs
+ struct attrl * current_p_attrl = _p_attrl;
+ while (current_p_attrl) {
+ struct attrl * next = current_p_attrl->next;
+ delete[] current_p_attrl->name;
+ delete[] current_p_attrl->resource;
+ delete[] current_p_attrl->value;
+ delete current_p_attrl;
+ current_p_attrl = next;
+ }
+
+ // On detruit les champs alloues
+ delete[] _script;
+ delete[] _destination;
+ }
+
+
+ // Accesseur
+ struct attropl * Job_PBS::getAttributesOP()
+ {
+ return _p_attropl;
+ }
+
+ // Accesseur
+ // Cette methode sert pour les pbs_alter de PBS
+ // Pbs_alter est buggé par rapport a la specification ers_all.ps car les
+ // variables d'environnement ne sont pas supportees (ATTR_v)
+ struct attrl * Job_PBS::getAttributes()
+ {
+ if (_p_attrl == 0) {
+
+ // On remplit la structure attrl a partir de la strucuture attropl
+ // (elles ne different que par le parametre op, mais elles ne sont pas interchangeables
+ // dans les appels)
+
+ struct attropl * current_p_attropl = _p_attropl;
+ while (current_p_attropl) {
+ if (strcmp(current_p_attropl->name, ATTR_v)) // Bug fix for ATTR_v
+ setResourceAttribute(&_p_attrl,
+ current_p_attropl->name,
+ current_p_attropl->resource,
+ current_p_attropl->value);
+
+ current_p_attropl = current_p_attropl->next;
+ }
+
+ }
+
+ return _p_attrl;
+ }
+
+ // Accesseur
+ char * Job_PBS::getScript()
+ {
+ return _script;
+ }
+
+ // Accesseur
+ char * Job_PBS::getDestination()
+ {
+ return _destination;
+ }
+
+}
--- /dev/null
+/*
+ * Job_PBS.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Fri Nov 14 11:00:39 2003
+ * Projet : Salome 2
+ *
+ */
+
+#ifndef _JOB_PBS_H_
+#define _JOB_PBS_H_
+
+extern "C" {
+
+#include <pbs_error.h>
+#include <pbs_ifl.h>
+}
+#include "Batch_Job.hxx"
+
+namespace Batch {
+
+ class Job_PBS
+ {
+ public:
+ // Constructeur et destructeur
+ Job_PBS(const Job & job);
+ virtual ~Job_PBS();
+
+ // Accesseurs
+ struct attropl * getAttributesOP();
+ struct attrl * getAttributes();
+ char * getScript();
+ char * getDestination();
+
+ protected:
+ struct attropl * _p_attropl; // liste chainee d'attributs + operateur
+ struct attrl * _p_attrl; // liste chainee d'attributs
+ char * _script; // chemin d'acces au script du job
+ char * _destination; // queue dans laquelle le job est soumis
+
+ private:
+ // Ajoute un element (name,resource,value) a la liste chainee d'attributs + operateur
+ void setResourceAttributeOP(struct attropl ** attr_list, const char * attr_name, const char * attr_resource, const char * attr_value);
+
+ // Recherche un element (name,resource,value) dans la liste chainee d'attributs + operateur
+ struct attropl * findResourceAttributeOP(struct attropl * attr_list, const char * attr_name, const char * attr_resource);
+
+ // Recherche le dernier element de la liste chainee d'attributs + operateur
+ struct attropl * lastAttributeOP(struct attropl * attr_list);
+
+ // Convertit un objet Parametre en liste chainee d'attributs + operateur
+ struct attropl * ParametreToAttributeOPList(struct attropl ** _p_attr_list, Parametre & param);
+
+ // Convertit un objet Environnement en liste chainee d'attributs + operateur
+ struct attropl * EnvironnementToAttributeOPList(struct attropl ** _p_attr_list, Environnement & env);
+
+ // Ajoute les variables d'environnement presentes dans tout job PBS
+ void addPBSEnvironnement(Environnement & E);
+
+
+ // Ajoute un element (name,resource,value) a la liste chainee d'attributs
+ void setResourceAttribute(struct attrl ** attr_list, const char * attr_name, const char * attr_resource, const char * attr_value);
+
+ // Recherche un element (name,resource,value) dans la liste chainee d'attributs
+ struct attrl * findResourceAttribute(struct attrl * attr_list, const char * attr_name, const char * attr_resource);
+
+ // Recherche le dernier element de la liste chainee d'attributs
+ struct attrl * lastAttribute(struct attrl * attr_list);
+
+ };
+
+}
+
+#endif
--- /dev/null
+/*
+ * ListIsFullException.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#include "Batch_ListIsFullException.hxx"
+
+
+namespace Batch {
+
+}
--- /dev/null
+/*
+ * ListIsFullException.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#ifndef _LISTISFULLEXCEPTION_H_
+#define _LISTISFULLEXCEPTION_H_
+
+#include "Batch_GenericException.hxx"
+
+namespace Batch {
+
+ class ListIsFullException : public GenericException
+ {
+ public:
+ // Constructeur
+ ListIsFullException(string ch = "undefined") : GenericException("ListIsFullException", ch) {}
+ };
+
+}
+
+#endif
+
--- /dev/null
+/*
+ * LongType.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#include <string>
+#include <sstream>
+//#include "MEDMEM_STRING.hxx"
+#include "Batch_LongType.hxx"
+
+namespace Batch {
+
+ // Conversion en chaine
+ string LongType::affiche() const
+ {
+ //MEDMEM::STRING sst;
+ ostringstream sst;
+ sst << _data;
+ return sst.str();
+ }
+
+ // Operateur d'affectation
+ LongType & LongType::operator =(long l)
+ {
+ _data = l;
+ return *this;
+ }
+
+ // Conversion en long
+ LongType::operator long() const
+ {
+ return this->_data;
+ }
+
+ // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
+ // qu'il faudra detruire ensuite manuellement
+ GenericType * LongType::clone() const
+ {
+ LongType * pL = new LongType(this->_data);
+ assert(pL != 0);
+ return pL;
+ }
+
+}
--- /dev/null
+/*
+ * LongType.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#ifndef _LONGTYPE_H_
+#define _LONGTYPE_H_
+
+using namespace std;
+#include <string>
+#include "Batch_GenericType.hxx"
+
+namespace Batch {
+
+ class LongType : public GenericType
+ {
+ public:
+ // Constructeur
+ LongType(const long l=0L) : _data(l) {}
+
+ // Conversion en chaine
+ virtual string affiche() const;
+
+ // Operateur d'affectation
+ virtual LongType & operator =(long);
+
+ // Conversion en long
+ virtual operator long() const;
+
+ // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
+ // qu'il faudra detruire ensuite manuellement
+ virtual GenericType * clone() const;
+
+ protected:
+ long _data;
+
+ private:
+
+ };
+
+}
+
+#endif
--- /dev/null
+/*
+ * MapKey.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Tue Oct 14 14:00:30 2003
+ * Projet : Salome 2
+ *
+ */
+
+#include <string>
+#include "Batch_MapKey.hxx"
+
+namespace Batch {
+
+
+}
+
+
+// COMMENTS
--- /dev/null
+/*
+ * MapKey.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Tue Oct 14 14:00:29 2003
+ * Projet : Salome 2
+ *
+ */
+
+#ifndef _MAPKEY_H_
+#define _MAPKEY_H_
+
+
+using namespace std;
+#include <string>
+
+namespace Batch {
+
+ // une classe privee pour les differents types
+ // ces types ne peuvent pas etre redefinis
+ class MapKey : public string
+ {
+ private:
+ friend class Parametre; // seule la classe Parametre peut creer des MapKey
+ MapKey() : string() {}
+ MapKey(const MapKey & mk, size_type pos, size_type npos) : string(mk, pos, npos) {}
+ MapKey(const char * s, size_type n) : string(s, n) {}
+ MapKey(const char * s) : string(s) {}
+ MapKey(size_type n, char c) : string(n, c) {}
+#ifdef __STL_MEMBER_TEMPLATES
+ template<class InputIterator>
+ MapKey(InputIterator __begin, InputIterator __end) : string(__begin, __end) {}
+#else
+ MapKey(const_iterator __begin, const_iterator __end) : string(__begin, __end) {}
+#endif
+
+ public:
+ MapKey(const MapKey & mk) : string(mk) {}
+
+ };
+
+}
+
+#endif
+
+// COMMENTS
--- /dev/null
+/*
+ * NotYetImplementedException.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Tue Nov 25 11:35:07 2003
+ * Projet : Salome 2
+ *
+ */
+
+#include "Batch_NotYetImplementedException.hxx"
+
+namespace Batch {
+
+}
+
--- /dev/null
+/*
+ * NotYetImplementedException.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Tue Nov 25 11:35:07 2003
+ * Projet : Salome 2
+ *
+ */
+
+#ifndef _NOTYETIMPLEMENTEDEXCEPTION_H_
+#define _NOTYETIMPLEMENTEDEXCEPTION_H_
+
+
+#include "Batch_GenericException.hxx"
+
+namespace Batch {
+
+ class NotYetImplementedException : public GenericException
+ {
+ public:
+ // Constructeur
+ NotYetImplementedException(string ch = "undefined") : GenericException("NotYetImplementedException", ch) {}
+ };
+
+}
+
+#endif
+
--- /dev/null
+/*
+ * Parametre.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#include <map>
+#include "Batch_Versatile.hxx"
+#include "Batch_InvalidKeyException.hxx"
+#include "Batch_Parametre.hxx"
+
+// Definition des membres constants statiques
+// Definition des noms globaux pour les clefs en tant que references
+// TODO : supprimer les declarations statiques des clefs de la map
+def_static_MapKey(ACCOUNT);
+def_static_MapKey(CHECKPOINT);
+def_static_MapKey(CKPTINTERVAL);
+def_static_MapKey(CREATIONTIME);
+def_static_MapKey(EGROUP);
+def_static_MapKey(ELIGIBLETIME);
+def_static_MapKey(EUSER);
+def_static_MapKey(EXECUTABLE);
+def_static_MapKey(EXECUTIONHOST);
+def_static_MapKey(HOLD);
+def_static_MapKey(ID);
+def_static_MapKey(INFILE);
+def_static_MapKey(MAIL);
+def_static_MapKey(MAXCPUTIME);
+def_static_MapKey(MAXDISKSIZE);
+def_static_MapKey(MAXRAMSIZE);
+def_static_MapKey(MAXWALLTIME);
+def_static_MapKey(MODIFICATIONTIME);
+def_static_MapKey(NAME);
+def_static_MapKey(OUTFILE);
+def_static_MapKey(PID);
+def_static_MapKey(QUEUE);
+def_static_MapKey(QUEUEDTIME);
+def_static_MapKey(SERVER);
+def_static_MapKey(STARTDATE);
+def_static_MapKey(STATE);
+def_static_MapKey(TEXT);
+def_static_MapKey(TMPDIR);
+def_static_MapKey(USEDCPUTIME);
+def_static_MapKey(USEDDISKSIZE);
+def_static_MapKey(USEDRAMSIZE);
+def_static_MapKey(USEDWALLTIME);
+def_static_MapKey(USER);
+
+namespace Batch {
+
+ // Constructeur standard
+ // La map interne TypeMap possede les memes clefs que la map principale, mais les
+ // valeurs associees contiennent le type des clefs de la map principale ainsi que
+ // le nombre de valeurs autorisees dans l'objet Versatile (0=nombre quelconque,
+ // sinon valeur precisee)
+ Parametre::Parametre() : map< string, Versatile >()
+ {
+ TypeMap[ACCOUNT].type = STRING;
+ TypeMap[ACCOUNT].maxelem = 1;
+
+ TypeMap[CHECKPOINT].type = LONG;
+ TypeMap[CHECKPOINT].maxelem = 1;
+
+ TypeMap[CKPTINTERVAL].type = LONG;
+ TypeMap[CKPTINTERVAL].maxelem = 1;
+
+ TypeMap[CREATIONTIME].type = LONG;
+ TypeMap[CREATIONTIME].maxelem = 1;
+
+ TypeMap[EGROUP].type = STRING;
+ TypeMap[EGROUP].maxelem = 1;
+
+ TypeMap[ELIGIBLETIME].type = LONG;
+ TypeMap[ELIGIBLETIME].maxelem = 1;
+
+ TypeMap[EUSER].type = STRING;
+ TypeMap[EUSER].maxelem = 1;
+
+ TypeMap[EXECUTABLE].type = STRING;
+ TypeMap[EXECUTABLE].maxelem = 1;
+
+ TypeMap[EXECUTIONHOST].type = STRING;
+ TypeMap[EXECUTIONHOST].maxelem = 0;
+
+ TypeMap[HOLD].type = LONG;
+ TypeMap[HOLD].maxelem = 1;
+
+ TypeMap[ID].type = STRING;
+ TypeMap[ID].maxelem = 1;
+
+ TypeMap[INFILE].type = COUPLE;
+ TypeMap[INFILE].maxelem = 0;
+
+ TypeMap[MAIL].type = STRING;
+ TypeMap[MAIL].maxelem = 1;
+
+ TypeMap[MAXCPUTIME].type = LONG;
+ TypeMap[MAXCPUTIME].maxelem = 1;
+
+ TypeMap[MAXDISKSIZE].type = LONG;
+ TypeMap[MAXDISKSIZE].maxelem = 1;
+
+ TypeMap[MAXRAMSIZE].type = LONG;
+ TypeMap[MAXRAMSIZE].maxelem = 1;
+
+ TypeMap[MAXWALLTIME].type = LONG;
+ TypeMap[MAXWALLTIME].maxelem = 1;
+
+ TypeMap[MODIFICATIONTIME].type = LONG;
+ TypeMap[MODIFICATIONTIME].maxelem = 1;
+
+ TypeMap[NAME].type = STRING;
+ TypeMap[NAME].maxelem = 1;
+
+ TypeMap[OUTFILE].type = COUPLE;
+ TypeMap[OUTFILE].maxelem = 0;
+
+ TypeMap[PID].type = LONG;
+ TypeMap[PID].maxelem = 1;
+
+ TypeMap[QUEUE].type = STRING;
+ TypeMap[QUEUE].maxelem = 1;
+
+ TypeMap[QUEUEDTIME].type = LONG;
+ TypeMap[QUEUEDTIME].maxelem = 1;
+
+ TypeMap[SERVER].type = STRING;
+ TypeMap[SERVER].maxelem = 1;
+
+ TypeMap[STARTDATE].type = LONG;
+ TypeMap[STARTDATE].maxelem = 1;
+
+ TypeMap[STATE].type = STRING;
+ TypeMap[STATE].maxelem = 1;
+
+ TypeMap[TEXT].type = STRING;
+ TypeMap[TEXT].maxelem = 1;
+
+ TypeMap[TMPDIR].type = STRING;
+ TypeMap[TMPDIR].maxelem = 1;
+
+ TypeMap[USEDCPUTIME].type = LONG;
+ TypeMap[USEDCPUTIME].maxelem = 1;
+
+ TypeMap[USEDDISKSIZE].type = LONG;
+ TypeMap[USEDDISKSIZE].maxelem = 1;
+
+ TypeMap[USEDRAMSIZE].type = LONG;
+ TypeMap[USEDRAMSIZE].maxelem = 1;
+
+ TypeMap[USEDWALLTIME].type = LONG;
+ TypeMap[USEDWALLTIME].maxelem = 1;
+
+ TypeMap[USER].type = STRING;
+ TypeMap[USER].maxelem = 1;
+ }
+
+ // Operateur de recherche dans la map
+ // Cet operateur agit sur les objets NON CONSTANTS, il autorise la modification de
+ // la valeur associée à la clef car il retourne une reference non constante
+ Versatile & Parametre::operator [] (const string & mk)
+ {
+ // On controle que la clef est valide
+ if (TypeMap.find(mk) == TypeMap.end()) throw InvalidKeyException(mk.c_str());
+
+ // On recherche la valeur associee...
+ Versatile & V = map< string, Versatile >::operator [] (mk);
+
+ // ... et on l'initialise systematiquement
+ // ATTENTION : si un probleme de type survient (ie, on stocke une valeur d'un type
+ // different de celui inscrit dans TypeMap) une exception TypeMismatchException est
+ // levee
+ V.setName(mk);
+ V.setType(TypeMap[mk].type);
+ V.setMaxSize(TypeMap[mk].maxelem);
+
+ return V;
+ }
+
+ // Operateur de recherche dans la map
+ // Cet operateur agit sur les objets CONSTANTS
+ const Versatile & Parametre::operator [] (const string & mk) const
+ {
+ // On controle que la clef est valide
+ if (TypeMap.find(mk) == TypeMap.end()) throw InvalidKeyException(mk.c_str());
+
+ // On recherche la valeur associee
+ Parametre::const_iterator it = find(mk);
+ const Versatile & V = (*it).second;
+
+ return V;
+ }
+
+ // Operateur d'affectation
+ Parametre & Parametre::operator =(const Parametre & PM)
+ {
+ // On ne reaffecte pas l'objet a lui-meme, sinon aie, aie, aie
+ if (this == &PM) return *this;
+
+ // On efface toute la map
+ erase(begin(), end());
+
+ // On recopie la map interne
+ // Meme si cela ne sert a rien pour le moment car les maps internes sont identiques,
+ // il n'est pas exclu que dans un avenir proche elles puissent etre differentes
+ (*this).TypeMap = PM.TypeMap;
+
+ // On recree la structure interne de la map avec les valeurs de celle passee en argument
+ Parametre::const_iterator it;
+ for(it=PM.begin(); it!=PM.end(); it++)
+ insert(make_pair( (*it).first ,
+ Versatile( (*it).second)
+ ) );
+
+ return *this;
+ }
+
+ // Constructeur par recopie
+ Parametre::Parametre(const Parametre & PM)
+ {
+ // inutile car l'objet est vierge : il vient d'etre cree
+ // On efface toute la map
+ // erase(begin(), end());
+
+ // On recopie la map interne
+ (*this).TypeMap = PM.TypeMap;
+
+ // On cree la structure interne de la map avec les valeurs de celle passee en argument
+ Parametre::const_iterator it;
+ for(it=PM.begin();
+ it!=PM.end();
+ it++)
+ insert(
+ make_pair(
+ (*it).first ,
+ Versatile( (*it).second)
+ ) );
+ }
+
+ // map< string, TypeParam > Parametre::getTypeMap() const
+ // {
+ // return TypeMap;
+ // }
+
+}
--- /dev/null
+/*
+ * Parametre.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#ifndef _PARAMETRE_H_
+#define _PARAMETRE_H_
+
+using namespace std;
+#include <map>
+#include <string>
+#include "Batch_InvalidKeyException.hxx"
+#include "Batch_Versatile.hxx"
+
+
+// Ces macros permettent de simplifier l'ajout de nouvelles
+// clefs dans la map Parametre
+// TODO : remplacer ce mecanisme statique par la lecture
+// TODO : d'une descrption dans un fichier exterieur (genre XML)
+
+#define def_extern_MapKey(mk) extern const string & mk;
+#define def_static_MapKey(mk) const string Batch::Parametre::mk(#mk); \
+ const string & mk = Batch::Parametre::mk;
+
+namespace Batch {
+
+ class Parametre : public map< string, Versatile >
+ {
+ public:
+ // Constructeur standard
+ Parametre();
+
+ // Constructeur par recopie
+ Parametre::Parametre(const Parametre & PM);
+
+ // Operateur de recherche dans la map
+ Versatile & operator [] (const string &);
+ const Versatile & operator [] (const string &) const;
+
+ // Operateur d'affectation
+ Parametre & operator =(const Parametre & PM);
+
+ // Declarations statique des clefs de la map
+ // TODO : supprimer les declarations statiques des clefs de la map
+ static const string ACCOUNT;
+ static const string CHECKPOINT;
+ static const string CKPTINTERVAL;
+ static const string CREATIONTIME;
+ static const string EGROUP;
+ static const string ELIGIBLETIME;
+ static const string EUSER;
+ static const string EXECUTABLE;
+ static const string EXECUTIONHOST;
+ static const string HOLD;
+ static const string ID;
+ static const string INFILE;
+ static const string MAIL;
+ static const string MAXCPUTIME;
+ static const string MAXDISKSIZE;
+ static const string MAXRAMSIZE;
+ static const string MAXWALLTIME;
+ static const string MODIFICATIONTIME;
+ static const string NAME;
+ static const string OUTFILE;
+ static const string PID;
+ static const string QUEUE;
+ static const string QUEUEDTIME;
+ static const string SERVER;
+ static const string STARTDATE;
+ static const string STATE;
+ static const string TEXT;
+ static const string TMPDIR;
+ static const string USEDCPUTIME;
+ static const string USEDDISKSIZE;
+ static const string USEDRAMSIZE;
+ static const string USEDWALLTIME;
+ static const string USER;
+
+ protected:
+ map< string, TypeParam > TypeMap; // map interne servant a controler le type de la valeur associee a chaque clef
+
+ private:
+
+ };
+
+}
+
+def_extern_MapKey(ACCOUNT);
+def_extern_MapKey(CHECKPOINT);
+def_extern_MapKey(CKPTINTERVAL);
+def_extern_MapKey(CREATIONTIME);
+def_extern_MapKey(EGROUP);
+def_extern_MapKey(ELIGIBLETIME);
+def_extern_MapKey(EUSER);
+def_extern_MapKey(EXECUTABLE);
+def_extern_MapKey(EXECUTIONHOST);
+def_extern_MapKey(HOLD);
+def_extern_MapKey(ID);
+def_extern_MapKey(INFILE);
+def_extern_MapKey(MAIL);
+def_extern_MapKey(MAXCPUTIME);
+def_extern_MapKey(MAXDISKSIZE);
+def_extern_MapKey(MAXRAMSIZE);
+def_extern_MapKey(MAXWALLTIME);
+def_extern_MapKey(MODIFICATIONTIME);
+def_extern_MapKey(NAME);
+def_extern_MapKey(OUTFILE);
+def_extern_MapKey(PID);
+def_extern_MapKey(QUEUE);
+def_extern_MapKey(QUEUEDTIME);
+def_extern_MapKey(SERVER);
+def_extern_MapKey(STARTDATE);
+def_extern_MapKey(STATE);
+def_extern_MapKey(TEXT);
+def_extern_MapKey(TMPDIR);
+def_extern_MapKey(USEDCPUTIME);
+def_extern_MapKey(USEDDISKSIZE);
+def_extern_MapKey(USEDRAMSIZE);
+def_extern_MapKey(USEDWALLTIME);
+def_extern_MapKey(USER);
+
+#endif
--- /dev/null
+/*
+ * PyVersatile.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Mon Oct 13 12:01:12 2003
+ * Projet : Salome 2
+ *
+ */
+
+#include <string>
+#include <Python.h>
+#include "Batch_TypeMismatchException.hxx"
+#include "Batch_ListIsFullException.hxx"
+#include "Batch_InvalidArgumentException.hxx"
+#include "Batch_PyVersatile.hxx"
+
+namespace Batch {
+
+ // Constructeur a partir d'un objet Versatile
+ PyVersatile::PyVersatile(const Versatile & V) : Versatile(V)
+ {
+ // Nothing to do
+ }
+
+
+ // Constructeur a partir d'un PyObject
+ // Les objets autorises sont les strings et les ints,
+ // ainsi que les listes de strings
+ PyVersatile::PyVersatile(const PyObject * PyO) throw(TypeMismatchException, ListIsFullException, InvalidArgumentException) : Versatile()
+ {
+ PyObject * _PyO = const_cast<PyObject *>(PyO);
+
+ if (PyList_Check(_PyO)) { // c'est une liste
+ _maxsize = PyList_Size(_PyO);
+ for(int i=0; i<_maxsize; i++) {
+ PyObject * val = PyList_GetItem(_PyO, i);
+ if (PyString_Check(val)) {
+ *this += PyString_AsString(val);
+
+ } else if (PyTuple_Check(val) &&
+ (PyTuple_Size(val) == 2) &&
+ PyString_Check( PyTuple_GetItem(val,0) ) &&
+ PyString_Check( PyTuple_GetItem(val,1) ) ) {
+ *this += Couple( PyString_AsString( PyTuple_GetItem(val,0) ),
+ PyString_AsString( PyTuple_GetItem(val,1) )
+ );
+
+ } else {
+ PyErr_SetString(PyExc_RuntimeWarning, "PyVersatile::PyVersatile(const PyObject * PyO) : invalid PyObject");
+ }
+ }
+
+ } else if (PyString_Check(_PyO)) { // c'est une string
+ const char * s = PyString_AsString(_PyO);
+ Versatile V = string(s);
+ *this = V;
+
+ } else if (PyInt_Check(_PyO)) { // c'est un int
+ *this = PyInt_AsLong(_PyO);
+
+ } else { // erreur
+ PyErr_SetString(PyExc_RuntimeWarning, "PyVersatile::PyVersatile(const PyObject * PyO) : invalid PyObject");
+ }
+ }
+
+
+
+ // Conversion de type vers un PyObject
+ PyVersatile::operator PyObject *() const
+ {
+ PyObject * obj;
+
+ if (_maxsize != 1) { // une liste
+ obj = PyList_New(0);
+ for(Versatile::const_iterator it=begin(); it!=end(); it++) {
+ char ch[2] = {0, 0};
+ string st;
+ Couple cp;
+// PyObject * tuple;
+ switch (_discriminator) {
+ // case BOOL:
+ // PyList_Append(obj, PyInt_FromLong(* static_cast<BoolType *>(*it)));
+ // break;
+
+ // case CHAR:
+ // *ch = * static_cast<CharType *>(*it);
+ // PyList_Append(obj, PyString_FromString(ch));
+ // break;
+
+ // case INT:
+ // PyList_Append(obj, PyInt_FromLong(* static_cast<IntType *>(*it)));
+ // break;
+
+ case LONG:
+ PyList_Append(obj, PyInt_FromLong(* static_cast<LongType *>(*it)));
+ break;
+
+ case STRING:
+ st = * static_cast<StringType *>(*it);
+ PyList_Append(obj, PyString_FromString(st.c_str()));
+ break;
+
+ case COUPLE:
+ cp = * static_cast<CoupleType *>(*it);
+// tuple = PyTuple_New(2);
+// PyTuple_SetItem(tuple, 0, PyString_FromString( cp.getLocal().c_str() ) );
+// PyTuple_SetItem(tuple, 1, PyString_FromString( cp.getRemote().c_str() ) );
+// PyList_Append(obj, tuple);
+ PyList_Append(obj, Py_BuildValue("(ss)", cp.getLocal().c_str(), cp.getRemote().c_str() ));
+ break;
+
+ case UNDEFINED:
+ PyList_Append(obj, Py_None);
+ break;
+ }
+
+ }
+
+ } else { // un scalaire
+ char ch[2] = {0, 0};
+ string st;
+ Couple cp;
+// PyObject * tuple;
+ switch (_discriminator) {
+ // case BOOL:
+ // obj = PyInt_FromLong(* static_cast<BoolType *>(front()));
+ // break;
+
+ // case CHAR:
+ // *ch = * static_cast<CharType *>(front());
+ // obj = PyString_FromString(ch);
+ // break;
+
+ // case INT:
+ // obj = PyInt_FromLong(* static_cast<IntType *>(front()));
+ // break;
+
+ case LONG:
+ obj = PyInt_FromLong(* static_cast<LongType *>(front()));
+ break;
+
+ case STRING:
+ st = * static_cast<StringType *>(front());
+ obj = PyString_FromString(st.c_str());
+ break;
+
+ case COUPLE:
+ cp = * static_cast<CoupleType *>(front());
+// tuple = PyTuple_New(2);
+// PyTuple_SetItem(tuple, 0, PyString_FromString( cp.getLocal().c_str() ) );
+// PyTuple_SetItem(tuple, 1, PyString_FromString( cp.getRemote().c_str() ) );
+// obj = PyList_New(0);
+// PyList_Append(obj, tuple);
+ obj = Py_BuildValue("[(ss)]", cp.getLocal().c_str(), cp.getRemote().c_str() );
+ break;
+
+ case UNDEFINED:
+ obj = Py_None;
+ break;
+ }
+ }
+
+ return obj;
+ }
+
+
+ // Operateur d'affectation a partir d'un objet Versatile
+ PyVersatile & PyVersatile::operator =(const Versatile & V)
+ {
+ Versatile * me = this;
+ *me = V;
+ return *this;
+ }
+
+}
+
+
+// COMMENTS
--- /dev/null
+/*
+ * PyVersatile.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Mon Oct 13 12:01:12 2003
+ * Projet : Salome 2
+ *
+ */
+
+#ifndef _PYVERSATILE_H_
+#define _PYVERSATILE_H_
+
+
+#include <Python.h>
+#include "Batch_Versatile.hxx"
+#include "Batch_TypeMismatchException.hxx"
+#include "Batch_ListIsFullException.hxx"
+#include "Batch_InvalidArgumentException.hxx"
+
+namespace Batch {
+
+ class PyVersatile : public Versatile
+ {
+ public:
+ // Constructeur a partir d'un objet Versatile
+ PyVersatile(const Versatile &);
+
+ // Constructeur a partir d'un PyObject
+ PyVersatile(const PyObject *) throw(TypeMismatchException, ListIsFullException, InvalidArgumentException);
+
+ // Conversion de type vers un PyObject
+ operator PyObject *() const;
+
+ // Operateur d'affectation a partir d'un objet Versatile
+ PyVersatile & operator =(const Versatile &);
+
+ protected:
+
+ private:
+
+ };
+
+}
+
+#endif
--- /dev/null
+/*
+ * RunTimeException.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Tue Nov 25 14:04:13 2003
+ * Projet : Salome 2
+ *
+ */
+
+#include "Batch_RunTimeException.hxx"
+
+namespace Batch {
+
+}
--- /dev/null
+/*
+ * RunTimeException.hxx :
+ *
+ * Auteur : %author% - EDF R&D
+ * Mail : mailto:ivan.dutka-malen@der.edf.fr
+ * Date : Tue Nov 25 14:04:13 2003
+ * Projet : Salome 2
+ *
+ */
+
+#ifndef _RUNTIMEEXCEPTION_H_
+#define _RUNTIMEEXCEPTION_H_
+
+
+#include "Batch_GenericException.hxx"
+
+namespace Batch {
+
+ class RunTimeException : public GenericException
+ {
+ public:
+ // Constructeur
+ RunTimeException(string ch = "undefined") : GenericException("RunTimeException", ch) {}
+ };
+
+}
+
+#endif
--- /dev/null
+/*
+ * StringType.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#include <string>
+#include "Batch_StringType.hxx"
+
+namespace Batch {
+
+ // Conversion en chaine
+ string StringType::affiche() const
+ {
+ return _data;
+ }
+
+ // Operateur d'affectation
+ StringType & StringType::operator =(string s)
+ {
+ _data = s;
+ return *this;
+ }
+
+ // Conversion en chaine
+ StringType::operator string() const
+ {
+ return this->_data;
+ }
+
+ // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
+ // qu'il faudra detruire ensuite manuellement
+ GenericType * StringType::clone() const
+ {
+ StringType * pS = new StringType(this->_data);
+ assert(pS != 0);
+ return pS;
+ }
+
+}
--- /dev/null
+/*
+ * StringType.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#ifndef _STRINGTYPE_H_
+#define _STRINGTYPE_H_
+
+using namespace std;
+#include <string>
+#include "Batch_GenericType.hxx"
+
+namespace Batch {
+
+ class StringType : public GenericType
+ {
+ public:
+ // Constructeur
+ StringType(const string & s="") : _data(s) {}
+
+ // Conversion en chaine
+ virtual string affiche() const;
+ virtual operator string() const;
+
+ // Operateur d'affectation
+ virtual StringType & operator =(string);
+
+ // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
+ // qu'il faudra detruire ensuite manuellement
+ virtual GenericType * clone() const;
+
+ protected:
+ string _data;
+
+ private:
+
+ };
+
+}
+
+#endif
--- /dev/null
+/*
+ * TypeMismatchException.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#include "Batch_TypeMismatchException.hxx"
+
+namespace Batch {
+
+}
--- /dev/null
+/*
+ * TypeMismatchException.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#ifndef _TYPEMISMATCHEXCEPTION_H_
+#define _TYPEMISMATCHEXCEPTION_H_
+
+
+#include "Batch_GenericException.hxx"
+
+namespace Batch {
+
+ class TypeMismatchException : public GenericException
+ {
+ public:
+ // Constructeur
+ TypeMismatchException(string ch = "undefined") : GenericException("TypeMismatchException", ch) {}
+ };
+
+}
+
+#endif
+
--- /dev/null
+/*
+ * Versatile.cxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#include <iostream>
+#include <list>
+#include <string>
+#include <sstream>
+//#include "MEDMEM_STRING.hxx"
+#include "Batch_GenericType.hxx"
+#include "Batch_IntType.hxx"
+#include "Batch_BoolType.hxx"
+#include "Batch_CharType.hxx"
+#include "Batch_LongType.hxx"
+#include "Batch_StringType.hxx"
+#include "Batch_Versatile.hxx"
+#include "Batch_TypeMismatchException.hxx"
+#include "Batch_ListIsFullException.hxx"
+
+namespace Batch {
+
+ // Constructeur par recopie
+ Versatile::Versatile(const Versatile & V) : _discriminator(V._discriminator), _maxsize(V._maxsize), _name(V._name) // , _str_value(0)
+ {
+ Versatile::const_iterator it;
+
+ // On prend un a un les elements de l'objet passe en argument qu'on duplique
+ for(it=V.begin(); it!=V.end(); it++)
+ push_back( (*it)->clone() ); // Attention, la methode clone fait un new implicite
+ }
+
+ // Destructeur
+ Versatile::~Versatile()
+ {
+ eraseAll();
+ }
+
+ // Operateur d'affectation entre objets
+ Versatile & Versatile::operator = (const Versatile & Vrhs) throw(TypeMismatchException)
+ {
+ // ATTENTION : le forçage de type leve une exception TypeMismatchException entre cas de conflit
+ setType(Vrhs._discriminator);
+ setMaxSize(Vrhs._maxsize);
+ _name = Vrhs._name;
+
+ // On efface les donnees precedentes
+ eraseAll();
+
+ // On copie les donnees de Vrhs
+ Versatile::const_iterator it;
+
+ for(it=Vrhs.begin(); it!=Vrhs.end(); it++)
+ push_back( (*it)->clone() ); // Attention, la methode clone fait un new implicite
+
+ return *this;
+ }
+
+ // Operateur d'affectation a partir d'un long
+ Versatile & Versatile::operator = (const long l) throw(TypeMismatchException)
+ {
+ // ATTENTION : le forçage de type leve une exception TypeMismatchException entre cas de conflit
+ setType(LONG);
+
+ // On efface les donnees precedentes
+ eraseAll();
+
+ // On ajoute un element interne de type long a l'objet
+ LongType * pL = new LongType(l);
+ assert(pL != 0);
+ push_back(pL);
+ return *this;
+ }
+
+ // Operateur d'affectation a partir d'une string
+ Versatile & Versatile::operator = (const string & ch) throw(TypeMismatchException)
+ {
+ // ATTENTION : le forçage de type leve une exception TypeMismatchException entre cas de conflit
+ setType(STRING);
+
+ // On efface les donnees precedentes
+ eraseAll();
+
+ // On ajoute un element interne de type string a l'objet
+ StringType * pS = new StringType(ch);
+ assert(pS != 0);
+ push_back(pS);
+
+ return *this;
+ }
+
+ // Operateur de concatenation a partir d'une string
+ Versatile & Versatile::operator +=(const string & ch) throw(TypeMismatchException,ListIsFullException)
+ {
+ // ATTENTION : le forçage de type leve une exception TypeMismatchException entre cas de conflit
+ setType(STRING);
+
+ // Si la taille maximale est atteinte, on leve une exception ListIsFullException
+ if (_maxsize == 0) push_back(new StringType(ch));
+ else if ((_maxsize > 0) && (size() < _maxsize)) push_back(new StringType(ch));
+ else {
+ //MEDMEM::STRING msg;
+ ostringstream msg;
+ msg << "Taille maximum : " << _maxsize;
+ throw(ListIsFullException(msg.str()));
+ }
+ return *this;
+ }
+
+ // Operateur de concatenation a partir d'une string
+ Versatile & Versatile::operator , (const string & ch) throw(TypeMismatchException,ListIsFullException)
+ {
+ *this += ch;
+ return *this;
+ }
+
+ // Operateur d'affectation a partir d'un Couple
+ Versatile & Versatile::operator = (const Couple & cp) throw(TypeMismatchException)
+ {
+ // ATTENTION : le forçage de type leve une exception TypeMismatchException entre cas de conflit
+ setType(COUPLE);
+
+ // On efface les donnees precedentes
+ eraseAll();
+
+ // On ajoute un element interne de type Couple a l'objet
+ CoupleType * pC = new CoupleType(cp);
+ assert(pC != 0);
+ push_back(pC);
+
+ return *this;
+ }
+
+ // Operateur de concatenation a partir d'un Couple
+ Versatile & Versatile::operator +=(const Couple & cp) throw(TypeMismatchException,ListIsFullException)
+ {
+ // ATTENTION : le forçage de type leve une exception TypeMismatchException entre cas de conflit
+ setType(COUPLE);
+
+ // Si la taille maximale est atteinte, on leve une exception ListIsFullException
+ if (_maxsize == 0) push_back(new CoupleType(cp));
+ else if ((_maxsize > 0) && (size() < _maxsize)) push_back(new CoupleType(cp));
+ else {
+ //MEDMEM::STRING msg;
+ ostringstream msg;
+ msg << "Taille maximum : " << _maxsize;
+ throw(ListIsFullException(msg.str()));
+ }
+ return *this;
+ }
+
+ // Operateur de concatenation a partir d'un Couple
+ Versatile & Versatile::operator , (const Couple & cp) throw(TypeMismatchException,ListIsFullException)
+ {
+ *this += cp;
+ return *this;
+ }
+
+ ostream & operator << (ostream & os, const Versatile & V)
+ {
+ Versatile::const_iterator it;
+ char * sep = "";
+
+ for(it=V.begin(); it!=V.end(); it++, sep=" ") {
+ string s = (*it)->affiche();
+ os << sep << s;
+ }
+ return os;
+ }
+
+ // Positionnement du type de l'element interne
+ void Versatile::setType(DiscriminatorType t) throw(TypeMismatchException)
+ {
+ // Si le type est deja defini et ne correspond pas au type en argument
+ // une exception TypeMismatchException est levee
+ if ( (_discriminator == UNDEFINED) || (_discriminator == t) )
+ _discriminator = t;
+ else {
+ //MEDMEM::STRING sst;
+ ostringstream sst;
+ sst << "Trying to change type of Versatile object \""
+ << _name << "\"";
+ throw(TypeMismatchException(sst.str()));
+ }
+ }
+
+ // Positionnement du nombre d'elements internes
+ void Versatile::setMaxSize(int i)
+ {
+ _maxsize = i;
+ if (i <= 0) return;
+ // Si la nouvelle taille est inferieure au nombre d'elements deja
+ // presents, les elements en surplus sont effaces (troncature)
+ if (size() > _maxsize)
+ {
+ int reste = size() - _maxsize;
+ Versatile::iterator it;
+ for(it=end(); (it!=begin()) && reste; it--, reste--)
+ {
+ delete back();
+ pop_back();
+ }
+ }
+ }
+
+
+ // Conversion de type vers un long
+ Versatile::operator long() const throw(TypeMismatchException)
+ {
+ // Si le type ne correspond pas ou si la liste contient plus d'un element,
+ // la conversion est impossible et une exception TypeMismatchException
+ // est levee
+ if ( (_maxsize != 1) || (_discriminator != LONG) || (size() == 0) ) {
+ //MEDMEM::STRING sst;
+ ostringstream sst;
+ sst << "Cannot cast Versatile object \""
+ << _name << "\" to long";
+ throw(TypeMismatchException(sst.str()));
+ }
+ return *( static_cast<LongType *>(this->front()) );
+ }
+
+ // Conversion de type vers un Couple
+ Versatile::operator Couple() const throw(TypeMismatchException)
+ {
+ // Si le type ne correspond pas ou si la liste contient plus d'un element,
+ // la conversion est impossible et une exception TypeMismatchException
+ // est levee
+ if ( (_maxsize != 1) || (_discriminator != COUPLE) || (size() == 0) ) {
+ //MEDMEM::STRING sst;
+ ostringstream sst;
+ sst << "Cannot cast Versatile object \""
+ << _name << "\" to Couple";
+ throw(TypeMismatchException(sst.str()));
+ }
+ return *( static_cast<CoupleType *>(this->front()) );
+ }
+
+ // Conversion de type vers une string
+ string Versatile::str() const throw(TypeMismatchException)
+ {
+ // Si le type ne correspond pas, la conversion est impossible et
+ // une exception TypeMismatchException est levee
+ if ( (_discriminator != STRING) || (size() == 0) ) {
+ //MEDMEM::STRING sst;
+ ostringstream sst;
+ sst << "Cannot cast Versatile object \""
+ << _name << "\" to string";
+ throw(TypeMismatchException(sst.str()));
+ }
+
+ // La chaine renvoyee est la concatenation des chaines internes
+ string s;
+ Versatile::const_iterator it;
+ const char * sep = "";
+ for(it=begin(); it!=end(); it++, s+=sep, sep=" ")
+ s += *( static_cast<StringType *>(*it));
+
+ return s;
+ }
+
+ // Conversion de type vers une string
+ Versatile::operator string () const throw(TypeMismatchException)
+ {
+ return str();
+ }
+
+ // Efface tous les elements internes de l'objet
+ void Versatile::eraseAll()
+ {
+ while(!empty())
+ {
+ delete back();
+ pop_back();
+ }
+ }
+
+
+ // Recuperation du type de l'element interne
+ DiscriminatorType Versatile::getType() const
+ {
+ return _discriminator;
+ }
+
+ // Recuperation du nom de l'objet
+ string Versatile::getName() const
+ {
+ return _name;
+ }
+
+ // Positionnement du nom de l'objet
+ void Versatile::setName(const string & name)
+ {
+ _name = name;
+ }
+}
--- /dev/null
+/*
+ * Versatile.hxx :
+ *
+ * Auteur : Ivan DUTKA-MALEN - EDF R&D
+ * Date : Septembre 2003
+ * Projet : SALOME 2
+ *
+ */
+
+#ifndef _VERSATILE_H_
+#define _VERSATILE_H_
+
+using namespace std;
+#include <iostream>
+#include <list>
+#include <string>
+#include "Batch_GenericType.hxx"
+#include "Batch_IntType.hxx"
+#include "Batch_BoolType.hxx"
+#include "Batch_CharType.hxx"
+#include "Batch_LongType.hxx"
+#include "Batch_StringType.hxx"
+#include "Batch_CoupleType.hxx"
+#include "Batch_TypeMismatchException.hxx"
+#include "Batch_ListIsFullException.hxx"
+
+namespace Batch {
+
+ // Les types autorises
+ // enum DiscriminatorType { UNDEFINED, BOOL, CHAR, INT, LONG, STRING};
+ enum DiscriminatorType { UNDEFINED, LONG, STRING, COUPLE };
+
+ typedef struct {
+ DiscriminatorType type; // le type de l'element interne
+ int maxelem; // le nombre d'elements autorises
+ } TypeParam;
+
+ class Versatile : public list< GenericType * >
+ {
+ public:
+ // Constructeur standard et destructeur
+ Versatile() : _discriminator(UNDEFINED), _maxsize(1), _name("undefined") {}
+ virtual ~Versatile();
+
+ // Constructeur par recopie
+ Versatile(const Versatile & V);
+
+ // Constructeur depuis le type de "base"
+ Versatile(long l) : _discriminator(LONG), _maxsize(1), _name("long") { push_back(new LongType(l)); }
+ Versatile(const string & s) : _discriminator(STRING), _maxsize(1), _name("string") { push_back(new StringType(s)); }
+ Versatile(const Couple & c) : _discriminator(COUPLE), _maxsize(1), _name("couple") { push_back(new CoupleType(c)); }
+
+ // Operateur d'affectation et de concatenation a partir d'un type de "base"
+ Versatile & operator = (const long l) throw(TypeMismatchException);
+ Versatile & operator = (const string & ch) throw(TypeMismatchException);
+ Versatile & operator +=(const string & ch) throw(TypeMismatchException,ListIsFullException);
+ Versatile & operator , (const string & ch) throw(TypeMismatchException,ListIsFullException);
+ Versatile & operator = (const Couple & cp) throw(TypeMismatchException);
+ Versatile & operator +=(const Couple & cp) throw(TypeMismatchException,ListIsFullException);
+ Versatile & operator , (const Couple & cp) throw(TypeMismatchException,ListIsFullException);
+
+ // Operateur d'affectation entre objets
+ Versatile & operator = (const Versatile & V) throw(TypeMismatchException);
+
+ // Conversion de type vers un type de "base"
+ operator long() const throw(TypeMismatchException);
+ operator string() const throw(TypeMismatchException);
+ operator Couple() const throw(TypeMismatchException);
+ string str() const throw(TypeMismatchException);
+
+ // Operateur pour l'affichage sur un stream
+ friend ostream & operator << (ostream & os, const Versatile & );
+
+ // Positionnement et recuperation du type de l'element interne
+ void setType(DiscriminatorType) throw(TypeMismatchException);
+ DiscriminatorType getType() const;
+
+ // Positionnement et recuperation du nombre d'elements internes
+ void setMaxSize(int i);
+ int getMaxSize() const { return _maxsize; }
+
+ // Positionnement et recuperation du nom de l'objet
+ string getName() const;
+ void setName(const string & name);
+
+ protected:
+ // Efface tous les elements internes de l'objet
+ virtual void eraseAll();
+
+ DiscriminatorType _discriminator; // type de l'element interne
+ int _maxsize; // nombre max d'elements internes
+ string _name; // nom de l'objet (sert pour les exceptions)
+
+ private:
+
+ };
+
+}
+
+#endif
+
--- /dev/null
+# SALOME Container : implementation of container and engine for Kernel
+#
+# Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+#
+#
+#
+# File : Makefile.in
+# Author : EDF
+# Module : SALOME
+# $Header$
+
+top_srcdir=@top_srcdir@
+top_builddir=../..
+srcdir=@srcdir@
+VPATH=.:@srcdir@:@top_srcdir@/idl
+
+
+@COMMENCE@
+
+EXPORT_HEADERS = \
+ Batch_APIInternalFailureException.hxx \
+ Batch_BatchManager.hxx \
+ Batch_BatchManagerCatalog.hxx \
+ Batch_BoolType.hxx \
+ Batch_CharType.hxx \
+ Batch_ConnexionFailureException.hxx \
+ Batch_Couple.hxx \
+ Batch_CoupleType.hxx \
+ Batch_Date.hxx \
+ Batch_DateType.hxx \
+ Batch_Environnement.hxx \
+ Batch_FactBatchManager.hxx \
+ Batch_GenericException.hxx \
+ Batch_GenericType.hxx \
+ Batch_IntType.hxx \
+ Batch_InvalidArgumentException.hxx \
+ Batch_InvalidKeyException.hxx \
+ Batch_Job.hxx \
+ Batch_JobId.hxx \
+ Batch_JobInfo.hxx \
+ Batch_ListIsFullException.hxx \
+ Batch_LongType.hxx \
+ Batch_MapKey.hxx \
+ Batch_NotYetImplementedException.hxx \
+ Batch_Parametre.hxx \
+ Batch_PyVersatile.hxx \
+ Batch_RunTimeException.hxx \
+ Batch_StringType.hxx \
+ Batch_TypeMismatchException.hxx \
+ Batch_Versatile.hxx
+
+# Specialisation pour OpenPBS
+EXPORT_HEADERS += \
+ Batch_BatchManager_PBS.hxx \
+ Batch_FactBatchManager_PBS.hxx \
+ Batch_JobInfo_PBS.hxx \
+ Batch_Job_PBS.hxx
+
+
+# Libraries targets
+
+LIB = libSalomeBatch.la
+LIB_SRC = \
+ Batch_APIInternalFailureException.cxx \
+ Batch_BatchManager.cxx \
+ Batch_BatchManagerCatalog.cxx \
+ Batch_BoolType.cxx \
+ Batch_CharType.cxx \
+ Batch_ConnexionFailureException.cxx \
+ Batch_Couple.cxx \
+ Batch_CoupleType.cxx \
+ Batch_Date.cxx \
+ Batch_DateType.cxx \
+ Batch_Environnement.cxx \
+ Batch_FactBatchManager.cxx \
+ Batch_GenericException.cxx \
+ Batch_GenericType.cxx \
+ Batch_IntType.cxx \
+ Batch_InvalidArgumentException.cxx \
+ Batch_InvalidKeyException.cxx \
+ Batch_Job.cxx \
+ Batch_JobId.cxx \
+ Batch_JobInfo.cxx \
+ Batch_ListIsFullException.cxx \
+ Batch_LongType.cxx \
+ Batch_MapKey.cxx \
+ Batch_NotYetImplementedException.cxx \
+ Batch_Parametre.cxx \
+ Batch_PyVersatile.cxx \
+ Batch_RunTimeException.cxx \
+ Batch_StringType.cxx \
+ Batch_TypeMismatchException.cxx \
+ Batch_Versatile.cxx
+
+# Specialisation pour OpenPBS
+LIB_SRC += \
+ Batch_BatchManager_PBS.cxx \
+ Batch_FactBatchManager_PBS.cxx \
+ Batch_JobInfo_PBS.cxx \
+ Batch_Job_PBS.cxx
+
+LIB_SERVER_IDL =
+
+
+CPPFLAGS += $(PYTHON_INCLUDES) $(OPENPBS_INCLUDES)
+
+CXXFLAGS += $(PYTHON_INCLUDES) $(OPENPBS_INCLUDES)
+
+LDFLAGS += $(OPENPBS_LIBDIR)
+
+LIBS += $(OPENPBS_LIBS) -lSALOMELocalTrace
+
+@CONCLUDE@
