idl/SALOME_Component.idl

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