idl/SALOME_Component.idl

   1 // Copyright (C) 2007-2015  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //  File   : SALOME_Component.idl
  23 //  Author : Paul RASCLE, EDF
  24
  25 #ifndef _SALOME_COMPONENT_IDL_
  26 #define _SALOME_COMPONENT_IDL_
  27
  28 #include "SALOME_GenericObj.idl"
  29 #include "SALOMEDS.idl"
  30 #include "SALOME_Exception.idl"
  31 #include "SALOME_PyNode.idl"
  32
  33 /*! \file SALOME_Component.idl \brief interfaces for EngineComponent and Container
  34 */
  35
  36 /*! \brief
  37 This is a package of interfaces used for connecting new components to %SALOME
  38 application. It also contains a set of interfaces used for management of %MED
  39 component in %SALOME application.
  40 */
  41 module Engines
  42 {
  43   /*!
  44     A byte stream which is used for binary data transfer between different
  45     components
  46   */
  47   typedef sequence<octet> TMPFile;
  48
  49   //!  General Key Value Structure to set or get properties, for component
  50   struct KeyValuePair
  51   {
  52     string key;
  53     any value;
  54   };
  55
  56   //!  Structure data type to hold reference on data
  57   struct dataref
  58   {
  59     string ref;
  60   };
  61
  62   typedef sequence<KeyValuePair> FieldsDict;
  63   typedef sequence<string> ListOfOptions;
  64   typedef sequence<string> ListOfIdentifiers;
  65
  66   interface EngineComponent ;
  67   interface fileRef ;
  68   interface fileTransfer ;
  69   interface Salome_file;
  70   interface DataContainer;
  71
  72   typedef sequence<DataContainer> ListOfData;
  73
  74   /*! \brief Interface of the %Container.
  75   This interface defines the process of loading and registration
  76   of new components in %SALOME application
  77   */
  78
  79   interface Container
  80   {
  81
  82     /*! \brief Loads a new component class (dynamic library).
  83
  84       \param componentName like COMPONENT, (Python or C++ implementation)
  85                            try to make a Python import of COMPONENT,
  86                            then a lib open of libCOMPONENTEngine.so
  87       \param reason      in case of error (return false) a string explaining the error
  88       \return true if load successfull or already done, false otherwise
  89     */
  90     boolean load_component_Library(in string componentName, out string reason);
  91
  92     //! Create a new servant instance of a component.
  93     /*!
  94       Component library must be loaded.
  95       \param componentName Name of the component which will be registered
  96                            in Registry and Name Service,
  97                          (instance number suffix added to the registered name)
  98       \param studyId        0 if instance is not associated to a study,
  99                             >0 otherwise (== study id)
 100       \return a loaded component
 101     */
 102     Engines::EngineComponent create_component_instance(in string componentName,
 103                                                        in long studyId);
 104
 105     //! Create a new Python servant instance of a generic service.
 106         /*!
 107           This simply loads the service in the current container by importing the
 108           corresponding Python module.
 109           Warning: no internal registration is done, so it is up to the caller to
 110           manage the various instanciation.
 111           \param serviceName Name of the service
 112
 113                                 >0 otherwise (== study id)
 114           \param reason  in case of error (return void string) a string explaining the error
 115           \return the IOR of the loaded service.
 116         */
 117     string create_python_service_instance(in string serviceName,
 118                                           out string reason);
 119
 120     //! Create a new servant instance of a component with environment variables specified.
 121     /*!
 122       Component library must be loaded.
 123       \param componentName Name of the component which will be registered
 124                            in Registry and Name Service,
 125                          (instance number suffix added to the registered name)
 126       \param studyId        0 if instance is not associated to a study,
 127                             >0 otherwise (== study id)
 128       \param env         a dict of env variables
 129       \param reason      in case of error (return nil) a string explaining the error
 130       \return a loaded component
 131     */
 132     Engines::EngineComponent create_component_instance_env(in string componentName,
 133                                                            in long studyId, in FieldsDict env,
 134                                                            out string reason);
 135     //! Find a servant instance of a component
 136     /*!
 137       \param registeredName  Name of the component in Registry or Name Service,
 138                              without instance suffix number
 139       \param studyId        0 if instance is not associated to a study,
 140                             >0 otherwise (== study id)
 141       \return the first instance found with same studyId
 142     */
 143     EngineComponent find_component_instance(in string registeredName,
 144                                             in long studyId);
 145
 146     //! Find a servant instance of a component, or create a new one.
 147     /*!
 148       Loads the component library if needed.
 149       Only applicable to multiStudy components.
 150       \param nameToRegister Name of the component which will be registered
 151                             in Registry (or Name Service)
 152       \param componentName  Name of the constructed library of the %component
 153                             (not used any more, give empty string)
 154       \return a loaded component
 155     */
 156     EngineComponent load_impl(in string nameToRegister,
 157                               in string componentName);
 158
 159     //! Remove the component servant, and deletes all related objects
 160     /*!
 161       \param component_i     Component to be removed
 162     */
 163     void remove_impl(in EngineComponent component_i);
 164
 165     //!  Unload component libraries from the container.
 166     void finalize_removal() ;
 167
 168     //!  Determines whether the server has been loaded or not.
 169     void ping();
 170
 171     //!  Name of the %container
 172     readonly attribute string name ;
 173
 174     //!  working directory of the %container
 175     readonly attribute string workingdir ;
 176
 177     //!  name of the %container log file (this has been set by the launcher)
 178     attribute string logfilename ;
 179
 180     //!  Shutdown the Container process.
 181     void Shutdown();
 182
 183     //!  Returns the hostname of the container
 184     string getHostName();
 185
 186     //!  Returns the PID of the container
 187     long getPID();
 188
 189     //! Kill the container
 190     /*!
 191       Returns True if the %container has been killed.
 192       Kept for Superv compilation but can't work, unless oneway...
 193       TO REMOVE !
 194     */
 195     boolean Kill_impl() ;
 196
 197     //! Create a fileRef
 198     /*!
 199       returns a fileRef object if origFileName exists and is readable
 200       else returns null object. Only one fileRef is created for a given
 201       file name, so, several calls with the same file name returns the
 202       same object.
 203     */
 204     fileRef createFileRef(in string origFileName);
 205
 206     //! Create a Salome_file
 207     /*!
 208       returns a Salome_file object if origFileName exists and is readable
 209       else returns null object.
 210
 211       \param origFileName name of the file to be managed (can contain the path).
 212
 213       \return Salome_file CORBA reference.
 214     */
 215     Salome_file createSalome_file(in string origFileName);
 216
 217     //! Create a fileTransfer
 218     /*!
 219       returns a fileTransfer object used to copy files from the container
 220       machine to the clients machines. Only one fileTransfer instance is
 221       created in a container.
 222     */
 223     fileTransfer getFileTransfer();
 224
 225     //! Copy a file from a remote host (container) to a local file
 226     /*!
 227       \param contai the remote container
 228       \param remoteFile the file on the remote host to copy
 229       \param localFile the local file to create by copy
 230      */
 231     void copyFile(in Container contai, in string remoteFile, in string localFile);
 232
 233     //! Create a PyNode in the container
 234     /*!
 235       \param nodeName the name of the PyNode
 236       \param code python code as text to load in the node
 237      */
 238     PyNode createPyNode(in string nodeName, in string code)  raises(SALOME::SALOME_Exception);
 239
 240     //! Retrieves the last created PyNode instance with createPyNode.
 241     PyNode getDefaultPyNode();
 242
 243     //! Create a PyScriptNode in the container
 244     /*!
 245       \param nodeName the name of the PyScriptNode
 246       \param code python code as text to load in the node
 247      */
 248     PyScriptNode createPyScriptNode(in string nodeName, in string code)  raises(SALOME::SALOME_Exception);
 249
 250     //! Retrieves the last created PyScriptNode instance with createPyScriptNode.
 251     PyScriptNode getDefaultPyScriptNode();
 252   };
 253
 254   /*! \brief Interface to pass data files from the client side to the SALOME Container.
 255     Passes data from client side to the SALOME container (where component engine is running)
 256     size via the CORBA bus as a stream of bytes.
 257   */
 258
 259   interface DataContainer
 260   {
 261     //! This operation returns the stream with the data file content.
 262     TMPFile get();
 263
 264     //! Returns the name of the document corresponding to this data container.
 265     string name();
 266
 267     //! Returns the identifier of the document corresponding to this data container.
 268     string identifier();
 269
 270     //! Returns the extension (type) of the document corresponding to this data container.
 271     //! It is taked from the SIMAN URL.
 272     string extension();
 273
 274     //! Defines the extension. It is required is extension of the file is not
 275     //! matched with a read extension: archived file, for example.
 276     void setExtension(in string extension);
 277   };
 278
 279
 280   /*! \brief Interface of the %component.
 281   This interface is used for interaction between the %container and the
 282   %component and between the components inside the container.
 283   */
 284   interface EngineComponent
 285   {
 286     //!  The name of the instance of the %Component
 287     readonly attribute string instanceName ;
 288
 289     //!  The name of the interface of the %Component
 290     readonly attribute string interfaceName ;
 291
 292     //!  Determines whether the server has already been loaded or not.
 293     void ping();
 294
 295     //!  Get study associated to component instance
 296     /*!
 297       get study associated to component instance
 298       \return -1: not initialised (Internal Error)
 299                0: multistudy component instance
 300               >0: study id associated to this instance
 301     */
 302     long getStudyId();
 303
 304     //! Remove component instance from container
 305     /*!
 306       Deactivates the %Component.
 307       -- TO BE USED BY CONTAINER ONLY (Container housekeeping) --
 308       use remove_impl from Container instead !
 309     */
 310     void destroy() ;
 311
 312     //!  Returns the container that the %Component refers to.
 313     Container GetContainerRef() ;
 314
 315     //! Set component instance properties
 316     /*!
 317       Gives a sequence of (key=string,value=any) to the component.
 318       Base class component stores the sequence in a map.
 319       The map is cleared before.
 320       This map is for use by derived classes.
 321     */
 322     void setProperties(in FieldsDict dico);
 323
 324     //! Get component instance properties
 325     /*!
 326       returns a previously stored map (key=string,value=any) as a sequence.
 327       See setProperties(in FieldsDict dico).
 328     */
 329     FieldsDict getProperties();
 330
 331     //! Set an option value
 332     /*!
 333       This method is to set an option specific to a certain EngineComponent.
 334     */
 335     void SetOption(in string optionName, in string value);
 336
 337     //! Return an option value
 338     /*!
 339       This method is to get value of an option specific to a certain EngineComponent.
 340     */
 341     string GetOption(in string optionName);
 342
 343     //! Set name of a node in a graph (for %SUPERVISOR use)
 344     /*!
 345       This method is used by the %SUPERVISOR component. It sets the names of
 346       the graph and of the node.
 347       \param aGraphName Name of graph
 348       \param aNodeName  Name of node
 349     */
 350     void Names( in string aGraphName , in string aNodeName ) ;
 351
 352     //! Kill the component (if you can)
 353     /*!
 354       Returns True if the %Component has been killed.
 355     */
 356     boolean Kill_impl() ;
 357
 358     //! Stop the component (if you can)
 359     /*!
 360       Returns True if the activity of the %Component has been stopped.
 361       (It's action can't be resumed)
 362     */
 363     boolean Stop_impl() ;
 364
 365     //! Suspend the component
 366     /*!
 367       Returns True if the activity of the %Component has been suspended.
 368       (It's action can be resumed)
 369     */
 370     boolean Suspend_impl() ;
 371
 372     //! Resume the component
 373     /*!
 374       Returns True if the activity of the %Component has been resumed.
 375     */
 376     boolean Resume_impl() ;
 377
 378     //! Get the cpu used
 379     /*!
 380       Returns the Cpu used
 381     */
 382     long CpuUsed_impl() ;
 383
 384     //! Get a python dump
 385     /*!
 386       Returns a python script, which is being played back reproduces
 387       the data model of component
 388     */
 389     TMPFile DumpPython(in Object theStudy,
 390                        in boolean isPublished,
 391                        in boolean isMultiFile,
 392                        out boolean isValidScript);
 393
 394
 395     //! Returns a CORBA Ref of a input Salome_file managed by a service.
 396     /*!
 397
 398       \param service_name service's name.
 399       \param file_name name of the requested file.
 400
 401       \return CORBA Ref of the requested file.
 402
 403       \exception contains informations of what if the component cannot
 404       sends the file's reference.
 405     */
 406     Engines::Salome_file getInputFileToService(in string service_name,
 407                                                in string Salome_file_name) raises(SALOME::SALOME_Exception);
 408
 409     //! Check service input files (transfer them if needed)
 410     /*!
 411       This method is used before the activation of the service. It calls
 412       recvFiles() on all the input Salome_file files of the service.
 413
 414       Before each recvFiles(), it uses the callback method named configureSalome_file.
 415       This method allows the user to configure the files managed by the Salome_file.
 416
 417       By default, there is no files managed when a Salome_file is created,
 418       but the supervisor set some files managed by the Salome_file from the information contained
 419       into the schema file.
 420
 421       \param service_name service's name.
 422
 423       \exception contains informations about files that are not in a good state.
 424     */
 425     void checkInputFilesToService(in string service_name)           raises(SALOME::SALOME_Exception);
 426
 427     //!  This method adds a input Salome_file to a service of the component.
 428     /*!
 429
 430       \param service_name service's name.
 431       \param Salome_file_name name of the Salome_file
 432
 433       \return a reference of the Salome_file
 434
 435       \exception raises an exception if there is already
 436       a Salome_file with this name for the service.
 437     */
 438     Engines::Salome_file setInputFileToService(in string service_name,
 439                                                in string Salome_file_name)   raises(SALOME::SALOME_Exception);
 440
 441     //!  Returns a CORBA Ref of a output Salome_file managed by a service.
 442     /*!
 443
 444       \param service_name service's name.
 445       \param file_name name of the requested file.
 446
 447       \return CORBA Ref of the requested file.
 448
 449       \exception contains informations of what if the component cannot
 450       sends the file's reference.
 451     */
 452     Engines::Salome_file getOutputFileToService(in string service_name,
 453                                                 in string Salome_file_name) raises(SALOME::SALOME_Exception);
 454
 455     //! Check service output files (transfer them if needed)
 456     /*!
 457       This method is used at the end of the service. It calls
 458       recvFiles() on all the output Salome_file files of the service.
 459
 460       Before each recvFiles(), it uses the callback method named configureSalome_file.
 461       This method allows the user to configure the files managed by the Salome_file.
 462
 463       By default, there is no files managed when a Salome_file is created,
 464       but the supervisor set some files managed by the Salome_file from the information contained
 465       into the schema file.
 466
 467       \param service_name service's name.
 468
 469       \exception contains informations about files that are not in a good state.
 470     */
 471     void checkOutputFilesToService(in string service_name)        raises(SALOME::SALOME_Exception);
 472
 473     //!  This method adds an output Salome_file to a service of the component.
 474     /*!
 475
 476       \param service_name service's name.
 477       \param Salome_file_name name of the Salome_file
 478
 479       \return a reference of the Salome_file
 480
 481       \exception raises an exception if there is already
 482       a Salome_file with this name for the service.
 483     */
 484     Engines::Salome_file setOutputFileToService(in string service_name,
 485                                                 in string Salome_file_name)  raises(SALOME::SALOME_Exception);
 486
 487     //! Indicate if the component instance provides custom information about its objects.
 488     /*!
 489       Returns true if the component provides custom information about its objects, false otherwise.
 490       Should be redefined in the certain component to return true in case of this
 491       component provides such information.
 492     */
 493     boolean hasObjectInfo();
 494
 495     //! Get custom information about the given object.
 496     /*!
 497       This method is used to get the custom information about the given object.
 498       Should be redefined in the certain component in case of this
 499       component provides such information.
 500       It is worth using this method only if hasObjectInfo() method returns true.
 501
 502       \param entry object's entry.
 503       \param studyId study id
 504
 505       \return an information about the given object.
 506     */
 507     string getObjectInfo(in long studyId, in string entry);
 508
 509     //! Get version of the component
 510     /*!
 511       This method is supposed to be implemented in all derived classes; default implementation
 512       returns "unknown" string that means that no version information about the component is available.
 513       \note The version of the component is stored to the study, as a part of general persistence
 514       mechanism; once stored, version information in the study cannot be changed.
 515
 516       \return string containing component's version, e.g. "1.0"
 517     */
 518     string getVersion();
 519
 520     //! Generic Import operation to let the component to import data, corresponding to it.
 521     /*!
 522       \param studyId indentifier of the study where the data must be placed
 523       \param data data for import: usually this is just imported file content
 524       \param options additional options for Importat operation
 525       \return the sequence of identifiers of the importedData in the component (to use later in the export function)
 526     */
 527     ListOfIdentifiers importData(in long studyId, in DataContainer data, in ListOfOptions options);
 528
 529     //! Generic Export operation to ket the component export all modified data corresponding to it.
 530     /*!
 531       \param studyId identifier of the study that contains the exported data
 532      */
 533     ListOfData getModifiedData(in long studyId);
 534   };
 535
 536   /*!
 537     \brief Base interface of the %component that supports exporting data.
 538   */
 539   interface ImportableComponent
 540   {
 541     /*! \brief Get a list of supported formats */
 542     SALOME::StringSeq GetImportableFormats();
 543     boolean           ImportDataAs(in string format, in SALOME::GenericObj exporter);
 544   };
 545
 546   //!  A block of binary data used for file transfer. The maximum size of the block is defined on server side.
 547   typedef sequence<octet> fileBlock;
 548
 549   /*! \brief Interface of fileTransfer.
 550      The fileTransfer and fileRef interfaces provide a file transfer service
 551      between different computers.
 552   */
 553   interface fileTransfer : SALOME::GenericObj
 554   {
 555     //! Open the file transfer
 556     /*!
 557       open method returns a key (fileId) that identifies the structure
 558       (ex: C FILE), associated to the original file on the server.
 559       The structure is created by a container for transfer of files availables
 560       on the computer which runs the container.
 561       Each open gives a unique fileId, to allow concurrent reads of the same
 562       File.
 563     */
 564     long open(in string fileName);
 565     //! Open the file transfer in write mode for file fileName
 566     /*!
 567       \param fileName the file to copy into with putBlock
 568       \return the id to use with putBlock
 569     */
 570     long openW(in string fileName);
 571
 572     //! Close the file transfer
 573     /*!
 574     when the file transfer is finished, close method releases structures
 575     created by open method, identified by fileId.
 576     */
 577     void close(in long fileId);
 578
 579     //! Get a file data block
 580     /*!
 581       Get successive blocks of octets from the original file.
 582       The last block is empty, and identifies the end of file.
 583     */
 584     fileBlock getBlock(in long fileId);
 585
 586     //! Put a file data block
 587     /*!
 588        \param fileId identification of the file obtained by openW
 589        \param block a data block to copy into the file identified by fileId
 590     */
 591     void putBlock(in long fileId, in fileBlock block);
 592
 593   };
 594
 595   //!  A file managed by a Salome_file.
 596   struct file {
 597     //! file name
 598     string file_name;
 599     //! path name
 600     string path;
 601     string type;
 602     string source_file_name;
 603     //! status ("present" or "notpresent")
 604     string status;
 605     long   node;
 606     Engines::Container container;
 607   };
 608
 609   //!  A sequence of Engines::file.
 610   typedef sequence<Engines::file> files;
 611
 612
 613   //!  The state of a Salome_file.
 614   struct SfState {
 615     //! file name
 616     string  name;
 617     //! hdf5 file where the file can be saved
 618     string  hdf5_file_name;
 619     //! number of files managed
 620     long    number_of_files;
 621     //! information if all the files are received
 622     boolean files_ok;
 623
 624   };
 625
 626   /*! \brief Interface of a Salome_file managed
 627     This file is independent of a Salome module. It can managed one or more
 628     real files. It's useful for parallel files. Currently Salome_file cannot manage
 629     two files that have the same name but not the same path.
 630   */
 631   interface Salome_file : Engines::fileTransfer
 632   {
 633     //!  Load a Salome_file from a hdf5 file.
 634     /*!
 635
 636       \param hdf5_file name (with path) of the hdf5_file.
 637
 638       \exception contains informations of errors if the loading doesn't succeed.
 639      */
 640     void load(in string hdf5_file)                            raises (SALOME::SALOME_Exception);
 641
 642     //!  Save a Salome_file into a hdf5_file.
 643     /*!
 644
 645       \param  hdf5_file name (with path) of the hdf5_file.
 646
 647       \exception contains informations of errors if the save doesn't succeed.
 648
 649     */
 650     void save(in string hdf5_file)                            raises (SALOME::SALOME_Exception);
 651
 652     //!  Save a Salome_file into a hdf5_file.
 653     /*!
 654       All files that are managed are saved into the hdf5_file
 655
 656       \param  hdf5_file name (with path) of the hdf5_file.
 657
 658       \exception contains informations of errors if the save doesn't succeed.
 659
 660     */
 661     void save_all(in string hdf5_file)                            raises (SALOME::SALOME_Exception);
 662
 663 /**************/
 664
 665     //!  Add a Local file to the Salome_file.
 666     /*!
 667
 668       \param file_name name of the file with the path.
 669
 670       \exception raised if the file is already added into the Salome_file.
 671     */
 672     void setLocalFile(in string comp_file_name) raises (SALOME::SALOME_Exception);
 673
 674     //!  Add a Distributed file to the Salome_file.
 675     /*!
 676
 677       \param comp_file_name name of the file with the path.
 678
 679       \exception raised if the file is already added into the Salome_file.
 680     */
 681     void setDistributedFile(in string comp_file_name) raises (SALOME::SALOME_Exception);
 682
 683     //!  Connect a Salome_file with another Salome_file.
 684     /*!
 685       It works only if the Salome_file managed only one file
 686
 687       \param source_Salome_file Salome_file that managed the distributed version of the file.
 688
 689       \exception raised if there is more or less than one file.
 690     */
 691     void connect(in Engines::Salome_file source_Salome_file) raises (SALOME::SALOME_Exception);
 692
 693     //!  Connect the managed file file_name to a Salome_file.
 694     /*!
 695
 696       \param file_name name of the file without the path.
 697       \param source_Salome_file Salome_file that managed the distributed version of the file.
 698
 699       \exception raised if the file doesn't exist.
 700     */
 701     void connectDistributedFile(in string file_name,
 702                                 in Engines::Salome_file source_Salome_file) raises (SALOME::SALOME_Exception);
 703
 704     //!  Connect the file_name with a Distributed file_name.
 705     /*!
 706
 707       \param file_name name of the file without the path.
 708       \param source_file_name It's the name of the file managed by the distributed source Salome_file.
 709
 710       \exception raised if the file doesn't exist.
 711     */
 712     void setDistributedSourceFile(in string file_name,
 713                                   in string source_file_name) raises (SALOME::SALOME_Exception);
 714
 715 /**************/
 716
 717     //! Get all the distributed files managed by the Salome_file and check all the local files.
 718     /*!
 719
 720       \exception raised if some of the files are not ok.
 721     */
 722     void recvFiles()                                            raises (SALOME::SALOME_Exception) ;
 723
 724 /**************/
 725
 726     //!  Remove a file of the Salome_file.
 727     /*!
 728
 729       \param file_name name of the file.
 730
 731       \exception raised if the file doesn't exist.
 732     */
 733     void removeFile(in string file_name)                    raises (SALOME::SALOME_Exception);
 734
 735     //!  Remove all the files of the Salome_file.
 736     void removeFiles();
 737
 738 /**************/
 739
 740     //! Get the list of the files managed by the Salome_file.
 741     /*!
 742       The list can be empty.
 743     */
 744     Engines::files getFilesInfos();
 745
 746     //! Get a file managed by the Salome_file.
 747     /*!
 748
 749       \param file_name the name of the file.
 750
 751       \return CORBA file reference.
 752
 753       \exception raised if the file doesn't exist.
 754     */
 755     Engines::file  getFileInfos(in string file_name) raises (SALOME::SALOME_Exception);
 756
 757     //!  Return the state of the Salome_file.
 758     Engines::SfState getSalome_fileState();
 759
 760
 761     //! Set the container where files are.
 762     /*!
 763
 764       \param container container CORBA's reference.
 765     */
 766     void setContainer(in Engines::Container container);
 767   };
 768
 769   /*! \brief Interface of fileRef.
 770      The fileTransfer and fileRef interfaces provide a file transfer service
 771      between different computers.
 772
 773      A fileRef object is associated to an original file (origFileName) on a
 774      machine (refMachine).
 775      It is created by a container (factoryServer) on refMachine,
 776      with createFileRef(in string origFileName) method.
 777      The fileRef object maintains a list of (machine,filename) for copies.
 778      If a copy exists on myMachine, getRef(myMachine) returns the file name
 779      of the copy on myMachine, else returns empy string.
 780      If there is no copy on myMachine, method getFileTransfer() from container
 781      factoryServer on refMachine provides a fileTransfer object dedicated to
 782      CORBA file copy.
 783      After the copy, addRef(myMachine, localFileNameOnMyMachine) registers
 784      the file name of the copy on myMachine.
 785   */
 786   interface fileRef
 787   {
 788     //! the original file
 789     readonly attribute string origFileName;
 790     //! the machine of the original file
 791     readonly attribute string refMachine;
 792
 793     Container getContainer();
 794
 795     boolean addRef(in string machine,
 796                    in string fileName);
 797
 798     string getRef(in string machine);
 799   };
 800 };
 801
 802 #endif