Arcane  v3.16.8.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
ISimpleTableReaderWriter.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/* ISimpleTableReaderWriter.h (C) 2000-2025 */
9/* */
10/* Interface représentant un lecteur/écrivain de tableau simple. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_CORE_ISIMPLETABLEREADERWRITER_H
13#define ARCANE_CORE_ISIMPLETABLEREADERWRITER_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/core/ISimpleTableInternalMng.h"
18
19#include "arcane/core/Directory.h"
20#include "arcane/core/IParallelMng.h"
22#include "arcane/utils/Iostream.h"
23
24/*---------------------------------------------------------------------------*/
25/*---------------------------------------------------------------------------*/
26
27namespace Arcane
28{
29
30/*---------------------------------------------------------------------------*/
31/*---------------------------------------------------------------------------*/
32
33/**
34 * @brief Classe contenant deux méthodes statiques
35 * utile pour les implémentations.
36 *
37 */
38class ARCANE_CORE_EXPORT SimpleTableReaderWriterUtils
39{
40 public:
41 /**
42 * @brief Méthode statique permettant de créer un répertoire avec plusieurs
43 * processus.
44 * @note C'est une méthode collective qui doit être appelée par tous les processus.
45 *
46 * @param parallel_mng Le parallel manager du contexte actuel.
47 * @param directory Le répertoire à créer.
48 * @return true Si le répertoire a été correctement créé.
49 * @return false Si le répertoire n'a pas pu être créé.
50 */
51 static bool createDirectoryOnlyProcess0(IParallelMng* parallel_mng, const Directory& directory)
52 {
53 int sf = 0;
54 if (parallel_mng->commRank() == 0) {
55 sf = directory.createDirectory();
56 }
57 if (parallel_mng->commSize() > 1) {
58 sf = parallel_mng->reduce(Parallel::ReduceMax, sf);
59 }
60 return sf == 0;
61 };
62 /**
63 * @brief Méthode statique permettant de vérifier l'existance d'un fichier.
64 *
65 * @param directory Le répertoire où se situe le fichier.
66 * @param file Le nom du fichier (avec l'extension).
67 * @return true Si le fichier existe déjà.
68 * @return false Si le fichier n'existe pas.
69 */
70 static bool isFileExist(const Directory& directory, const String& file)
71 {
72 std::ifstream stream;
73 stream.open(directory.file(file).localstr(), std::ifstream::in);
74 bool fin = stream.good();
75 stream.close();
76 return fin;
77 };
78};
79
80/*---------------------------------------------------------------------------*/
81/*---------------------------------------------------------------------------*/
82
83/**
84 * @brief Interface de classe permettant de lire un fichier et d'écrire
85 * un fichier avec ou à partir d'un SimpleTableInternal.
86 *
87 * Le fichier lu devra, de préférence, avoir été écrit par une implémentation
88 * de cette même interface.
89 *
90 * Impérativement donc, un fichier écrit par une implémentation de cette
91 * interface devra pouvoir être lu par cette même implémentation.
92 *
93 * L'implémentation ne devra pas détruire l'objet SimpleTableInternal
94 * pointé par le pointeur utilisé. C'est à l'appelant de gérer ça.
95 */
96class ARCANE_CORE_EXPORT ISimpleTableReaderWriter
97{
98 public:
99 virtual ~ISimpleTableReaderWriter() = default;
100
101 public:
102 /**
103 * @brief Méthode permettant d'écrire un tableau simple dans un fichier.
104 *
105 * L'extension sera ajouté par l'implémentation.
106 *
107 * Le répertoire de destination sera créé par l'implémentation s'il
108 * n'existe pas.
109 *
110 * Les élements de SimpleTableInternal qui doivent impérativement
111 * être écrits sont :
112 * - les noms des lignes (m_row_names),
113 * - les noms des colonnes (m_column_names),
114 * - le nom du tableau (m_table_name),
115 * - les valeurs du tableau (m_values).
116 *
117 * Les autres élements de SimpleTableInternal ne sont pas obligatoire.
118 *
119 * @param dst Le répertoire de destination.
120 * @param file_name Le nom du fichier (sans extension).
121 * @return true Si le fichier a bien été écrit.
122 * @return false Si le fichier n'a pas pu être écrit.
123 */
124 virtual bool writeTable(const Directory& dst, const String& file_name) = 0;
125
126 /**
127 * @brief Méthode permettant de lire un fichier contenant un tableau simple.
128 *
129 * L'extension sera ajouté par l'implémentation.
130 *
131 * Un appel à SimpleTableInternal::clear() devra être effectué avant la lecture.
132 *
133 * Les élements qui doivent impérativement être récupérés sont :
134 * - les noms des lignes (m_row_names),
135 * - les noms des colonnes (m_column_names),
136 * - le nom du tableau (m_table_name),
137 * - les valeurs du tableau (m_values).
138 *
139 * Les élements qui doivent être déduit si non récupérés sont :
140 * - les tailles des lignes (m_row_sizes),
141 * - les tailles des colonnes (m_column_sizes).
142 *
143 * Déduction par défaut pour m_row_sizes :
144 * - len(m_row_sizes) = len(m_row_names)
145 * - m_row_sizes[*] = m_values.dim2Size()
146 *
147 * Déduction par défaut pour m_column_sizes :
148 * - len(m_column_sizes) = len(m_column_names)
149 * - m_column_sizes[*] = m_values.dim1Size()
150 *
151 *
152 * @param src Le répertoire source.
153 * @param file_name Le nom du fichier (sans extension).
154 * @return true Si le fichier a bien été lu.
155 * @return false Si le fichier n'a pas pu être lu.
156 */
157 virtual bool readTable(const Directory& src, const String& file_name) = 0;
158
159 /**
160 * @brief Méthode permettant d'effacer le contenu de l'objet
161 * SimpleTableInternal.
162 */
163 virtual void clearInternal() = 0;
164
165 /**
166 * @brief Méthode permettant d'écrire le tableau dans la
167 * sortie standard.
168 *
169 * Le format d'écriture est libre (pour l'implémentation
170 * csv, l'écriture se fait pareil que dans un fichier csv).
171 */
172 virtual void print() = 0;
173
174 /**
175 * @brief Méthode permettant de récupérer la précision actuellement
176 * utilisée pour l'écriture des valeurs.
177 *
178 * @return Integer La précision.
179 */
180 virtual Integer precision() = 0;
181
182 /**
183 * @brief Méthode permettant de modifier la précision du print.
184 *
185 * Aussi bien pour la méthode 'print()' que la méthode 'writetable()'.
186 *
187 * @warning Le flag "std::fixed" modifie le comportement de "setPrecision()",
188 * si le flag "std::fixed" est désactivé, la précision définira le
189 * nombre de chiffres total (avant et après la virgule) ;
190 * si le flag "std::fixed" est activé, la précision définira le
191 * nombre de chiffres après la virgule. Attention donc lors de
192 * l'utilisation de "std::numeric_limits<Real>::max_digits10"
193 * (pour l'écriture) ou de "std::numeric_limits<Real>::digits10"
194 * (pour la lecture) qui sont à utiliser sans le flag "std::fixed".
195 *
196 * @param precision La nouvelle précision.
197 */
198 virtual void setPrecision(Integer precision) = 0;
199
200 /**
201 * @brief Méthode permettant de savoir si le frag 'std::fixed' est
202 * actif ou non pour l'écriture des valeurs.
203 *
204 * @return true Si oui.
205 * @return false Si non.
206 */
207 virtual bool isFixed() = 0;
208 /**
209 * @brief Méthode permettant de définir le flag 'std::fixed' ou non.
210 *
211 * Aussi bien pour la méthode 'print()' que la méthode 'writetable()'.
212 *
213 * Ce flag permet de 'forcer' le nombre de chiffre après la virgule à
214 * la précision voulu. Par exemple, si l'on a appelé 'setPrecision(4)',
215 * et que l'on appelle 'setFixed(true)', le print de '6.1' donnera '6.1000'.
216 *
217 * @warning Le flag "std::fixed" modifie le comportement de "setPrecision()",
218 * si le flag "std::fixed" est désactivé, la précision définira le
219 * nombre de chiffres total (avant et après la virgule) ;
220 * si le flag "std::fixed" est activé, la précision définira le
221 * nombre de chiffres après la virgule. Attention donc lors de
222 * l'utilisation de "std::numeric_limits<Real>::max_digits10"
223 * (pour l'écriture) ou de "std::numeric_limits<Real>::digits10"
224 * (pour la lecture) qui sont à utiliser sans le flag "std::fixed".
225 *
226 * @param fixed Si le flag 'std::fixed' doit être défini ou non.
227 */
228 virtual void setFixed(bool fixed) = 0;
229
230 /**
231 * @brief Méthode permettant de savoir si le frag 'std::scientific' est
232 * actif ou non pour l'écriture des valeurs.
233 *
234 * @return true Si oui.
235 * @return false Si non.
236 */
238 /**
239 * @brief Méthode permettant de définir le flag 'std::scientific' ou non.
240 *
241 * Aussi bien pour la méthode 'print()' que la méthode 'writetable()'.
242 *
243 * Ce flag permet de 'forcer' l'affichage des valeurs en écriture
244 * scientifique.
245 *
246 * @param use_scientific Si le flag 'std::scientific' doit être défini ou non.
247 */
248 virtual void setForcedToUseScientificNotation(bool use_scientific) = 0;
249
250 /**
251 * @brief Méthode permettant de récupérer le type de fichier
252 * qui sera écrit par l'implémentation. ("csv" sera retourné
253 * pour l'implémentation csv).
254 *
255 * @return String Le type/l'extension du fichier utilisé.
256 */
257 virtual String fileType() = 0;
258
259 /**
260 * @brief Méthode permettant de récupérer une référence vers l'objet
261 * SimpleTableInternal utilisé.
262 *
263 * @return Ref<SimpleTableInternal> Une copie de la référence.
264 */
266
267 /**
268 * @brief Méthode permettant de définir une référence vers un
269 * SimpleTableInternal.
270 *
271 * @param simple_table_internal La référence vers un SimpleTableInternal.
272 */
273 virtual void setInternal(const Ref<SimpleTableInternal>& simple_table_internal) = 0;
274};
275
276/*---------------------------------------------------------------------------*/
277/*---------------------------------------------------------------------------*/
278
279} // End namespace Arcane
280
281/*---------------------------------------------------------------------------*/
282/*---------------------------------------------------------------------------*/
283
284#endif
285
286/*---------------------------------------------------------------------------*/
287/*---------------------------------------------------------------------------*/
Déclarations de types sur les entités.
Classe gérant un répertoire.
Definition Directory.h:35
String file(const String &file_name) const override
Retourne le chemin complet du fichier file_name dans le répertoire.
Definition Directory.cc:120
bool createDirectory() const override
Créé le répertoire.
Definition Directory.cc:102
Interface du gestionnaire de parallélisme pour un sous-domaine.
virtual Int32 commRank() const =0
Rang de cette instance dans le communicateur.
virtual Int32 commSize() const =0
Nombre d'instance dans le communicateur.
virtual char reduce(eReduceType rt, char v)=0
Effectue la réduction de type rt sur le réel v et retourne la valeur.
Interface de classe permettant de lire un fichier et d'écrire un fichier avec ou à partir d'un Simple...
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 writeTable(const Directory &dst, const String &file_name)=0
Méthode permettant d'écrire un tableau simple dans un fichier.
virtual void setPrecision(Integer precision)=0
Méthode permettant de modifier la précision du print.
virtual void setInternal(const Ref< SimpleTableInternal > &simple_table_internal)=0
Méthode permettant de définir une référence vers un SimpleTableInternal.
virtual Integer precision()=0
Méthode permettant de récupérer la précision actuellement utilisée pour l'écriture des valeurs.
virtual bool isFixed()=0
Méthode permettant de savoir si le frag 'std::fixed' est actif ou non pour l'écriture des valeurs.
virtual bool readTable(const Directory &src, const String &file_name)=0
Méthode permettant de lire un fichier contenant un tableau simple.
virtual void setFixed(bool fixed)=0
Méthode permettant de définir le flag 'std::fixed' ou non.
virtual Ref< SimpleTableInternal > internal()=0
Méthode permettant de récupérer une référence vers l'objet SimpleTableInternal utilisé.
virtual void setForcedToUseScientificNotation(bool use_scientific)=0
Méthode permettant de définir le flag 'std::scientific' ou non.
virtual String fileType()=0
Méthode permettant de récupérer le type de fichier qui sera écrit par l'implémentation....
virtual void clearInternal()=0
Méthode permettant d'effacer le contenu de l'objet SimpleTableInternal.
virtual void print()=0
Méthode permettant d'écrire le tableau dans la sortie standard.
Référence à une instance.
Classe contenant deux méthodes statiques utile pour les implémentations.
static bool createDirectoryOnlyProcess0(IParallelMng *parallel_mng, const Directory &directory)
Méthode statique permettant de créer un répertoire avec plusieurs processus.
static bool isFileExist(const Directory &directory, const String &file)
Méthode statique permettant de vérifier l'existance d'un fichier.
Chaîne de caractères unicode.
const char * localstr() const
Retourne la conversion de l'instance dans l'encodage UTF-8.
Definition String.cc:228
@ ReduceMax
Maximum des valeurs.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Int32 Integer
Type représentant un entier.