Arcane  v3.16.9.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
ISimpleTableOutput.h
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* ISimpleTableOutput.h (C) 2000-2025 */
9/* */
10/* Interface pour simples services de sortie de tableaux de valeurs. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_CORE_ISIMPLETABLEOUTPUT_H
13#define ARCANE_CORE_ISIMPLETABLEOUTPUT_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/core/ISimpleTableInternalMng.h"
18#include "arcane/core/ISimpleTableWriterHelper.h"
19
20/*---------------------------------------------------------------------------*/
21/*---------------------------------------------------------------------------*/
22
23namespace Arcane
24{
25
26/*---------------------------------------------------------------------------*/
27/*---------------------------------------------------------------------------*/
28
29/**
30 * @ingroup StandardService
31 * @brief Interface représentant une sortie de tableau simple.
32 */
33class ARCANE_CORE_EXPORT ISimpleTableOutput
34{
35 public:
36 virtual ~ISimpleTableOutput() = default;
37
38 public:
39 /**
40 * @brief Méthode permettant d'initialiser le tableau.
41 */
42 virtual bool init() = 0;
43 /**
44 * @brief Méthode permettant d'initialiser le tableau.
45 *
46 * @param table_name Le nom du tableau (et du fichier de sortie).
47 */
48 virtual bool init(const String& table_name) = 0;
49 /**
50 * @brief Méthode permettant d'initialiser le tableau.
51 *
52 * @param table_name Le nom du tableau (et du fichier de sortie).
53 * @param directory_name Le nom du dossier dans lequel enregistrer les tableaux.
54 */
55 virtual bool init(const String& table_name, const String& directory_name) = 0;
56
57 /*---------------------------------------------------------------------------*/
58 /*---------------------------------------------------------------------------*/
59
60 /**
61 * @brief Méthode permettant de remettre à zéro les tableaux
62 */
63 virtual void clear() = 0;
64
65 /*---------------------------------------------------------------------------*/
66 /*---------------------------------------------------------------------------*/
67
68 /**
69 * @brief Méthode permettant d'ajouter une ligne.
70 *
71 * @param row_name Le nom de la ligne.
72 * @return Integer La position de la ligne dans le tableau.
73 */
74 virtual Integer addRow(const String& row_name) = 0;
75 /**
76 * @brief Méthode permettant d'ajouter une ligne.
77 *
78 * Si le nombre d'élements dans 'elements' est plus grand que le
79 * nombre de colonnes, l'ajout s'effectue quand même (mais les
80 * éléments en trop ne seront pas ajoutés).
81 *
82 * @param row_name Le nom de la ligne.
83 * @param elements Les éléments à insérer sur la ligne.
84 * @return Integer La position de la ligne dans le tableau.
85 */
86 virtual Integer addRow(const String& row_name, ConstArrayView<Real> elements) = 0;
87 /**
88 * @brief Méthode permettant d'ajouter plusieurs lignes.
89 *
90 * @param rows_names Les noms des lignes.
91 * @return true Si toutes les lignes ont été créées.
92 * @return false Si toutes les lignes n'ont pas été créées.
93 */
94 virtual bool addRows(StringConstArrayView rows_names) = 0;
95
96 /*---------------------------------------------------------------------------*/
97 /*---------------------------------------------------------------------------*/
98
99 /**
100 * @brief Méthode permettant d'ajouter une colonne.
101 *
102 * @param column_name Le nom de la colonne.
103 * @return Integer La position de la colonne dans le tableau.
104 */
105 virtual Integer addColumn(const String& column_name) = 0;
106 /**
107 * @brief Méthode permettant d'ajouter une colonne.
108 *
109 * Si le nombre d'élements dans 'elements' est plus grand que le
110 * nombre de lignes, l'ajout s'effectue quand même (mais les
111 * éléments en trop ne seront pas ajoutés).
112 *
113 * @param column_name Le nom de la colonne.
114 * @param elements Les éléments à ajouter sur la colonne.
115 * @return Integer La position de la colonne dans le tableau.
116 */
117 virtual Integer addColumn(const String& column_name, ConstArrayView<Real> elements) = 0;
118 /**
119 * @brief Méthode permettant d'ajouter plusieurs colonnes.
120 *
121 * @param rows_names Les noms des colonnes.
122 * @return true Si toutes les colonnes ont été créées.
123 * @return false Si toutes les colonnes n'ont pas été créées.
124 */
125 virtual bool addColumns(StringConstArrayView columns_names) = 0;
126
127 /*---------------------------------------------------------------------------*/
128 /*---------------------------------------------------------------------------*/
129
130 /**
131 * @brief Méthode permettant d'ajouter un élément à une ligne.
132 *
133 * @param position La position de la ligne.
134 * @param element L'élément à ajouter.
135 * @return true Si l'élément a pu être ajouté.
136 * @return false Si l'élément n'a pas pu être ajouté.
137 */
138 virtual bool addElementInRow(Integer position, Real element) = 0;
139 /**
140 * @brief Méthode permettant l'ajouter un élément sur une ligne.
141 *
142 * @param row_name Le nom de la ligne.
143 * @param element L'élément à ajouter.
144 * @param create_if_not_exist Pour savoir si l'on doit créer la
145 * ligne si elle n'existe pas encore.
146 * @return true Si l'élément a pu être ajouté.
147 * @return false Si l'élément n'a pas pu être ajouté.
148 */
149 virtual bool addElementInRow(const String& row_name, Real element, bool create_if_not_exist = true) = 0;
150 /**
151 * @brief Méthode permettant d'ajouter un élément sur la ligne
152 * dernièrement manipulée.
153 *
154 * Cette méthode diffère de 'editElementRight()' car ici, on ajoute
155 * un élément à la fin de la ligne, pas forcement après le
156 * dernier élement ajouté.
157 *
158 * @param element L'élément à ajouter.
159 * @return true Si l'élément a été ajouté.
160 * @return false Si l'élément n'a pas pu être ajouté.
161 */
163
164 /*---------------------------------------------------------------------------*/
165 /*---------------------------------------------------------------------------*/
166
167 /**
168 * @brief Méthode permettant d'ajouter plusieurs éléments sur une ligne.
169 *
170 * Si le nombre d'élements dans 'elements' est plus grand que le
171 * nombre de colonnes disponibles, l'ajout s'effectue quand même (mais les
172 * éléments en trop ne seront pas ajoutés) et on aura un return false.
173 *
174 * @param position La position de la ligne.
175 * @param elements Le tableau d'élement à ajouter.
176 * @return true Si tous les éléments ont été ajoutés.
177 * @return false Si [0;len(elements)[ éléments ont été ajoutés.
178 */
179 virtual bool addElementsInRow(Integer position, ConstArrayView<Real> elements) = 0;
180 /**
181 * @brief Méthode permettant d'ajouter plusieurs éléments sur une ligne.
182 *
183 * Si le nombre d'élements dans 'elements' est plus grand que le
184 * nombre de colonnes disponibles, l'ajout s'effectue quand même (mais les
185 * éléments en trop ne seront pas ajoutés) et on aura un return false.
186 *
187 * @param row_name Le nom de la ligne.
188 * @param elements Le tableau d'élement à ajouter.
189 * @param create_if_not_exist Pour savoir si l'on doit créer la ligne
190 * si elle n'existe pas encore.
191 * @return true Si tous les éléments ont été ajoutés.
192 * @return false Si [0;len(elements)[ éléments ont été ajoutés.
193 */
194 virtual bool addElementsInRow(const String& row_name, ConstArrayView<Real> elements, bool create_if_not_exist = true) = 0;
195 /**
196 * @brief Méthode permettant d'ajouter plusieurs éléments sur la
197 * ligne dernièrement manipulée.
198 *
199 * Si le nombre d'élements dans 'elements' est plus grand que le
200 * nombre de colonnes disponibles, l'ajout s'effectue quand même (mais les
201 * éléments en trop ne seront pas ajoutés) et on aura un return false.
202 *
203 * Mis à part le fait qu'ici, on manipule un tableau, cette méthode diffère
204 * de 'editElementRight()' car ici, on ajoute des éléments à la fin de la ligne,
205 * pas forcement après le dernier élement ajouté.
206 *
207 * @param elements Le tableau d'élement à ajouter.
208 * @return true Si tous les éléments ont été ajoutés.
209 * @return false Si [0;len(elements)[ éléments ont été ajoutés.
210 */
211 virtual bool addElementsInSameRow(ConstArrayView<Real> elements) = 0;
212
213 /*---------------------------------------------------------------------------*/
214 /*---------------------------------------------------------------------------*/
215
216 /**
217 * @brief Méthode permettant d'ajouter un élément à une colonne.
218 *
219 * @param position La position de la colonne.
220 * @param element L'élément à ajouter.
221 * @return true Si l'élément a pu être ajouté.
222 * @return false Si l'élément n'a pas pu être ajouté.
223 */
224 virtual bool addElementInColumn(Integer position, Real element) = 0;
225 /**
226 * @brief Méthode permettant l'ajouter un élément sur une colonne.
227 *
228 * @param column_name Le nom de la colonne.
229 * @param element L'élément à ajouter.
230 * @param create_if_not_exist Pour savoir si l'on doit créer la colonne
231 * si elle n'existe pas encore.
232 * @return true Si l'élément a pu être ajouté.
233 * @return false Si l'élément n'a pas pu être ajouté.
234 */
235 virtual bool addElementInColumn(const String& column_name, Real element, bool create_if_not_exist = true) = 0;
236 /**
237 * @brief Méthode permettant d'ajouter un élément sur la colonne
238 * dernièrement manipulée.
239 *
240 * Cette méthode diffère de 'editElementDown()' car ici, on ajoute un élément
241 * à la fin de la colonne, pas forcement après le dernier élement ajouté.
242 *
243 * @param element L'élément à ajouter.
244 * @return true Si l'élément a été ajouté.
245 * @return false Si l'élément n'a pas pu être ajouté.
246 */
248
249 /*---------------------------------------------------------------------------*/
250 /*---------------------------------------------------------------------------*/
251
252 /**
253 * @brief Méthode permettant d'ajouter plusieurs éléments sur une colonne.
254 *
255 * Si le nombre d'élements dans 'elements' est plus grand que le
256 * nombre de lignes disponibles, l'ajout s'effectue quand même (mais les
257 * éléments en trop ne seront pas ajoutés) et on aura un return false.
258 *
259 * @param position La position de la colonne.
260 * @param elements Le tableau d'élement à ajouter.
261 * @return true Si tous les éléments ont été ajoutés.
262 * @return false Si [0;len(elements)[ éléments ont été ajoutés.
263 */
264 virtual bool addElementsInColumn(Integer position, ConstArrayView<Real> elements) = 0;
265 /**
266 * @brief Méthode permettant d'ajouter plusieurs éléments sur une colonne.
267 *
268 * Si le nombre d'élements dans 'elements' est plus grand que le
269 * nombre de lignes disponibles, l'ajout s'effectue quand même (mais les
270 * éléments en trop ne seront pas ajoutés) et on aura un return false.
271 *
272 * @param column_name Le nom de la colonne.
273 * @param elements Le tableau d'élement à ajouter.
274 * @param create_if_not_exist Pour savoir si l'on doit créer la colonne si
275 * elle n'existe pas encore.
276 * @return true Si tous les éléments ont été ajoutés.
277 * @return false Si [0;len(elements)[ éléments ont été ajoutés.
278 */
279 virtual bool addElementsInColumn(const String& column_name, ConstArrayView<Real> elements, bool create_if_not_exist = true) = 0;
280 /**
281 * @brief Méthode permettant d'ajouter plusieurs éléments sur la
282 * colonne dernièrement manipulée.
283 *
284 * Si le nombre d'élements dans 'elements' est plus grand que le
285 * nombre de lignes disponibles, l'ajout s'effectue quand même (mais les
286 * éléments en trop ne seront pas ajoutés) et on aura un return false.
287 *
288 * Mis à part le fait qu'ici, on manipule un tableau, cette méthode diffère
289 * de 'editElementDown()' car ici, on ajoute des éléments à la fin de la colonne,
290 * pas forcement après le dernier élement ajouté.
291 *
292 * @param elements Le tableau d'élement à ajouter.
293 * @return true Si tous les éléments ont été ajoutés.
294 * @return false Si [0;len(elements)[ éléments ont été ajoutés.
295 */
297
298 /*---------------------------------------------------------------------------*/
299 /*---------------------------------------------------------------------------*/
300
301 /**
302 * @brief Méthode permettant d'éditer un élément au-dessus du dernier
303 * élement dernièrement manipulé (ligne du dessus/même colonne).
304 *
305 * L'élement que l'on modifie devient donc le dernier élement modifié
306 * à la fin de cette méthode (si update_last_position = true).
307 *
308 * @param element L'élement à modifier.
309 * @param update_last_position Doit-on déplacer le curseur "dernier élement modifié" ?
310 * @return true Si l'élément a été modifié.
311 * @return false Si l'élément n'a pas pu être modifié.
312 */
313 virtual bool editElementUp(Real element, bool update_last_position = true) = 0;
314 /**
315 * @brief Méthode permettant d'éditer un élément en-dessous du dernier
316 * élement dernièrement manipulé (ligne du dessous/même colonne).
317 *
318 * L'élement que l'on modifie devient donc le dernier élement modifié
319 * à la fin de cette méthode (si update_last_position = true).
320 *
321 * Cette méthode diffère de 'addElementInSameColumn()' car ici, on ajoute
322 * (ou modifie) un élement sous le dernier élement manipulé, qui n'est
323 * pas forcement à la fin de la colonne.
324 *
325 * @param element L'élement à modifier.
326 * @param update_last_position Doit-on déplacer le curseur "dernier élement modifié" ?
327 * @return true Si l'élément a été modifié.
328 * @return false Si l'élément n'a pas pu être modifié.
329 */
330 virtual bool editElementDown(Real element, bool update_last_position = true) = 0;
331 /**
332 * @brief Méthode permettant d'éditer un élément à gauche du dernier
333 * élement dernièrement manipulé (même ligne/colonne à gauche).
334 *
335 * L'élement que l'on modifie devient donc le dernier élement modifié
336 * à la fin de cette méthode (si update_last_position = true).
337 *
338 * @param element L'élement à modifier.
339 * @param update_last_position Doit-on déplacer le curseur "dernier élement modifié" ?
340 * @return true Si l'élément a été modifié.
341 * @return false Si l'élément n'a pas pu être modifié.
342 */
343 virtual bool editElementLeft(Real element, bool update_last_position = true) = 0;
344 /**
345 * @brief Méthode permettant d'éditer un élément à droite du dernier
346 * élement dernièrement manipulé (même ligne/colonne à droite).
347 *
348 * L'élement que l'on modifie devient donc le dernier élement modifié
349 * à la fin de cette méthode (si update_last_position = true).
350 *
351 * Cette méthode diffère de 'addElementInSameRow()' car ici, on ajoute
352 * (ou modifie) un élement à la droite du dernier élement manipulé,
353 * qui n'est pas forcement à la fin de la colonne.
354 *
355 * @param element L'élement à modifier.
356 * @param update_last_position Doit-on déplacer le curseur "dernier élement modifié" ?
357 * @return true Si l'élément a été modifié.
358 * @return false Si l'élément n'a pas pu être modifié.
359 */
360 virtual bool editElementRight(Real element, bool update_last_position = true) = 0;
361
362 /*---------------------------------------------------------------------------*/
363 /*---------------------------------------------------------------------------*/
364
365 /**
366 * @brief Méthode permettant de récupérer un élément au-dessus du dernier
367 * élement dernièrement manipulé (ligne du dessus/même colonne).
368 *
369 * L'élement que l'on récupère devient donc le dernier élement "modifié"
370 * à la fin de cette méthode (si update_last_position = true).
371 *
372 * @param update_last_position Doit-on déplacer le curseur "dernier élement modifié" ?
373 * @return Real L'élement trouvé (0 si non trouvé).
374 */
375 virtual Real elementUp(bool update_last_position = false) = 0;
376 /**
377 * @brief Méthode permettant de récupérer un élément en-dessous du dernier
378 * élement dernièrement manipulé (ligne du dessous/même colonne).
379 *
380 * L'élement que l'on récupère devient donc le dernier élement "modifié"
381 * à la fin de cette méthode (si update_last_position = true).
382 *
383 * @param update_last_position Doit-on déplacer le curseur "dernier élement modifié" ?
384 * @return Real L'élement trouvé (0 si non trouvé).
385 */
386 virtual Real elementDown(bool update_last_position = false) = 0;
387 /**
388 * @brief Méthode permettant de récupérer un élément à gauche du dernier
389 * élement dernièrement manipulé (même ligne/colonne à gauche).
390 *
391 * L'élement que l'on récupère devient donc le dernier élement "modifié"
392 * à la fin de cette méthode (si update_last_position = true).
393 *
394 * @param update_last_position Doit-on déplacer le curseur "dernier élement modifié" ?
395 * @return Real L'élement trouvé (0 si non trouvé).
396 */
397 virtual Real elementLeft(bool update_last_position = false) = 0;
398 /**
399 * @brief Méthode permettant de récupérer un élément à droite du dernier
400 * élement dernièrement manipulé (même ligne/colonne à droite).
401 *
402 * L'élement que l'on récupère devient donc le dernier élement "modifié"
403 * à la fin de cette méthode (si update_last_position = true).
404 *
405 * @param update_last_position Doit-on déplacer le curseur "dernier élement modifié" ?
406 * @return Real L'élement trouvé (0 si non trouvé).
407 */
408 virtual Real elementRight(bool update_last_position = false) = 0;
409
410 /*---------------------------------------------------------------------------*/
411 /*---------------------------------------------------------------------------*/
412
413 /**
414 * @brief Méthode permettant de modifier un élement dans le tableau.
415 *
416 * Les positions x et y correspondent à l'emplacement du dernier
417 * élement manipulé.
418 *
419 * Cette méthode a de l'intéret après l'utilisation de
420 * 'elemUDLR(true)' par exemple.
421 *
422 * @param element L'élement remplaçant.
423 * @return true Si l'élement a bien été remplacé.
424 * @return false Si l'élement n'a pas été remplacé.
425 */
426 virtual bool editElement(Real element) = 0;
427 /**
428 * @brief Méthode permettant de modifier un élement dans le tableau.
429 *
430 * @param position_x La position de la colonne à modifier.
431 * @param position_y La position de la ligne à modifier.
432 * @param element L'élement remplaçant.
433 * @return true Si l'élement a bien été remplacé.
434 * @return false Si l'élement n'a pas été remplacé.
435 */
436 virtual bool editElement(Integer position_x, Integer position_y, Real element) = 0;
437 /**
438 * @brief Méthode permettant de modifier un élement dans le tableau.
439 *
440 * @param column_name Le nom de la colonne où se trouve l'élement.
441 * @param row_name Le nom de la ligne où se trouve l'élement.
442 * @param element L'élement remplaçant.
443 * @return true Si l'élement a bien été remplacé.
444 * @return false Si l'élement n'a pas pu être remplacé.
445 */
446 virtual bool editElement(const String& column_name, const String& row_name, Real element) = 0;
447
448 /*---------------------------------------------------------------------------*/
449 /*---------------------------------------------------------------------------*/
450
451 /**
452 * @brief Méthode permettant d'obtenir une copie d'un élement.
453 *
454 * Les positions x et y correspondent à l'emplacement du dernier élement manipulé.
455 *
456 * @return Real L'élement trouvé (0 si non trouvé).
457 */
458 virtual Real element() = 0;
459 /**
460 * @brief Méthode permettant d'obtenir une copie d'un élement.
461 *
462 * @param position_x La position de la colonne où se trouve l'élement.
463 * @param position_y La position de la ligne où se trouve l'élement.
464 * @param update_last_position Doit-on déplacer le curseur "dernier élement modifié" ?
465 * @return Real L'élement trouvé (0 si non trouvé).
466 */
467 virtual Real element(Integer position_x, Integer position_y, bool update_last_position = false) = 0;
468 /**
469 * @brief Méthode permettant d'obtenir une copie d'un élement.
470 *
471 * @param column_name Le nom de la colonne où se trouve l'élement.
472 * @param row_name Le nom de la ligne où se trouve l'élement.
473 * @param update_last_position Doit-on déplacer le curseur "dernier élement modifié" ?
474 * @return Real L'élement trouvé (0 si non trouvé).
475 */
476 virtual Real element(const String& column_name, const String& row_name, bool update_last_position = false) = 0;
477
478 /*---------------------------------------------------------------------------*/
479 /*---------------------------------------------------------------------------*/
480
481 /**
482 * @brief Méthode permettant d'obtenir une copie d'une ligne.
483 *
484 * @param position La position de la ligne.
485 * @return RealUniqueArray La copie de la ligne (tableau vide si non trouvée).
486 */
487 virtual RealUniqueArray row(Integer position) = 0;
488 /**
489 * @brief Méthode permettant d'obtenir une copie d'une ligne.
490 *
491 * @param row_name Le nom de la ligne.
492 * @return RealUniqueArray La copie de la ligne (tableau vide si non trouvée).
493 */
494 virtual RealUniqueArray row(const String& row_name) = 0;
495
496 /**
497 * @brief Méthode permettant d'obtenir une copie d'une colonne.
498 *
499 * @param position La position de la colonne.
500 * @return RealUniqueArray La copie de la colonne (tableau vide si non trouvée).
501 */
502 virtual RealUniqueArray column(Integer position) = 0;
503 /**
504 * @brief Méthode permettant d'obtenir une copie d'une colonne.
505 *
506 * @param column_name Le nom de la colonne.
507 * @return RealUniqueArray La copie de la colonne (tableau vide si non trouvée).
508 */
509 virtual RealUniqueArray column(const String& column_name) = 0;
510
511 /*---------------------------------------------------------------------------*/
512 /*---------------------------------------------------------------------------*/
513
514 /**
515 * @brief Méthode permettant d'obtenir la taille d'une ligne.
516 * Incluant les hypothétiques 'trous' dans la ligne.
517 *
518 * @param position La position de la ligne.
519 * @return Integer La taille de la ligne (0 si non trouvée).
520 */
521 virtual Integer rowSize(Integer position) = 0;
522 /**
523 * @brief Méthode permettant d'obtenir la taille d'une ligne.
524 * Incluant les hypotétiques 'trous' dans la ligne.
525 *
526 * @param position Le nom de la ligne.
527 * @return Integer La taille de la ligne (0 si non trouvée).
528 */
529 virtual Integer rowSize(const String& row_name) = 0;
530
531 /**
532 * @brief Méthode permettant d'obtenir la taille d'une colonne.
533 * Incluant les hypotétiques 'trous' dans la colonne.
534 *
535 * @param position La position de la colonne.
536 * @return Integer La taille de la colonne (0 si non trouvée).
537 */
538 virtual Integer columnSize(Integer position) = 0;
539 /**
540 * @brief Méthode permettant d'obtenir la taille d'une colonne.
541 * Incluant les hypotétiques 'trous' dans la colonne.
542 *
543 * @param position Le nom de la colonne.
544 * @return Integer La taille de la colonne (0 si non trouvée).
545 */
546 virtual Integer columnSize(const String& column_name) = 0;
547
548 /*---------------------------------------------------------------------------*/
549 /*---------------------------------------------------------------------------*/
550
551 /**
552 * @brief Méthode permettant de récupérer la position d'une ligne.
553 *
554 * @param row_name Le nom de la ligne.
555 * @return Integer La position de la ligne (-1 si non trouvée).
556 */
557 virtual Integer rowPosition(const String& row_name) = 0;
558 /**
559 * @brief Méthode permettant de récupérer la position d'une colonne.
560 *
561 * @param row_name Le nom de la colonne.
562 * @return Integer La position de la colonne (-1 si non trouvée).
563 */
564 virtual Integer columnPosition(const String& column_name) = 0;
565
566 /*---------------------------------------------------------------------------*/
567 /*---------------------------------------------------------------------------*/
568
569 /**
570 * @brief Méthode permettant de récupérer le nombre de lignes dans le tableau.
571 * C'est, en quelque sorte, le nombre max d'élements que peut contenir une colonne.
572 *
573 * @return Integer Le nombre de lignes du tableau.
574 */
575 virtual Integer numberOfRows() = 0;
576 /**
577 * @brief Méthode permettant de récupérer le nombre de colonnes dans le tableau.
578 * C'est, en quelque sorte, le nombre max d'élements que peut contenir une ligne.
579 *
580 * @return Integer Le nombre de colonnes du tableau.
581 */
583
584 /*---------------------------------------------------------------------------*/
585 /*---------------------------------------------------------------------------*/
586
587 virtual String rowName(Integer position) = 0;
588 virtual String columnName(Integer position) = 0;
589
590 /*---------------------------------------------------------------------------*/
591 /*---------------------------------------------------------------------------*/
592
593 /**
594 * @brief Méthode permettant de changer le nom d'une ligne.
595 *
596 * @param position La position de la ligne.
597 * @param new_name Le nouveau nom de la ligne.
598 * @return true Si le changement a eu lieu.
599 * @return false Si le changement n'a pas eu lieu.
600 */
601 virtual bool editRowName(Integer position, const String& new_name) = 0;
602 /**
603 * @brief Méthode permettant de changer le nom d'une ligne.
604 *
605 * @param row_name Le nom actuel de la ligne.
606 * @param new_name Le nouveau nom de la ligne.
607 * @return true Si le changement a eu lieu.
608 * @return false Si le changement n'a pas eu lieu.
609 */
610 virtual bool editRowName(const String& row_name, const String& new_name) = 0;
611
612 /**
613 * @brief Méthode permettant de changer le nom d'une colonne.
614 *
615 * @param position La position de la colonne.
616 * @param new_name Le nouveau nom de la colonne.
617 * @return true Si le changement a eu lieu.
618 * @return false Si le changement n'a pas eu lieu.
619 */
620 virtual bool editColumnName(Integer position, const String& new_name) = 0;
621 /**
622 * @brief Méthode permettant de changer le nom d'une colonne.
623 *
624 * @param column_name Le nom actuel de la colonne.
625 * @param new_name Le nouveau nom de la colonne.
626 * @return true Si le changement a eu lieu.
627 * @return false Si le changement n'a pas eu lieu.
628 */
629 virtual bool editColumnName(const String& column_name, const String& new_name) = 0;
630
631 /**
632 * @brief Méthode permettant de créer une colonne contenant la moyenne des
633 * éléments de chaque ligne.
634 *
635 * @param column_name Le nom de la nouvelle colonne.
636 * @return Integer La position de la colonne.
637 */
638 virtual Integer addAverageColumn(const String& column_name) = 0;
639
640 /*---------------------------------------------------------------------------*/
641 /*---------------------------------------------------------------------------*/
642 /**
643 * @brief Méthode permettant d'afficher le tableau.
644 * Méthode effectuant des opérations collectives.
645 *
646 * @param rank L'id du processus devant afficher le tableau (-1 pour
647 * signifier "tous les processus").
648 */
649 virtual void print(Integer rank = 0) = 0;
650
651 virtual bool writeFile(const Directory& root_directory, Integer rank) = 0;
652
653 /**
654 * @brief Méthode permettant d'écrire le tableau dans un fichier.
655 * Méthode effectuant des opérations collectives.
656 * Si rank != -1, les processus autres que P0 retournent true.
657 *
658 * @param rank L'id du processus devant écrire dans un fichier
659 * le tableau (-1 pour signifier "tous les processus").
660 * @return true Si le fichier a été correctement écrit.
661 * @return false Si le fichier n'a pas été correctement écrit.
662 */
663 virtual bool writeFile(Integer rank = -1) = 0;
664 /**
665 * @brief Méthode permettant d'écrire le tableau dans un fichier.
666 * Méthode effectuant des opérations collectives.
667 * Si rank != -1, les processus autres que P0 retournent true.
668 *
669 * @param directory Le répertoire où sera écrit le fichier
670 * . Le chemin final sera "./[output_dir]/csv/[directory]/"
671 * @param rank L'id du processus devant écrire dans un fichier
672 * le tableau (-1 pour signifier "tous les processus").
673 * @return true Si le fichier a été correctement écrit.
674 * @return false Si le fichier n'a pas été correctement écrit.
675 *
676 * @deprecated Utiliser setOutputDirectory() puis writeFile() à la place.
677 */
678 virtual bool writeFile(const String& directory, Integer rank = -1) = 0;
679
680 /*---------------------------------------------------------------------------*/
681 /*---------------------------------------------------------------------------*/
682
683 /**
684 * @brief Méthode permettant de récupérer la précision actuellement
685 * utilisée pour l'écriture des valeurs.
686 *
687 * @return Integer La précision.
688 */
689 virtual Integer precision() = 0;
690 /**
691 * @brief Méthode permettant de modifier la précision du print.
692 *
693 * Aussi bien pour la méthode 'print()' que les méthodes 'writeFile()'.
694 *
695 * @warning Le flag "std::fixed" modifie le comportement de "setPrecision()",
696 * si le flag "std::fixed" est désactivé, la précision définira le
697 * nombre de chiffres total (avant et après la virgule) ;
698 * si le flag "std::fixed" est activé, la précision définira le
699 * nombre de chiffres après la virgule. Attention donc lors de
700 * l'utilisation de "std::numeric_limits<Real>::max_digits10"
701 * (pour l'écriture) ou de "std::numeric_limits<Real>::digits10"
702 * (pour la lecture) qui sont à utiliser sans le flag "std::fixed".
703 *
704 * @param precision La nouvelle précision.
705 */
706 virtual void setPrecision(Integer precision) = 0;
707
708 /**
709 * @brief Méthode permettant de savoir si le frag 'std::fixed' est
710 * actif ou non pour l'écriture des valeurs.
711 *
712 * @return true Si oui.
713 * @return false Si non.
714 */
715 virtual bool isFixed() = 0;
716 /**
717 * @brief Méthode permettant de définir le flag 'std::fixed' ou non.
718 *
719 * Aussi bien pour la méthode 'print()' que la méthode 'writetable()'.
720 *
721 * Ce flag permet de 'forcer' le nombre de chiffre après la virgule à
722 * la précision voulu. Par exemple, si l'on a appelé 'setPrecision(4)',
723 * et que l'on appelle 'setFixed(true)', le print de '6.1' donnera '6.1000'.
724 *
725 * @warning Le flag "std::fixed" modifie le comportement de "setPrecision()",
726 * si le flag "std::fixed" est désactivé, la précision définira le
727 * nombre de chiffres total (avant et après la virgule) ;
728 * si le flag "std::fixed" est activé, la précision définira le
729 * nombre de chiffres après la virgule. Attention donc lors de
730 * l'utilisation de "std::numeric_limits<Real>::max_digits10"
731 * (pour l'écriture) ou de "std::numeric_limits<Real>::digits10"
732 * (pour la lecture) qui sont à utiliser sans le flag "std::fixed".
733 *
734 * @param fixed Si le flag 'std::fixed' doit être défini ou non.
735 */
736 virtual void setFixed(bool fixed) = 0;
737
738 /**
739 * @brief Méthode permettant de savoir si le frag 'std::scientific' est
740 * actif ou non pour l'écriture des valeurs.
741 *
742 * @return true Si oui.
743 * @return false Si non.
744 */
746 /**
747 * @brief Méthode permettant de définir le flag 'std::scientific' ou non.
748 *
749 * Aussi bien pour la méthode 'print()' que la méthode 'writetable()'.
750 *
751 * Ce flag permet de 'forcer' l'affichage des valeurs en écriture
752 * scientifique.
753 *
754 * @param use_scientific Si le flag 'std::scientific' doit être défini ou non.
755 */
756 virtual void setForcedToUseScientificNotation(bool use_scientific) = 0;
757
758 /**
759 * @brief Accesseur permettant de récupérer le nom du répertoire où sera
760 * placé les tableaux.
761 *
762 * Peut-être différent pour chaque processus (dépendant de l'implémentation).
763 *
764 * @return String Le répertoire.
765 */
766 virtual String outputDirectory() = 0;
767 /**
768 * @brief Accesseur permettant de définir le répertoire
769 * dans lequel enregistrer les tableaux.
770 *
771 * Peut-être différent pour chaque processus (dépendant de l'implémentation).
772 *
773 * @param directory Le répertoire.
774 */
775 virtual void setOutputDirectory(const String& directory) = 0;
776
777 /**
778 * @brief Accesseur permettant de récupérer le nom des tableaux.
779 *
780 * Peut-être différent pour chaque processus (dépendant de l'implémentation).
781 *
782 * @return String Le nom.
783 */
784 virtual String tableName() = 0;
785 /**
786 * @brief Accesseur permettant de définir le nom du tableau.
787 *
788 * Peut-être différent pour chaque processus (dépendant de l'implémentation).
789 *
790 * @param name Le nom.
791 */
792 virtual void setTableName(const String& name) = 0;
793
794 /**
795 * @brief Accesseur permettant de récupérer le nom des fichiers.
796 *
797 * Peut-être différent pour chaque processus (dépendant de l'implémentation).
798 *
799 * @return String Le nom.
800 */
801 virtual String fileName() = 0;
802
803 /**
804 * @brief Accesseur permettant de récupérer le chemin où sera
805 * enregistrés les tableaux.
806 *
807 * En comparaison avec rootPathOutput(), le retour peut être
808 * different selon le "directory" et le "name".
809 *
810 * @return String Le chemin.
811 */
812 virtual Directory outputPath() = 0;
813
814 /**
815 * @brief Accesseur permettant de récupérer le chemin où l'implémentation
816 * enregistre ces tableaux.
817 *
818 * En comparaison avec pathOutput(), le retour ne dépend pas de "directory" ou de "name".
819 *
820 * @return String Le chemin.
821 */
822 virtual Directory rootPath() = 0;
823
824 /**
825 * @brief Méthode permettant de savoir si les paramètres actuellement en possession
826 * de l'implémentation lui permet d'écrire un fichier par processus.
827 *
828 * @return true Si oui, l'implémentation peut écrire un fichier par processus.
829 * @return false Sinon, il n'y a qu'un seul fichier qui peut être écrit.
830 */
831 virtual bool isOneFileByRanksPermited() = 0;
832
833 /**
834 * @brief Méthode permettant de connaitre le type de fichier du service.
835 *
836 * @return String Le type de fichier.
837 */
838 virtual String fileType() = 0;
839
840 /**
841 * @brief Méthode permettant de récupérer une référence vers l'objet
842 * SimpleTableInternal utilisé.
843 *
844 * @return Ref<SimpleTableInternal> Une copie de la référence.
845 */
847
848 /**
849 * @brief Méthode permettant de récupérer une référence vers l'objet
850 * ISimpleTableReaderWriter utilisé.
851 *
852 * @return Ref<ISimpleTableReaderWriter> Une copie de la référence.
853 */
855};
856
857/*---------------------------------------------------------------------------*/
858/*---------------------------------------------------------------------------*/
859
860} // End namespace Arcane
861
862/*---------------------------------------------------------------------------*/
863/*---------------------------------------------------------------------------*/
864
865#endif
866
867/*---------------------------------------------------------------------------*/
868/*---------------------------------------------------------------------------*/
Vue constante d'un tableau de type T.
Classe gérant un répertoire.
Definition Directory.h:35
Interface représentant une sortie de tableau simple.
virtual bool addElementsInColumn(Integer position, ConstArrayView< Real > elements)=0
Méthode permettant d'ajouter plusieurs éléments sur une colonne.
virtual bool addElementsInRow(Integer position, ConstArrayView< Real > elements)=0
Méthode permettant d'ajouter plusieurs éléments sur une ligne.
virtual void setTableName(const String &name)=0
Accesseur permettant de définir le nom du tableau.
virtual Real elementDown(bool update_last_position=false)=0
Méthode permettant de récupérer un élément en-dessous du dernier élement dernièrement manipulé (ligne...
virtual bool init(const String &table_name)=0
Méthode permettant d'initialiser le tableau.
virtual bool editElementDown(Real element, bool update_last_position=true)=0
Méthode permettant d'éditer un élément en-dessous du dernier élement dernièrement manipulé (ligne du ...
virtual void setPrecision(Integer precision)=0
Méthode permettant de modifier la précision du print.
virtual bool addElementInRow(Integer position, Real element)=0
Méthode permettant d'ajouter un élément à une ligne.
virtual Ref< SimpleTableInternal > internal()=0
Méthode permettant de récupérer une référence vers l'objet SimpleTableInternal utilisé.
virtual String fileType()=0
Méthode permettant de connaitre le type de fichier du service.
virtual bool init(const String &table_name, const String &directory_name)=0
Méthode permettant d'initialiser le tableau.
virtual Integer rowSize(Integer position)=0
Méthode permettant d'obtenir la taille d'une ligne. Incluant les hypothétiques 'trous' dans la ligne.
virtual String fileName()=0
Accesseur permettant de récupérer le nom des fichiers.
virtual bool addElementInColumn(const String &column_name, Real element, bool create_if_not_exist=true)=0
Méthode permettant l'ajouter un élément sur une colonne.
virtual Integer columnSize(const String &column_name)=0
Méthode permettant d'obtenir la taille d'une colonne. Incluant les hypotétiques 'trous' dans la colon...
virtual Integer numberOfRows()=0
Méthode permettant de récupérer le nombre de lignes dans le tableau. C'est, en quelque sorte,...
virtual bool editColumnName(Integer position, const String &new_name)=0
Méthode permettant de changer le nom d'une colonne.
virtual bool addElementInColumn(Integer position, Real element)=0
Méthode permettant d'ajouter un élément à une colonne.
virtual bool editElementRight(Real element, bool update_last_position=true)=0
Méthode permettant d'éditer un élément à droite du dernier élement dernièrement manipulé (même ligne/...
virtual bool writeFile(Integer rank=-1)=0
Méthode permettant d'écrire le tableau dans un fichier. Méthode effectuant des opérations collectives...
virtual void setOutputDirectory(const String &directory)=0
Accesseur permettant de définir le répertoire dans lequel enregistrer les tableaux.
virtual bool editElementUp(Real element, bool update_last_position=true)=0
Méthode permettant d'éditer un élément au-dessus du dernier élement dernièrement manipulé (ligne du d...
virtual RealUniqueArray column(Integer position)=0
Méthode permettant d'obtenir une copie d'une colonne.
virtual Integer rowPosition(const String &row_name)=0
Méthode permettant de récupérer la position d'une ligne.
virtual bool addElementsInRow(const String &row_name, ConstArrayView< Real > elements, bool create_if_not_exist=true)=0
Méthode permettant d'ajouter plusieurs éléments sur une ligne.
virtual String outputDirectory()=0
Accesseur permettant de récupérer le nom du répertoire où sera placé les tableaux.
virtual bool addElementInSameRow(Real element)=0
Méthode permettant d'ajouter un élément sur la ligne dernièrement manipulée.
virtual Real elementRight(bool update_last_position=false)=0
Méthode permettant de récupérer un élément à droite du dernier élement dernièrement manipulé (même li...
virtual Integer addRow(const String &row_name)=0
Méthode permettant d'ajouter une ligne.
virtual Integer addColumn(const String &column_name)=0
Méthode permettant d'ajouter une colonne.
virtual bool editColumnName(const String &column_name, const String &new_name)=0
Méthode permettant de changer le nom d'une colonne.
virtual bool editElement(Integer position_x, Integer position_y, Real element)=0
Méthode permettant de modifier un élement dans le tableau.
virtual Real elementLeft(bool update_last_position=false)=0
Méthode permettant de récupérer un élément à gauche du dernier élement dernièrement manipulé (même li...
virtual bool addColumns(StringConstArrayView columns_names)=0
Méthode permettant d'ajouter plusieurs colonnes.
virtual bool editRowName(const String &row_name, const String &new_name)=0
Méthode permettant de changer le nom d'une ligne.
virtual RealUniqueArray row(const String &row_name)=0
Méthode permettant d'obtenir une copie d'une ligne.
virtual bool addElementInSameColumn(Real element)=0
Méthode permettant d'ajouter un élément sur la colonne dernièrement manipulée.
virtual Integer addRow(const String &row_name, ConstArrayView< Real > elements)=0
Méthode permettant d'ajouter une ligne.
virtual Ref< ISimpleTableReaderWriter > readerWriter()=0
Méthode permettant de récupérer une référence vers l'objet ISimpleTableReaderWriter utilisé.
virtual RealUniqueArray row(Integer position)=0
Méthode permettant d'obtenir une copie d'une ligne.
virtual Integer columnPosition(const String &column_name)=0
Méthode permettant de récupérer la position d'une colonne.
virtual Integer precision()=0
Méthode permettant de récupérer la précision actuellement utilisée pour l'écriture des valeurs.
virtual String tableName()=0
Accesseur permettant de récupérer le nom des tableaux.
virtual void print(Integer rank=0)=0
Méthode permettant d'afficher le tableau. Méthode effectuant des opérations collectives.
virtual Integer numberOfColumns()=0
Méthode permettant de récupérer le nombre de colonnes dans le tableau. C'est, en quelque sorte,...
virtual bool addElementsInSameRow(ConstArrayView< Real > elements)=0
Méthode permettant d'ajouter plusieurs éléments sur la ligne dernièrement manipulée.
virtual RealUniqueArray column(const String &column_name)=0
Méthode permettant d'obtenir une copie d'une colonne.
virtual Integer addAverageColumn(const String &column_name)=0
Méthode permettant de créer une colonne contenant la moyenne des éléments de chaque ligne.
virtual Real elementUp(bool update_last_position=false)=0
Méthode permettant de récupérer un élément au-dessus du dernier élement dernièrement manipulé (ligne ...
virtual bool isForcedToUseScientificNotation()=0
Méthode permettant de savoir si le frag 'std::scientific' est actif ou non pour l'écriture des valeur...
virtual bool writeFile(const String &directory, Integer rank=-1)=0
Méthode permettant d'écrire le tableau dans un fichier. Méthode effectuant des opérations collectives...
virtual bool addElementsInColumn(const String &column_name, ConstArrayView< Real > elements, bool create_if_not_exist=true)=0
Méthode permettant d'ajouter plusieurs éléments sur une colonne.
virtual Real element(Integer position_x, Integer position_y, bool update_last_position=false)=0
Méthode permettant d'obtenir une copie d'un élement.
virtual Real element(const String &column_name, const String &row_name, bool update_last_position=false)=0
Méthode permettant d'obtenir une copie d'un élement.
virtual Real element()=0
Méthode permettant d'obtenir une copie d'un élement.
virtual bool init()=0
Méthode permettant d'initialiser le tableau.
virtual bool editElement(Real element)=0
Méthode permettant de modifier un élement dans le tableau.
virtual bool isFixed()=0
Méthode permettant de savoir si le frag 'std::fixed' est actif ou non pour l'écriture des valeurs.
virtual Integer rowSize(const String &row_name)=0
Méthode permettant d'obtenir la taille d'une ligne. Incluant les hypotétiques 'trous' dans la ligne.
virtual bool addElementInRow(const String &row_name, Real element, bool create_if_not_exist=true)=0
Méthode permettant l'ajouter un élément sur une ligne.
virtual void clear()=0
Méthode permettant de remettre à zéro les tableaux.
virtual void setFixed(bool fixed)=0
Méthode permettant de définir le flag 'std::fixed' ou non.
virtual bool addElementsInSameColumn(ConstArrayView< Real > elements)=0
Méthode permettant d'ajouter plusieurs éléments sur la colonne dernièrement manipulée.
virtual bool addRows(StringConstArrayView rows_names)=0
Méthode permettant d'ajouter plusieurs lignes.
virtual bool editRowName(Integer position, const String &new_name)=0
Méthode permettant de changer le nom d'une ligne.
virtual Directory rootPath()=0
Accesseur permettant de récupérer le chemin où l'implémentation enregistre ces tableaux.
virtual bool isOneFileByRanksPermited()=0
Méthode permettant de savoir si les paramètres actuellement en possession de l'implémentation lui per...
virtual Directory outputPath()=0
Accesseur permettant de récupérer le chemin où sera enregistrés les tableaux.
virtual bool editElement(const String &column_name, const String &row_name, Real element)=0
Méthode permettant de modifier un élement dans le tableau.
virtual Integer columnSize(Integer position)=0
Méthode permettant d'obtenir la taille d'une colonne. Incluant les hypotétiques 'trous' dans la colon...
virtual Integer addColumn(const String &column_name, ConstArrayView< Real > elements)=0
Méthode permettant d'ajouter une colonne.
virtual void setForcedToUseScientificNotation(bool use_scientific)=0
Méthode permettant de définir le flag 'std::scientific' ou non.
virtual bool editElementLeft(Real element, bool update_last_position=true)=0
Méthode permettant d'éditer un élément à gauche du dernier élement dernièrement manipulé (même ligne/...
Référence à une instance.
Chaîne de caractères unicode.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
ConstArrayView< String > StringConstArrayView
Equivalent C d'un tableau à une dimension de chaînes de caractères.
Definition UtilsTypes.h:579
Int32 Integer
Type représentant un entier.
UniqueArray< Real > RealUniqueArray
Tableau dynamique à une dimension de réels.
Definition UtilsTypes.h:436
double Real
Type représentant un réel.