--- /dev/null
+// 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 <string>
+#include <iostream>
+#include <sstream>
+#include <memory>
+
+#include "utilities.h"
+
+#ifndef WNT
+extern "C"
+{
+#endif
+#include <string.h>
+#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 <class T>
+ 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 */
--- /dev/null
+// 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 "
+ <<port_fab_type));
+
+ return rtn_port;
+}
+
+uses_port *
+Superv_Component_i::create_uses_data_port(const char* port_fab_type)
+throw (BadFabType)
+{
+ assert(port_fab_type);
+
+ uses_port * rtn_proxy = NULL;
+ string the_type(port_fab_type);
+ int search_result;
+
+ search_result = the_type.find("BASIC_");
+ if (search_result == 0) {
+ rtn_proxy = _my_basic_factory->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 "
+ <<port_fab_type));
+
+ return rtn_proxy;
+}
+
+void
+Superv_Component_i::add_port(const char * port_fab_type,
+ const char * port_type,
+ const char * port_name)
+ throw (PortAlreadyDefined, BadFabType, BadType, BadProperty)
+{
+ assert(port_fab_type);
+ assert(port_type);
+ assert(port_name);
+
+ 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);
+ }
+ else if (s_port_type == "uses") {
+ std::cout << "---- Superv_Component_i::add_port : MARK 1 ---- " << std::endl;
+ uses_port * port = create_uses_data_port(port_fab_type);
+ std::cout << "---- Superv_Component_i::add_port : MARK 2 ---- " << std::endl;
+ add_port(port, port_name);
+ }
+ else
+ throw BadType( LOC(OSS()<< "Le port_type doit être soit 'provides' soit 'uses' not "
+ << port_type));
+
+}
+
+void
+Superv_Component_i::add_port(provides_port * port,
+ const char* provides_port_name)
+ throw (PortAlreadyDefined, NilPort, BadProperty)
+{
+ assert(port);
+ assert(provides_port_name);
+
+ try {
+
+ Engines_DSC_interface::add_provides_port(port->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<std::string> & 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);
+}
--- /dev/null
+// 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<std::string> & port_names,
+ const std::string servicename="") const;
+
+ template <typename SpecificPortType >
+ 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<std::string, superv_port_t *> 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<SpecificPortType *>(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<SpecificPortType *>(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 <typename SpecificPortType > 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<SpecificPortType *>(port);
+ if ( retPort == NULL ) {
+ delete port;
+ throw BadCast( LOC("La conversion vers le type de port demandé n'est pas possible " ));
+ }
+
+ return retPort;
+};
+
+
+#endif
--- /dev/null
+// 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
+
--- /dev/null
+// 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();
+}
--- /dev/null
+// 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
+
--- /dev/null
+#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;
+ }
+
+};
--- /dev/null
+// 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();
+}
--- /dev/null
+// 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
+
