From: ribes Date: Thu, 1 Mar 2007 13:53:32 +0000 (+0000) Subject: DSC_User base files added X-Git-Tag: DSC_OK~11 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=68bdf2bae39c1b04c35c799911258c2297cc62fb;p=modules%2Fkernel.git DSC_User base files added --- diff --git a/src/DSC/DSC_User/DSC_Exception.hxx b/src/DSC/DSC_User/DSC_Exception.hxx new file mode 100644 index 000000000..102957696 --- /dev/null +++ b/src/DSC/DSC_User/DSC_Exception.hxx @@ -0,0 +1,158 @@ +// Eric Fayolle - EDF R&D +// Modified by : $LastChangedBy$ +// Date : $LastChangedDate: 2007-02-06 10:44:23 +0100 (mar, 06 fév 2007) $ +// Id : $Id$ + +#ifndef DSC_EXCEPTION_HXX +#define DSC_EXCEPTION_HXX + +#include "Utils_SALOME_Exception.hxx" +#include +#include +#include +#include + +#include "utilities.h" + +#ifndef WNT +extern "C" +{ +#endif +#include +#ifndef WNT +} +#endif + + +#ifdef _DEBUG_ +# ifdef __GNUC__ +# define LOC(message) (message), __FILE__ , __LINE__ , __FUNCTION__ +# else +# define LOC(message) (message), __FILE__, __LINE__ +# endif +#else +# define LOC(message) (message) +#endif + + +#ifndef SWIG +/** + * Class OSS is useful when streaming data through a function + * that expect a string as parameter + */ +class OSS +{ +private: + std::ostringstream oss_; + +public: + explicit OSS() : oss_() {} + + template + OSS & operator<<(T obj) + { + oss_ << obj; + return *this; + } + + operator std::string() + { + return oss_.str(); + } + + // Surtout ne pas écrire le code suivant: + // car oss_.str() renvoie une string temporaire + // operator const char*() + // { + // return oss_.str().c_str(); + // } + +}; /* end class OSS */ +#endif + + +// Cette fonction provient de Utils_SALOME_Exception +// Solution pas très élégante mais contrainte par les manques de la classe SALOME_Exception +const char *makeText( const char *text, const char *fileName, const unsigned int lineNumber); + +struct DSC_Exception : public SALOME_Exception { + + // Attention, en cas de modification des paramètres par défaut + // il est necessaire de les repporter dans la macro DSC_EXCEPTION ci-dessous + // Le constructeur de la SALOME_Exception demande une chaine non vide + // Du coup on est obliger de la désallouer avant d'y mettre la notre + // car le what n'est pas virtuel donc il faut que le contenu de SALOME_Exception::_text + // soit utilisable. + // Ne pas mettre lineNumber=0 à cause du calcul log dans la SALOME_Exception si fileName est défini + DSC_Exception( const std::string & text, + const char *fileName="", + const unsigned int lineNumber=0, + const char *funcName="" ): + SALOME_Exception(text.c_str()) , + _dscText(text), + _filefuncName(setFileFuncName(fileName?fileName:"",funcName?funcName:"")), + _lineNumber(lineNumber), + _exceptionName("DSC_Exception") + { + // Mise en cohérence avec l'exception SALOME (à revoir) + delete [] ((char*)SALOME_Exception::_text); + if (! _filefuncName.empty() ) + SALOME_Exception::_text = makeText(text.c_str(),_filefuncName.c_str(),lineNumber) ; + else + SALOME_Exception::_text = makeText(text.c_str(),0,lineNumber) ; + + OSS oss ; + oss << _exceptionName ; + if (!_filefuncName.empty() ) oss << " in " << _filefuncName; + if (_lineNumber) oss << " [" << _lineNumber << "]"; + oss << " : " << _dscText; + _what = oss; + } + + virtual const char* what( void ) const throw () + { + return _what.c_str() ; + } + + // L'opérateur = de SALOME_Exception n'est pas défini + // problème potentiel concernant la recopie de son pointeur _text + + // Le destructeur de la SALOME_Exception devrait être virtuel + // sinon pb avec nos attributs de type pointeur. + virtual ~DSC_Exception(void) throw() {}; + +private: + + std::string setFileFuncName(const char * fileName, const char * funcName) { + ASSERT(fileName); + ASSERT(funcName); + OSS oss; + if ( strcmp(fileName,"") ) + oss << fileName << "##" << funcName; + + return oss; + }; + + //DSC_Exception(void) {}; +protected: + std::string _dscText; + std::string _filefuncName; + std::string _exceptionName; + int _lineNumber; + std::string _what; +}; + +#define DSC_EXCEPTION(Derived) struct Derived : public DSC_Exception { \ + Derived ( const std::string & text, const char *fileName="", const unsigned int lineNumber=0, const char *funcName="" \ + ) : DSC_Exception(text,fileName,lineNumber,funcName) { \ + _exceptionName = #Derived; \ + } \ + virtual ~Derived(void) throw();\ +};\ + +//Sert à eviter le problème d'identification RTTI des exceptions +//Crée un unique typeInfo pour tous les bibliothèques composants SALOME +//dans un fichier cxx +#define DSC_EXCEPTION_CXX(NameSpace,Derived) NameSpace::Derived::~Derived(void) throw() {}; + +#endif /* DSC_EXCEPTION_HXX */ diff --git a/src/DSC/DSC_User/Superv_Component_i.cxx b/src/DSC/DSC_User/Superv_Component_i.cxx new file mode 100644 index 000000000..f1155e2e9 --- /dev/null +++ b/src/DSC/DSC_User/Superv_Component_i.cxx @@ -0,0 +1,266 @@ +// André Ribes - EDF R&D +#include "Superv_Component_i.hxx" + +DSC_EXCEPTION_CXX(Superv_Component_i,BadFabType); +DSC_EXCEPTION_CXX(Superv_Component_i,BadType); +DSC_EXCEPTION_CXX(Superv_Component_i,BadCast); +DSC_EXCEPTION_CXX(Superv_Component_i,UnexpectedState); +DSC_EXCEPTION_CXX(Superv_Component_i,PortAlreadyDefined); +DSC_EXCEPTION_CXX(Superv_Component_i,PortNotDefined); +DSC_EXCEPTION_CXX(Superv_Component_i,PortNotConnected); +DSC_EXCEPTION_CXX(Superv_Component_i,NilPort); +DSC_EXCEPTION_CXX(Superv_Component_i,BadProperty); + +Superv_Component_i::Superv_Component_i(CORBA::ORB_ptr orb, + PortableServer::POA_ptr poa, + PortableServer::ObjectId * contId, + const char *instanceName, + const char *interfaceName, + bool notif) : + Engines_DSC_i(orb, poa, contId, instanceName, interfaceName) +{ + _my_basic_factory = new basic_port_factory(); + _my_palm_factory = new palm_port_factory(); + _my_calcium_factory = new calcium_port_factory(); +} + + +Superv_Component_i::~Superv_Component_i() { + delete _my_basic_factory; +} + +// Dans ces méthodes, on analyse le type pour connaître +// quel constructeur appelé. +// Le nom du port est sous la forme : +// TYPE_name, exemple : BASIC_short +// : PALM_sequence_long +// : CALCIUM_long +// : etc ... + +provides_port * +Superv_Component_i::create_provides_data_port(const char* port_fab_type) + throw (BadFabType) +{ + assert(port_fab_type); + + provides_port * rtn_port = NULL; + string the_type(port_fab_type); + int search_result; + + search_result = the_type.find("BASIC_"); + if (search_result == 0) { + rtn_port = _my_basic_factory->create_data_servant(the_type.substr(search_result+6, + the_type.length())); + } + search_result = the_type.find("PALM_"); + if (search_result == 0) { + rtn_port = _my_palm_factory->create_data_servant(the_type.substr(search_result+5, + the_type.length())); + } + + search_result = the_type.find("CALCIUM_"); + if (search_result == 0) { + rtn_port = _my_calcium_factory->create_data_servant(the_type.substr(search_result+8, the_type.length())); + } + + if (rtn_port == NULL) + throw BadFabType( LOC(OSS()<< "Impossible d'accéder à la fabrique " + <create_data_proxy(the_type.substr(search_result+6, + the_type.length())); + } + + search_result = the_type.find("CALCIUM_"); + if (search_result == 0) { + std::cout << "---- Superv_Component_i::create_uses_data_port : MARK 1 ---- " << the_type.substr(search_result+8, the_type.length()) << "----" << std::endl; + rtn_proxy = _my_calcium_factory->create_data_proxy(the_type.substr(search_result+8, the_type.length())); + } + + if (rtn_proxy == NULL) + throw BadFabType( LOC(OSS()<< "Impossible d'accéder à la fabrique " + <get_port_ref(), + provides_port_name, + port->get_port_properties()); + + superv_port_t * new_superv_port = new superv_port_t(); + new_superv_port->p_ref = port; + my_superv_ports[provides_port_name] = new_superv_port; + + } + catch (const Engines::DSC::PortAlreadyDefined&) { + throw PortAlreadyDefined( LOC(OSS()<< "Le port provides " + << provides_port_name <<" existe déjà.")); + } + catch (const Engines::DSC::NilPort&) { + throw NilPort( LOC(OSS()<< "Le pointeur sur port provides est nul.")); + } + catch (const Engines::DSC::BadProperty&) { + throw BadProperty( LOC(OSS()<< "La propriété est mal définie")); + } +} + +void +Superv_Component_i::add_port(uses_port * port, + const char* uses_port_name) + throw (PortAlreadyDefined, NilPort, BadProperty) +{ + assert(port); + assert(uses_port_name); + + try { + Engines_DSC_interface::add_uses_port(port->get_repository_id(), + uses_port_name, + port->get_port_properties()); + superv_port_t * new_superv_port = new superv_port_t(); + new_superv_port->u_ref = port; + my_superv_ports[uses_port_name] = new_superv_port; + } + catch (const Engines::DSC::PortAlreadyDefined&) { + throw PortAlreadyDefined( LOC(OSS()<< "Le port uses " + << uses_port_name <<" existe déjà.")); + } + catch (const Engines::DSC::NilPort&) { + throw NilPort( LOC(OSS()<< "Le pointeur sur port uses est nul.")); + } + catch (const Engines::DSC::BadProperty&) { + throw BadProperty( LOC(OSS()<< "La propriété est mal définie")); + } +} + +void +Superv_Component_i::get_port(provides_port *& port, + const char * provides_port_name) + throw (PortNotDefined,PortNotConnected) +{ + assert(provides_port_name); + + try { + Engines_DSC_interface::get_provides_port(provides_port_name, false); + port = my_superv_ports[provides_port_name]->p_ref; + } catch (const Engines::DSC::PortNotDefined&) { + throw PortNotDefined( LOC(OSS()<< "Le port provides " + << provides_port_name <<" n'existe pas.")); + } catch (const Engines::DSC::PortNotConnected&) { + throw PortNotConnected( LOC(OSS()<< "Le port provides " << provides_port_name + << " n'est pas connecté.")); + } +} + +void +Superv_Component_i::get_port(uses_port *& port, + const char * uses_port_name) + throw (PortNotDefined, PortNotConnected) +{ + assert(uses_port_name); + + try { + Engines_DSC_i::get_uses_port(uses_port_name); + port = my_superv_ports[uses_port_name]->u_ref; + } catch (const Engines::DSC::PortNotDefined&) { + throw PortNotDefined( LOC(OSS()<< "Le port uses " + << uses_port_name <<" n'existe pas.")); + } catch (const Engines::DSC::PortNotConnected&) { + throw PortNotConnected( LOC(OSS()<< "Le port uses " << uses_port_name + << " n'est pas connecté.")); + } +} + + + +void +Superv_Component_i::provides_port_changed(const char* provides_port_name, + int connection_nbr, + const Engines::DSC::Message message) +{ + // On cherche tout d'abord à savoir si le port + // est un port que l'on a dans la liste ... + my_superv_ports_it = my_superv_ports.find(provides_port_name); + if (my_superv_ports_it != my_superv_ports.end()) + my_superv_ports[provides_port_name]->p_ref->provides_port_changed(connection_nbr, + message); +} + +void +Superv_Component_i::uses_port_changed(const char* uses_port_name, + Engines::DSC::uses_port * new_uses_port, + const Engines::DSC::Message message) +{ + // On cherche tout d'abord à savoir si le port + // est un port que l'on a dans la liste ... + my_superv_ports_it = my_superv_ports.find(uses_port_name); + if (my_superv_ports_it != my_superv_ports.end()) + my_superv_ports[uses_port_name]->u_ref->uses_port_changed(new_uses_port, + message); +} + + + +void +Superv_Component_i::get_uses_port_names(std::vector & port_names, + const std::string servicename) const { + + port_names.reserve(my_superv_ports.size()); + + superv_ports::const_iterator it; + + for (it=my_superv_ports.begin(); it!=my_superv_ports.end();++it) + if( (*it).second->p_ref == NULL ) port_names.push_back((*it).first); +} diff --git a/src/DSC/DSC_User/Superv_Component_i.hxx b/src/DSC/DSC_User/Superv_Component_i.hxx new file mode 100644 index 000000000..a515f864a --- /dev/null +++ b/src/DSC/DSC_User/Superv_Component_i.hxx @@ -0,0 +1,253 @@ +// André Ribes - EDF R&D 2006 +// +// Cette classe implémente le moteur de la plate-forme Salomé +// +// Elle dispose de deux types méthodes : +// Des méthodes pour les ports provides +// Des méthodes pour les ports uses +// +// Les ports provides sont des ports fournis par la plate-forme réalisant +// par exemple le fonctionnement des ports Calcium ou des ports Basiques sur les +// types CORBA +// +// Les ports uses sont des objets C++ faisant office de proxy pour le code du service afin +// de réaliser des fonctionnalités avant le transfert des données. Ces fonctionnalités doivent d'ailleurs +// être écrites par le développeur s'il utilise un port spécifique à son application. +// +// +// +// Pour ces besoins le moteur redéfini la méthode connect et fourni une méthode register +// pour les proxy +// +// On notera que la méthode init n'est pas implémenté. Elle est laissée à l'implémentation +// du moteur et des services. +// +// Author : ribes +// +// Modified by : $LastChangedBy: fayolle $ +// Date : $LastChangedDate: 2007-03-01 13:36:05 +0100 (jeu, 01 mar 2007) $ +// Id : $Id$ + +#ifndef _SUPERV_COMPONENT_I_HXX_ +#define _SUPERV_COMPONENT_I_HXX_ + +#include "parallel_salome_config.h" +#include "DSC_i.hxx" +#include "base_port.hxx" +#include "uses_port.hxx" +#include "provides_port.hxx" + +// Les différentes fabriques de ports +#include "basic_port_factory.hxx" +#include "palm_port_factory.hxx" +#include "calcium_port_factory.hxx" + +#include "DSC_Exception.hxx" + + +using namespace std; + +class Superv_Component_i : + public Engines_DSC_i, + virtual public POA_Engines::Superv_Component +{ +public: + Superv_Component_i(CORBA::ORB_ptr orb, + PortableServer::POA_ptr poa, + PortableServer::ObjectId * contId, + const char *instanceName, + const char *interfaceName, + bool notif = false); + virtual ~Superv_Component_i(); + + // Déclarations des Exceptions + // Les définitions sont dans le .cxx + DSC_EXCEPTION(BadFabType); + DSC_EXCEPTION(BadType); + DSC_EXCEPTION(BadCast); + DSC_EXCEPTION(UnexpectedState); + DSC_EXCEPTION(PortAlreadyDefined); + DSC_EXCEPTION(PortNotDefined); + DSC_EXCEPTION(PortNotConnected); + DSC_EXCEPTION(NilPort); + DSC_EXCEPTION(BadProperty); + + // C++ methods currently disabled + virtual provides_port * create_provides_control_port() + {return NULL;} + virtual provides_port * create_provides_data_and_control_port(const char* port_type) + {return NULL;} + virtual uses_port * create_uses_control_port() + {return NULL;} + virtual uses_port * create_uses_data_and_control_port(const char* port_type) + {return NULL;} + + // Fabriques + // Note: Il manque les méthodes pour ajouter des fabriques + // Dans ce cas là, les fabriques doivent contenir le constructeur + // Bref à revoir éventuellement puisque'on peut faire + // autrement en surchargement ces méthodes dans le composant + // utilisateur + virtual provides_port * create_provides_data_port(const char* port_fab_type) + throw (BadFabType); + virtual uses_port * create_uses_data_port(const char* port_fab_type) + throw (BadFabType); + + // Ajouts/Récuperations + virtual void add_port(const char * port_fab_type, + const char * port_type, + const char * port_name) + throw (PortAlreadyDefined, BadFabType, BadType, BadProperty); + + template < typename SpecificPortType > + SpecificPortType * add_port(const char * port_fab_type, + const char * port_type, + const char * port_name) + throw (PortAlreadyDefined, BadFabType, BadType, BadCast, BadProperty); + + virtual void add_port(provides_port * port, + const char* provides_port_name) + throw (PortAlreadyDefined, NilPort, BadProperty); + virtual void add_port(uses_port * port, + const char* uses_port_name) + throw (PortAlreadyDefined, NilPort, BadProperty); + + virtual void get_port(provides_port *& port, + const char* provides_port_name) + throw (PortNotDefined, PortNotConnected); + + virtual void get_port(uses_port *& port, + const char* uses_port_name) + throw (PortNotDefined, PortNotConnected); + + virtual void get_uses_port_names(std::vector & port_names, + const std::string servicename="") const; + + template + SpecificPortType * get_port( const char * provides_port_name) + throw (PortNotDefined, PortNotConnected, BadCast, UnexpectedState); + + // Connexions/Déconnexions + // Actuellement vide, mais on rajoutera bientôt des + // méthodes afin de gérer la connexion dans un même container. + + // Callbacks + virtual void provides_port_changed(const char* provides_port_name, + int connection_nbr, + const Engines::DSC::Message message); + + virtual void uses_port_changed(const char* uses_port_name, + Engines::DSC::uses_port * new_uses_port, + const Engines::DSC::Message message); + + +private: + + // Les fabriques + basic_port_factory * _my_basic_factory; + palm_port_factory * _my_palm_factory; + calcium_port_factory * _my_calcium_factory; + + /*-------------------------------------------------*/ + // Gestion des ports + struct superv_port_t { + superv_port_t():u_ref(NULL),p_ref(NULL){}; + // Specifique aux uses port + uses_port * u_ref; + // Specifique aux provides port; + provides_port * p_ref; + }; + + typedef std::map superv_ports; + + /*-------------------------------------------------*/ + /*-------------------------------------------------*/ + + superv_ports my_superv_ports; + superv_ports::iterator my_superv_ports_it; +}; + + + +template < typename SpecificPortType > SpecificPortType * +Superv_Component_i::add_port(const char * port_fab_type, + const char * port_type, + const char * port_name) + throw (PortAlreadyDefined, BadFabType, BadType, BadCast, BadProperty) +{ + assert(port_fab_type); + assert(port_type); + assert(port_name); + SpecificPortType * retPort; + + std::cout << "---- Superv_Component_i::add_port : Mark 0 ---- " << port_name << "----" << std::endl; + + std::string s_port_type(port_type); + if (s_port_type == "provides") { + provides_port * port = create_provides_data_port(port_fab_type); + add_port(port, port_name); + retPort = dynamic_cast(port); + if ( retPort == NULL ) { delete port; + throw BadCast( LOC("La conversion vers le type de port demandé n'est pas possible " )); + } + } + else if (s_port_type == "uses") { + uses_port * port = create_uses_data_port(port_fab_type); + add_port(port, port_name); + std::cout << "---- Superv_Component_i::add_port : Mark 1 ---- " << port << "----" << std::endl; + std::cout << "---- Superv_Component_i::add_port : Mark 1 ---- get_repository_id()" << port->get_repository_id() << std::endl; + retPort = dynamic_cast(port); + std::cout << "---- Superv_Component_i::add_port : Mark 2 ---- " << retPort << "----" << std::endl; + if ( retPort == NULL ) { delete port; + throw BadCast( LOC("La conversion vers le type de port demandé n'est pas possible " )); + } + } + else + throw BadType(LOC(OSS()<< "Le port_type doit être soit 'provides' soit 'uses' not " + << port_type)); + + return retPort; +}; + + +template SpecificPortType * +Superv_Component_i::get_port( const char * port_name) + throw (PortNotDefined, PortNotConnected, BadCast, UnexpectedState) +{ + assert(port_name); + + SpecificPortType * retPort; + base_port * port; + + superv_port_t * superv_port = my_superv_ports[port_name]; + try { + if ( superv_port->p_ref != NULL ) { + port = superv_port->p_ref; + Engines_DSC_interface::get_provides_port(port_name, false); + } + else if ( superv_port->u_ref != NULL ) { + port = superv_port->u_ref; + Engines_DSC_i::get_uses_port(port_name); + } else { + throw UnexpectedState( LOC(OSS()<< "Internal Error superv_port struct is inconsistent ")); + + } + } catch (const Engines::DSC::PortNotDefined&) { + throw PortNotDefined( LOC(OSS()<< "Le port " + << port_name <<" n'existe pas.")); + } catch (const Engines::DSC::PortNotConnected&) { + throw PortNotConnected( LOC(OSS()<< "Le port " << port_name + << " n'est pas connecté.")); + } + + retPort = dynamic_cast(port); + if ( retPort == NULL ) { + delete port; + throw BadCast( LOC("La conversion vers le type de port demandé n'est pas possible " )); + } + + return retPort; +}; + + +#endif diff --git a/src/DSC/DSC_User/base_port.hxx b/src/DSC/DSC_User/base_port.hxx new file mode 100644 index 000000000..55aa42f9e --- /dev/null +++ b/src/DSC/DSC_User/base_port.hxx @@ -0,0 +1,16 @@ +// Eric Fayolle - EDF R&D +// Modified by : $LastChangedBy$ +// Date : $LastChangedDate: 2007-01-08 18:41:18 +0100 (lun, 08 jan 2007) $ +// Id : $Id$ + +#ifndef _PORT_HXX_ +#define _PORT_HXX_ + +class base_port +{ +public : + virtual ~base_port() {}; +}; + +#endif + diff --git a/src/DSC/DSC_User/provides_port.cxx b/src/DSC/DSC_User/provides_port.cxx new file mode 100644 index 000000000..4787bc306 --- /dev/null +++ b/src/DSC/DSC_User/provides_port.cxx @@ -0,0 +1,20 @@ +// André Ribes EDF R&D - 2006 +// + +#include "provides_port.hxx" + +provides_port::provides_port() +{ + default_properties = new PortProperties_i(); +} + +provides_port::~provides_port() +{ + delete default_properties; +} + +Ports::PortProperties_ptr +provides_port::get_port_properties() +{ + return default_properties->_this(); +} diff --git a/src/DSC/DSC_User/provides_port.hxx b/src/DSC/DSC_User/provides_port.hxx new file mode 100644 index 000000000..673f56716 --- /dev/null +++ b/src/DSC/DSC_User/provides_port.hxx @@ -0,0 +1,28 @@ +// André Ribes - EDF R&D - 2006 +// + +#ifndef _PROVIDES_PORT_HXX_ +#define _PROVIDES_PORT_HXX_ + +#include "base_port.hxx" +#include "SALOME_Ports.hh" +#include "DSC_Engines.hh" +#include "PortProperties_i.hxx" + +class provides_port : public base_port +{ + public : + provides_port(); + virtual ~provides_port(); + + virtual Ports::Port_ptr get_port_ref() = 0; + virtual void provides_port_changed(int connection_nbr, + const Engines::DSC::Message message) {} + virtual Ports::PortProperties_ptr get_port_properties(); + + private : + PortProperties_i * default_properties; +}; + +#endif + diff --git a/src/DSC/DSC_User/test_DSC_Exception.cxx b/src/DSC/DSC_User/test_DSC_Exception.cxx new file mode 100644 index 000000000..7b81e4cba --- /dev/null +++ b/src/DSC/DSC_User/test_DSC_Exception.cxx @@ -0,0 +1,132 @@ +#include "DSC_Exception.hxx" + +//Compiler ce fichier en mode _DEBUG_ et sans _DEBUG_ +class A { + +public: + DSC_EXCEPTION(Exp1); + DSC_EXCEPTION(Exp2); + + A() {}; + virtual ~A() {}; + // La salome exception ne permet pas de passer une chaine "" + void lanceException1_1() throw(Exp1) { throw Exp1("_");} + void lanceException1_2() throw(Exp1) { throw Exp1("Ceci est l'exception 1_2");} + void lanceException1_3() throw(Exp1) { throw Exp1(LOC("Ceci est l'exception 1_3"));} + void lanceException1_4() throw(Exp1) { throw Exp1(LOC(OSS() << "Ceci est l'exeption 1_4" )); } + void lanceException1_5() throw(Exp1) { + int a=1; + throw Exp1(LOC(OSS() << "Ceci est l'exeption 1_5 avec la valeur A : " << a )); } + void lanceException1_6() throw(Exp1) { + Exp1 exp1(LOC(OSS() << "Ceci est l'exeption 1_6")); + std::cout << "Affichage de exp1.what() dans lanceException1_6() " << exp1.what() << std::endl; + throw Exp1(exp1); + } + void lanceException1_7() throw(Exp1) { + throw Exp1(LOC(OSS() << "Ceci est l'exeption 1_7")); + } +}; + +DSC_EXCEPTION_CXX(A,Exp1); +DSC_EXCEPTION_CXX(A,Exp2); + + +int main() { + + A a; + + + try { + a.lanceException1_1(); + } + catch ( const A::Exp1 & ex ) { + std::cout << "Exception 1 bien reçue" << std::endl; + std::cout << ex.what() << std::endl; + } catch ( const DSC_Exception & dscE ) { + std::cout << "Exception DSC reçue mais aurait dû recevoir Exception 1" << std::endl; + } catch ( ...) { + std::cout << "Exception ... reçue mais aurait dû recevoir Exception 1" << std::endl; + } + + try { + a.lanceException1_2(); + } + // Essai par valeur (ne pas faire çà !) + catch ( A::Exp1 ex ) { + std::cout << "Exception 1 bien reçue" << std::endl; + std::cout << ex.what() << std::endl; + } catch ( const DSC_Exception & dscE ) { + std::cout << "Exception DSC reçue mais aurait dû recevoir Exception 1" << std::endl; + } catch ( ...) { + std::cout << "Exception ... reçue mais aurait dû recevoir Exception 1" << std::endl; + } + + try { + a.lanceException1_3(); + } + catch ( const A::Exp1 & ex ) { + std::cout << "Exception 1 bien reçue" << std::endl; + std::cout << ex.what() << std::endl; + } catch ( const DSC_Exception & dscE ) { + std::cout << "Exception DSC reçue mais aurait dû recevoir Exception 1" << std::endl; + } catch ( ...) { + std::cout << "Exception ... reçue mais aurait dû recevoir Exception 1" << std::endl; + } + + try { + a.lanceException1_4(); + } + catch ( const A::Exp1 & ex ) { + std::cout << "Exception 1 bien reçue" << std::endl; + std::cout << ex.what() << std::endl; + } catch ( const DSC_Exception & dscE ) { + std::cout << "Exception DSC reçue mais aurait dû recevoir Exception 1" << std::endl; + } catch ( ...) { + std::cout << "Exception ... reçue mais aurait dû recevoir Exception 1" << std::endl; + } + + try { + a.lanceException1_5(); + } + catch ( const A::Exp1 & ex ) { + std::cout << "Exception 1 bien reçue" << std::endl; + std::cout << ex.what() << std::endl; + } catch ( const DSC_Exception & dscE ) { + std::cout << "Exception DSC reçue mais aurait dû recevoir Exception 1" << std::endl; + } catch ( ...) { + std::cout << "Exception ... reçue mais aurait dû recevoir Exception 1" << std::endl; + } + + try { + a.lanceException1_6(); + } + catch ( SALOME_Exception ex ) { + std::cout << "Exception SALOME bien reçue" << std::endl; + std::cout << ex.what() << std::endl; + } catch ( ...) { + std::cout << "Exception ... reçue mais aurait dû recevoir Exception SALOME" << std::endl; + } + + try { + a.lanceException1_6(); + } + catch ( const SALOME_Exception & ex ) { + std::cout << "Exception SALOME bien reçue" << std::endl; + std::cout << ex.what() << std::endl; + } catch ( ...) { + std::cout << "Exception ... reçue mais aurait dû recevoir Exception SALOME" << std::endl; + } + + try { + a.lanceException1_7(); + } catch ( const DSC_Exception & ex ) { + std::cout << "Exception DSC bien reçue" << std::endl; + std::cout << ex.what() << std::endl; + } catch ( const SALOME_Exception & ex ) { + std::cout << "Exception SALOME reçue mais aurais dû recevoir une exception DSC" << std::endl; + std::cout << ex.what() << std::endl; + } catch ( ...) { + std::cout << "Exception ... reçue mais aurait dû recevoir Exception DSC" << std::endl; + } + +}; diff --git a/src/DSC/DSC_User/uses_port.cxx b/src/DSC/DSC_User/uses_port.cxx new file mode 100644 index 000000000..85881da85 --- /dev/null +++ b/src/DSC/DSC_User/uses_port.cxx @@ -0,0 +1,20 @@ +// André Ribes EDF R&D - 2006 +// + +#include "uses_port.hxx" + +uses_port::uses_port() +{ + default_properties = new PortProperties_i(); +} + +uses_port::~uses_port() +{ + delete default_properties; +} + +Ports::PortProperties_ptr +uses_port::get_port_properties() +{ + return default_properties->_this(); +} diff --git a/src/DSC/DSC_User/uses_port.hxx b/src/DSC/DSC_User/uses_port.hxx new file mode 100644 index 000000000..0e91c877e --- /dev/null +++ b/src/DSC/DSC_User/uses_port.hxx @@ -0,0 +1,35 @@ +// André Ribes - EDF R&D - 2006 +// + +// Tous les proxy hérites de cette classe +// Elle permet d'identifier un proxy, de gérer +// la référence réelle de l'objet distant ainsi qu'un support +// aux ports multiples + +#ifndef _USES_PORT_HXX_ +#define _USES_PORT_HXX_ + +#include "base_port.hxx" +#include "SALOME_Ports.hh" +#include "DSC_Engines.hh" +#include "PortProperties_i.hxx" + +class uses_port : public base_port +{ + public : + uses_port(); + virtual ~uses_port(); + + virtual const char * get_repository_id() = 0; + virtual bool set_port(Ports::Port_ptr port) = 0; + + virtual void uses_port_changed(Engines::DSC::uses_port * new_uses_port, + const Engines::DSC::Message message) = 0; + virtual Ports::PortProperties_ptr get_port_properties(); + + private : + PortProperties_i * default_properties; +}; + +#endif +