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