Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
SimpleTableInternalMng.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2022 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/* SimpleTableInternalMng.cc (C) 2000-2022 */
9/* */
10/* Classe permettant de modifier facilement un SimpleTableInternal. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/std/SimpleTableInternalMng.h"
15
16#include <optional>
17
18/*---------------------------------------------------------------------------*/
19/*---------------------------------------------------------------------------*/
20
21namespace Arcane
22{
23
24/*---------------------------------------------------------------------------*/
25/*---------------------------------------------------------------------------*/
26
27void SimpleTableInternalMng::
28clearInternal()
29{
30 m_simple_table_internal->clear();
31}
32
33/*---------------------------------------------------------------------------*/
34/*---------------------------------------------------------------------------*/
35
36Integer SimpleTableInternalMng::
37addRow(const String& row_name)
38{
39 if(row_name.empty()) return -1;
40
41 Integer position = m_simple_table_internal->m_values.dim1Size();
42 m_simple_table_internal->m_values.resize(position + 1);
43
44 m_simple_table_internal->m_row_names.add(row_name);
45 m_simple_table_internal->m_row_sizes.add(0);
46
47 m_simple_table_internal->m_last_row = position;
48
49 return position;
50}
51
52Integer SimpleTableInternalMng::
53addRow(const String& row_name, ConstArrayView<Real> elements)
54{
55 if(row_name.empty()) return -1;
56
57 Integer position = m_simple_table_internal->m_values.dim1Size();
58 m_simple_table_internal->m_values.resize(position + 1);
59
60 m_simple_table_internal->m_row_names.add(row_name);
61 m_simple_table_internal->m_row_sizes.add(0);
62
63 addElementsInRow(position, elements);
64
65 return position;
66}
67
68bool SimpleTableInternalMng::
69addRows(StringConstArrayView rows_names)
70{
71 if(rows_names.contains("")) return false;
72
73 Integer size = rows_names.size();
74 if (size == 0)
75 return true;
76
77 Integer position = m_simple_table_internal->m_values.dim1Size();
78 m_simple_table_internal->m_values.resize(position + size);
79
80 m_simple_table_internal->m_row_names.addRange(rows_names);
81 m_simple_table_internal->m_row_sizes.addRange(IntegerUniqueArray(size, 0));
82
83 m_simple_table_internal->m_last_row = position;
84
85 return true;
86}
87
88/*---------------------------------------------------------------------------*/
89/*---------------------------------------------------------------------------*/
90
91Integer SimpleTableInternalMng::
92addColumn(const String& column_name)
93{
94 if(column_name.empty()) return -1;
95
96 Integer position = m_simple_table_internal->m_values.dim2Size();
97 m_simple_table_internal->m_values.resize(m_simple_table_internal->m_values.dim1Size(), position + 1);
98
99 m_simple_table_internal->m_column_names.add(column_name);
100 m_simple_table_internal->m_column_sizes.add(0);
101
102 m_simple_table_internal->m_last_column = position;
103
104 return position;
105}
106
107Integer SimpleTableInternalMng::
108addColumn(const String& column_name, ConstArrayView<Real> elements)
109{
110 if(column_name.empty()) return -1;
111
112 Integer position = m_simple_table_internal->m_values.dim2Size();
113 m_simple_table_internal->m_values.resize(m_simple_table_internal->m_values.dim1Size(), position + 1);
114
115 m_simple_table_internal->m_column_names.add(column_name);
116 m_simple_table_internal->m_column_sizes.add(0);
117
118 addElementsInColumn(position, elements);
119
120 return position;
121}
122
123bool SimpleTableInternalMng::
124addColumns(StringConstArrayView columns_names)
125{
126 if(columns_names.contains("")) return false;
127
128 Integer size = columns_names.size();
129 if (size == 0)
130 return true;
131
132 Integer position = m_simple_table_internal->m_values.dim2Size();
133 m_simple_table_internal->m_values.resize(m_simple_table_internal->m_values.dim1Size(), position + size);
134
135 m_simple_table_internal->m_column_names.addRange(columns_names);
136 m_simple_table_internal->m_column_sizes.addRange(IntegerUniqueArray(size, 0));
137
138 m_simple_table_internal->m_last_column = position;
139
140 return true;
141}
142
143/*---------------------------------------------------------------------------*/
144/*---------------------------------------------------------------------------*/
145
146bool SimpleTableInternalMng::
147addElementInRow(Integer position, Real element)
148{
149 if (position < 0 || position >= m_simple_table_internal->m_values.dim1Size())
150 return false;
151
152 ArrayView<Real> view = m_simple_table_internal->m_values[position];
153 Integer size_row = m_simple_table_internal->m_row_sizes[position];
154
155 if (m_simple_table_internal->m_values.dim2Size() < size_row + 1)
156 return false;
157
158 view[size_row] = element;
159
160 m_simple_table_internal->m_last_row = position;
161 m_simple_table_internal->m_last_column = size_row;
162
163 m_simple_table_internal->m_row_sizes[position]++;
164 // Il peut y avoir des élements sur la ligne d'après à la même colonne.
165 // Exemple : addElementInRow(position=L01, element=NEW):
166 // aaa|C00|C01|C02
167 // L00|123|456|789
168 // L01|147|NEW|
169 // L02|159|753|852
170 // Il y a 753 donc la taille de la colonne reste égale à 3.
171 m_simple_table_internal->m_column_sizes[size_row] = std::max(position + 1, m_simple_table_internal->m_column_sizes[size_row]);
172
173 return true;
174}
175
176bool SimpleTableInternalMng::
177addElementInRow(const String& row_name, Real element, bool create_if_not_exist)
178{
179 std::optional<Integer> position = m_simple_table_internal->m_row_names.span().findFirst(row_name);
180
181 if (position)
182 return addElementInRow(position.value(), element);
183 else if (create_if_not_exist)
184 return addElementInRow(addRow(row_name), element);
185 else
186 return false;
187}
188
189bool SimpleTableInternalMng::
190addElementInSameRow(Real element)
191{
192 if (m_simple_table_internal->m_last_row == -1 || m_simple_table_internal->m_last_column == -1)
193 return false;
194 return addElementInRow(m_simple_table_internal->m_last_row, element);
195}
196
197/*---------------------------------------------------------------------------*/
198/*---------------------------------------------------------------------------*/
199
200bool SimpleTableInternalMng::
201addElementsInRow(Integer position, ConstArrayView<Real> elements)
202{
203 if (position < 0 || position >= m_simple_table_internal->m_values.dim1Size())
204 return false;
205
206 ArrayView<Real> view = m_simple_table_internal->m_values[position];
207 Integer size_row = m_simple_table_internal->m_row_sizes[position];
208 Integer min_size = (elements.size() <= m_simple_table_internal->m_values.dim2Size() - size_row
209 ? elements.size()
210 : m_simple_table_internal->m_values.dim2Size() - size_row);
211
212 for (Integer i = 0; i < min_size; i++) {
213 view[i + size_row] = elements[i];
214 m_simple_table_internal->m_column_sizes[i + size_row] = std::max(position + 1, m_simple_table_internal->m_column_sizes[i + size_row]);
215 }
216 m_simple_table_internal->m_row_sizes[position] += min_size;
217
218 m_simple_table_internal->m_last_row = position;
219 m_simple_table_internal->m_last_column = m_simple_table_internal->m_row_sizes[position] - 1;
220
221 return elements.size() <= m_simple_table_internal->m_values.dim2Size() - size_row;
222}
223
224bool SimpleTableInternalMng::
225addElementsInRow(const String& row_name, ConstArrayView<Real> elements, bool create_if_not_exist)
226{
227 std::optional<Integer> position = m_simple_table_internal->m_row_names.span().findFirst(row_name);
228
229 if (position)
230 return addElementsInRow(position.value(), elements);
231 // Permet d'avoir un return bool (sinon on pourrait simplement faire addRow(row_name, elements)).
232 else if (create_if_not_exist)
233 return addElementsInRow(addRow(row_name), elements);
234 else
235 return false;
236}
237
238bool SimpleTableInternalMng::
239addElementsInSameRow(ConstArrayView<Real> elements)
240{
241 if (m_simple_table_internal->m_last_row == -1 || m_simple_table_internal->m_last_column == -1)
242 return false;
243 return addElementsInRow(m_simple_table_internal->m_last_row, elements);
244}
245
246/*---------------------------------------------------------------------------*/
247/*---------------------------------------------------------------------------*/
248
249bool SimpleTableInternalMng::
250addElementInColumn(Integer position, Real element)
251{
252 if (position < 0 || position >= m_simple_table_internal->m_values.dim2Size())
253 return false;
254
255 Integer size_column = m_simple_table_internal->m_column_sizes[position];
256
257 if (m_simple_table_internal->m_values.dim1Size() < size_column + 1)
258 return false;
259
260 m_simple_table_internal->m_values[size_column][position] = element;
261
262 m_simple_table_internal->m_last_column = position;
263 m_simple_table_internal->m_last_row = size_column;
264
265 m_simple_table_internal->m_column_sizes[position]++;
266 m_simple_table_internal->m_row_sizes[size_column] = std::max(position + 1, m_simple_table_internal->m_row_sizes[size_column]);
267
268 return true;
269}
270
271bool SimpleTableInternalMng::
272addElementInColumn(const String& column_name, Real element, bool create_if_not_exist)
273{
274 std::optional<Integer> position = m_simple_table_internal->m_column_names.span().findFirst(column_name);
275
276 if (position)
277 return addElementInColumn(position.value(), element);
278 else if (create_if_not_exist)
279 return addElementInColumn(addColumn(column_name), element);
280 else
281 return false;
282}
283
284bool SimpleTableInternalMng::
285addElementInSameColumn(Real element)
286{
287 if (m_simple_table_internal->m_last_row == -1 || m_simple_table_internal->m_last_column == -1)
288 return false;
289 return addElementInColumn(m_simple_table_internal->m_last_column, element);
290}
291
292/*---------------------------------------------------------------------------*/
293/*---------------------------------------------------------------------------*/
294
295bool SimpleTableInternalMng::
296addElementsInColumn(Integer position, ConstArrayView<Real> elements)
297{
298 if (position < 0 || position >= m_simple_table_internal->m_values.dim2Size())
299 return false;
300
301 Integer size_column = m_simple_table_internal->m_column_sizes[position];
302 Integer min_size = (elements.size() <= m_simple_table_internal->m_values.dim1Size() - size_column
303 ? elements.size()
304 : m_simple_table_internal->m_values.dim1Size() - size_column);
305
306 for (Integer i = 0; i < min_size; i++) {
307 m_simple_table_internal->m_values[i + size_column][position] = elements[i];
308 m_simple_table_internal->m_row_sizes[i + size_column] = std::max(position + 1, m_simple_table_internal->m_row_sizes[i + size_column]);
309 }
310 m_simple_table_internal->m_column_sizes[position] += min_size;
311
312 m_simple_table_internal->m_last_column = position;
313 m_simple_table_internal->m_last_row = m_simple_table_internal->m_column_sizes[position] - 1;
314
315 return elements.size() <= m_simple_table_internal->m_values.dim1Size() - size_column;
316}
317
318bool SimpleTableInternalMng::
319addElementsInColumn(const String& column_name, ConstArrayView<Real> elements, bool create_if_not_exist)
320{
321 std::optional<Integer> position = m_simple_table_internal->m_column_names.span().findFirst(column_name);
322
323 if (position)
324 return addElementsInColumn(position.value(), elements);
325 // Permet d'avoir un return bool (sinon on pourrait simplement faire addColumn(column_name, elements)).
326 else if (create_if_not_exist)
327 return addElementsInColumn(addColumn(column_name), elements);
328 else
329 return false;
330}
331
332bool SimpleTableInternalMng::
333addElementsInSameColumn(ConstArrayView<Real> elements)
334{
335 if (m_simple_table_internal->m_last_row == -1 || m_simple_table_internal->m_last_column == -1)
336 return false;
337 return addElementsInColumn(m_simple_table_internal->m_last_column, elements);
338}
339
340/*---------------------------------------------------------------------------*/
341/*---------------------------------------------------------------------------*/
342
343bool SimpleTableInternalMng::
344editElementUp(Real element, bool update_last_position)
345{
346 if (m_simple_table_internal->m_last_row == -1 || m_simple_table_internal->m_last_column == -1 || m_simple_table_internal->m_last_row - 1 < 0)
347 return false;
348 m_simple_table_internal->m_last_row--;
349
350 // Pas besoin d'ajuster la taille de la colonne car on est sûr que m_simple_table_internal->m_column_sizes[m_simple_table_internal->m_last_column] >= m_simple_table_internal->m_last_row.
351 if (m_simple_table_internal->m_row_sizes[m_simple_table_internal->m_last_row] <= m_simple_table_internal->m_last_column)
352 m_simple_table_internal->m_row_sizes[m_simple_table_internal->m_last_row] = m_simple_table_internal->m_last_column + 1;
353
354 m_simple_table_internal->m_values[m_simple_table_internal->m_last_row][m_simple_table_internal->m_last_column] = element;
355 if (!update_last_position)
356 m_simple_table_internal->m_last_row++;
357 return true;
358}
359
360bool SimpleTableInternalMng::
361editElementDown(Real element, bool update_last_position)
362{
363 if (m_simple_table_internal->m_last_row == -1 || m_simple_table_internal->m_last_column == -1 || m_simple_table_internal->m_last_row + 1 >= m_simple_table_internal->m_values.dim1Size())
364 return false;
365 m_simple_table_internal->m_last_row++;
366
367 if (m_simple_table_internal->m_row_sizes[m_simple_table_internal->m_last_row] <= m_simple_table_internal->m_last_column)
368 m_simple_table_internal->m_row_sizes[m_simple_table_internal->m_last_row] = m_simple_table_internal->m_last_column + 1;
369 if (m_simple_table_internal->m_column_sizes[m_simple_table_internal->m_last_column] <= m_simple_table_internal->m_last_row)
370 m_simple_table_internal->m_column_sizes[m_simple_table_internal->m_last_column] = m_simple_table_internal->m_last_row + 1;
371
372 m_simple_table_internal->m_values[m_simple_table_internal->m_last_row][m_simple_table_internal->m_last_column] = element;
373 if (!update_last_position)
374 m_simple_table_internal->m_last_row--;
375 return true;
376}
377
378bool SimpleTableInternalMng::
379editElementLeft(Real element, bool update_last_position)
380{
381 if (m_simple_table_internal->m_last_row == -1 || m_simple_table_internal->m_last_column == -1 || m_simple_table_internal->m_last_column - 1 < 0)
382 return false;
383 m_simple_table_internal->m_last_column--;
384
385 // Pas besoin d'ajuster la taille de la ligne car on est sûr que m_simple_table_internal->m_row_sizes[m_simple_table_internal->m_last_row] >= m_simple_table_internal->m_last_column.
386 if (m_simple_table_internal->m_column_sizes[m_simple_table_internal->m_last_column] <= m_simple_table_internal->m_last_row)
387 m_simple_table_internal->m_column_sizes[m_simple_table_internal->m_last_column] = m_simple_table_internal->m_last_row + 1;
388
389 m_simple_table_internal->m_values[m_simple_table_internal->m_last_row][m_simple_table_internal->m_last_column] = element;
390 if (!update_last_position)
391 m_simple_table_internal->m_last_column++;
392 return true;
393}
394
395bool SimpleTableInternalMng::
396editElementRight(Real element, bool update_last_position)
397{
398 if (m_simple_table_internal->m_last_row == -1 || m_simple_table_internal->m_last_column == -1 || m_simple_table_internal->m_last_column + 1 >= m_simple_table_internal->m_values.dim2Size())
399 return false;
400 m_simple_table_internal->m_last_column++;
401
402 if (m_simple_table_internal->m_row_sizes[m_simple_table_internal->m_last_row] <= m_simple_table_internal->m_last_column)
403 m_simple_table_internal->m_row_sizes[m_simple_table_internal->m_last_row] = m_simple_table_internal->m_last_column + 1;
404 if (m_simple_table_internal->m_column_sizes[m_simple_table_internal->m_last_column] <= m_simple_table_internal->m_last_row)
405 m_simple_table_internal->m_column_sizes[m_simple_table_internal->m_last_column] = m_simple_table_internal->m_last_row + 1;
406
407 m_simple_table_internal->m_values[m_simple_table_internal->m_last_row][m_simple_table_internal->m_last_column] = element;
408 if (!update_last_position)
409 m_simple_table_internal->m_last_column--;
410 return true;
411}
412
413/*---------------------------------------------------------------------------*/
414/*---------------------------------------------------------------------------*/
415
416Real SimpleTableInternalMng::
417elementUp(bool update_last_position)
418{
419 if (m_simple_table_internal->m_last_row == -1 || m_simple_table_internal->m_last_column == -1 || m_simple_table_internal->m_last_row - 1 < 0)
420 return 0;
421
422 // Par rapport à editElementUp(), si on ne veut pas mettre à jour la dernière position,
423 // on ne verifie pas ni modifie m_simple_table_internal->m_row_sizes.
424 if (update_last_position) {
425 m_simple_table_internal->m_last_row--;
426 // Pas besoin d'ajuster la taille de la colonne car on est sûr que m_simple_table_internal->m_column_sizes[m_simple_table_internal->m_last_column] >= m_simple_table_internal->m_last_row.
427 if (m_simple_table_internal->m_row_sizes[m_simple_table_internal->m_last_row] <= m_simple_table_internal->m_last_column)
428 m_simple_table_internal->m_row_sizes[m_simple_table_internal->m_last_row] = m_simple_table_internal->m_last_column + 1;
429 return m_simple_table_internal->m_values[m_simple_table_internal->m_last_row][m_simple_table_internal->m_last_column];
430 }
431
432 return m_simple_table_internal->m_values[m_simple_table_internal->m_last_row - 1][m_simple_table_internal->m_last_column];
433}
434
435Real SimpleTableInternalMng::
436elementDown(bool update_last_position)
437{
438 if (m_simple_table_internal->m_last_row == -1 || m_simple_table_internal->m_last_column == -1 || m_simple_table_internal->m_last_row + 1 >= m_simple_table_internal->m_values.dim1Size())
439 return 0;
440
441 // Par rapport à editElementDown(), si on ne veut pas mettre à jour la dernière position,
442 // on ne verifie pas ni modifie m_simple_table_internal->m_row_sizes.
443 if (update_last_position) {
444 m_simple_table_internal->m_last_row++;
445
446 if (m_simple_table_internal->m_row_sizes[m_simple_table_internal->m_last_row] <= m_simple_table_internal->m_last_column)
447 m_simple_table_internal->m_row_sizes[m_simple_table_internal->m_last_row] = m_simple_table_internal->m_last_column + 1;
448 if (m_simple_table_internal->m_column_sizes[m_simple_table_internal->m_last_column] <= m_simple_table_internal->m_last_row)
449 m_simple_table_internal->m_column_sizes[m_simple_table_internal->m_last_column] = m_simple_table_internal->m_last_row + 1;
450 return m_simple_table_internal->m_values[m_simple_table_internal->m_last_row][m_simple_table_internal->m_last_column];
451 }
452 return m_simple_table_internal->m_values[m_simple_table_internal->m_last_row + 1][m_simple_table_internal->m_last_column];
453}
454
455Real SimpleTableInternalMng::
456elementLeft(bool update_last_position)
457{
458 if (m_simple_table_internal->m_last_row == -1 || m_simple_table_internal->m_last_column == -1 || m_simple_table_internal->m_last_column - 1 < 0)
459 return 0;
460
461 // Par rapport à editElementLeft(), si on ne veut pas mettre à jour la dernière position,
462 // on ne verifie pas ni modifie m_simple_table_internal->m_column_sizes.
463 if (update_last_position) {
464 m_simple_table_internal->m_last_column--;
465
466 // Pas besoin d'ajuster la taille de la ligne car on est sûr que m_simple_table_internal->m_row_sizes[m_simple_table_internal->m_last_row] >= m_simple_table_internal->m_last_column.
467 if (m_simple_table_internal->m_column_sizes[m_simple_table_internal->m_last_column] <= m_simple_table_internal->m_last_row)
468 m_simple_table_internal->m_column_sizes[m_simple_table_internal->m_last_column] = m_simple_table_internal->m_last_row + 1;
469 return m_simple_table_internal->m_values[m_simple_table_internal->m_last_row][m_simple_table_internal->m_last_column];
470 }
471 return m_simple_table_internal->m_values[m_simple_table_internal->m_last_row][m_simple_table_internal->m_last_column - 1];
472}
473
474Real SimpleTableInternalMng::
475elementRight(bool update_last_position)
476{
477 if (m_simple_table_internal->m_last_row == -1 || m_simple_table_internal->m_last_column == -1 || m_simple_table_internal->m_last_column + 1 >= m_simple_table_internal->m_values.dim2Size())
478 return 0;
479
480 // Par rapport à editElementRight(), si on ne veut pas mettre à jour la dernière position,
481 // on ne verifie pas ni modifie m_simple_table_internal->m_column_sizes.
482 if (update_last_position) {
483 m_simple_table_internal->m_last_column++;
484
485 if (m_simple_table_internal->m_row_sizes[m_simple_table_internal->m_last_row] <= m_simple_table_internal->m_last_column)
486 m_simple_table_internal->m_row_sizes[m_simple_table_internal->m_last_row] = m_simple_table_internal->m_last_column + 1;
487 if (m_simple_table_internal->m_column_sizes[m_simple_table_internal->m_last_column] <= m_simple_table_internal->m_last_row)
488 m_simple_table_internal->m_column_sizes[m_simple_table_internal->m_last_column] = m_simple_table_internal->m_last_row + 1;
489 return m_simple_table_internal->m_values[m_simple_table_internal->m_last_row][m_simple_table_internal->m_last_column];
490 }
491 return m_simple_table_internal->m_values[m_simple_table_internal->m_last_row][m_simple_table_internal->m_last_column + 1];
492}
493
494/*---------------------------------------------------------------------------*/
495/*---------------------------------------------------------------------------*/
496
497bool SimpleTableInternalMng::
498editElement(Real element)
499{
500 m_simple_table_internal->m_values[m_simple_table_internal->m_last_row][m_simple_table_internal->m_last_column] = element;
501 return true;
502}
503
504bool SimpleTableInternalMng::
505editElement(Integer position_x, Integer position_y, Real element)
506{
507 if (position_x < 0 || position_x >= m_simple_table_internal->m_values.dim2Size() || position_y < 0 || position_y >= m_simple_table_internal->m_values.dim1Size())
508 return false;
509
510 if (m_simple_table_internal->m_column_sizes[position_x] <= position_y)
511 m_simple_table_internal->m_column_sizes[position_x] = position_y + 1;
512 if (m_simple_table_internal->m_row_sizes[position_y] <= position_x)
513 m_simple_table_internal->m_row_sizes[position_y] = position_x + 1;
514
515 m_simple_table_internal->m_values[position_y][position_x] = element;
516
517 m_simple_table_internal->m_last_row = position_y;
518 m_simple_table_internal->m_last_column = position_x;
519
520 return true;
521}
522
523bool SimpleTableInternalMng::
524editElement(const String& column_name, const String& row_name, Real element)
525{
526 std::optional<Integer> position_x = m_simple_table_internal->m_column_names.span().findFirst(column_name);
527 std::optional<Integer> position_y = m_simple_table_internal->m_row_names.span().findFirst(row_name);
528
529 if (position_x && position_y)
530 return editElement(position_x.value(), position_y.value(), element);
531 return false;
532}
533
534/*---------------------------------------------------------------------------*/
535/*---------------------------------------------------------------------------*/
536
537Real SimpleTableInternalMng::
538element()
539{
540 return m_simple_table_internal->m_values[m_simple_table_internal->m_last_row][m_simple_table_internal->m_last_column];
541}
542
543Real SimpleTableInternalMng::
544element(Integer position_x, Integer position_y, bool update_last_position)
545{
546 if (position_x < 0 || position_x >= m_simple_table_internal->m_values.dim2Size() || position_y < 0 || position_y >= m_simple_table_internal->m_values.dim1Size())
547 return 0;
548
549 if (update_last_position) {
550 m_simple_table_internal->m_last_column = position_x;
551 m_simple_table_internal->m_last_row = position_y;
552 }
553
554 return m_simple_table_internal->m_values[position_y][position_x];
555}
556
557Real SimpleTableInternalMng::
558element(const String& column_name, const String& row_name, bool update_last_position)
559{
560 std::optional<Integer> position_x = m_simple_table_internal->m_column_names.span().findFirst(column_name);
561 std::optional<Integer> position_y = m_simple_table_internal->m_row_names.span().findFirst(row_name);
562
563 if (position_x && position_y)
564 return element(position_x.value(), position_y.value(), update_last_position);
565 return 0;
566}
567
568/*---------------------------------------------------------------------------*/
569/*---------------------------------------------------------------------------*/
570
571RealUniqueArray SimpleTableInternalMng::
572row(Integer position)
573{
574 Integer size = rowSize(position);
575 RealUniqueArray copie(size);
576 for (Integer i = 0; i < size; i++) {
577 copie[i] = m_simple_table_internal->m_values[position][i];
578 }
579 return copie;
580}
581
582RealUniqueArray SimpleTableInternalMng::
583row(const String& row_name)
584{
585 std::optional<Integer> position_y = m_simple_table_internal->m_row_names.span().findFirst(row_name);
586 if (position_y)
587 return row(position_y.value());
588 return RealUniqueArray(0);
589}
590
591/*---------------------------------------------------------------------------*/
592/*---------------------------------------------------------------------------*/
593
594RealUniqueArray SimpleTableInternalMng::
595column(Integer position)
596{
597 Integer size = columnSize(position);
598
599 RealUniqueArray copie(size);
600 for (Integer i = 0; i < size; i++) {
601 copie[i] = m_simple_table_internal->m_values[i][position];
602 }
603 return copie;
604}
605
606RealUniqueArray SimpleTableInternalMng::
607column(const String& column_name)
608{
609 std::optional<Integer> position_x = m_simple_table_internal->m_column_names.span().findFirst(column_name);
610 if (position_x)
611 return column(position_x.value());
612 return RealUniqueArray(0);
613}
614
615/*---------------------------------------------------------------------------*/
616/*---------------------------------------------------------------------------*/
617
618Integer SimpleTableInternalMng::
619rowSize(Integer position)
620{
621 if (position < 0 || position >= m_simple_table_internal->m_values.dim1Size())
622 return 0;
623 return m_simple_table_internal->m_row_sizes[position];
624}
625
626Integer SimpleTableInternalMng::
627rowSize(const String& row_name)
628{
629 std::optional<Integer> position_y = m_simple_table_internal->m_row_names.span().findFirst(row_name);
630 if (position_y)
631 return rowSize(position_y.value());
632 return 0;
633}
634
635/*---------------------------------------------------------------------------*/
636/*---------------------------------------------------------------------------*/
637
638Integer SimpleTableInternalMng::
639columnSize(Integer position)
640{
641 if (position < 0 || position >= m_simple_table_internal->m_values.dim2Size())
642 return 0;
643 return m_simple_table_internal->m_column_sizes[position];
644}
645
646Integer SimpleTableInternalMng::
647columnSize(const String& column_name)
648{
649 std::optional<Integer> position_x = m_simple_table_internal->m_column_names.span().findFirst(column_name);
650 if (position_x)
651 return columnSize(position_x.value());
652 return 0;
653}
654
655/*---------------------------------------------------------------------------*/
656/*---------------------------------------------------------------------------*/
657
658Integer SimpleTableInternalMng::
659rowPosition(const String& row_name)
660{
661 std::optional<Integer> position_y = m_simple_table_internal->m_row_names.span().findFirst(row_name);
662 if (position_y)
663 return position_y.value();
664 return -1;
665}
666
667Integer SimpleTableInternalMng::
668columnPosition(const String& column_name)
669{
670 std::optional<Integer> position_x = m_simple_table_internal->m_column_names.span().findFirst(column_name);
671 if (position_x)
672 return position_x.value();
673 return -1;
674}
675
676/*---------------------------------------------------------------------------*/
677/*---------------------------------------------------------------------------*/
678
679Integer SimpleTableInternalMng::
680numberOfRows()
681{
682 return m_simple_table_internal->m_values.dim1Size();
683}
684
685Integer SimpleTableInternalMng::
686numberOfColumns()
687{
688 return m_simple_table_internal->m_values.dim2Size();
689}
690
691/*---------------------------------------------------------------------------*/
692/*---------------------------------------------------------------------------*/
693
694String SimpleTableInternalMng::
695rowName(Integer position)
696{
697 if (position < 0 || position >= m_simple_table_internal->m_values.dim1Size())
698 return "";
699
700 return m_simple_table_internal->m_row_names[position];
701}
702
703String SimpleTableInternalMng::
704columnName(Integer position)
705{
706 if (position < 0 || position >= m_simple_table_internal->m_values.dim2Size())
707 return "";
708
709 return m_simple_table_internal->m_column_names[position];
710}
711
712/*---------------------------------------------------------------------------*/
713/*---------------------------------------------------------------------------*/
714
715bool SimpleTableInternalMng::
716editRowName(Integer position, const String& new_name)
717{
718 if (new_name.empty() || position < 0 || position >= m_simple_table_internal->m_values.dim1Size())
719 return false;
720 m_simple_table_internal->m_row_names[position] = new_name;
721 return true;
722}
723
724bool SimpleTableInternalMng::
725editRowName(const String& row_name, const String& new_name)
726{
727 std::optional<Integer> position_y = m_simple_table_internal->m_row_names.span().findFirst(row_name);
728 if (position_y)
729 return editRowName(position_y.value(), new_name);
730 return false;
731}
732
733bool SimpleTableInternalMng::
734editColumnName(Integer position, const String& new_name)
735{
736 if (new_name.empty() || position < 0 || position >= m_simple_table_internal->m_values.dim2Size())
737 return false;
738 m_simple_table_internal->m_column_names[position] = new_name;
739 return true;
740}
741
742bool SimpleTableInternalMng::
743editColumnName(const String& column_name, const String& new_name)
744{
745 std::optional<Integer> position_x = m_simple_table_internal->m_column_names.span().findFirst(column_name);
746 if (position_x)
747 return editColumnName(position_x.value(), new_name);
748 return false;
749}
750
751/*---------------------------------------------------------------------------*/
752/*---------------------------------------------------------------------------*/
753
754Integer SimpleTableInternalMng::
755addAverageColumn(const String& column_name)
756{
757 if(column_name.empty()) return -1;
758
759 Integer position = addColumn(column_name);
760 for (Integer i = 0; i < m_simple_table_internal->m_values.dim1Size(); i++) {
761 Real avg = 0.0;
762 ConstArrayView<Real> view = m_simple_table_internal->m_values[i];
763 for (Integer j = 0; j < view.size() - 1; j++) {
764 avg += view[j];
765 }
766 avg /= view.size() - 1;
767 addElementInColumn(position, avg);
768 }
769 return position;
770}
771
772/*---------------------------------------------------------------------------*/
773/*---------------------------------------------------------------------------*/
774
775Ref<SimpleTableInternal> SimpleTableInternalMng::
776internal()
777{
778 return m_simple_table_internal;
779}
780
781void SimpleTableInternalMng::
782setInternal(const Ref<SimpleTableInternal>& simple_table_internal)
783{
784 if (simple_table_internal.isNull())
785 ARCANE_FATAL("La réference passée en paramètre est Null.");
786 m_simple_table_internal = simple_table_internal;
787}
788
789/*---------------------------------------------------------------------------*/
790/*---------------------------------------------------------------------------*/
791
792} // End namespace Arcane
793
794/*---------------------------------------------------------------------------*/
795/*---------------------------------------------------------------------------*/
ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Definition ArcaneGlobal.h:764
Arcane::ArrayView
Vue modifiable d'un tableau d'un type T.
Definition arccore/src/base/arccore/base/ArrayView.h:94
Arcane::Array::m_values
Arcane::UniqueArray< Arcane::UniqueArray< DataType > > m_values
Conteneur des variables génériques.
Definition AnyItemArray.h:92
Arcane::Array::span
Span< const T > span() const
Vue immutable sur ce tableau.
Definition arccore/src/collections/arccore/collections/Array.h:1112
Arcane::ConstArrayView
Vue constante d'un tableau de type T.
Definition arccore/src/base/arccore/base/ArrayView.h:533
Arcane::ConstArrayView::contains
bool contains(const_reference v) const
true si le tableau contient l'élément de valeur v
Definition arccore/src/base/arccore/base/ArrayView.h:727
Arcane::ConstArrayView::size
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
Definition arccore/src/base/arccore/base/ArrayView.h:713
Arcane::Ref
Référence à une instance.
Definition arccore/src/base/arccore/base/Ref.h:143
Arcane::Ref::isNull
bool isNull() const
Indique si le compteur référence une instance non nulle.
Definition arccore/src/base/arccore/base/Ref.h:295
Arcane::SimpleTableInternalMng::editElementLeft
bool editElementLeft(Real element, bool update_last_position) override
Méthode permettant d'éditer un élément à gauche du dernier élement dernièrement manipulé (même ligne/...
Definition SimpleTableInternalMng.cc:379
Arcane::SimpleTableInternalMng::addElementInRow
bool addElementInRow(Integer position, Real element) override
Méthode permettant d'ajouter un élément à une ligne.
Definition SimpleTableInternalMng.cc:147
Arcane::SimpleTableInternalMng::internal
Ref< SimpleTableInternal > internal() override
Méthode permettant de récupérer une référence vers l'objet SimpleTableInternal utilisé.
Definition SimpleTableInternalMng.cc:776
Arcane::SimpleTableInternalMng::rowPosition
Integer rowPosition(const String &row_name) override
Méthode permettant de récupérer la position d'une ligne.
Definition SimpleTableInternalMng.cc:659
Arcane::SimpleTableInternalMng::addElementInColumn
bool addElementInColumn(Integer position, Real element) override
Méthode permettant d'ajouter un élément à une colonne.
Definition SimpleTableInternalMng.cc:250
Arcane::SimpleTableInternalMng::columnName
String columnName(Integer position) override
Méthode permettant de récupérer le nom d'une colonne à partir de sa position.
Definition SimpleTableInternalMng.cc:704
Arcane::SimpleTableInternalMng::addElementsInColumn
bool addElementsInColumn(Integer position, ConstArrayView< Real > elements) override
Méthode permettant d'ajouter plusieurs éléments sur une colonne.
Definition SimpleTableInternalMng.cc:296
Arcane::SimpleTableInternalMng::numberOfRows
Integer numberOfRows() override
Méthode permettant de récupérer le nombre de lignes dans le tableau. C'est, en quelque sorte,...
Definition SimpleTableInternalMng.cc:680
Arcane::SimpleTableInternalMng::column
RealUniqueArray column(Integer position) override
Méthode permettant d'obtenir une copie d'une colonne.
Definition SimpleTableInternalMng.cc:595
Arcane::SimpleTableInternalMng::addElementsInSameColumn
bool addElementsInSameColumn(ConstArrayView< Real > elements) override
Méthode permettant d'ajouter plusieurs éléments sur la colonne dernièrement manipulée.
Definition SimpleTableInternalMng.cc:333
Arcane::SimpleTableInternalMng::addRows
bool addRows(StringConstArrayView rows_names) override
Méthode permettant d'ajouter plusieurs lignes.
Definition SimpleTableInternalMng.cc:69
Arcane::SimpleTableInternalMng::addElementsInSameRow
bool addElementsInSameRow(ConstArrayView< Real > elements) override
Méthode permettant d'ajouter plusieurs éléments sur la ligne dernièrement manipulée.
Definition SimpleTableInternalMng.cc:239
Arcane::SimpleTableInternalMng::elementDown
Real elementDown(bool update_last_position) override
Méthode permettant de récupérer un élément en-dessous du dernier élement dernièrement manipulé (ligne...
Definition SimpleTableInternalMng.cc:436
Arcane::SimpleTableInternalMng::clearInternal
void clearInternal() override
Méthode permettant d'effacer le contenu du SimpleTableInternal.
Definition SimpleTableInternalMng.cc:28
Arcane::SimpleTableInternalMng::setInternal
void setInternal(const Ref< SimpleTableInternal > &simple_table_internal) override
Méthode permettant de définir une référence vers un SimpleTableInternal.
Definition SimpleTableInternalMng.cc:782
Arcane::SimpleTableInternalMng::element
Real element() override
Méthode permettant d'obtenir une copie d'un élement.
Definition SimpleTableInternalMng.cc:538
Arcane::SimpleTableInternalMng::editElementDown
bool editElementDown(Real element, bool update_last_position) override
Méthode permettant d'éditer un élément en-dessous du dernier élement dernièrement manipulé (ligne du ...
Definition SimpleTableInternalMng.cc:361
Arcane::SimpleTableInternalMng::addAverageColumn
Integer addAverageColumn(const String &column_name) override
Méthode permettant de créer une colonne contenant la moyenne des éléments de chaque ligne.
Definition SimpleTableInternalMng.cc:755
Arcane::SimpleTableInternalMng::editColumnName
bool editColumnName(Integer position, const String &new_name) override
Méthode permettant de changer le nom d'une colonne.
Definition SimpleTableInternalMng.cc:734
Arcane::SimpleTableInternalMng::editRowName
bool editRowName(Integer position, const String &new_name) override
Méthode permettant de changer le nom d'une ligne.
Definition SimpleTableInternalMng.cc:716
Arcane::SimpleTableInternalMng::addElementInSameColumn
bool addElementInSameColumn(Real element) override
Méthode permettant d'ajouter un élément sur la colonne dernièrement manipulée.
Definition SimpleTableInternalMng.cc:285
Arcane::SimpleTableInternalMng::rowName
String rowName(Integer position) override
Méthode permettant de récupérer le nom d'une ligne à partir de sa position.
Definition SimpleTableInternalMng.cc:695
Arcane::SimpleTableInternalMng::addColumn
Integer addColumn(const String &column_name) override
Méthode permettant d'ajouter une colonne.
Definition SimpleTableInternalMng.cc:92
Arcane::SimpleTableInternalMng::row
RealUniqueArray row(Integer position) override
Méthode permettant d'obtenir une copie d'une ligne.
Definition SimpleTableInternalMng.cc:572
Arcane::SimpleTableInternalMng::elementUp
Real elementUp(bool update_last_position) override
Méthode permettant de récupérer un élément au-dessus du dernier élement dernièrement manipulé (ligne ...
Definition SimpleTableInternalMng.cc:417
Arcane::SimpleTableInternalMng::editElementRight
bool editElementRight(Real element, bool update_last_position) override
Méthode permettant d'éditer un élément à droite du dernier élement dernièrement manipulé (même ligne/...
Definition SimpleTableInternalMng.cc:396
Arcane::SimpleTableInternalMng::addElementInSameRow
bool addElementInSameRow(Real element) override
Méthode permettant d'ajouter un élément sur la ligne dernièrement manipulée.
Definition SimpleTableInternalMng.cc:190
Arcane::SimpleTableInternalMng::addElementsInRow
bool addElementsInRow(Integer position, ConstArrayView< Real > elements) override
Méthode permettant d'ajouter plusieurs éléments sur une ligne.
Definition SimpleTableInternalMng.cc:201
Arcane::SimpleTableInternalMng::rowSize
Integer rowSize(Integer position) override
Méthode permettant d'obtenir la taille d'une ligne. Incluant les hypothétiques 'trous' dans la ligne.
Definition SimpleTableInternalMng.cc:619
Arcane::SimpleTableInternalMng::columnSize
Integer columnSize(Integer position) override
Méthode permettant d'obtenir la taille d'une colonne. Incluant les hypotétiques 'trous' dans la colon...
Definition SimpleTableInternalMng.cc:639
Arcane::SimpleTableInternalMng::editElement
bool editElement(Real element) override
Méthode permettant de modifier un élement dans le tableau.
Definition SimpleTableInternalMng.cc:498
Arcane::SimpleTableInternalMng::editElementUp
bool editElementUp(Real element, bool update_last_position) override
Méthode permettant d'éditer un élément au-dessus du dernier élement dernièrement manipulé (ligne du d...
Definition SimpleTableInternalMng.cc:344
Arcane::SimpleTableInternalMng::numberOfColumns
Integer numberOfColumns() override
Méthode permettant de récupérer le nombre de colonnes dans le tableau. C'est, en quelque sorte,...
Definition SimpleTableInternalMng.cc:686
Arcane::SimpleTableInternalMng::columnPosition
Integer columnPosition(const String &column_name) override
Méthode permettant de récupérer la position d'une colonne.
Definition SimpleTableInternalMng.cc:668
Arcane::SimpleTableInternalMng::elementRight
Real elementRight(bool update_last_position) override
Méthode permettant de récupérer un élément à droite du dernier élement dernièrement manipulé (même li...
Definition SimpleTableInternalMng.cc:475
Arcane::SimpleTableInternalMng::addRow
Integer addRow(const String &row_name) override
Méthode permettant d'ajouter une ligne.
Definition SimpleTableInternalMng.cc:37
Arcane::SimpleTableInternalMng::elementLeft
Real elementLeft(bool update_last_position) override
Méthode permettant de récupérer un élément à gauche du dernier élement dernièrement manipulé (même li...
Definition SimpleTableInternalMng.cc:456
Arcane::SimpleTableInternalMng::addColumns
bool addColumns(StringConstArrayView columns_names) override
Méthode permettant d'ajouter plusieurs colonnes.
Definition SimpleTableInternalMng.cc:124
Arcane::String
Chaîne de caractères unicode.
Definition arccore/src/base/arccore/base/String.h:70
Arcane::String::empty
bool empty() const
Vrai si la chaîne est vide (nulle ou "")
Definition String.cc:315
Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition AcceleratorGlobal.h:36
Arcane::StringConstArrayView
ConstArrayView< String > StringConstArrayView
Equivalent C d'un tableau à une dimension de chaînes de caractères.
Definition UtilsTypes.h:579
Arcane::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:240
Arcane::RealUniqueArray
UniqueArray< Real > RealUniqueArray
Tableau dynamique à une dimension de réels.
Definition UtilsTypes.h:436
Arcane::Real
double Real
Type représentant un réel.
Definition ArccoreGlobal.h:223
Arcane::IntegerUniqueArray
UniqueArray< Integer > IntegerUniqueArray
Tableau dynamique à une dimension d'entiers.
Definition UtilsTypes.h:434