.. _secaccescorba:
-Composant à accès distant (via CORBA)
-=====================================
-
-
-Principe
---------
-
-Les interfaces nécessaires pour "voir" un objet interne comme un composant
-distant reposent sur la définition d'un "contrat" qui précise les services
-proposés par un composant et le mode d'accès à ces services (paramètres
-d'entrée et de sortie, exceptions renvoyées).
-
-Ces déclarations sont contenues
-dans un **fichier IDL** qui sert de référence pour définir le code d'interface
-côté composant et côté clients du composant. Des exemples sont donnés plus
-loin. A partir du fichier IDL, le concepteur du composant développe une
-interface côté serveur pour faire communiquer le réseau (via CORBA) et l'objet
-interne. A partir du fichier IDL, le concepteur de chaque client développe
-une interface pour faire communiquer le réseau (via CORBA) et le code
-utilisateur du composant.
+Component with remote access (through CORBA)
+================================================
+Principle
+----------
+The interfaces necessary to “see” an internal object like a remote component are based on the definition of a “contract” that
+specifies the services proposed by a component and the mode of accessing these services (input and output parameters, exceptions returned).
+
+These declarations are contained in an **IDL file** that is used as a reference to define the interface code at the component end
+and at the clients end of the component. Examples are given later. The designer of the component starts from the IDL file and
+develops a server end interface to set up communication between the network (through CORBA) and the internal object.
+The designer of each client starts from the IDL file and develops an interface to set up communication between the
+network (through CORBA) and the component user code.
.. _figaccescorba2:
.. image:: images/accesCorbaIDL.png
- :width: 62ex
:align: center
- .. centered:: Accès depuis CORBA
-
+ .. centered:: Access from CORBA
-Fichier IDL
+IDL file
-----------
-
-La première étape consiste, pour le développeur du composant à définir dans un
-fichier dit fichier IDL, la liste des services proposés et leur mode d'appel.
-Ce fichier contient des déclarations de structures de données et des classes
-("interface" dans la terminologie CORBA) dans un langage défini par la norme
-CORBA (IDL). Un document de référence sur la syntaxe du langage IDL est `OMG
-IDL Syntax and Semantics <http://doc.ece.uci.edu/CORBA/formal/01-12-07.pdf>`_
-[IDL]_.
-
-**Remarque**
- Ce langage est proche d'un sous-ensemble des langages C++ et java.
- CORBA a défini son propre langage d'interface pour assurer la transparence par
- rapport aux langages d'implémentation des clients et serveurs. Un client
- écrit avec un langage de programmation peut se connecter à travers CORBA, à un
- serveur implémenté dans un autre langage. La seule condition est que l'on
- dispose de 2 ORB (ou systèmes) CORBA interfacés aux langages utilisés dans le
- serveur et le client. Pour de nombreux langages (C, C++, java, python, ...),
- il existe des ORB capables de les gérer. Au sein de Salomé, on a choisi un
- ORB unique, omniORB, qui permet d'utiliser des clients et des serveurs écrits
- indifféremment en C++ ou en python.
-
-
-Exemple 6 (1ère partie)
+The first step is for the component developer to define a list of proposed services and the method of calling them, in
+a file called the IDL file. This file contains data structures declarations and classes (“interface” in the CORBA terminology) in
+a language defined by the CORBA (IDL) standard.
+`OMG IDL Syntax and Semantics <http://doc.ece.uci.edu/CORBA/formal/01-12-07.pdf>`_ [IDL]_ is a reference document on the IDL language syntax.
+
+**Note**
+ This language is similar to a sub-set of the C++ and java languages. CORBA defined its own interface language to achieve
+ transparency relative to client and server implementation languages. A client written with a programming language can connect
+ through CORBA to a server implemented in another language. The only condition is that there are two CORBA ORBs (or systems)
+ interfaced with languages used in the server and the client. There are ORBs capable of managing many
+ languages (C, C++, java, python, etc.). A single ORB (omniORB) was chosen within SALOME, making it possible to use clients
+ and servers written in C++ or in python indifferently.
+
+Example 6 (Part 1)
^^^^^^^^^^^^^^^^^^^^^^^
-
-On construit un fichier IDL pour accéder depuis CORBA à des objets (C++) de la
-classe alglin (voir fichier ``alglin.hxx`` d'Exemple 1 et suivants).
-Le fichier IDL correspondant contiendra par exemple :
+An IDL file is written to access objects (C++) in the alglin class from CORBA (see the ``alglin.hxx`` file in Example 1 and
+other examples). The corresponding IDL file may for example contain:
.. _alglin.idl:
.. include:: ./exemples/exemple6/alglin.idl
:literal:
+**Comments**
-**Commentaires**
-
- #. Le fichier IDL commence par la ligne ``module Distant {``. Autant que
- possible, on conseille d'encadrer les déclarations d'interfaces dans un module.
-
- #. La classe ``vecteur`` de la version C++ n'a pas besoin d'être déclarée dans
- l'IDL. Le langage IDL possède en effet un type de base (``sequence <double>``)
- capable de gérer un vecteur simple.
+#. The IDL file begins with the ``module Distant {`` line. Whenever possible, it is recommended that interface declarations
+ should be contained within a module.
+#. The ``vecteur`` class of the C++ version does not have to be declared in IDL. The IDL language has a base type (``sequence <double>``)
+ that can manage a simple vector.
-
-Exemple 7 (1ère partie)
+Example 7 (Part 1)
^^^^^^^^^^^^^^^^^^^^^^^
-
-On construit un fichier IDL pour accéder depuis CORBA à des objets (python) de
-la classe FreeFem (voir ``FreeFem.py``, Exemple 4 et suivants) Le
-fichier IDL correspondant contiendra par exemple :
+An IDL file is constructed to access (python) objects in the FreeFem class from CORBA (see ``FreeFem.py``, Example 4 and
+subsequent examples). The corresponding IDL file may for example contain:
.. _freefem.idl:
:literal:
-Interface côté serveur
+Server end interface
----------------------
-
-A partir du fichier IDL, il faut développer une interface côté serveur. Le
-principe consiste à définir un objet communicant avec l'objet interne d'une
-part et avec la couche de communication CORBA d'autre part. L'écriture
-dépendra du langage d'implémentation de l'objet interne (C++ ou python).
-
+A server end interface has to be developed from the IDL file. The principle consists of defining an object communicating
+firstly with the internal object and secondly with the CORBA communication layer. It will be written in a manner that will
+depend on the implementation language of the internal object (C++ or python).
.. _interfacec++:
-Interface serveur C++
+C++ server interface
^^^^^^^^^^^^^^^^^^^^^
-
.. image:: images/objCorbaCpp.png
- :width: 61ex
:align: center
-.. centered:: Génération d'interface C++ CORBA
-
-Lorsque l'objet interne est écrit en C++ (ou possède une couche supérieure
-C++), il faut définir une classe d'implémentation C++ côté serveur qui
-
-* dérive de la classe ``POA_<nom module>::<nom classe idl>`` (classe générée
- par le système à partir du fichier IDL),
-
-* dérive de la classe ``PortableServer::RefCountServantBase`` (classe fournie
- par le système, qui muni la classe d'implémentation d'un compteur de
- référence),
+.. centered:: CORBA C++ interface generation
-* définit des méthodes correspondant aux méthodes et attributs de la classe
- IDL,
+When the internal object is written in C++ (or it has a C++ higher layer), a C++ implementation class will have to be
+defined at the server end that
-* possède en attribut un pointeur vers l'objet interne.
+- is derived from the ``POA_<module name>::<idl class name>`` class (class generated by the system starting from the IDL file)
+- is derived from the ``PortableServer::ServantBase`` class (class provided by the system, that provides a reference
+ counter to the implementation class)
+- defines methods corresponding to the methods and attributes of the IDL class
+- has a pointer to the internal object as an attribute.
-**Remarque**
- Le dernier point ci-dessus peut être remplacé par :
+**Note**
+ The final point above can be replaced by:
.. epigraph::
- dérive de la classe de l'objet interne.
+ is derived from the class of the internal object
- On conseille plutôt la première version qui est plus simple à mettre en oeuvre.
+ The first version is recommended in preference, because it is easier to implement.
+**Important**: Most CORBA implementations can generate skeletons of implementation classes. It is strongly recommended
+that this feature should be used to facilitate writing implementation classes.
-**Important** : La plupart des implémentations CORBA peuvent générer des squelettes de classes
-d'implémentations. On conseille vivement d'utiliser cette possibilité pour
-faciliter l'écriture des classes d'implémentation.
-
-Dans le cas d'omniORB, la commande ::
+In the case of omniORB::
omniidl -bcxx -Wbexample <nom>.idl
-(remarquer l'option -Wbexample) génère un fichier ``<nom>_i.cc`` qui contient
-la classe d'implémentation et un exemple de programme principal côté serveur.
-Il faut alors "nettoyer" ce fichier (en conservant les prototypes d'appel des
-méthodes) et le compléter. Les méthodes des classes d'implémentation
-reçoivent et renvoient des objets CORBA. Il faut donc, si nécessaire, que
-chaque méthode :
-
-* convertisse les objets CORBA en entrée en objets (ou en type simples) C++
-
-* appelle la (ou les) méthodes de l'objet interne
-
-* convertisse les objets C++, résultats des méthodes de l'objet interne en
- objets CORBA
+(note the –Wbexample option) generates a ``<name>_i.cc`` file that contains the implementation class and an example of
+the main program at the server end. This file then has to be “cleaned” (keeping the method call prototypes) and completed.
+Methods for implementation classes receive and return CORBA objects. Therefore, if necessary, each method must:
+- convert CORBA objects in input into C++ objects (or into simple types)
+- call the method(s) of the internal object
+- convert the C++ objects resulting from the methods of the internal object into CORBA objects
.. _implc++:
-Exemple 6 (suite)
-^^^^^^^^^^^^^^^^^
-
-Donnons comme exemple, une classe d'implémentation côté serveur qui permette
-d'appeler depuis CORBA les objets de la classe ``alglin`` :
+Example 6 (continued)
+^^^^^^^^^^^^^^^^^^^^^^^
+Consider an example consisting of a server end implementation class that calls objects in the ``alglin`` class from CORBA:
.. _alglini.hxx:
.. include:: ./exemples/exemple6/alglin_i.cxx
:literal:
-**Remarque**
- Notons que les fonctions ``create_vector`` et ``destroy_vector`` ne sont pas
- exportées dans l'IDL, puisqu'on utilise un type CORBA standard
- (``sequence<double>``.
+**Note**
+ Note that the ``create_vector`` and ``destroy_vector`` functions are not exported in IDL, because a standard CORBA type
+ is used (``sequence<double>``).
-Interface serveur python
+Python server interface
^^^^^^^^^^^^^^^^^^^^^^^^
-
-Ce cas est similaire au précédent. Il peut
-être plus simple (il n'est pas toujours nécessaire d'inclure les phases de
-conversion des paramètres d'entrée et de sortie).
+This case is similar to the previous case. It can be simpler (it is not always necessary to include input and output
+parameter conversion phases).
.. _interfacepython:
.. image:: images/objCorbapy.png
- :width: 61ex
:align: center
- .. centered:: Génération d'interface python CORBA
-
+ .. centered:: Generation of the python CORBA interface
-**Remarque**
- Ceci est dû au fait que python est moins fortement typé que C++ : une fonction
- python peut s'exécuter si les paramètres d'entrée possèdent toutes les méthodes
- et attributs appelés dans la fonction. C'est le cas, si les méthodes de la
- classe d'implémentation ont les mêmes signatures que des méthodes de la classe
- de l'objet interne, comme dans l'exemple 7 ci-après.
+**Note**
+ This is due to the fact that python is not as strongly typed as C++: a python function can be executed if the input parameters
+ possess all methods and attributes called in the function. This is the case if the methods in the implementation class have
+ the same signatures as methods in the internal object class, as in example 7 below.
-Exemple 7 (suite)
-^^^^^^^^^^^^^^^^^
-
-Donnons comme exemple, une classe d'implémentation python côté serveur qui
-permette d'appeler depuis CORBA les objets de la classe ``FreeFem`` :
+Example 7 (continued)
+^^^^^^^^^^^^^^^^^^^^^^^^^
+We will consider an example consisting of the python implementation class at the server end used to call objects in
+the ``FreeFem`` class from CORBA:
.. _freefemi.py:
.. include:: ./exemples/exemple7/FreeFem_i.py
:literal:
-
-Interface client
+Client interface
----------------
+The client end interface code can be written in any language (provided that there is a CORBA implementation in this
+language), independently of the language(s) used at the server end.
-Le code d'interface côté client peut être écrit dans n'importe quel langage
-(pourvu que l'on dispose d'une implémentation CORBA dans ce langage),
-indépendamment du ou des langages utilisés côté serveur.
-
-Essentiellement, il faut :
-
-* lors de la compilation, faire générer l'interface CORBA côté client (en
- général, CORBA génère simultanément les 2 interfaces côté client et serveur) et
- l'intégrer dans le code client,
+Essentially, it is necessary:
-* lors de l'exécution, récupérer la référence CORBA du composant côté serveur,
+- during compilation, to have the CORBA interface generated at the client end (generally, CORBA generates the two
+ interfaces at the client and server ends simultaneously) and to integrate it into the client code,
+- during execution, retrieve the CORBA reference of the server end component,
+- call component methods on this CORBA reference.
-* appeler sur cette référence CORBA, les méthodes du composant.
-
-
-Exemple 8
+Example 8
^^^^^^^^^
-
-Dans le cadre de Salomé, l'écriture de clients n'est pas nécessaire pour les
-composants utilisateur. Donnons cependant un exemple de client C++ et un
-exemple de client python de la classe CORBA AlgLin :
-
+In the context of SALOME, there is no need to write clients for user components. However, consider a C++ client example
+and a python client example in the CORBA AlgLin class:
``client.cxx``
