From: dutka Date: Thu, 7 Oct 2004 07:28:51 +0000 (+0000) Subject: Bibliothèque de classes Batch (new) X-Git-Tag: BR_BATCH_20041020~1 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=d8b3ebb15f468e636388bc39cf2b66bcc698f1f2;p=modules%2Fkernel.git Bibliothèque de classes Batch (new) --- diff --git a/src/Batch/Batch_APIInternalFailureException.cxx b/src/Batch/Batch_APIInternalFailureException.cxx new file mode 100644 index 000000000..42e52aa9e --- /dev/null +++ b/src/Batch/Batch_APIInternalFailureException.cxx @@ -0,0 +1,15 @@ +/* + * 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 { + +} diff --git a/src/Batch/Batch_APIInternalFailureException.hxx b/src/Batch/Batch_APIInternalFailureException.hxx new file mode 100644 index 000000000..14bf01f4f --- /dev/null +++ b/src/Batch/Batch_APIInternalFailureException.hxx @@ -0,0 +1,29 @@ +/* + * 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 diff --git a/src/Batch/Batch_BatchManager.cxx b/src/Batch/Batch_BatchManager.cxx new file mode 100644 index 000000000..e84d3bdaf --- /dev/null +++ b/src/Batch/Batch_BatchManager.cxx @@ -0,0 +1,122 @@ +/* + * BatchManager.cxx : + * + * Auteur : Ivan DUTKA-MALEN - EDF R&D + * Date : Septembre 2003 + * Projet : SALOME 2 + * + */ + +#include +#include +#include +#include +//#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 << "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(); +// } + +} diff --git a/src/Batch/Batch_BatchManager.hxx b/src/Batch/Batch_BatchManager.hxx new file mode 100644 index 000000000..47820ef0b --- /dev/null +++ b/src/Batch/Batch_BatchManager.hxx @@ -0,0 +1,62 @@ +/* + * 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 +#include +#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 diff --git a/src/Batch/Batch_BatchManagerCatalog.cxx b/src/Batch/Batch_BatchManagerCatalog.cxx new file mode 100644 index 000000000..437be93fb --- /dev/null +++ b/src/Batch/Batch_BatchManagerCatalog.cxx @@ -0,0 +1,73 @@ +/* + * BatchManagerCatalog.cxx : + * + * Auteur : Ivan DUTKA-MALEN - EDF R&D + * Date : Septembre 2004 + * Projet : SALOME 2 + * + */ + +#include +#include +#include +#include "Batch_BatchManagerCatalog.hxx" +#include "Batch_FactBatchManager.hxx" + +namespace Batch { + + pthread_mutex_t BatchManagerCatalog::_mutex = PTHREAD_MUTEX_INITIALIZER; + map * 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; + (*BatchManagerCatalog::_p_catalog)[type] = pFBM; + + pthread_mutex_unlock(&_mutex); + } + } + + FactBatchManager * BatchManagerCatalog::operator() (const char * type) const + { + return BatchManagerCatalog::getFactBatchManager(type); + } + + map * BatchManagerCatalog::dict() const + { + return _p_catalog; + } + + string BatchManagerCatalog::__repr__() const + { + ostringstream oss; + oss << "::const_iterator it = (*_p_catalog).begin(); it != (*_p_catalog).end(); it++, sep=", ") { + oss << sep << "'" << (*it).first << "' : '" << (*it).second->__repr__() << "'"; + } + oss << "}>"; + return oss.str(); + } + +} diff --git a/src/Batch/Batch_BatchManagerCatalog.hxx b/src/Batch/Batch_BatchManagerCatalog.hxx new file mode 100644 index 000000000..cff458293 --- /dev/null +++ b/src/Batch/Batch_BatchManagerCatalog.hxx @@ -0,0 +1,47 @@ +/* + * 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 +#include +#include + +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 * dict() const; + virtual string __repr__() const; + + protected: + static map * _p_catalog; + static pthread_mutex_t _mutex; + + private: + + }; + +} + +#endif diff --git a/src/Batch/Batch_BatchManager_PBS.cxx b/src/Batch/Batch_BatchManager_PBS.cxx new file mode 100644 index 000000000..45fceedde --- /dev/null +++ b/src/Batch/Batch_BatchManager_PBS.cxx @@ -0,0 +1,194 @@ +/* + * 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 +#include +} +#include +#include +#include +//#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; + } + + + +} diff --git a/src/Batch/Batch_BatchManager_PBS.hxx b/src/Batch/Batch_BatchManager_PBS.hxx new file mode 100644 index 000000000..53c7437cc --- /dev/null +++ b/src/Batch/Batch_BatchManager_PBS.hxx @@ -0,0 +1,76 @@ +/* + * 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 diff --git a/src/Batch/Batch_BoolType.cxx b/src/Batch/Batch_BoolType.cxx new file mode 100644 index 000000000..b70696341 --- /dev/null +++ b/src/Batch/Batch_BoolType.cxx @@ -0,0 +1,43 @@ +/* + * BoolType.cxx : + * + * Auteur : Ivan DUTKA-MALEN - EDF R&D + * Date : Septembre 2003 + * Projet : SALOME 2 + * + */ + +#include +#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; + } + +} diff --git a/src/Batch/Batch_BoolType.hxx b/src/Batch/Batch_BoolType.hxx new file mode 100644 index 000000000..1bb58d16d --- /dev/null +++ b/src/Batch/Batch_BoolType.hxx @@ -0,0 +1,47 @@ +/* + * 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 +#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 diff --git a/src/Batch/Batch_CharType.cxx b/src/Batch/Batch_CharType.cxx new file mode 100644 index 000000000..66197f84c --- /dev/null +++ b/src/Batch/Batch_CharType.cxx @@ -0,0 +1,43 @@ +/* + * CharType.cxx : + * + * Auteur : Ivan DUTKA-MALEN - EDF R&D + * Date : Septembre 2003 + * Projet : SALOME 2 + * + */ + +#include +#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; + } + +} diff --git a/src/Batch/Batch_CharType.hxx b/src/Batch/Batch_CharType.hxx new file mode 100644 index 000000000..0aae9f45b --- /dev/null +++ b/src/Batch/Batch_CharType.hxx @@ -0,0 +1,48 @@ +/* + * 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 +#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 + diff --git a/src/Batch/Batch_ConnexionFailureException.cxx b/src/Batch/Batch_ConnexionFailureException.cxx new file mode 100644 index 000000000..df1096fd9 --- /dev/null +++ b/src/Batch/Batch_ConnexionFailureException.cxx @@ -0,0 +1,15 @@ +/* + * 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 { + +} diff --git a/src/Batch/Batch_ConnexionFailureException.hxx b/src/Batch/Batch_ConnexionFailureException.hxx new file mode 100644 index 000000000..22d9584b2 --- /dev/null +++ b/src/Batch/Batch_ConnexionFailureException.hxx @@ -0,0 +1,30 @@ +/* + * 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 + diff --git a/src/Batch/Batch_Couple.cxx b/src/Batch/Batch_Couple.cxx new file mode 100644 index 000000000..8a08d7040 --- /dev/null +++ b/src/Batch/Batch_Couple.cxx @@ -0,0 +1,41 @@ +/* + * 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(); + } + +} diff --git a/src/Batch/Batch_Couple.hxx b/src/Batch/Batch_Couple.hxx new file mode 100644 index 000000000..4efe11762 --- /dev/null +++ b/src/Batch/Batch_Couple.hxx @@ -0,0 +1,52 @@ +/* + * 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 + +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 + diff --git a/src/Batch/Batch_CoupleType.cxx b/src/Batch/Batch_CoupleType.cxx new file mode 100644 index 000000000..1de0b21f0 --- /dev/null +++ b/src/Batch/Batch_CoupleType.cxx @@ -0,0 +1,50 @@ +/* + * 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; + } + +} + diff --git a/src/Batch/Batch_CoupleType.hxx b/src/Batch/Batch_CoupleType.hxx new file mode 100644 index 000000000..a8913d575 --- /dev/null +++ b/src/Batch/Batch_CoupleType.hxx @@ -0,0 +1,50 @@ +/* + * 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 +#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 diff --git a/src/Batch/Batch_Date.cxx b/src/Batch/Batch_Date.cxx new file mode 100644 index 000000000..9ac52b12d --- /dev/null +++ b/src/Batch/Batch_Date.cxx @@ -0,0 +1,169 @@ +/* + * 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 +#include +#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 diff --git a/src/Batch/Batch_Date.hxx b/src/Batch/Batch_Date.hxx new file mode 100644 index 000000000..0091850d1 --- /dev/null +++ b/src/Batch/Batch_Date.hxx @@ -0,0 +1,45 @@ +/* + * 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 + +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 diff --git a/src/Batch/Batch_DateType.cxx b/src/Batch/Batch_DateType.cxx new file mode 100644 index 000000000..fac8830d6 --- /dev/null +++ b/src/Batch/Batch_DateType.cxx @@ -0,0 +1,51 @@ +/* + * 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 +} +#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; + } + +} diff --git a/src/Batch/Batch_DateType.hxx b/src/Batch/Batch_DateType.hxx new file mode 100644 index 000000000..868272086 --- /dev/null +++ b/src/Batch/Batch_DateType.hxx @@ -0,0 +1,52 @@ +/* + * 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 +#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 + diff --git a/src/Batch/Batch_Environnement.cxx b/src/Batch/Batch_Environnement.cxx new file mode 100644 index 000000000..d658d3855 --- /dev/null +++ b/src/Batch/Batch_Environnement.cxx @@ -0,0 +1,16 @@ +/* + * 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 { + + +} diff --git a/src/Batch/Batch_Environnement.hxx b/src/Batch/Batch_Environnement.hxx new file mode 100644 index 000000000..cda22aeff --- /dev/null +++ b/src/Batch/Batch_Environnement.hxx @@ -0,0 +1,26 @@ +/* + * 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 +#include + +namespace Batch { + + typedef map < string, string > Environnement; + +} + +#endif + diff --git a/src/Batch/Batch_FactBatchManager.cxx b/src/Batch/Batch_FactBatchManager.cxx new file mode 100644 index 000000000..c8123cbfd --- /dev/null +++ b/src/Batch/Batch_FactBatchManager.cxx @@ -0,0 +1,46 @@ +/* + * FactBatchManager.cxx : + * + * Auteur : Ivan DUTKA-MALEN - EDF R&D + * Date : Septembre 2004 + * Projet : SALOME 2 + * + */ + +#include +#include +#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 << ""; + return oss.str(); + } + +} diff --git a/src/Batch/Batch_FactBatchManager.hxx b/src/Batch/Batch_FactBatchManager.hxx new file mode 100644 index 000000000..4e4282344 --- /dev/null +++ b/src/Batch/Batch_FactBatchManager.hxx @@ -0,0 +1,41 @@ +/* + * 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 +#include + +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 diff --git a/src/Batch/Batch_FactBatchManager_PBS.cxx b/src/Batch/Batch_FactBatchManager_PBS.cxx new file mode 100644 index 000000000..3a0e39763 --- /dev/null +++ b/src/Batch/Batch_FactBatchManager_PBS.cxx @@ -0,0 +1,39 @@ +/* + * FactBatchManager_PBS.cxx : + * + * Auteur : Ivan DUTKA-MALEN - EDF R&D + * Date : Septembre 2004 + * Projet : SALOME 2 + * + */ + +#include +#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); + } + + +} diff --git a/src/Batch/Batch_FactBatchManager_PBS.hxx b/src/Batch/Batch_FactBatchManager_PBS.hxx new file mode 100644 index 000000000..55d4bec90 --- /dev/null +++ b/src/Batch/Batch_FactBatchManager_PBS.hxx @@ -0,0 +1,39 @@ +/* + * 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 +#include +#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 diff --git a/src/Batch/Batch_GenericException.cxx b/src/Batch/Batch_GenericException.cxx new file mode 100644 index 000000000..6cf7a935f --- /dev/null +++ b/src/Batch/Batch_GenericException.cxx @@ -0,0 +1,15 @@ +/* + * 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 { + +} diff --git a/src/Batch/Batch_GenericException.hxx b/src/Batch/Batch_GenericException.hxx new file mode 100644 index 000000000..59ecd8413 --- /dev/null +++ b/src/Batch/Batch_GenericException.hxx @@ -0,0 +1,32 @@ +/* + * 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 + +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 diff --git a/src/Batch/Batch_GenericType.cxx b/src/Batch/Batch_GenericType.cxx new file mode 100644 index 000000000..997222a73 --- /dev/null +++ b/src/Batch/Batch_GenericType.cxx @@ -0,0 +1,42 @@ +/* + * GenericType.cxx : + * + * Auteur : Ivan DUTKA-MALEN - EDF R&D + * Date : Septembre 2003 + * Projet : SALOME 2 + * + */ + + +#include +#include +#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; + } + +} + diff --git a/src/Batch/Batch_GenericType.hxx b/src/Batch/Batch_GenericType.hxx new file mode 100644 index 000000000..5a3dfe28e --- /dev/null +++ b/src/Batch/Batch_GenericType.hxx @@ -0,0 +1,50 @@ +/* + * 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 +#include + +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 + diff --git a/src/Batch/Batch_IntType.cxx b/src/Batch/Batch_IntType.cxx new file mode 100644 index 000000000..b5b1eb9cb --- /dev/null +++ b/src/Batch/Batch_IntType.cxx @@ -0,0 +1,49 @@ +/* + * IntType.cxx : + * + * Auteur : Ivan DUTKA-MALEN - EDF R&D + * Date : Septembre 2003 + * Projet : SALOME 2 + * + */ + +#include +#include +//#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; + } + +} diff --git a/src/Batch/Batch_IntType.hxx b/src/Batch/Batch_IntType.hxx new file mode 100644 index 000000000..6d07fe50f --- /dev/null +++ b/src/Batch/Batch_IntType.hxx @@ -0,0 +1,47 @@ +/* + * 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 +#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 diff --git a/src/Batch/Batch_InvalidArgumentException.cxx b/src/Batch/Batch_InvalidArgumentException.cxx new file mode 100644 index 000000000..fa077bcbb --- /dev/null +++ b/src/Batch/Batch_InvalidArgumentException.cxx @@ -0,0 +1,15 @@ +/* + * 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 { + +} diff --git a/src/Batch/Batch_InvalidArgumentException.hxx b/src/Batch/Batch_InvalidArgumentException.hxx new file mode 100644 index 000000000..62a972bd4 --- /dev/null +++ b/src/Batch/Batch_InvalidArgumentException.hxx @@ -0,0 +1,30 @@ +/* + * 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 + diff --git a/src/Batch/Batch_InvalidKeyException.cxx b/src/Batch/Batch_InvalidKeyException.cxx new file mode 100644 index 000000000..bec522ef9 --- /dev/null +++ b/src/Batch/Batch_InvalidKeyException.cxx @@ -0,0 +1,16 @@ +/* + * 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 { + +} + diff --git a/src/Batch/Batch_InvalidKeyException.hxx b/src/Batch/Batch_InvalidKeyException.hxx new file mode 100644 index 000000000..8e0c45b9c --- /dev/null +++ b/src/Batch/Batch_InvalidKeyException.hxx @@ -0,0 +1,35 @@ +/* + * 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 + diff --git a/src/Batch/Batch_Job.cxx b/src/Batch/Batch_Job.cxx new file mode 100644 index 000000000..6fa203ed5 --- /dev/null +++ b/src/Batch/Batch_Job.cxx @@ -0,0 +1,95 @@ +/* + * Job.cxx : + * + * Auteur : Ivan DUTKA-MALEN - EDF R&D + * Date : Septembre 2003 + * Projet : SALOME 2 + * + */ + +#include "Batch_Job.hxx" +#include "Batch_Parametre.hxx" +#include +//#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 << ""; + return str.str(); + } + + +} diff --git a/src/Batch/Batch_Job.hxx b/src/Batch/Batch_Job.hxx new file mode 100644 index 000000000..efd8a90ce --- /dev/null +++ b/src/Batch/Batch_Job.hxx @@ -0,0 +1,55 @@ +/* + * 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 diff --git a/src/Batch/Batch_JobId.cxx b/src/Batch/Batch_JobId.cxx new file mode 100644 index 000000000..f642b4ce2 --- /dev/null +++ b/src/Batch/Batch_JobId.cxx @@ -0,0 +1,114 @@ +/* + * JobId.cxx : + * + * Auteur : Ivan DUTKA-MALEN - EDF R&D + * Date : Septembre 2003 + * Projet : SALOME 2 + * + */ + +#include "Batch_JobId.hxx" +#include "Batch_BatchManager.hxx" +#include +//#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 << ""; + return str.str(); + } + +} diff --git a/src/Batch/Batch_JobId.hxx b/src/Batch/Batch_JobId.hxx new file mode 100644 index 000000000..d2811bc6d --- /dev/null +++ b/src/Batch/Batch_JobId.hxx @@ -0,0 +1,68 @@ +/* + * 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 diff --git a/src/Batch/Batch_JobInfo.cxx b/src/Batch/Batch_JobInfo.cxx new file mode 100644 index 000000000..3192f21d5 --- /dev/null +++ b/src/Batch/Batch_JobInfo.cxx @@ -0,0 +1,73 @@ +/* + * 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 +#include +#include +//#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 << ""; + + return sst.str(); + } + + // Accesseur + Parametre JobInfo::getParametre() const + { + return _param; + } + + // Accesseur + Environnement JobInfo::getEnvironnement() const + { + return _env; + } + + +} diff --git a/src/Batch/Batch_JobInfo.hxx b/src/Batch/Batch_JobInfo.hxx new file mode 100644 index 000000000..093d8e3a9 --- /dev/null +++ b/src/Batch/Batch_JobInfo.hxx @@ -0,0 +1,54 @@ +/* + * 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 +#include +#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 diff --git a/src/Batch/Batch_JobInfo_PBS.cxx b/src/Batch/Batch_JobInfo_PBS.cxx new file mode 100644 index 000000000..a079b9249 --- /dev/null +++ b/src/Batch/Batch_JobInfo_PBS.cxx @@ -0,0 +1,176 @@ +/* + * 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 +#include +//#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 << " +#include +} +#include +#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 diff --git a/src/Batch/Batch_Job_PBS.cxx b/src/Batch/Batch_Job_PBS.cxx new file mode 100644 index 000000000..78450133e --- /dev/null +++ b/src/Batch/Batch_Job_PBS.cxx @@ -0,0 +1,450 @@ +/* + * 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 +#include +#include +#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; iinext; + 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; + } + +} diff --git a/src/Batch/Batch_Job_PBS.hxx b/src/Batch/Batch_Job_PBS.hxx new file mode 100644 index 000000000..b93c9998e --- /dev/null +++ b/src/Batch/Batch_Job_PBS.hxx @@ -0,0 +1,75 @@ +/* + * 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 +#include +} +#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 diff --git a/src/Batch/Batch_ListIsFullException.cxx b/src/Batch/Batch_ListIsFullException.cxx new file mode 100644 index 000000000..aba5d44ab --- /dev/null +++ b/src/Batch/Batch_ListIsFullException.cxx @@ -0,0 +1,15 @@ +/* + * ListIsFullException.cxx : + * + * Auteur : Ivan DUTKA-MALEN - EDF R&D + * Date : Septembre 2003 + * Projet : SALOME 2 + * + */ + +#include "Batch_ListIsFullException.hxx" + + +namespace Batch { + +} diff --git a/src/Batch/Batch_ListIsFullException.hxx b/src/Batch/Batch_ListIsFullException.hxx new file mode 100644 index 000000000..c9807b132 --- /dev/null +++ b/src/Batch/Batch_ListIsFullException.hxx @@ -0,0 +1,27 @@ +/* + * 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 + diff --git a/src/Batch/Batch_LongType.cxx b/src/Batch/Batch_LongType.cxx new file mode 100644 index 000000000..2bd92c6c0 --- /dev/null +++ b/src/Batch/Batch_LongType.cxx @@ -0,0 +1,48 @@ +/* + * LongType.cxx : + * + * Auteur : Ivan DUTKA-MALEN - EDF R&D + * Date : Septembre 2003 + * Projet : SALOME 2 + * + */ + +#include +#include +//#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; + } + +} diff --git a/src/Batch/Batch_LongType.hxx b/src/Batch/Batch_LongType.hxx new file mode 100644 index 000000000..bf82d2ed3 --- /dev/null +++ b/src/Batch/Batch_LongType.hxx @@ -0,0 +1,47 @@ +/* + * 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 +#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 diff --git a/src/Batch/Batch_MapKey.cxx b/src/Batch/Batch_MapKey.cxx new file mode 100644 index 000000000..170bd00cf --- /dev/null +++ b/src/Batch/Batch_MapKey.cxx @@ -0,0 +1,20 @@ +/* + * 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 +#include "Batch_MapKey.hxx" + +namespace Batch { + + +} + + +// COMMENTS diff --git a/src/Batch/Batch_MapKey.hxx b/src/Batch/Batch_MapKey.hxx new file mode 100644 index 000000000..caee3633f --- /dev/null +++ b/src/Batch/Batch_MapKey.hxx @@ -0,0 +1,47 @@ +/* + * 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 + +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 + 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 diff --git a/src/Batch/Batch_NotYetImplementedException.cxx b/src/Batch/Batch_NotYetImplementedException.cxx new file mode 100644 index 000000000..d5b248241 --- /dev/null +++ b/src/Batch/Batch_NotYetImplementedException.cxx @@ -0,0 +1,16 @@ +/* + * 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 { + +} + diff --git a/src/Batch/Batch_NotYetImplementedException.hxx b/src/Batch/Batch_NotYetImplementedException.hxx new file mode 100644 index 000000000..753290d81 --- /dev/null +++ b/src/Batch/Batch_NotYetImplementedException.hxx @@ -0,0 +1,29 @@ +/* + * 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 + diff --git a/src/Batch/Batch_Parametre.cxx b/src/Batch/Batch_Parametre.cxx new file mode 100644 index 000000000..fb8605c1b --- /dev/null +++ b/src/Batch/Batch_Parametre.cxx @@ -0,0 +1,248 @@ +/* + * Parametre.cxx : + * + * Auteur : Ivan DUTKA-MALEN - EDF R&D + * Date : Septembre 2003 + * Projet : SALOME 2 + * + */ + +#include +#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; + // } + +} diff --git a/src/Batch/Batch_Parametre.hxx b/src/Batch/Batch_Parametre.hxx new file mode 100644 index 000000000..5a2d78a52 --- /dev/null +++ b/src/Batch/Batch_Parametre.hxx @@ -0,0 +1,126 @@ +/* + * 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 +#include +#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 diff --git a/src/Batch/Batch_PyVersatile.cxx b/src/Batch/Batch_PyVersatile.cxx new file mode 100644 index 000000000..fc3a79276 --- /dev/null +++ b/src/Batch/Batch_PyVersatile.cxx @@ -0,0 +1,179 @@ +/* + * 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 +#include +#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(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(*it))); + // break; + + // case CHAR: + // *ch = * static_cast(*it); + // PyList_Append(obj, PyString_FromString(ch)); + // break; + + // case INT: + // PyList_Append(obj, PyInt_FromLong(* static_cast(*it))); + // break; + + case LONG: + PyList_Append(obj, PyInt_FromLong(* static_cast(*it))); + break; + + case STRING: + st = * static_cast(*it); + PyList_Append(obj, PyString_FromString(st.c_str())); + break; + + case COUPLE: + cp = * static_cast(*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(front())); + // break; + + // case CHAR: + // *ch = * static_cast(front()); + // obj = PyString_FromString(ch); + // break; + + // case INT: + // obj = PyInt_FromLong(* static_cast(front())); + // break; + + case LONG: + obj = PyInt_FromLong(* static_cast(front())); + break; + + case STRING: + st = * static_cast(front()); + obj = PyString_FromString(st.c_str()); + break; + + case COUPLE: + cp = * static_cast(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 diff --git a/src/Batch/Batch_PyVersatile.hxx b/src/Batch/Batch_PyVersatile.hxx new file mode 100644 index 000000000..c8321fb56 --- /dev/null +++ b/src/Batch/Batch_PyVersatile.hxx @@ -0,0 +1,46 @@ +/* + * 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 +#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 diff --git a/src/Batch/Batch_RunTimeException.cxx b/src/Batch/Batch_RunTimeException.cxx new file mode 100644 index 000000000..fd9156078 --- /dev/null +++ b/src/Batch/Batch_RunTimeException.cxx @@ -0,0 +1,15 @@ +/* + * 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 { + +} diff --git a/src/Batch/Batch_RunTimeException.hxx b/src/Batch/Batch_RunTimeException.hxx new file mode 100644 index 000000000..53194ac0b --- /dev/null +++ b/src/Batch/Batch_RunTimeException.hxx @@ -0,0 +1,28 @@ +/* + * 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 diff --git a/src/Batch/Batch_StringType.cxx b/src/Batch/Batch_StringType.cxx new file mode 100644 index 000000000..4d71c333c --- /dev/null +++ b/src/Batch/Batch_StringType.cxx @@ -0,0 +1,43 @@ +/* + * StringType.cxx : + * + * Auteur : Ivan DUTKA-MALEN - EDF R&D + * Date : Septembre 2003 + * Projet : SALOME 2 + * + */ + +#include +#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; + } + +} diff --git a/src/Batch/Batch_StringType.hxx b/src/Batch/Batch_StringType.hxx new file mode 100644 index 000000000..4471b2976 --- /dev/null +++ b/src/Batch/Batch_StringType.hxx @@ -0,0 +1,45 @@ +/* + * 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 +#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 diff --git a/src/Batch/Batch_TypeMismatchException.cxx b/src/Batch/Batch_TypeMismatchException.cxx new file mode 100644 index 000000000..7376eedb6 --- /dev/null +++ b/src/Batch/Batch_TypeMismatchException.cxx @@ -0,0 +1,14 @@ +/* + * TypeMismatchException.cxx : + * + * Auteur : Ivan DUTKA-MALEN - EDF R&D + * Date : Septembre 2003 + * Projet : SALOME 2 + * + */ + +#include "Batch_TypeMismatchException.hxx" + +namespace Batch { + +} diff --git a/src/Batch/Batch_TypeMismatchException.hxx b/src/Batch/Batch_TypeMismatchException.hxx new file mode 100644 index 000000000..fb6d1f913 --- /dev/null +++ b/src/Batch/Batch_TypeMismatchException.hxx @@ -0,0 +1,28 @@ +/* + * 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 + diff --git a/src/Batch/Batch_Versatile.cxx b/src/Batch/Batch_Versatile.cxx new file mode 100644 index 000000000..a0adaf1bc --- /dev/null +++ b/src/Batch/Batch_Versatile.cxx @@ -0,0 +1,300 @@ +/* + * Versatile.cxx : + * + * Auteur : Ivan DUTKA-MALEN - EDF R&D + * Date : Septembre 2003 + * Projet : SALOME 2 + * + */ + +#include +#include +#include +#include +//#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(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(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(*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; + } +} diff --git a/src/Batch/Batch_Versatile.hxx b/src/Batch/Batch_Versatile.hxx new file mode 100644 index 000000000..bf44b961e --- /dev/null +++ b/src/Batch/Batch_Versatile.hxx @@ -0,0 +1,101 @@ +/* + * 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 +#include +#include +#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 + diff --git a/src/Batch/Makefile.in b/src/Batch/Makefile.in new file mode 100644 index 000000000..703e6c7e1 --- /dev/null +++ b/src/Batch/Makefile.in @@ -0,0 +1,130 @@ +# 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@