*/
#include "Batch_APIInternalFailureException.hxx"
+using namespace std;
namespace Batch {
#include "Batch_InvalidArgumentException.hxx"
#include "Batch_FactBatchManager.hxx"
#include "Batch_BatchManager.hxx"
+using namespace std;
namespace Batch {
#ifndef _BATCHMANAGER_H_
#define _BATCHMANAGER_H_
-using namespace std;
#include <string>
#include <map>
#include "Batch_Job.hxx"
{
public:
// Constructeur et destructeur
- //BatchManager(string host="localhost") throw(InvalidArgumentException); // connexion a la machine host
+ //BatchManager(std::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;
+ virtual std::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 std::string & ref);
virtual const JobId getJobIdByReference(const char * ref);
// Methodes pour le controle des jobs : virtuelles pures
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
+ std::string _hostname; // serveur ou tourne le BatchManager
+ std::map< const std::string, const JobId * > jobid_map; // table des jobs deja soumis
const FactBatchManager * _parent;
private:
#include <map>
#include "Batch_BatchManagerCatalog.hxx"
#include "Batch_FactBatchManager.hxx"
+using namespace std;
namespace Batch {
#ifndef _CATALOG_H_
#define _CATALOG_H_
-using namespace std;
#include <string>
#include <map>
#include <pthread.h>
static void addFactBatchManager(const char * type, FactBatchManager * pFBM);
virtual FactBatchManager * operator() (const char * type) const;
- virtual map<string, FactBatchManager *> * dict() const;
- virtual string __repr__() const;
+ virtual std::map<std::string, FactBatchManager *> * dict() const;
+ virtual std::string __repr__() const;
protected:
- static map<string, FactBatchManager *> * _p_catalog;
+ static std::map<std::string, FactBatchManager *> * _p_catalog;
static pthread_mutex_t _mutex;
private:
#include <sstream>
//#include "MEDMEM_STRING.hxx"
#include "Batch_BatchManager_PBS.hxx"
+using namespace std;
namespace Batch {
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(std::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();
+ // static std::string BatchManager_PBS::getDefaultServer();
// Methodes pour le controle des jobs
virtual const JobId submitJob(const Job & job); // soumet un job au gestionnaire
#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 std::string & ref) { return BatchManager::getJobIdByReference(ref); }
virtual const JobId getJobIdByReference(const char * ref) { return BatchManager::getJobIdByReference(ref); }
#endif
#include <string>
#include "Batch_BoolType.hxx"
+using namespace std;
namespace Batch {
#ifndef _BOOLTYPE_H_
#define _BOOLTYPE_H_
-using namespace std;
#include <string>
#include "Batch_GenericType.hxx"
BoolType(const bool b=false) : _data(b) {}
// Conversion en chaine
- virtual string affiche() const;
+ virtual std::string affiche() const;
// Operateur d'affectation
virtual BoolType & operator =(bool);
#include <string>
#include "Batch_CharType.hxx"
+using namespace std;
namespace Batch {
#ifndef _CHARTYPE_H_
#define _CHARTYPE_H_
-using namespace std;
#include <string>
#include "Batch_GenericType.hxx"
CharType(const char c=0) : _data(c) {}
// Conversion en chaine
- virtual string affiche() const;
+ virtual std::string affiche() const;
// Operateur d'affectation
virtual CharType & operator =(char);
*/
#include "Batch_ConnexionFailureException.hxx"
+using namespace std;
namespace Batch {
{
public:
// Constructeur
- ConnexionFailureException(string ch = "undefined") : GenericException("ConnexionFailureException", ch) {}
+ ConnexionFailureException(std::string ch = "undefined") : GenericException("ConnexionFailureException", ch) {}
};
*/
#include "Batch_Couple.hxx"
+using namespace std;
namespace Batch {
#ifndef _COUPLE_H_
#define _COUPLE_H_
-using namespace std;
#include <string>
namespace Batch {
{
public:
// Constructeur standard
- Couple(const string & local="", const string & remote="") : _local(local), _remote(remote) {}
+ Couple(const std::string & local="", const std::string & remote="") : _local(local), _remote(remote) {}
// Constructeur par recopie
Couple(const Couple & C) : _local(C._local), _remote(C._remote) {}
virtual Couple & operator =(const Couple &);
// Conversion en chaine
- virtual string str() const;
+ virtual std::string str() const;
// Accesseurs
- virtual string getLocal() const { return _local; }
- virtual string getRemote() const { return _remote; }
+ virtual std::string getLocal() const { return _local; }
+ virtual std::string getRemote() const { return _remote; }
protected:
- string _local; // chemin d'acces au fichier local
- string _remote; // chemin d'acees au fichier distant
+ std::string _local; // chemin d'acces au fichier local
+ std::string _remote; // chemin d'acees au fichier distant
private:
*/
#include "Batch_CoupleType.hxx"
+using namespace std;
namespace Batch {
#ifndef _COUPLETYPE_H_
#define _COUPLETYPE_H_
-using namespace std;
#include <string>
#include "Batch_GenericType.hxx"
#include "Batch_Couple.hxx"
CoupleType(const Couple & C) : _data(C) {}
// Conversion en chaine
- virtual string affiche() const;
- virtual operator string() const;
+ virtual std::string affiche() const;
+ virtual operator std::string() const;
// Operateur d'affectation
virtual CoupleType & operator =(const Couple & C);
#include <cstdio>
#include <ctime>
#include "Batch_Date.hxx"
+using namespace std;
namespace Batch {
#ifndef _DATE_H_
#define _DATE_H_
-using namespace std;
#include <string>
namespace Batch {
{
public:
Date(const long l=0);
- Date(const string s);
+ Date(const std::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 Date & operator =(const std::string & s);
+ virtual std::string str() const;
virtual long epoch() const;
protected:
#include <time.h>
}
#include "Batch_DateType.hxx"
+using namespace std;
namespace Batch {
#ifndef _DATETYPE_H_
#define _DATETYPE_H_
-using namespace std;
#include <string>
#include "Batch_GenericType.hxx"
#include "Batch_Date.hxx"
DateType(const Date & d) : _data(d) {};
// Conversion en chaine
- virtual string affiche() const;
+ virtual std::string affiche() const;
// Operateur d'affectation
virtual DateType & operator =(const Date &);
*/
#include "Batch_Environnement.hxx"
+using namespace std;
namespace Batch {
#define _ENVIRONNEMENT_H_
-using namespace std;
#include <string>
#include <map>
namespace Batch {
- typedef map < string, string > Environnement;
+ typedef std::map < std::string, std::string > Environnement;
}
#include "Batch_BatchManagerCatalog.hxx"
#include "Batch_FactBatchManager.hxx"
#include "utilities.h"
+using namespace std;
namespace Batch {
#ifndef _FACTBATCHMANAGER_H_
#define _FACTBATCHMANAGER_H_
-using namespace std;
#include <string>
#include <map>
{
public:
// Constructeur et destructeur
- FactBatchManager(const string & type);
+ FactBatchManager(const std::string & type);
virtual ~FactBatchManager();
virtual BatchManager * operator() (const char * hostname) const = 0;
- string getType() const;
- string __repr__() const;
+ std::string getType() const;
+ std::string __repr__() const;
protected:
- string type;
+ std::string type;
private:
#include "Batch_BatchManager_PBS.hxx"
#include "Batch_FactBatchManager_PBS.hxx"
#include "utilities.h"
+using namespace std;
namespace Batch {
#ifndef _FACTBATCHMANAGER_PBS_H_
#define _FACTBATCHMANAGER_PBS_H_
-using namespace std;
-#include <string>
-#include <map>
#include "Batch_FactBatchManager.hxx"
namespace Batch {
*/
#include "Batch_GenericException.hxx"
+using namespace std;
namespace Batch {
#define _GENERICEXCEPTION_H_
-using namespace std;
#include <string>
namespace Batch {
class GenericException
{
public:
- const string type; // la nature de l'exception
- const string message; // la raison de l'exception
+ const std::string type; // la nature de l'exception
+ const std::string message; // la raison de l'exception
// Constructeur
- GenericException(const string tp = "GenericException", const string ch = "undefined") : type(tp), message(ch) {}
+ GenericException(const std::string tp = "GenericException", const std::string ch = "undefined") : type(tp), message(ch) {}
};
}
#include <iostream>
#include <string>
#include "Batch_GenericType.hxx"
+using namespace std;
namespace Batch {
#define _GENERICTYPE_H_
-using namespace std;
#include <iostream>
#include <string>
virtual ~GenericType() { _nb--; }
// Operateur pour l'affichage sur un stream
- friend ostream & operator << (ostream & os, const GenericType & obj);
+ friend std::ostream & operator << (std::ostream & os, const GenericType & obj);
// Conversion en chaine
- virtual string affiche() const;
+ virtual std::string affiche() const;
// Clone duplique l'objet et en fabrique un nouveau a l'aide de new
// qu'il faudra detruire ensuite manuellement
#include <sstream>
//#include "MEDMEM_STRING.hxx"
#include "Batch_IntType.hxx"
+using namespace std;
namespace Batch {
#ifndef _INTTYPE_H_
#define _INTTYPE_H_
-using namespace std;
#include <string>
#include "Batch_GenericType.hxx"
IntType(const int i=0) : _data(i) {}
// Conversion en chaine
- virtual string affiche() const;
+ virtual std::string affiche() const;
// Operateur d'affectation
virtual IntType & operator =(int);
*/
#include "Batch_InvalidArgumentException.hxx"
+using namespace std;
namespace Batch {
*/
#include "Batch_InvalidKeyException.hxx"
+using namespace std;
namespace Batch {
{
public:
// Constructeur
- InvalidKeyException(string ch = "undefined") : GenericException("InvalidKeyException", ch) {}
+ InvalidKeyException(std::string ch = "undefined") : GenericException("InvalidKeyException", ch) {}
protected:
#include "Batch_Parametre.hxx"
#include <sstream>
//#include "MEDMEM_STRING.hxx"
+using namespace std;
namespace Batch {
virtual ~Job() {}
// Operateur pour l'affichage sur un stream
- friend ostream & operator <<(ostream & os, const Job & job);
+ friend std::ostream & operator <<(std::ostream & os, const Job & job);
// Accesseurs
Parametre getParametre() 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
+ std::string __str__() const; // SWIG : affichage en Python
+ std::string __repr__() const { return __str__(); }; // SWIG : affichage en Python
protected:
Parametre _param; // table des parametres batch du job
#include "Batch_BatchManager.hxx"
#include <sstream>
//#include "MEDMEM_STRING.hxx"
+using namespace std;
namespace Batch {
virtual ~JobId();
// Constructeur avec le pointeur sur le BatchManager associe et avec une reference
- JobId(BatchManager *, string ref);
+ JobId(BatchManager *, std::string ref);
// Operateur d'affectation entre objets
virtual JobId & operator =(const JobId &);
JobId(const JobId &);
// Accesseur pour la reference interne
- virtual string getReference() const;
+ virtual std::string getReference() const;
// Methodes pour le controle du job
virtual void deleteJob() const; // retire un job du gestionnaire
// 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
+ std::string __str__() const; // SWIG : affichage en Python
+ std::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
+ std::string _reference; // reference du job au sein du BatchManager
private:
#include <sstream>
//#include "MEDMEM_STRING.hxx"
#include "Batch_JobInfo.hxx"
+using namespace std;
namespace Batch {
#ifndef _JOBINFO_H_
#define _JOBINFO_H_
-using namespace std;
#include <iostream>
#include <string>
#include "Batch_Parametre.hxx"
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);
+ friend std::ostream & operator <<(std::ostream & os, const JobInfo & ji);
// Accesseurs
virtual Parametre getParametre() 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
+ std::string __str__() const; // SWIG : affichage en Python
+ std::string __repr__() const { return __str__(); }; // SWIG : affichage en Python
protected:
Parametre _param; // parametres du job
#include "Batch_Environnement.hxx"
#include "Batch_RunTimeException.hxx"
#include "Batch_JobInfo_PBS.hxx"
+using namespace std;
namespace Batch {
// 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
+ std::string __str__() const; // SWIG : affichage en Python
+ std::string __repr__() const { return __str__(); }; // SWIG : affichage en Python
protected:
#include <stdlib.h>
#include <unistd.h>
#include "Batch_Job_PBS.hxx"
+using namespace std;
namespace Batch {
*/
#include "Batch_ListIsFullException.hxx"
+using namespace std;
namespace Batch {
{
public:
// Constructeur
- ListIsFullException(string ch = "undefined") : GenericException("ListIsFullException", ch) {}
+ ListIsFullException(std::string ch = "undefined") : GenericException("ListIsFullException", ch) {}
};
}
#ifndef _LONGTYPE_H_
#define _LONGTYPE_H_
-using namespace std;
#include <string>
#include "Batch_GenericType.hxx"
LongType(const long l=0L) : _data(l) {}
// Conversion en chaine
- virtual string affiche() const;
+ virtual std::string affiche() const;
// Operateur d'affectation
virtual LongType & operator =(long);
#include <string>
#include "Batch_MapKey.hxx"
+using namespace std;
namespace Batch {
#define _MAPKEY_H_
-using namespace std;
#include <string>
namespace Batch {
// une classe privee pour les differents types
// ces types ne peuvent pas etre redefinis
- class MapKey : public string
+ class MapKey : public std::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) {}
+ MapKey() : std::string() {}
+ MapKey(const MapKey & mk, size_type pos, size_type npos) : std::string(mk, pos, npos) {}
+ MapKey(const char * s, size_type n) : std::string(s, n) {}
+ MapKey(const char * s) : std::string(s) {}
+ MapKey(size_type n, char c) : std::string(n, c) {}
#ifdef __STL_MEMBER_TEMPLATES
template<class InputIterator>
- MapKey(InputIterator __begin, InputIterator __end) : string(__begin, __end) {}
+ MapKey(InputIterator __begin, InputIterator __end) : std::string(__begin, __end) {}
#else
- MapKey(const_iterator __begin, const_iterator __end) : string(__begin, __end) {}
+ MapKey(const_iterator __begin, const_iterator __end) : std::string(__begin, __end) {}
#endif
public:
- MapKey(const MapKey & mk) : string(mk) {}
+ MapKey(const MapKey & mk) : std::string(mk) {}
};
#include "Batch_GenericException.hxx"
+using namespace std;
namespace Batch {
#ifndef _PARAMETRE_H_
#define _PARAMETRE_H_
-using namespace std;
#include <map>
#include <string>
#include "Batch_InvalidKeyException.hxx"
// 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;
+#define def_extern_MapKey(mk) extern const std::string & mk;
+#define def_static_MapKey(mk) const std::string Batch::Parametre::mk(#mk); \
+ const std::string & mk = Batch::Parametre::mk;
namespace Batch {
- class Parametre : public map< string, Versatile >
+ class Parametre : public std::map< std::string, Versatile >
{
public:
// Constructeur standard
Parametre::Parametre(const Parametre & PM);
// Operateur de recherche dans la map
- Versatile & operator [] (const string &);
- const Versatile & operator [] (const string &) const;
+ Versatile & operator [] (const std::string &);
+ const Versatile & operator [] (const std::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;
+ static const std::string ACCOUNT;
+ static const std::string CHECKPOINT;
+ static const std::string CKPTINTERVAL;
+ static const std::string CREATIONTIME;
+ static const std::string EGROUP;
+ static const std::string ELIGIBLETIME;
+ static const std::string EUSER;
+ static const std::string EXECUTABLE;
+ static const std::string EXECUTIONHOST;
+ static const std::string HOLD;
+ static const std::string ID;
+ static const std::string INFILE;
+ static const std::string MAIL;
+ static const std::string MAXCPUTIME;
+ static const std::string MAXDISKSIZE;
+ static const std::string MAXRAMSIZE;
+ static const std::string MAXWALLTIME;
+ static const std::string MODIFICATIONTIME;
+ static const std::string NAME;
+ static const std::string OUTFILE;
+ static const std::string PID;
+ static const std::string QUEUE;
+ static const std::string QUEUEDTIME;
+ static const std::string SERVER;
+ static const std::string STARTDATE;
+ static const std::string STATE;
+ static const std::string TEXT;
+ static const std::string TMPDIR;
+ static const std::string USEDCPUTIME;
+ static const std::string USEDDISKSIZE;
+ static const std::string USEDRAMSIZE;
+ static const std::string USEDWALLTIME;
+ static const std::string USER;
protected:
- map< string, TypeParam > TypeMap; // map interne servant a controler le type de la valeur associee a chaque clef
+ std::map< std::string, TypeParam > TypeMap; // map interne servant a controler le type de la valeur associee a chaque clef
private:
#include "Batch_TypeMismatchException.hxx"
#include "Batch_ListIsFullException.hxx"
#include "Batch_InvalidArgumentException.hxx"
+using namespace std;
namespace Batch {
*/
#include "Batch_RunTimeException.hxx"
+using namespace std;
namespace Batch {
{
public:
// Constructeur
- RunTimeException(string ch = "undefined") : GenericException("RunTimeException", ch) {}
+ RunTimeException(std::string ch = "undefined") : GenericException("RunTimeException", ch) {}
};
}
#include <string>
#include "Batch_StringType.hxx"
+using namespace std;
namespace Batch {
#ifndef _STRINGTYPE_H_
#define _STRINGTYPE_H_
-using namespace std;
#include <string>
#include "Batch_GenericType.hxx"
{
public:
// Constructeur
- StringType(const string & s="") : _data(s) {}
+ StringType(const std::string & s="") : _data(s) {}
// Conversion en chaine
- virtual string affiche() const;
- virtual operator string() const;
+ virtual std::string affiche() const;
+ virtual operator std::string() const;
// Operateur d'affectation
- virtual StringType & operator =(string);
+ virtual StringType & operator =(std::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;
+ std::string _data;
private:
*/
#include "Batch_TypeMismatchException.hxx"
+using namespace std;
namespace Batch {
{
public:
// Constructeur
- TypeMismatchException(string ch = "undefined") : GenericException("TypeMismatchException", ch) {}
+ TypeMismatchException(std::string ch = "undefined") : GenericException("TypeMismatchException", ch) {}
};
}
#include "Batch_Versatile.hxx"
#include "Batch_TypeMismatchException.hxx"
#include "Batch_ListIsFullException.hxx"
+using namespace std;
namespace Batch {
#ifndef _VERSATILE_H_
#define _VERSATILE_H_
-using namespace std;
#include <iostream>
#include <list>
#include <string>
int maxelem; // le nombre d'elements autorises
} TypeParam;
- class Versatile : public list< GenericType * >
+ class Versatile : public std::list< GenericType * >
{
public:
// Constructeur standard et destructeur
// 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 std::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 std::string & ch) throw(TypeMismatchException);
+ Versatile & operator +=(const std::string & ch) throw(TypeMismatchException,ListIsFullException);
+ Versatile & operator , (const std::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);
operator long() const throw(TypeMismatchException);
operator string() const throw(TypeMismatchException);
operator Couple() const throw(TypeMismatchException);
- string str() const throw(TypeMismatchException);
+ std::string str() const throw(TypeMismatchException);
// Operateur pour l'affichage sur un stream
- friend ostream & operator << (ostream & os, const Versatile & );
+ friend std::ostream & operator << (std::ostream & os, const Versatile & );
// Positionnement et recuperation du type de l'element interne
void setType(DiscriminatorType) throw(TypeMismatchException);
// Positionnement et recuperation du nom de l'objet
string getName() const;
- void setName(const string & name);
+ void setName(const std::string & name);
protected:
// Efface tous les elements internes de l'objet
DiscriminatorType _discriminator; // type de l'element interne
int _maxsize; // nombre max d'elements internes
- string _name; // nom de l'objet (sert pour les exceptions)
+ std::string _name; // nom de l'objet (sert pour les exceptions)
private:
#include "CASCatch_SignalsHandler.h"
#include <OSD.hxx>
-
+using namespace std;
CASCatch_SignalsHandler::CASCatch_SignalsHandler(bool theFloatingSignal)
{
#include "MultiCommException.hxx"
+using namespace std;
MultiCommException::MultiCommException(const char *message)
{
#include <string>
-using namespace std;
class MultiCommException {
private:
- string _message;
+ std::string _message;
public:
MultiCommException(const char *message);
const char *what() const;
#include "Receiver.hxx"
#include <string.h>
+using namespace std;
/*!
return a deep copy of the array contained in the servant.
#include "ReceiverFactory.hxx"
#include "Receivers.hxx"
+using namespace std;
#ifdef COMP_CORBA_DOUBLE
#define CorbaDNoCopyReceiver CorbaNCNoCopyReceiver
#include "poa.h"
#include "utilities.h"
+using namespace std;
#define TAILLE_SPLIT 100000
#define TIMEOUT 20
#include "SALOMEMultiComm.hxx"
+using namespace std;
SALOMEMultiComm::SALOMEMultiComm():_type(SALOME::CORBA_)
{
#include "utilities.h"
#include "SenderFactory.hxx"
+using namespace std;
CORBA::ORB_var &getGlobalORB(){
ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance();
#define TIMEOUT 20
-using namespace std;
/*!
Generic servant class for senders that factorizes all the common methods and attributes necessary to senders.
#include "utilities.h"
#include "SALOMEMultiComm.hxx"
#include "SALOME_Comm_i.hxx"
+using namespace std;
#ifdef COMP_CORBA_DOUBLE
#define SALOME_CorbaDoubleSender SALOME_CorbaDoubleNCSender_i
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOME_Component_i.hxx"
#include "RegistryConnexion.hxx"
#include "OpUtil.hxx"
#include <dlfcn.h>
#include <cstdlib>
#include "utilities.h"
+using namespace std;
extern bool _Sleeping ;
static Engines_Component_i * theEngines_Component ;
#include <Python.h>
-extern "C" void HandleServerSideSignals(CORBA::ORB_ptr theORB);
-
using namespace std;
+extern "C" void HandleServerSideSignals(CORBA::ORB_ptr theORB);
+
static PyMethodDef MethodPyVoidMethod[] = {{ NULL, NULL }};
int main(int argc, char* argv[])
#include "CASCatch_SignalsHandler.h" // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
+using namespace std;
extern "C" void HandleServerSideSignals(CORBA::ORB_ptr theORB)
{
// File : SALOME_DataTypeCatalog_Client.cxx
// Module : SALOME
-using namespace std;
/* $Header$ */
#include <iostream.h>
#include "SALOME_DataTypeCatalog.hh"
#include <string>
#include "utilities.h"
+using namespace std;
int main(int argc,char **argv)
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOME_DataTypeCatalog_impl.hxx"
#include "Utils_ExceptHandlers.hxx"
#include <fstream>
+using namespace std;
UNEXPECT_CATCH(DTC_NotFound, SALOME_DataTypeCatalog::NotFound);
#include <qapplication.h>
#include <qthread.h>
#include <pthread.h>
+using namespace std;
#ifdef _DEBUG_
static int MYDEBUG = 0;
-using namespace std;
// File : SALOMEDS_Tool.cxx
// Created : Mon Oct 21 16:24:34 2002
// Author : Sergey RUIN
#include <string.h>
#include <fcntl.h>
#include <stdio.h>
+using namespace std;
bool CreateAttributeFromASCII(HDFinternalObject *father, FILE* fp);
bool CreateDatasetFromASCII(HDFcontainerObject *father, FILE *fp);
// File : HDFattribute.cc
// Module : SALOME
-using namespace std;
extern "C"
{
#include "hdfi.h"
#include "HDFexception.hxx"
#include "HDFattribute.hxx"
#include "HDFinternalObject.hxx"
+using namespace std;
HDFattribute::HDFattribute(char *name,HDFinternalObject *father,hdf_type type, size_t size)
: HDFobject(name)
// File : HDFcontainerObject.cc
// Module : SALOME
-using namespace std;
extern "C"
{
#include "hdfi.h"
#include "HDFcontainerObject.hxx"
#include "HDFexception.hxx"
#include "utilities.h"
+using namespace std;
HDFcontainerObject::HDFcontainerObject(char *name)
: HDFinternalObject(name)
// File : HDFconvert.cc
// Module : SALOME
-using namespace std;
#include "HDFconvert.hxx"
+using namespace std;
int HDFConvert::FromAscii(const string& file, const HDFcontainerObject & hdf_container, const string& nomdataset)
{
// File : HDFdataset.cc
// Module : SALOME
-using namespace std;
extern "C"
{
#include "hdfi.h"
#include "HDFexception.hxx"
#include <iostream.h>
+using namespace std;
herr_t dataset_attr(hid_t loc_id, const char *attr_name, void *operator_data)
{
// File : HDFexplorer.cc
// Module : SALOME
-using namespace std;
#include "HDFcontainerObject.hxx"
#include "HDFexception.hxx"
#include "HDFinternalObject.hxx"
#include "HDFexplorer.hxx"
+using namespace std;
HDFexplorer::HDFexplorer(HDFcontainerObject *container)
{
// File : HDFfile.cc
// Module : SALOME
-using namespace std;
extern "C"
{
#include "hdfi.h"
#include <iostream.h>
#include "HDFfile.hxx"
#include "HDFexception.hxx"
+using namespace std;
herr_t file_attr(hid_t loc_id, const char *attr_name, void *operator_data)
{
// File : HDFgroup.cc
// Module : SALOME
-using namespace std;
extern "C"
{
#include "hdfi.h"
}
#include "HDFgroup.hxx"
#include "HDFexception.hxx"
+using namespace std;
herr_t group_attr(hid_t loc_id, const char *attr_name, void *operator_data)
{
// File : HDFinternalObject.cc
// Module : SALOME
-using namespace std;
extern "C"
{
#include "hdfi.h"
}
#include "HDFinternalObject.hxx"
+using namespace std;
HDFinternalObject::HDFinternalObject(char *name)
: HDFobject(name)
// File : HDFobject.cc
// Module : SALOME
-using namespace std;
#include "HDFobject.hxx"
extern "C"
{
#include <string.h>
}
#include "utilities.h"
+using namespace std;
HDFobject::HDFobject(char *name)
{
// File : test3.cxx
// Module : SALOME
-using namespace std;
#include <iostream.h>
#include "HDFOI.hxx"
#include <stdlib.h>
+using namespace std;
int main()
// File : test4.cxx
// Module : SALOME
-using namespace std;
#include <iostream.h>
#include "HDFOI.hxx"
#include <stdlib.h>
+using namespace std;
int main()
// File : test5.cxx
// Module : SALOME
-using namespace std;
#include <iostream.h>
#include "HDFOI.hxx"
#include <stdlib.h>
+using namespace std;
int main()
// File : test6.cxx
// Module : SALOME
-using namespace std;
#include <iostream.h>
#include "HDFOI.hxx"
#include <stdlib.h>
+using namespace std;
int main()
{
// File : test7.cxx
// Module : SALOME
-using namespace std;
#include "HDFIO.hxx"
#include <iostream.h>
+using namespace std;
int main()
{
// File : test8.cxx
// Module : SALOME
-using namespace std;
#include <iostream.h>
#include "HDFOI.hxx"
#include <stdlib.h>
+using namespace std;
int main()
// File : test9.cxx
// Module : SALOME
-using namespace std;
#include <iostream.h>
#include "HDFOI.hxx"
#include <stdlib.h>
+using namespace std;
int main()
// Module : SALOME
// $Header$
-using namespace std;
#include <iostream>
#include <fstream>
#include <sstream>
#include "SALOME_LifeCycleCORBA.hxx"
#include CORBA_CLIENT_HEADER(SALOME_ModuleCatalog)
#include "SALOME_NamingService.hxx"
+using namespace std;
SALOME_LifeCycleCORBA::SALOME_LifeCycleCORBA()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "utilities.h"
#include <iostream>
#include <unistd.h>
#include "SALOME_NamingService.hxx"
#include "SALOME_LifeCycleCORBA.hxx"
#include <OpUtil.hxx>
+using namespace std;
int main (int argc, char * argv[])
{
// Module : SALOME
// $Header$
-using namespace std;
#include "utilities.h"
#include "InquireServersQThread.h"
#include "SALOME_NamingService.hxx"
//#include "utilities.h"
#include "OpUtil.hxx"
+using namespace std;
#include CORBA_CLIENT_HEADER(SALOME_Session)
#include CORBA_CLIENT_HEADER(SALOME_Registry)
// Module : SALOME
// $Header$
-using namespace std;
/*! \file SALOME_Session_loader.cxx
*/
#include <qapplication.h>
#include "InquireServersQThread.h"
+using namespace std;
int main(int argc, char **argv)
{
// Author : Vasily Rusyaev
// Module : SALOME
-using namespace std;
#include <iostream>
#include "SALOME_Logger_Server.hxx"
#include <SALOMEconfig.h>
#include <sys/types.h>
#include <unistd.h>
+using namespace std;
+
omni_mutex Logger::myLock;
/////////////////////////////////////////////////////////////////////
// Author : Vasily Rusyaev
// Module : SALOME
-using namespace std;
#include "SALOME_Trace.hxx"
#include <memory.h>
#include <string>
//#include <stdio.h>
#include <stdlib.h>
#include <iostream>
+using namespace std;
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
// File : MPIContainer_i.cxx
// Module : SALOME
-using namespace std;
#include <iostream.h>
#include <dlfcn.h>
#include <stdio.h>
#include "MPIContainer_i.hxx"
#include "utilities.h"
+using namespace std;
MPIContainer_i::MPIContainer_i(int nbproc, int numproc,
CORBA::ORB_ptr orb,
// File : MPIObject_i.cxx
// Module : SALOME
-using namespace std;
#include "MPIObject_i.hxx"
#include "utilities.h"
#include <mpi.h>
+using namespace std;
MPIObject_i::MPIObject_i()
{
// File : SALOME_MPIContainer.cxx
// Module : SALOME
-using namespace std;
#include <iostream>
#include "MPIContainer_i.hxx"
#include "utilities.h"
#include "LocalTraceCollector.hxx"
#include <mpi.h>
+using namespace std;
int main(int argc, char* argv[])
{
#include "SALOME_NamingService.hxx"
#include "SALOME_MPILifeCycleCORBA.hxx"
#include "OpUtil.hxx"
+using namespace std;
int main (int argc, char * argv[])
{
**
*****************************************************************************/
-using namespace std;
#include <qfile.h>
#include <qtextstream.h>
#include <qtextcodec.h>
#include <stdio.h>
#include <stdlib.h>
+using namespace std;
static QString* defaultScope = 0;
#include "utilities.h"
#include <sstream>
+using namespace std;
#ifdef _DEBUG_
static int MYDEBUG = 0;
// Author : Francis KLOSS
// Module : SALOME
-using namespace std;
#include "NOTIFICATION_Swig.hxx"
+using namespace std;
// Swig notification supplier
// --------------------------
// Author : Francis KLOSS
// Module : SALOME
-using namespace std;
#include "NOTIFICATION.hxx"
class NOTIFICATION_Supplier_Swig {
// File : ServiceUnreachable.cxx
// Module : SALOME
-using namespace std;
#include "ServiceUnreachable.hxx"
+using namespace std;
ServiceUnreachable::ServiceUnreachable( void ): SALOME_Exception( "ServiceUnreachable" )
{
// Author : Laurent DADA / Francis KLOSS
// Module : SALOME
-using namespace std;
#include "NOTIFICATION.hxx"
-using namespace std;
#include "Utils_ORB_INIT.hxx"
#include "Utils_SINGLETON.hxx"
+using namespace std;
CosNA_EventChannel_ptr NOTIFICATION_channel() {
ORB_INIT& init = *SINGLETON_<ORB_INIT>::Instance(); ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting());
// Author : Laurent DADA / Francis KLOSS
// Module : SALOME
-using namespace std;
#include "NOTIFICATION.hxx"
+using namespace std;
NOTIFICATION_Consumer::NOTIFICATION_Consumer():
proxy_supplier(0),
// Author : Laurent DADA / Francis KLOSS
// Module : SALOME
-using namespace std;
#include "NOTIFICATION.hxx"
+using namespace std;
long NOTIFICATION_Supplier::_stamp = 0;
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOME_AISObject.ixx"
+using namespace std;
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOME_AISShape.ixx"
+using namespace std;
SALOME_AISShape::SALOME_AISShape(const TopoDS_Shape& shape): AIS_Shape(shape) {
}
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class SALOME_InteractiveObject SALOME_InteractiveObject.hxx
\brief ...
*/
#include "SALOME_InteractiveObject.ixx"
+using namespace std;
SALOME_InteractiveObject::SALOME_InteractiveObject()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "OCCViewer.h"
#include "OCCViewer_ViewFrame.h"
+using namespace std;
QAD_ViewFrame* OCCViewer::createView(QAD_RightFrame* parent)
{
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class OCCViewer_AISSelector OCCViewer_AISSelector.h
\brief Selector for AIS interactive context.
*/
#include "OCCViewer_AISSelector.h"
+using namespace std;
/*!
Constructor
// $Header$
#include "OCCViewer_Prs.h"
+using namespace std;
//==========================================================
/*!
// Module : SALOME
// $Header$
-using namespace std;
#include "OCCViewer_VService.h"
// Open CASCADE Includes
#include <Xdps_Driver.hxx>
#include <Xw_TypeOfMapping.hxx>
#endif
+using namespace std;
// For 2d
#define LOPTIM
// Module : SALOME
// $Header$
-using namespace std;
#include "OCCViewer_ViewFrame.h"
#include "OCCViewer_Viewer3d.h"
#include "OCCViewer_ViewPort.h"
#include <V3d_View.hxx>
#include <AIS_ListIteratorOfListOfInteractive.hxx>
#include <Visual3d_View.hxx>
+using namespace std;
/*!
Constructor
// Module : SALOME
// $Header$
-using namespace std;
#include "OCCViewer_ViewPort3d.h"
#include "QAD.h"
#if !defined WNT
#include <Xw.hxx>
#endif
+using namespace std;
/*!
Constructor
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class OCCViewer_Viewer3d OCCViewer_Viewer3d.h
\brief Open CASCADE Viewer 3D with viewport 3D and selection.
#include <TColStd_IndexedMapOfInteger.hxx>
#include <NCollection_DefineBaseCollection.hxx>
#include <NCollection_DefineDataMap.hxx>
+using namespace std;
DEFINE_BASECOLLECTION( OCCViewer_CollectionOfIndexedMapOfShapes, TopTools_IndexedMapOfShape )
DEFINE_DATAMAP( OCCViewer_MapOfIOIndexedMapOfShape, OCCViewer_CollectionOfIndexedMapOfShapes, Handle_SALOME_InteractiveObject, TopTools_IndexedMapOfShape)
#include "Plot2d.h"
#include "Plot2d_ViewFrame.h"
+using namespace std;
QAD_ViewFrame* Plot2d::createView(QAD_RightFrame* parent)
{
// Module : SALOME
// $Header$
-using namespace std;
#include "Plot2d_Curve.h"
#include "utilities.h"
+using namespace std;
/*!
Constructor
// Module : SALOME
// $Header$
-using namespace std;
#include "Plot2d_CurveContainer.h"
+using namespace std;
/*!
Constructor
#include "QAD_Tools.h"
#include "QAD_Application.h"
#include "QAD_Desktop.h"
+using namespace std;
#define SPACING_SIZE 6
#define MARGIN_SIZE 11
// $Header$
#include "Plot2d_Prs.h"
+using namespace std;
//==========================================================
/*!
#include <qlabel.h>
#include <qpushbutton.h>
#include <qcolordialog.h>
+using namespace std;
#define MARGIN_SIZE 11
#define SPACING_SIZE 6
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SALOMEDS)
#include CORBA_SERVER_HEADER(SALOMEDS_Attributes)
+using namespace std;
#define DEFAULT_LINE_WIDTH 0 // (default) line width
#define DEFAULT_MARKER_SIZE 9 // default marker size
// Module : SALOME
// $Header$
-using namespace std;
-using namespace std;
# include "Utils_ORB_INIT.hxx"
# include "RegistryConnexion.hxx"
# include "SALOME_NamingService.hxx"
{
# include <stdio.h>
}
+using namespace std;
Registry::Components_var Connexion( int argc , char **argv , const char *ptrSessionName ) throw( CommException )
protected :
const char* _Ior ; // engine ior
Registry::Components_var _VarComponents ; // RegistryService reference
- string _SessionName ;
- string _Name ; // code name
+ std::string _SessionName ;
+ std::string _Name ; // code name
int _Id ; // code identity returned by RegistryService
void add( const char *aName );
void remove( void );
// Module : SALOME
// $Header$
-using namespace std;
-using namespace std;
# include "RegistryService.hxx"
# include "OpUtil.hxx"
# include "utilities.h"
}
#include <unistd.h>
+using namespace std;
/* ------------------------------*/
/* Constructeurs et Destructeurs */
# include <map>
-using namespace std;
class RegistryService : public POA_Registry::Components //, public PortableServer::RefCountServantBase
{
const char *_SessionName ;
int _Compteur ;
- map<int,client_infos *> _reg ;
- map<int,client_infos *> _fin ;
+ std::map<int,client_infos *> _reg ;
+ std::map<int,client_infos *> _fin ;
- Registry::AllInfos* makeseq(map<int,client_infos *> &mymap );
+ Registry::AllInfos* makeseq(std::map<int,client_infos *> &mymap );
} ;
// Module : SALOME
// $Header$
-using namespace std;
# include "HelpWindow.hxx"
# include "utilities.h"
# include <qpushbutton.h>
# include <qtextstream.h>
# include <qfile.h>
+using namespace std;
HelpWindow::HelpWindow(QWidget* parent, const char* name )
: QMainWindow( parent, name, WType_TopLevel | WDestructiveClose )
#include <qpushbutton.h>
#include <qlayout.h>
# include "utilities.h"
+using namespace std;
#define MARGIN_SIZE 11
#define SPACING_SIZE 6
# include <qpushbutton.h>
# include <qspinbox.h>
-using namespace std;
class IntervalWindow : public QDialog
{
// Module : SALOME
// $Header$
-using namespace std;
# include <qpushbutton.h>
# include <qlistview.h>
# include <qtabwidget.h>
# include "RegWidget.hxx"
# include "HelpWindow.hxx"
# include "IntervalWindow.hxx"
+using namespace std;
typedef int PIXELS;
RegWidget* RegWidget::myRegWidgetPtr = 0;
// Module : SALOME
// $Header$
-using namespace std;
# include "RegWidget.hxx"
# include "utilities.h"
+using namespace std;
extern "C"
{
// File : SALOME_RessourcesCatalog_Client.cxx
// Module : SALOME
-using namespace std;
/* $Header$ */
#include <iostream.h>
#include CORBA_SERVER_HEADER(SALOME_RessourcesCatalog)
#include <string>
#include "utilities.h"
+using namespace std;
int main(int argc,char **argv)
{
// Author : Estelle Deville
// Module : SALOME
-using namespace std;
#include "SALOME_RessourcesCatalog_impl.hxx"
#include <fstream>
#include "Utils_ExceptHandlers.hxx"
+using namespace std;
UNEXPECT_CATCH(RC_NotFound, SALOME_RessourcesCatalog::NotFound);
//----------------------------------------------------------------------
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttLong_i.hxx"
#include "utilities.h"
#include <TDF_Tool.hxx>
#include <stdio.h>
+using namespace std;
//============================================================================
/*! Function : Set
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttReal_i.hxx"
#include "utilities.h"
#include <TDF_Tool.hxx>
#include <stdio.h>
#include <cstring>
+using namespace std;
//============================================================================
/*! Function : Set
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeComment_i.hxx"
#include <TCollection_ExtendedString.hxx>
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
char* SALOMEDS_AttributeComment_i::Value()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeDrawable_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
CORBA::Boolean SALOMEDS_AttributeDrawable_i::IsDrawable() {
return (Handle(SALOMEDS_DrawableAttribute)::DownCast(_myAttr)->Get() == 1);
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeExpandable_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
CORBA::Boolean SALOMEDS_AttributeExpandable_i::IsExpandable() {
return (Handle(SALOMEDS_ExpandableAttribute)::DownCast(_myAttr)->Get() == 1);
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeExternalFileDef_i.hxx"
#include <TCollection_ExtendedString.hxx>
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
char* SALOMEDS_AttributeExternalFileDef_i::Value()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeFileType_i.hxx"
#include <TCollection_ExtendedString.hxx>
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
char* SALOMEDS_AttributeFileType_i::Value()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeIOR_i.hxx"
#include <TCollection_ExtendedString.hxx>
#include "SALOMEDS_SObject_i.hxx"
#include "SALOMEDS_Study_i.hxx"
+using namespace std;
char* SALOMEDS_AttributeIOR_i::Value()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeInteger_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
CORBA::Long SALOMEDS_AttributeInteger_i::Value() {
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeLocalID_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
CORBA::Long SALOMEDS_AttributeLocalID_i::Value() {
return Handle(SALOMEDS_LocalIDAttribute)::DownCast(_myAttr)->Get();
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeName_i.hxx"
#include <TCollection_ExtendedString.hxx>
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
char* SALOMEDS_AttributeName_i::Value() {
TCollection_ExtendedString S = Handle(TDataStd_Name)::DownCast(_myAttr)->Get();
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeOpened_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
CORBA::Boolean SALOMEDS_AttributeOpened_i::IsOpened() {
return (Handle(SALOMEDS_OpenedAttribute)::DownCast(_myAttr)->Get() == 1);
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributePersistentRef_i.hxx"
#include <TCollection_ExtendedString.hxx>
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
char* SALOMEDS_AttributePersistentRef_i::Value()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributePixMap_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TCollection_AsciiString.hxx>
+using namespace std;
CORBA::Boolean SALOMEDS_AttributePixMap_i::HasPixMap() {
TCollection_ExtendedString S = Handle(SALOMEDS_PixMapAttribute)::DownCast(_myAttr)->Get();
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributePythonObject_i.hxx"
#include <TCollection_ExtendedString.hxx>
#include <TColStd_HArray1OfCharacter.hxx>
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
void SALOMEDS_AttributePythonObject_i::SetObject(const char* theSequence, CORBA::Boolean IsScript) {
CheckLocked();
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeSelectable_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
CORBA::Boolean SALOMEDS_AttributeSelectable_i::IsSelectable() {
return (Handle(SALOMEDS_SelectableAttribute)::DownCast(_myAttr)->Get() == 1);
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeSequenceOfInteger_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TColStd_HSequenceOfInteger.hxx>
+using namespace std;
void SALOMEDS_AttributeSequenceOfInteger_i::Assign(const SALOMEDS::LongSeq& other)
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeSequenceOfReal_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TColStd_HSequenceOfReal.hxx>
+using namespace std;
void SALOMEDS_AttributeSequenceOfReal_i::Assign(const SALOMEDS::DoubleSeq& other)
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeStudyProperties_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TColStd_HSequenceOfExtendedString.hxx>
#include <TColStd_HSequenceOfInteger.hxx>
+using namespace std;
#define CREATION_MODE_NOTDEFINED 0
#define CREATION_MODE_SCRATCH 1
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeTableOfInteger_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TColStd_HSequenceOfInteger.hxx>
#include <stdexcept>
#include <strstream>
#include <string>
+using namespace std;
#define SEPARATOR '\1'
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeTableOfReal_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TColStd_HSequenceOfReal.hxx>
#include <string>
#include "Utils_ExceptHandlers.hxx"
+using namespace std;
UNEXPECT_CATCH(ATR_IncorrectIndex, SALOMEDS::AttributeTableOfReal::IncorrectIndex);
UNEXPECT_CATCH(ATR_IncorrectArgumentLength, SALOMEDS::AttributeTableOfReal::IncorrectArgumentLength);
// Author : Sergey Ruin
// Module : SALOME
-using namespace std;
#include <TCollection_ExtendedString.hxx>
#include <TCollection_AsciiString.hxx>
#include <string>
#include "Utils_ExceptHandlers.hxx"
+using namespace std;
UNEXPECT_CATCH(ATS_IncorrectIndex, SALOMEDS::AttributeTableOfString::IncorrectIndex);
UNEXPECT_CATCH(ATS_IncorrectArgumentLength, SALOMEDS::AttributeTableOfString::IncorrectArgumentLength);
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeTarget_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TDF_LabelList.hxx>
#include <TDF_ListIteratorOfLabelList.hxx>
+using namespace std;
void SALOMEDS_AttributeTarget_i::Add(SALOMEDS::SObject_ptr anObject) {
TDF_Label aLabel;
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeTextColor_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TColStd_HArray1OfReal.hxx>
+using namespace std;
SALOMEDS::Color SALOMEDS_AttributeTextColor_i::TextColor() {
SALOMEDS::Color TextColor;
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeTextHighlightColor_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TColStd_HArray1OfReal.hxx>
+using namespace std;
SALOMEDS::Color SALOMEDS_AttributeTextHighlightColor_i::TextHighlightColor() {
SALOMEDS::Color TextHighlightColor;
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeTreeNode_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include "utilities.h"
#include <TDocStd_Document.hxx>
#include <TDF_Tool.hxx>
+using namespace std;
static Handle(TDataStd_TreeNode) GetNode(SALOMEDS::AttributeTreeNode_ptr value,
const Handle(TDataStd_TreeNode)& aNode) {
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_AttributeUserID_i.hxx"
#include <TCollection_ExtendedString.hxx>
#include "SALOMEDS_SObject_i.hxx"
+using namespace std;
char* SALOMEDS_AttributeUserID_i::Value() {
char aGUID[40];
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_BasicAttributeFactory.hxx"
#include "utilities.h"
+using namespace std;
//============================================================================
/*! Function : Create
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_BasicAttribute_i.hxx"
+using namespace std;
//============================================================================
/*! Function : SetLabel
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_ChildIterator_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include "utilities.h"
+using namespace std;
#ifndef _SALOMEDS_DataMapNodeOfDataMapOfIntegerString_HeaderFile
#include <SALOMEDS_DataMapNodeOfDataMapOfIntegerString.hxx>
#endif
+using namespace std;
#define TheKey Standard_Real
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_DataMapIteratorOfDataMapStringLabel.hxx"
#ifndef _Standard_NoSuchObject_HeaderFile
#ifndef _SALOMEDS_DataMapNodeOfDataMapStringLabel_HeaderFile
#include "SALOMEDS_DataMapNodeOfDataMapStringLabel.hxx"
#endif
-
+ using namespace std;
+
#define TheKey TCollection_ExtendedString
#define TheKey_hxx <TCollection_ExtendedString.hxx>
#ifndef _SALOMEDS_DataMapIteratorOfDataMapOfIntegerString_HeaderFile
#include <SALOMEDS_DataMapIteratorOfDataMapOfIntegerString.hxx>
#endif
+using namespace std;
SALOMEDS_DataMapNodeOfDataMapOfIntegerString::~SALOMEDS_DataMapNodeOfDataMapOfIntegerString() {}
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_DataMapNodeOfDataMapStringLabel.hxx"
#ifndef _Standard_TypeMismatch_HeaderFile
#ifndef _SALOMEDS_DataMapIteratorOfDataMapStringLabel_HeaderFile
#include "SALOMEDS_DataMapIteratorOfDataMapStringLabel.hxx"
#endif
+using namespace std;
SALOMEDS_DataMapNodeOfDataMapStringLabel::~SALOMEDS_DataMapNodeOfDataMapStringLabel() {}
#ifndef _SALOMEDS_DataMapIteratorOfDataMapOfIntegerString_HeaderFile
#include <SALOMEDS_DataMapIteratorOfDataMapOfIntegerString.hxx>
#endif
-
+ using namespace std;
+
#define TheKey Standard_Real
#define TheKey_hxx <Standard_Real.hxx>
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_DataMapStringLabel.hxx"
#ifndef _Standard_DomainError_HeaderFile
#ifndef _SALOMEDS_DataMapIteratorOfDataMapStringLabel_HeaderFile
#include "SALOMEDS_DataMapIteratorOfDataMapStringLabel.hxx"
#endif
-
+ using namespace std;
+
#define TheKey TCollection_ExtendedString
#define TheKey_hxx <TCollection_ExtendedString.hxx>
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_DrawableAttribute.ixx"
#include <TDataStd_Integer.hxx>
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_ExpandableAttribute.ixx"
#include <TDataStd_Integer.hxx>
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include <TDataStd_TreeNode.hxx>
#include <TDataStd_UAttribute.hxx>
#include "SALOMEDS_ExternalFileDef.hxx"
#include "SALOMEDS_FileType.hxx"
#include "Utils_ExceptHandlers.hxx"
+using namespace std;
#define RegisteredAttributes 26
UNEXPECT_CATCH(GALockProtection, SALOMEDS::GenericAttribute::LockProtection);
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_IORAttribute.ixx"
#include <TDataStd_Comment.hxx>
#include <TCollection_ExtendedString.hxx>
#include "SALOMEDS_Study_i.hxx"
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_LocalIDAttribute.ixx"
#include <TDataStd_Integer.hxx>
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_OCAFApplication.ixx"
+using namespace std;
//=======================================================================
//function : SALOMEDS_OCAFApplication
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_OpenedAttribute.ixx"
#include <TDataStd_Integer.hxx>
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_PersRefAttribute.ixx"
#include <TDataStd_Comment.hxx>
#include <TCollection_ExtendedString.hxx>
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_PixMapAttribute.ixx"
#include <TDataStd_Comment.hxx>
#include <TCollection_ExtendedString.hxx>
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_PythonObjectAttribute.ixx"
#include <string>
+using namespace std;
const Standard_GUID& SALOMEDS_PythonObjectAttribute::GetID()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_SComponentIterator_i.hxx"
+using namespace std;
//============================================================================
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_SComponent_i.hxx"
#include "utilities.h"
+using namespace std;
//============================================================================
// Module : SALOME
// $Header$
-using namespace std;
#include "utilities.h"
#include "SALOMEDS_SObject_i.hxx"
//SALOMEDS Headers
#include "SALOMEDS_GenericAttribute_i.hxx"
#include "SALOMEDS_IORAttribute.hxx"
#include <TDF_AttributeIterator.hxx>
+using namespace std;
//============================================================================
/*! Function : constructor
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_SelectableAttribute.ixx"
#include <TDataStd_Integer.hxx>
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_SequenceOfIntegerAttribute.ixx"
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_SequenceOfRealAttribute.ixx"
#include <TDataStd_Real.hxx>
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "utilities.h"
#include "SALOMEDS_Study_i.hxx"
//#include "SALOMEDS_StudyBuilder_i.hxx"
#include <HDFOI.hxx>
#include <stdlib.h>
+using namespace std;
#define USE_CASE_LABEL_TAG 2
#define DIRECTORYID 16661
#include "Utils_CorbaException.hxx"
#include <strstream>
-using namespace std;
#include "SALOME_GenericObj_i.hh"
#include "Utils_ExceptHandlers.hxx"
+using namespace std;
UNEXPECT_CATCH(SalomeException,SALOME::SALOME_Exception);
UNEXPECT_CATCH(LockProtection, SALOMEDS::StudyBuilder::LockProtection);
// Module : SALOME
// $Header$
-using namespace std;
#include <SALOMEDS_StudyPropertiesAttribute.ixx>
+using namespace std;
const Standard_GUID& SALOMEDS_StudyPropertiesAttribute::GetID()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "utilities.h"
#include "SALOMEDS_Study_i.hxx"
#include "SALOMEDS_LocalIDAttribute.hxx"
#include "SALOMEDS_PersRefAttribute.hxx"
#include "SALOMEDS_UseCaseIterator_i.hxx"
+using namespace std;
#define DIRECTORYID 16661
// Module : SALOME
// $Header$
-using namespace std;
#include <SALOMEDS_TableOfIntegerAttribute.ixx>
#include <Standard_Failure.hxx>
#include <TColStd_DataMapIteratorOfDataMapOfIntegerInteger.hxx>
#include <string>
+using namespace std;
const Standard_GUID& SALOMEDS_TableOfIntegerAttribute::GetID()
{
// Module : SALOME
// $Header$
-using namespace std;
#include <SALOMEDS_TableOfRealAttribute.ixx>
#include <Standard_Failure.hxx>
#include <TColStd_DataMapIteratorOfDataMapOfIntegerReal.hxx>
#include <string>
#include <stdio.h>
+using namespace std;
const Standard_GUID& SALOMEDS_TableOfRealAttribute::GetID()
{
// Author : Sergey Ruin
// Module : SALOME
-using namespace std;
#include <SALOMEDS_TableOfStringAttribute.ixx>
#include <Standard_Failure.hxx>
#include <SALOMEDS_DataMapIteratorOfDataMapOfIntegerString.hxx>
#include <string>
#include <stdio.h>
+using namespace std;
const Standard_GUID& SALOMEDS_TableOfStringAttribute::GetID()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_TargetAttribute.ixx"
#include <TDF_Reference.hxx>
#include <TDF_ListIteratorOfAttributeList.hxx>
#include "utilities.h"
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_TextColorAttribute.ixx"
+using namespace std;
//=======================================================================
//function : GetID
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEDS_TextHighlightColorAttribute.ixx"
+using namespace std;
//=======================================================================
//function : GetID
// Author : Yves FRICAUD
// Module : SALOME
-using namespace std;
#include "SALOMEDS_UseCaseBuilder_i.hxx"
#include "SALOMEDS_AttributeComment_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include <TDataStd_ChildNodeIterator.hxx>
#include <TCollection_AsciiString.hxx>
#include <TDF_ChildIterator.hxx>
+using namespace std;
#define USE_CASE_LABEL_TAG 2
#define USE_CASE_GUID "AA43BB12-D9CD-11d6-945D-0050DA506788"
// Author : Yves FRICAUD
// Module : SALOME
-using namespace std;
#include "SALOMEDS_UseCaseIterator_i.hxx"
#include "SALOMEDS_SObject_i.hxx"
#include "utilities.h"
+using namespace std;
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class QAD_Application QAD_Application.h
\brief Study manager for QAD-based application.
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
#include <Standard_Failure.hxx>
+using namespace std;
static bool checkPermission(QString fileName) {
if ( QFile::exists( fileName ) ) {
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class QAD_Config QAD_Config.h
\brief Settings file management for QAD-based application.
#include <qfile.h>
#include <qregexp.h>
#include <qtextstream.h>
+using namespace std;
/*!
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_DirListDlg.h"
#include "QAD_Desktop.h"
#include "QAD_FileDlg.h"
#include <qlabel.h>
#include <qpushbutton.h>
#include <qapplication.h>
+using namespace std;
#define MIN_WIDTH 400
#define MIN_HEIGHT 200
// Module : SALOME
// $Header$
-using namespace std;
#include <qapplication.h>
#include <qdir.h>
#include <qlabel.h>
#include "QAD_FileDlg.h"
#include "QAD_MessageBox.h"
#include "QAD_Tools.h"
+using namespace std;
#define MIN_COMBO_SIZE 100
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_Help.h"
+using namespace std;
/*!
\class QAD_Help QAD_HelpL.h
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class QAD_HelpWindow QAD_HelpWindow.h
\brief Html browser for help.
#include <qtoolbutton.h>
#include <qcombobox.h>
#include <qfileinfo.h>
+using namespace std;
/*!
Constructor
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_LeftFrame.h"
#include "QAD_ObjectBrowser.h"
#include <qlayout.h>
+using namespace std;
/*!
\class QAD_LeftFrame QAD_LeftFrame.h
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_ListMenuIdAction.h"
+using namespace std;
QAD_ListMenuIdAction::QAD_ListMenuIdAction(QPopupMenu* theMenu,
int id,
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_ListPopupMenu.h"
+using namespace std;
/*!
Constructor.
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_Menus.h"
+using namespace std;
/*!
Constructor.
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_Message.h"
#include "QAD_Application.h"
#include "QAD_Config.h"
#include <qstring.h>
#include <qpopupmenu.h>
#include <qmap.h>
+using namespace std;
enum { IdCopy, IdClear, IdSelectAll };
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class QAD_MessageBox QAD_MessageBox.h
\brief Message dialog box for QAD-based application.
// QT Includes
#include <qmessagebox.h>
#include <qapplication.h>
+using namespace std;
/*!
Shows info message box with one button [ static ]
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_NameBrowser.h"
#include "QAD_Study.h"
#include <qvariant.h>
#include <qtooltip.h>
#include <qwhatsthis.h>
+using namespace std;
/*!
Constructs a QAD_NameBrowser which is a child of 'parent', with the
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_ObjectBrowserItem.h"
#include <qcolor.h>
#include <qpixmap.h>
#include <qstringlist.h>
#include <qpainter.h>
+using namespace std;
/*!
Constructors
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class QAD_Operation QAD_Operation.h
\brief Base class for OCAF operations in QAD-based application.
// QT Include
#include <qapplication.h>
+using namespace std;
/*!
Constructor
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_OperatorMenus.h"
#include "QAD_Desktop.h"
+using namespace std;
/*!
Constructor.
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_ParserSettings.h"
#include <stdio.h>
#include <qfile.h>
#include <qfileinfo.h>
#include <qtextstream.h>
+using namespace std;
/*!
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD.h"
#include "QAD_Popup.h"
#include "utilities.h"
+using namespace std;
/*****************************************************************************
** Class QAD_PopupClientServer
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class QAD_ResourceMgr QAD_ResourceMgr.h
\brief ResourceMgr QAD-based application.
#include <qfileinfo.h>
#include <Standard.hxx>
+using namespace std;
/* configuration file */
static const char* CONFIG_FILE = "config";
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_Settings.h"
#include <stdio.h>
#include <qregexp.h>
#include <qstring.h>
#include <qtextstream.h>
+using namespace std;
/*!
Class QAD_Settings is a base class for different kind of settings
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_SpinBoxDbl.h"
#include <qpushbutton.h>
#include <qpainter.h>
#include <qpixmapcache.h>
#include <qapplication.h>
#include <limits.h>
+using namespace std;
//******************************************************************************
// QDblRangeControl class
// Module : SALOME
// $Header$
-using namespace std;
#include "QAD_Splitter.h"
+using namespace std;
/*!
Constructs an horizontal splitter.
// Module : SALOME
// $Header$
-using namespace std;
/*!
\class QAD_Tools QAD_Tools.h
\brief Helpful functions for QAD.
#include <string.h>
#include <ctype.h>
#include <qstringlist.h>
+using namespace std;
static char* tempName()
{
// Module : SALOME
// $Header$
-using namespace std;
#define INCLUDE_MENUITEM_DEF
#include "QAD_Desktop.h"
#include <qaccel.h>
#include <qstringlist.h>
#include <qfileinfo.h>
+using namespace std;
map<int,QString> QAD_XmlHandler::_bibmap;
#include "SALOMEGUI.h"
#include "QAD_Desktop.h"
+using namespace std;
//=============================================================================
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_AboutDlg.h"
#include "QAD_Desktop.h"
#include "QAD_Tools.h"
#include <qlayout.h>
#include <qpixmap.h>
#include <qmessagebox.h>
+using namespace std;
/*
* Constructor
// Author : Michael Zorin (mzn)
// Module : SALOME
-using namespace std;
#include "SALOMEGUI_ActivateComponentDlg.h"
#include <qframe.h>
#include <qpushbutton.h>
#include <qlayout.h>
#include <qpixmap.h>
+using namespace std;
static const char* const default_icon[] = {
"48 48 17 1",
// Author : Vasily RUSYAEV (vrv)
// Module : SALOME
-using namespace std;
#include "SALOMEGUI_CloseDlg.h"
#include <qpushbutton.h>
#include <qlayout.h>
#include <qlabel.h>
#include <qmessagebox.h>
+using namespace std;
SALOMEGUI_CloseDlg::SALOMEGUI_CloseDlg ( QWidget * parent, const char * name, bool modal, WFlags f )
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_Desktop.h"
#include "SALOME_Selection.h"
#include "SALOME_ListIteratorOfListIO.hxx"
#include CORBA_SERVER_HEADER(SALOMEDS_Attributes)
+using namespace std;
/*!
Constructor
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_ExternalBrowserDlg.h"
#include <qbuttongroup.h>
#include "QAD_FileDlg.h"
#include "QAD_Tools.h"
+using namespace std;
/*
* Constructs a modal SALOMEGUI_ExternalBowserDlg which is a child of 'parent'
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_ImportOperation.h"
+using namespace std;
SALOMEGUI_ImportOperation::SALOMEGUI_ImportOperation( QAD_Study* study ) :
QAD_Operation( study )
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_LoadStudiesDlg.h"
#include <qlabel.h>
#include <qlayout.h>
#include <qlistbox.h>
#include <qpushbutton.h>
+using namespace std;
#define SPACING_SIZE 6
#define MARGIN_SIZE 11
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_NameDlg.h"
#include "QAD_Application.h"
#include "QAD_Desktop.h"
#include <qlineedit.h>
#include <qpushbutton.h>
#include <qlayout.h>
+using namespace std;
/*!
Constructor
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_OpenWith.h"
#include <qlabel.h>
#include <qpushbutton.h>
#include <qlayout.h>
#include <qlistbox.h>
+using namespace std;
#define SPACING_SIZE 6
#define MARGIN_SIZE 11
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_QtCatchCorbaException.hxx"
#include "utilities.h"
#include "QAD_Desktop.h"
#include "QAD_MessageBox.h"
+using namespace std;
void QtCatchCorbaException(const SALOME::SALOME_Exception & S_ex)
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_SetValueDlg.h"
#include "QAD_Tools.h"
#include <qpushbutton.h>
#include <qlayout.h>
#include <qvalidator.h>
+using namespace std;
#define MARGIN_SIZE 11
#define SPACING_SIZE 6
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_SetupCurveDlg.h"
#include "QAD_Tools.h"
#include <qlayout.h>
#include <qtoolbutton.h>
#include <qgroupbox.h>
#include <qcolordialog.h>
+using namespace std;
#define MARGIN_SIZE 11
#define SPACING_SIZE 6
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_StudyPropertiesDlg.h"
#include "QAD_Desktop.h"
#include <qpushbutton.h>
#include <qlayout.h>
+using namespace std;
#define DEFAULT_MARGIN 11
#define DEFAULT_SPACING 6
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_TableDlg.h"
#include "QAD_Tools.h"
#include "QAD_MessageBox.h"
#include <qinputdialog.h>
#include <qlabel.h>
#include "utilities.h"
+using namespace std;
#define MARGIN_SIZE 11
#define SPACING_SIZE 6
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_TrihedronSizeDlg.h"
#include <qbuttongroup.h>
#include <qpushbutton.h>
#include <qspinbox.h>
#include <qlayout.h>
+using namespace std;
#define MARGIN_SIZE 11
#define SPACING_SIZE 6
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOMEGUI_ViewChoiceDlg.h"
#include "QAD_Config.h"
#include "QAD_StudyFrame.h"
#include <qvariant.h>
#include <qtooltip.h>
#include <qwhatsthis.h>
+using namespace std;
/*
* Constructs a SALOMEGUI_ViewChoiceDlg which is a child of 'parent', with the
// File : SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger_0.cxx
// Module : SALOME
-using namespace std;
#include "SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger.hxx"
#ifndef _Standard_NoSuchObject_HeaderFile
#ifndef _SALOME_DataMapNodeOfDataMapOfIOMapOfInteger_HeaderFile
#include "SALOME_DataMapNodeOfDataMapOfIOMapOfInteger.hxx"
#endif
-
+using namespace std;
+
#define TheKey Handle_SALOME_InteractiveObject
#define TheKey_hxx "SALOME_InteractiveObject.hxx"
// File : SALOME_DataMapNodeOfDataMapOfIOMapOfInteger_0.cxx
// Module : SALOME
-using namespace std;
#include "SALOME_DataMapNodeOfDataMapOfIOMapOfInteger.hxx"
#ifndef _Standard_TypeMismatch_HeaderFile
#ifndef _SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger_HeaderFile
#include "SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger.hxx"
#endif
+using namespace std;
SALOME_DataMapNodeOfDataMapOfIOMapOfInteger::~SALOME_DataMapNodeOfDataMapOfIOMapOfInteger() {}
// File : SALOME_DataMapOfIOMapOfInteger_0.cxx
// Module : SALOME
-using namespace std;
#include "SALOME_DataMapOfIOMapOfInteger.hxx"
#ifndef _Standard_DomainError_HeaderFile
#ifndef _SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger_HeaderFile
#include "SALOME_DataMapIteratorOfDataMapOfIOMapOfInteger.hxx"
#endif
-
+using namespace std;
+
#define TheKey Handle_SALOME_InteractiveObject
#define TheKey_hxx "SALOME_InteractiveObject.hxx"
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOME_Filter.ixx"
+using namespace std;
// File : SALOME_ListIO_0.cxx
// Module : SALOME
-using namespace std;
#include "SALOME_ListIO.hxx"
#ifndef _Standard_NoSuchObject_HeaderFile
#ifndef _SALOME_ListNodeOfListIO_HeaderFile
#include "SALOME_ListNodeOfListIO.hxx"
#endif
-
+using namespace std;
+
#define Item Handle_SALOME_InteractiveObject
#define Item_hxx "SALOME_InteractiveObject.hxx"
// File : SALOME_ListIteratorOfListIO_0.cxx
// Module : SALOME
-using namespace std;
#include "SALOME_ListIteratorOfListIO.hxx"
#ifndef _Standard_NoMoreObject_HeaderFile
#ifndef _SALOME_ListNodeOfListIO_HeaderFile
#include "SALOME_ListNodeOfListIO.hxx"
#endif
+using namespace std;
#define Item Handle_SALOME_InteractiveObject
// File : SALOME_ListIteratorOfListOfFilter_0.cxx
// Module : SALOME
-using namespace std;
#include "SALOME_ListIteratorOfListOfFilter.hxx"
#ifndef _Standard_NoMoreObject_HeaderFile
#ifndef _SALOME_ListNodeOfListOfFilter_HeaderFile
#include "SALOME_ListNodeOfListOfFilter.hxx"
#endif
+using namespace std;
#define Item Handle_SALOME_Filter
// File : SALOME_ListNodeOfListIO_0.cxx
// Module : SALOME
-using namespace std;
#include "SALOME_ListNodeOfListIO.hxx"
#ifndef _Standard_TypeMismatch_HeaderFile
#ifndef _SALOME_ListIteratorOfListIO_HeaderFile
#include "SALOME_ListIteratorOfListIO.hxx"
#endif
+using namespace std;
SALOME_ListNodeOfListIO::~SALOME_ListNodeOfListIO() {}
// File : SALOME_ListNodeOfListOfFilter_0.cxx
// Module : SALOME
-using namespace std;
#include "SALOME_ListNodeOfListOfFilter.hxx"
#ifndef _Standard_TypeMismatch_HeaderFile
#ifndef _SALOME_ListIteratorOfListOfFilter_HeaderFile
#include "SALOME_ListIteratorOfListOfFilter.hxx"
#endif
+using namespace std;
SALOME_ListNodeOfListOfFilter::~SALOME_ListNodeOfListOfFilter() {}
// File : SALOME_ListOfFilter_0.cxx
// Module : SALOME
-using namespace std;
#include "SALOME_ListOfFilter.hxx"
#ifndef _Standard_NoSuchObject_HeaderFile
#ifndef _SALOME_ListNodeOfListOfFilter_HeaderFile
#include "SALOME_ListNodeOfListOfFilter.hxx"
#endif
+using namespace std;
#define Item Handle_SALOME_Filter
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOME_NumberFilter.ixx"
#include "SALOME_Selection.h"
#include "SALOME_InteractiveObject.hxx"
#include "QAD_Application.h"
#include "QAD_Desktop.h"
#include "QAD_Study.h"
+using namespace std;
SALOME_NumberFilter::SALOME_NumberFilter(NumberFilter TheKind, Standard_Integer aValue):
myKind(TheKind),
// Module : SALOME
// $Header$
-using namespace std;
#include "SALOME_TypeFilter.ixx"
#include "SALOME_InteractiveObject.hxx"
+using namespace std;
SALOME_TypeFilter::SALOME_TypeFilter(const Standard_CString TheKind):
myKind(TheKind){}
#include "LocalTraceBufferPool.hxx"
#include "utilities.h"
+using namespace std;
+
// In case of truncated message, end of trace contains "...\n\0"
#define TRUNCATED_MESSAGE "...\n"
#define MAXMESS_LENGTH MAX_TRACE_LENGTH-5
-using namespace std;
-
LocalTraceBufferPool* LocalTraceBufferPool::_singleton = 0;
pthread_mutex_t LocalTraceBufferPool::_singletonMutex;
#include <sstream>
#include <cstdlib>
-using namespace std;
#include "LocalTraceBufferPool.hxx"
* thread waken up is not garanteed (no fifo or priority rules in Linux Kernel)
*/
-#define MESS_INIT(deb) ostringstream os; os<<deb
+#define MESS_INIT(deb) std::ostringstream os; os<<deb
#define MESS_BEGIN(deb) MESS_INIT(deb)<<__FILE__ <<" ["<<__LINE__<<"] : "
#define MESS_END endl; LocalTraceBufferPool::instance()->insert(NORMAL_MESS, os.str().c_str());
#define MESS_ABORT endl; LocalTraceBufferPool::instance()->insert(ABORT_MESS, os.str().c_str());
#define INFOS(msg) {MESS_BEGIN("- Trace ") << msg << MESS_END}
#define PYSCRIPT(msg) {MESS_INIT("---PYSCRIPT--- ") << msg << MESS_END}
#define INTERRUPTION(msg) {MESS_BEGIN("- INTERRUPTION: ")<< msg << MESS_ABORT}
-#define IMMEDIATE_ABORT(code) {cout <<flush; \
+#define IMMEDIATE_ABORT(code) {cout <<std::flush; \
cerr << "- ABORT " << __FILE__ << " [" <<__LINE__<< "] : " << flush; \
cerr << "ABORT return code= "<< code << endl; \
std::exit(code);}
#include <map>
#include <string>
+using namespace std;
+
static PyInterp_PyQt *interp = NULL;
static map<int,PyInterp_PyQt*> mapInterp;
// File : SalomePyQt.cxx
// Module : SALOME
-using namespace std;
#include "SalomePyQt.hxx"
#include <qapplication.h>
#include "QAD_Config.h"
#include "QAD_Settings.h"
+using namespace std;
QWidget* SalomePyQt::getDesktop()
{
// Module : SALOME
// $Header$
-using namespace std;
#include "SUPERVGraph.h"
#include "SUPERVGraph_ViewFrame.h"
+using namespace std;
QAD_ViewFrame* SUPERVGraph::createView(QAD_RightFrame* parent)
{
// Author : Francis KLOSS
// Module : SALOME
-using namespace std;
#include "SUPERVGraph_Graph.h"
#include "QAD_Settings.h"
#include <qcolordialog.h>
#include <qpopupmenu.h>
+using namespace std;
SUPERVGraph_Graph::SUPERVGraph_Graph(QWidget* parent) :
// Module : SALOME
// $Header$
-using namespace std;
#include "SUPERVGraph_ViewFrame.h"
#include "QAD_Settings.h"
//QT Include
#include <qlayout.h>
#include <qcolordialog.h>
+using namespace std;
SUPERVGraph_View::SUPERVGraph_View(QWidget* theParent): QWidget(theParent){
init(theParent);
// Module : SALOME
// $Header$
-using namespace std;
#include <qapplication.h>
#include <qlabel.h>
#include "Utils_CorbaException.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SALOMEDS)
+using namespace std;
//=============================================================================
/*! SALOME_Session_QThread
#include "SALOME_Session_i.hxx"
#include "Session_ServerLauncher.hxx"
+using namespace std;
extern "C" int HandleSignals(QApplication *theQApplication);
#include <qapplication.h>
#include "CASCatch_SignalsHandler.h" // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
+using namespace std;
extern "C" int HandleSignals(QApplication *theQApplication)
#include "Utils_SALOME_Exception.hxx"
#include "utilities.h"
+using namespace std;
//=============================================================================
/*!
#include <qthread.h>
#include <qwaitcondition.h>
-using namespace std;
class ServArg
{
PortableServer::POA_var _root_poa;
QMutex* _GUIMutex;
QWaitCondition *_ServerLaunch;
- list<ServArg> _argServToLaunch;
- vector<string> _argCopy;
- list<Session_ServerThread*> _serverThreads;
+ std::list<ServArg> _argServToLaunch;
+ std::vector<std::string> _argCopy;
+ std::list<Session_ServerThread*> _serverThreads;
};
#endif
#define _SESSION_SERVERTHREAD_HXX_
#include <CORBA.h>
-#include <string>
#include "SALOME_NamingService.hxx"
#include <qthread.h>
-using namespace std;
class Session_ServerThread
{
-using namespace std;
// File : SALOMEDS_Tool.cxx
// Created : Mon Oct 21 16:24:34 2002
// Author : Sergey RUIN
#include <sys/time.h>
#include <stdlib.h>
+using namespace std;
//============================================================================
// function : GetTempDir
// Module : SALOME
// $Header$
-using namespace std;
#include "ToolsGUI.h"
#include "ToolsGUI_CatalogGeneratorDlg.h"
#include "utilities.h"
#include <stdlib.h>
+using namespace std;
int ToolsGUI::runCommand(string & arg)
{
// Module : SALOME
// $Header$
-using namespace std;
#include "utilities.h"
#include "SALOME_TestComponent_i.hxx"
#include <stdio.h>
#include <cstdlib>
#include <map>
+using namespace std;
Engines_TestComponent_i::Engines_TestComponent_i(CORBA::ORB_ptr orb,
PortableServer::POA_ptr poa,
// Module : SALOME
// $Header$
-using namespace std;
#include "utilities.h"
#include <iostream>
#include <unistd.h>
#include <SALOMEconfig.h>
#include "SALOME_NamingService.hxx"
#include "OpUtil.hxx"
+using namespace std;
int main (int argc, char * argv[])
{
# include "Utils_SINGLETON.hxx"
#include "SALOME_NamingService.hxx"
#include "OpUtil.hxx"
+using namespace std;
int main (int argc, char * argv[])
{
// Module : SALOME
// $Header$
-using namespace std;
# include "Utils_CommException.hxx"
+using namespace std;
CommException::CommException( void ): SALOME_Exception( "CommException" )
{
# include "Utils_DESTRUCTEUR_GENERIQUE.hxx"
# include "utilities.h"
+using namespace std;
+
void Nettoyage();
#ifdef _DEBUG_
static int MYDEBUG = 0;
#endif
-using namespace std;
-
static list<DESTRUCTEUR_GENERIQUE_*> *Destructeurs=0 ;
/*! \class ATEXIT_
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SALOME_Exception)
+using namespace std;
+
void SalomeException ()
{
throw SALOME_Exception("Salome Exception");
// Module : SALOME
// $Header$
-using namespace std;
#include <iostream>
#include "Utils_SALOME_Exception.hxx"
#include "utilities.h"
+using namespace std;
extern "C"
{
#include <math.h>
#include <signal.h>
#include "Utils_SignalsHandler.h"
+using namespace std;
//============================================================================
# include "Utils_Timer.hxx"
# include <stream.h>
-using namespace std;
#include "utilities.h"
+using namespace std;
static struct timezone *tz=(struct timezone*) malloc(sizeof(struct timezone));
#include <vtkUnstructuredGrid.h>
#include <vtkVoxel.h>
#include <vtkWedge.h>
+using namespace std;
#ifdef _DEBUG_
static int MYDEBUG = 0;
#include <vtkDataSet.h>
#include <vtkObjectFactory.h>
#include <vtkPointData.h>
+using namespace std;
vtkCxxRevisionMacro(SALOME_PassThroughFilter, "$Revision$");
vtkStandardNewMacro(SALOME_PassThroughFilter);
#include <vtkObjectFactory.h>
#include <vtkPointData.h>
#include <vtkUnstructuredGrid.h>
+using namespace std;
#ifdef _DEBUG_
static int MYDEBUG = 0;
// Module : SALOME
// $Header$
-using namespace std;
#include "VTKViewer.h"
#include "VTKViewer_ViewFrame.h"
+using namespace std;
QAD_ViewFrame* VTKViewer::createView(QAD_RightFrame* parent)
{
// Module : SALOME\r
\r
#include "VTKViewer_Filter.h"\r
+using namespace std;\r
\r
IMPLEMENT_STANDARD_HANDLE(VTKViewer_Filter, MMgt_TShared)\r
IMPLEMENT_STANDARD_RTTIEXT(VTKViewer_Filter, MMgt_TShared)\r
// $Header$
#include "VTKViewer_Prs.h"
+using namespace std;
//==========================================================
/*!
// Module : SALOME
// $Header$
-using namespace std;
#include "VTKViewer_RenderWindow.h"
#include "utilities.h"
#include "QAD_Settings.h"
#if QT_VERSION > 300
#include <qcursor.h>
#endif
+using namespace std;
VTKViewer_RenderWindow::VTKViewer_RenderWindow(QWidget *parent, const char *name) :
QWidget(parent, name,
#include "vtkObjectFactory.h"
#include "vtkPoints.h"
#include "vtkPolyData.h"
+using namespace std;
vtkCxxRevisionMacro(VTKViewer_VectorText, "$Revision$");
vtkStandardNewMacro(VTKViewer_VectorText);
